1// SPDX-License-Identifier: GPL-2.0-only
   2/* Hewlett-Packard Harmony audio driver
   3 *
   4 *   This is a driver for the Harmony audio chipset found
   5 *   on the LASI ASIC of various early HP PA-RISC workstations.
   6 *
   7 *   Copyright (C) 2004, Kyle McMartin <kyle@{debian.org,parisc-linux.org}>
   8 *
   9 *     Based on the previous Harmony incarnations by,
  10 *       Copyright 2000 (c) Linuxcare Canada, Alex deVries
  11 *       Copyright 2000-2003 (c) Helge Deller
  12 *       Copyright 2001 (c) Matthieu Delahaye
  13 *       Copyright 2001 (c) Jean-Christophe Vaugeois
  14 *       Copyright 2003 (c) Laurent Canet
  15 *       Copyright 2004 (c) Stuart Brady
  16 *
  17 * Notes:
  18 *   - graveyard and silence buffers last for lifetime of
  19 *     the driver. playback and capture buffers are allocated
  20 *     per _open()/_close().
  21 * 
  22 * TODO:
  23 */
  24
  25#include <linux/init.h>
  26#include <linux/slab.h>
  27#include <linux/time.h>
  28#include <linux/wait.h>
  29#include <linux/delay.h>
  30#include <linux/module.h>
  31#include <linux/interrupt.h>
  32#include <linux/spinlock.h>
  33#include <linux/dma-mapping.h>
  34#include <linux/io.h>
  35
  36#include <sound/core.h>
  37#include <sound/pcm.h>
  38#include <sound/control.h>
  39#include <sound/rawmidi.h>
  40#include <sound/initval.h>
  41#include <sound/info.h>
  42
  43#include <asm/hardware.h>
  44#include <asm/parisc-device.h>
  45
  46#include "harmony.h"
  47
  48static int index = SNDRV_DEFAULT_IDX1;	/* Index 0-MAX */
  49static char *id = SNDRV_DEFAULT_STR1;	/* ID for this card */
  50module_param(index, int, 0444);
  51MODULE_PARM_DESC(index, "Index value for Harmony driver.");
  52module_param(id, charp, 0444);
  53MODULE_PARM_DESC(id, "ID string for Harmony driver.");
  54
  55
  56static const struct parisc_device_id snd_harmony_devtable[] __initconst = {
  57	/* bushmaster / flounder */
  58	{ HPHW_FIO, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0007A }, 
  59	/* 712 / 715 */
  60	{ HPHW_FIO, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0007B }, 
  61	/* pace */
  62	{ HPHW_FIO, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0007E }, 
  63	/* outfield / coral II */
  64	{ HPHW_FIO, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0007F },
  65	{ 0, }
  66};
  67
  68MODULE_DEVICE_TABLE(parisc, snd_harmony_devtable);
  69
  70#define NAME "harmony"
  71#define PFX  NAME ": "
  72
  73static const unsigned int snd_harmony_rates[] = {
  74	5512, 6615, 8000, 9600,
  75	11025, 16000, 18900, 22050,
  76	27428, 32000, 33075, 37800,
  77	44100, 48000
  78};
  79
  80static const unsigned int rate_bits[14] = {
  81	HARMONY_SR_5KHZ, HARMONY_SR_6KHZ, HARMONY_SR_8KHZ,
  82	HARMONY_SR_9KHZ, HARMONY_SR_11KHZ, HARMONY_SR_16KHZ,
  83	HARMONY_SR_18KHZ, HARMONY_SR_22KHZ, HARMONY_SR_27KHZ,
  84	HARMONY_SR_32KHZ, HARMONY_SR_33KHZ, HARMONY_SR_37KHZ,
  85	HARMONY_SR_44KHZ, HARMONY_SR_48KHZ
  86};
  87
  88static const struct snd_pcm_hw_constraint_list hw_constraint_rates = {
  89	.count = ARRAY_SIZE(snd_harmony_rates),
  90	.list = snd_harmony_rates,
  91	.mask = 0,
  92};
  93
  94static inline unsigned long
  95harmony_read(struct snd_harmony *h, unsigned r)
  96{
  97	return __raw_readl(h->iobase + r);
  98}
  99
 100static inline void
 101harmony_write(struct snd_harmony *h, unsigned r, unsigned long v)
 102{
 103	__raw_writel(v, h->iobase + r);
 104}
 105
 106static inline void
 107harmony_wait_for_control(struct snd_harmony *h)
 108{
 109	while (harmony_read(h, HARMONY_CNTL) & HARMONY_CNTL_C) ;
 110}
 111
 112static inline void
 113harmony_reset(struct snd_harmony *h)
 114{
 115	harmony_write(h, HARMONY_RESET, 1);
 116	mdelay(50);
 117	harmony_write(h, HARMONY_RESET, 0);
 118}
 119
 120static void
 121harmony_disable_interrupts(struct snd_harmony *h)
 122{
 123	u32 dstatus;
 124	harmony_wait_for_control(h);
 125	dstatus = harmony_read(h, HARMONY_DSTATUS);
 126	dstatus &= ~HARMONY_DSTATUS_IE;
 127	harmony_write(h, HARMONY_DSTATUS, dstatus);
 128}
 129
 130static void
 131harmony_enable_interrupts(struct snd_harmony *h)
 132{
 133	u32 dstatus;
 134	harmony_wait_for_control(h);
 135	dstatus = harmony_read(h, HARMONY_DSTATUS);
 136	dstatus |= HARMONY_DSTATUS_IE;
 137	harmony_write(h, HARMONY_DSTATUS, dstatus);
 138}
 139
 140static void
 141harmony_mute(struct snd_harmony *h)
 142{
 143	unsigned long flags;
 144
 145	spin_lock_irqsave(&h->mixer_lock, flags);
 146	harmony_wait_for_control(h);
 147	harmony_write(h, HARMONY_GAINCTL, HARMONY_GAIN_SILENCE);
 148	spin_unlock_irqrestore(&h->mixer_lock, flags);
 149}
 150
 151static void
 152harmony_unmute(struct snd_harmony *h)
 153{
 154	unsigned long flags;
 155
 156	spin_lock_irqsave(&h->mixer_lock, flags);
 157	harmony_wait_for_control(h);
 158	harmony_write(h, HARMONY_GAINCTL, h->st.gain);
 159	spin_unlock_irqrestore(&h->mixer_lock, flags);
 160}
 161
 162static void
 163harmony_set_control(struct snd_harmony *h)
 164{
 165	u32 ctrl;
 166	unsigned long flags;
 167
 168	spin_lock_irqsave(&h->lock, flags);
 169
 170	ctrl = (HARMONY_CNTL_C      |
 171		(h->st.format << 6) |
 172		(h->st.stereo << 5) |
 173		(h->st.rate));
 174
 175	harmony_wait_for_control(h);
 176	harmony_write(h, HARMONY_CNTL, ctrl);
 177
 178	spin_unlock_irqrestore(&h->lock, flags);
 179}
 180
 181static irqreturn_t
 182snd_harmony_interrupt(int irq, void *dev)
 183{
 184	u32 dstatus;
 185	struct snd_harmony *h = dev;
 186
 187	spin_lock(&h->lock);
 188	harmony_disable_interrupts(h);
 189	harmony_wait_for_control(h);
 190	dstatus = harmony_read(h, HARMONY_DSTATUS);
 191	spin_unlock(&h->lock);
 192
 193	if (dstatus & HARMONY_DSTATUS_PN) {
 194		if (h->psubs && h->st.playing) {
 195			spin_lock(&h->lock);
 196			h->pbuf.buf += h->pbuf.count; /* PAGE_SIZE */
 197			h->pbuf.buf %= h->pbuf.size; /* MAX_BUFS*PAGE_SIZE */
 198
 199			harmony_write(h, HARMONY_PNXTADD, 
 200				      h->pbuf.addr + h->pbuf.buf);
 201			h->stats.play_intr++;
 202			spin_unlock(&h->lock);
 203                        snd_pcm_period_elapsed(h->psubs);
 204		} else {
 205			spin_lock(&h->lock);
 206			harmony_write(h, HARMONY_PNXTADD, h->sdma.addr);
 207			h->stats.silence_intr++;
 208			spin_unlock(&h->lock);
 209		}
 210	}
 211
 212	if (dstatus & HARMONY_DSTATUS_RN) {
 213		if (h->csubs && h->st.capturing) {
 214			spin_lock(&h->lock);
 215			h->cbuf.buf += h->cbuf.count;
 216			h->cbuf.buf %= h->cbuf.size;
 217
 218			harmony_write(h, HARMONY_RNXTADD,
 219				      h->cbuf.addr + h->cbuf.buf);
 220			h->stats.rec_intr++;
 221			spin_unlock(&h->lock);
 222                        snd_pcm_period_elapsed(h->csubs);
 223		} else {
 224			spin_lock(&h->lock);
 225			harmony_write(h, HARMONY_RNXTADD, h->gdma.addr);
 226			h->stats.graveyard_intr++;
 227			spin_unlock(&h->lock);
 228		}
 229	}
 230
 231	spin_lock(&h->lock);
 232	harmony_enable_interrupts(h);
 233	spin_unlock(&h->lock);
 234
 235	return IRQ_HANDLED;
 236}
 237
 238static unsigned int 
 239snd_harmony_rate_bits(int rate)
 240{
 241	unsigned int i;
 242	
 243	for (i = 0; i < ARRAY_SIZE(snd_harmony_rates); i++)
 244		if (snd_harmony_rates[i] == rate)
 245			return rate_bits[i];
 246
 247	return HARMONY_SR_44KHZ;
 248}
 249
 250static const struct snd_pcm_hardware snd_harmony_playback =
 251{
 252	.info =	(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 
 253		 SNDRV_PCM_INFO_JOINT_DUPLEX | SNDRV_PCM_INFO_MMAP_VALID |
 254		 SNDRV_PCM_INFO_BLOCK_TRANSFER),
 255	.formats = (SNDRV_PCM_FMTBIT_S16_BE | SNDRV_PCM_FMTBIT_MU_LAW |
 256		    SNDRV_PCM_FMTBIT_A_LAW),
 257	.rates = (SNDRV_PCM_RATE_5512 | SNDRV_PCM_RATE_8000_48000 |
 258		  SNDRV_PCM_RATE_KNOT),
 259	.rate_min = 5512,
 260	.rate_max = 48000,
 261	.channels_min =	1,
 262	.channels_max =	2,
 263	.buffer_bytes_max = MAX_BUF_SIZE,
 264	.period_bytes_min = BUF_SIZE,
 265	.period_bytes_max = BUF_SIZE,
 266	.periods_min = 1,
 267	.periods_max = MAX_BUFS,
 268	.fifo_size = 0,
 269};
 270
 271static const struct snd_pcm_hardware snd_harmony_capture =
 272{
 273        .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
 274                 SNDRV_PCM_INFO_JOINT_DUPLEX | SNDRV_PCM_INFO_MMAP_VALID |
 275                 SNDRV_PCM_INFO_BLOCK_TRANSFER),
 276        .formats = (SNDRV_PCM_FMTBIT_S16_BE | SNDRV_PCM_FMTBIT_MU_LAW |
 277                    SNDRV_PCM_FMTBIT_A_LAW),
 278        .rates = (SNDRV_PCM_RATE_5512 | SNDRV_PCM_RATE_8000_48000 |
 279		  SNDRV_PCM_RATE_KNOT),
 280        .rate_min = 5512,
 281        .rate_max = 48000,
 282        .channels_min = 1,
 283        .channels_max = 2,
 284        .buffer_bytes_max = MAX_BUF_SIZE,
 285        .period_bytes_min = BUF_SIZE,
 286        .period_bytes_max = BUF_SIZE,
 287        .periods_min = 1,
 288        .periods_max = MAX_BUFS,
 289        .fifo_size = 0,
 290};
 291
 292static int
 293snd_harmony_playback_trigger(struct snd_pcm_substream *ss, int cmd)
 294{
 295	struct snd_harmony *h = snd_pcm_substream_chip(ss);
 296
 297	if (h->st.capturing)
 298		return -EBUSY;
 299
 300	spin_lock(&h->lock);
 301	switch (cmd) {
 302	case SNDRV_PCM_TRIGGER_START:
 303		h->st.playing = 1;
 304		harmony_write(h, HARMONY_PNXTADD, h->pbuf.addr);
 305		harmony_write(h, HARMONY_RNXTADD, h->gdma.addr);
 306		harmony_unmute(h);
 307		harmony_enable_interrupts(h);
 308		break;
 309	case SNDRV_PCM_TRIGGER_STOP:
 310		h->st.playing = 0;
 311		harmony_mute(h);
 312		harmony_write(h, HARMONY_PNXTADD, h->sdma.addr);
 313		harmony_disable_interrupts(h);
 314		break;
 315	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 316	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 317	case SNDRV_PCM_TRIGGER_SUSPEND:
 318	default:
 319		spin_unlock(&h->lock);
 320		snd_BUG();
 321		return -EINVAL;
 322	}
 323	spin_unlock(&h->lock);
 324	
 325	return 0;
 326}
 327
 328static int
 329snd_harmony_capture_trigger(struct snd_pcm_substream *ss, int cmd)
 330{
 331        struct snd_harmony *h = snd_pcm_substream_chip(ss);
 332
 333	if (h->st.playing)
 334		return -EBUSY;
 335
 336	spin_lock(&h->lock);
 337        switch (cmd) {
 338        case SNDRV_PCM_TRIGGER_START:
 339		h->st.capturing = 1;
 340                harmony_write(h, HARMONY_PNXTADD, h->sdma.addr);
 341                harmony_write(h, HARMONY_RNXTADD, h->cbuf.addr);
 342		harmony_unmute(h);
 343                harmony_enable_interrupts(h);
 344		break;
 345        case SNDRV_PCM_TRIGGER_STOP:
 346		h->st.capturing = 0;
 347		harmony_mute(h);
 348		harmony_write(h, HARMONY_RNXTADD, h->gdma.addr);
 349		harmony_disable_interrupts(h);
 350		break;
 351        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 352        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 353        case SNDRV_PCM_TRIGGER_SUSPEND:
 354	default:
 355		spin_unlock(&h->lock);
 356		snd_BUG();
 357                return -EINVAL;
 358        }
 359	spin_unlock(&h->lock);
 360		
 361        return 0;
 362}
 363
 364static int
 365snd_harmony_set_data_format(struct snd_harmony *h, int fmt, int force)
 366{
 367	int o = h->st.format;
 368	int n;
 369
 370	switch(fmt) {
 371	case SNDRV_PCM_FORMAT_S16_BE:
 372		n = HARMONY_DF_16BIT_LINEAR;
 373		break;
 374	case SNDRV_PCM_FORMAT_A_LAW:
 375		n = HARMONY_DF_8BIT_ALAW;
 376		break;
 377	case SNDRV_PCM_FORMAT_MU_LAW:
 378		n = HARMONY_DF_8BIT_ULAW;
 379		break;
 380	default:
 381		n = HARMONY_DF_16BIT_LINEAR;
 382		break;
 383	}
 384
 385	if (force || o != n) {
 386		snd_pcm_format_set_silence(fmt, h->sdma.area, SILENCE_BUFSZ / 
 387					   (snd_pcm_format_physical_width(fmt)
 388					    / 8));
 389	}
 390
 391	return n;
 392}
 393
 394static int
 395snd_harmony_playback_prepare(struct snd_pcm_substream *ss)
 396{
 397	struct snd_harmony *h = snd_pcm_substream_chip(ss);
 398	struct snd_pcm_runtime *rt = ss->runtime;
 399	
 400	if (h->st.capturing)
 401		return -EBUSY;
 402	
 403	h->pbuf.size = snd_pcm_lib_buffer_bytes(ss);
 404	h->pbuf.count = snd_pcm_lib_period_bytes(ss);
 405	if (h->pbuf.buf >= h->pbuf.size)
 406		h->pbuf.buf = 0;
 407	h->st.playing = 0;
 408
 409	h->st.rate = snd_harmony_rate_bits(rt->rate);
 410	h->st.format = snd_harmony_set_data_format(h, rt->format, 0);
 411	
 412	if (rt->channels == 2)
 413		h->st.stereo = HARMONY_SS_STEREO;
 414	else
 415		h->st.stereo = HARMONY_SS_MONO;
 416
 417	harmony_set_control(h);
 418
 419	h->pbuf.addr = rt->dma_addr;
 420
 421	return 0;
 422}
 423
 424static int
 425snd_harmony_capture_prepare(struct snd_pcm_substream *ss)
 426{
 427        struct snd_harmony *h = snd_pcm_substream_chip(ss);
 428        struct snd_pcm_runtime *rt = ss->runtime;
 429
 430	if (h->st.playing)
 431		return -EBUSY;
 432
 433        h->cbuf.size = snd_pcm_lib_buffer_bytes(ss);
 434        h->cbuf.count = snd_pcm_lib_period_bytes(ss);
 435	if (h->cbuf.buf >= h->cbuf.size)
 436	        h->cbuf.buf = 0;
 437	h->st.capturing = 0;
 438
 439        h->st.rate = snd_harmony_rate_bits(rt->rate);
 440        h->st.format = snd_harmony_set_data_format(h, rt->format, 0);
 441
 442        if (rt->channels == 2)
 443                h->st.stereo = HARMONY_SS_STEREO;
 444        else
 445                h->st.stereo = HARMONY_SS_MONO;
 446
 447        harmony_set_control(h);
 448
 449        h->cbuf.addr = rt->dma_addr;
 450
 451        return 0;
 452}
 453
 454static snd_pcm_uframes_t 
 455snd_harmony_playback_pointer(struct snd_pcm_substream *ss)
 456{
 457	struct snd_pcm_runtime *rt = ss->runtime;
 458	struct snd_harmony *h = snd_pcm_substream_chip(ss);
 459	unsigned long pcuradd;
 460	unsigned long played;
 461
 462	if (!(h->st.playing) || (h->psubs == NULL)) 
 463		return 0;
 464
 465	if ((h->pbuf.addr == 0) || (h->pbuf.size == 0))
 466		return 0;
 467	
 468	pcuradd = harmony_read(h, HARMONY_PCURADD);
 469	played = pcuradd - h->pbuf.addr;
 470
 471#ifdef HARMONY_DEBUG
 472	printk(KERN_DEBUG PFX "playback_pointer is 0x%lx-0x%lx = %d bytes\n", 
 473	       pcuradd, h->pbuf.addr, played);	
 474#endif
 475
 476	if (pcuradd > h->pbuf.addr + h->pbuf.size) {
 477		return 0;
 478	}
 479
 480	return bytes_to_frames(rt, played);
 481}
 482
 483static snd_pcm_uframes_t
 484snd_harmony_capture_pointer(struct snd_pcm_substream *ss)
 485{
 486        struct snd_pcm_runtime *rt = ss->runtime;
 487        struct snd_harmony *h = snd_pcm_substream_chip(ss);
 488        unsigned long rcuradd;
 489        unsigned long caught;
 490
 491        if (!(h->st.capturing) || (h->csubs == NULL))
 492                return 0;
 493
 494        if ((h->cbuf.addr == 0) || (h->cbuf.size == 0))
 495                return 0;
 496
 497        rcuradd = harmony_read(h, HARMONY_RCURADD);
 498        caught = rcuradd - h->cbuf.addr;
 499
 500#ifdef HARMONY_DEBUG
 501        printk(KERN_DEBUG PFX "capture_pointer is 0x%lx-0x%lx = %d bytes\n",
 502               rcuradd, h->cbuf.addr, caught);
 503#endif
 504
 505        if (rcuradd > h->cbuf.addr + h->cbuf.size) {
 506		return 0;
 507	}
 508
 509        return bytes_to_frames(rt, caught);
 510}
 511
 512static int 
 513snd_harmony_playback_open(struct snd_pcm_substream *ss)
 514{
 515	struct snd_harmony *h = snd_pcm_substream_chip(ss);
 516	struct snd_pcm_runtime *rt = ss->runtime;
 517	int err;
 518	
 519	h->psubs = ss;
 520	rt->hw = snd_harmony_playback;
 521	snd_pcm_hw_constraint_list(rt, 0, SNDRV_PCM_HW_PARAM_RATE, 
 522				   &hw_constraint_rates);
 523	
 524	err = snd_pcm_hw_constraint_integer(rt, SNDRV_PCM_HW_PARAM_PERIODS);
 525	if (err < 0)
 526		return err;
 527	
 528	return 0;
 529}
 530
 531static int
 532snd_harmony_capture_open(struct snd_pcm_substream *ss)
 533{
 534        struct snd_harmony *h = snd_pcm_substream_chip(ss);
 535        struct snd_pcm_runtime *rt = ss->runtime;
 536        int err;
 537
 538        h->csubs = ss;
 539        rt->hw = snd_harmony_capture;
 540        snd_pcm_hw_constraint_list(rt, 0, SNDRV_PCM_HW_PARAM_RATE,
 541                                   &hw_constraint_rates);
 542
 543        err = snd_pcm_hw_constraint_integer(rt, SNDRV_PCM_HW_PARAM_PERIODS);
 544        if (err < 0)
 545                return err;
 546
 547        return 0;
 548}
 549
 550static int 
 551snd_harmony_playback_close(struct snd_pcm_substream *ss)
 552{
 553	struct snd_harmony *h = snd_pcm_substream_chip(ss);
 554	h->psubs = NULL;
 555	return 0;
 556}
 557
 558static int
 559snd_harmony_capture_close(struct snd_pcm_substream *ss)
 560{
 561        struct snd_harmony *h = snd_pcm_substream_chip(ss);
 562        h->csubs = NULL;
 563        return 0;
 564}
 565
 566static int 
 567snd_harmony_hw_params(struct snd_pcm_substream *ss,
 568		      struct snd_pcm_hw_params *hw)
 569{
 
 570	struct snd_harmony *h = snd_pcm_substream_chip(ss);
 571	
 572	if (h->dma.type == SNDRV_DMA_TYPE_CONTINUOUS)
 
 573		ss->runtime->dma_addr = __pa(ss->runtime->dma_area);
 
 
 
 574
 575	return 0;
 
 
 
 576}
 577
 578static const struct snd_pcm_ops snd_harmony_playback_ops = {
 579	.open =	snd_harmony_playback_open,
 580	.close = snd_harmony_playback_close,
 
 581	.hw_params = snd_harmony_hw_params,
 
 582	.prepare = snd_harmony_playback_prepare,
 583	.trigger = snd_harmony_playback_trigger,
 584 	.pointer = snd_harmony_playback_pointer,
 585};
 586
 587static const struct snd_pcm_ops snd_harmony_capture_ops = {
 588        .open = snd_harmony_capture_open,
 589        .close = snd_harmony_capture_close,
 
 590        .hw_params = snd_harmony_hw_params,
 
 591        .prepare = snd_harmony_capture_prepare,
 592        .trigger = snd_harmony_capture_trigger,
 593        .pointer = snd_harmony_capture_pointer,
 594};
 595
 596static int 
 597snd_harmony_pcm_init(struct snd_harmony *h)
 598{
 599	struct snd_pcm *pcm;
 600	int err;
 601
 602	if (snd_BUG_ON(!h))
 603		return -EINVAL;
 604
 605	harmony_disable_interrupts(h);
 606	
 607   	err = snd_pcm_new(h->card, "harmony", 0, 1, 1, &pcm);
 608	if (err < 0)
 609		return err;
 610	
 611	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, 
 612			&snd_harmony_playback_ops);
 613	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
 614			&snd_harmony_capture_ops);
 615
 616	pcm->private_data = h;
 617	pcm->info_flags = 0;
 618	strcpy(pcm->name, "harmony");
 619	h->pcm = pcm;
 620
 621	h->psubs = NULL;
 622	h->csubs = NULL;
 623	
 624	/* initialize graveyard buffer */
 625	h->dma.type = SNDRV_DMA_TYPE_DEV;
 626	h->dma.dev = &h->dev->dev;
 627	err = snd_dma_alloc_pages(h->dma.type,
 628				  h->dma.dev,
 629				  BUF_SIZE*GRAVEYARD_BUFS,
 630				  &h->gdma);
 631	if (err < 0) {
 632		printk(KERN_ERR PFX "cannot allocate graveyard buffer!\n");
 633		return err;
 634	}
 635	
 636	/* initialize silence buffers */
 637	err = snd_dma_alloc_pages(h->dma.type,
 638				  h->dma.dev,
 639				  BUF_SIZE*SILENCE_BUFS,
 640				  &h->sdma);
 641	if (err < 0) {
 642		printk(KERN_ERR PFX "cannot allocate silence buffer!\n");
 643		return err;
 644	}
 645
 646	/* pre-allocate space for DMA */
 647	snd_pcm_set_managed_buffer_all(pcm, h->dma.type, h->dma.dev,
 648				       MAX_BUF_SIZE, MAX_BUF_SIZE);
 649
 650	h->st.format = snd_harmony_set_data_format(h,
 651		SNDRV_PCM_FORMAT_S16_BE, 1);
 652
 653	return 0;
 654}
 655
 656static void 
 657snd_harmony_set_new_gain(struct snd_harmony *h)
 658{
 659 	harmony_wait_for_control(h);
 660	harmony_write(h, HARMONY_GAINCTL, h->st.gain);
 661}
 662
 663static int 
 664snd_harmony_mixercontrol_info(struct snd_kcontrol *kc, 
 665			      struct snd_ctl_elem_info *uinfo)
 666{
 667	int mask = (kc->private_value >> 16) & 0xff;
 668	int left_shift = (kc->private_value) & 0xff;
 669	int right_shift = (kc->private_value >> 8) & 0xff;
 670	
 671	uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : 
 672		       SNDRV_CTL_ELEM_TYPE_INTEGER;
 673	uinfo->count = left_shift == right_shift ? 1 : 2;
 674	uinfo->value.integer.min = 0;
 675	uinfo->value.integer.max = mask;
 676
 677	return 0;
 678}
 679
 680static int 
 681snd_harmony_volume_get(struct snd_kcontrol *kc, 
 682		       struct snd_ctl_elem_value *ucontrol)
 683{
 684	struct snd_harmony *h = snd_kcontrol_chip(kc);
 685	int shift_left = (kc->private_value) & 0xff;
 686	int shift_right = (kc->private_value >> 8) & 0xff;
 687	int mask = (kc->private_value >> 16) & 0xff;
 688	int invert = (kc->private_value >> 24) & 0xff;
 689	int left, right;
 690	
 691	spin_lock_irq(&h->mixer_lock);
 692
 693	left = (h->st.gain >> shift_left) & mask;
 694	right = (h->st.gain >> shift_right) & mask;
 695	if (invert) {
 696		left = mask - left;
 697		right = mask - right;
 698	}
 699	
 700	ucontrol->value.integer.value[0] = left;
 701	if (shift_left != shift_right)
 702		ucontrol->value.integer.value[1] = right;
 703
 704	spin_unlock_irq(&h->mixer_lock);
 705
 706	return 0;
 707}  
 708
 709static int 
 710snd_harmony_volume_put(struct snd_kcontrol *kc, 
 711		       struct snd_ctl_elem_value *ucontrol)
 712{
 713	struct snd_harmony *h = snd_kcontrol_chip(kc);
 714	int shift_left = (kc->private_value) & 0xff;
 715	int shift_right = (kc->private_value >> 8) & 0xff;
 716	int mask = (kc->private_value >> 16) & 0xff;
 717	int invert = (kc->private_value >> 24) & 0xff;
 718	int left, right;
 719	int old_gain = h->st.gain;
 720	
 721	spin_lock_irq(&h->mixer_lock);
 722
 723	left = ucontrol->value.integer.value[0] & mask;
 724	if (invert)
 725		left = mask - left;
 726	h->st.gain &= ~( (mask << shift_left ) );
 727 	h->st.gain |= (left << shift_left);
 728
 729	if (shift_left != shift_right) {
 730		right = ucontrol->value.integer.value[1] & mask;
 731		if (invert)
 732			right = mask - right;
 733		h->st.gain &= ~( (mask << shift_right) );
 734		h->st.gain |= (right << shift_right);
 735	}
 736
 737	snd_harmony_set_new_gain(h);
 738
 739	spin_unlock_irq(&h->mixer_lock);
 740	
 741	return h->st.gain != old_gain;
 742}
 743
 744static int 
 745snd_harmony_captureroute_info(struct snd_kcontrol *kc, 
 746			      struct snd_ctl_elem_info *uinfo)
 747{
 748	static const char * const texts[2] = { "Line", "Mic" };
 749
 750	return snd_ctl_enum_info(uinfo, 1, 2, texts);
 751}
 752
 753static int 
 754snd_harmony_captureroute_get(struct snd_kcontrol *kc, 
 755			     struct snd_ctl_elem_value *ucontrol)
 756{
 757	struct snd_harmony *h = snd_kcontrol_chip(kc);
 758	int value;
 759	
 760	spin_lock_irq(&h->mixer_lock);
 761
 762	value = (h->st.gain >> HARMONY_GAIN_IS_SHIFT) & 1;
 763	ucontrol->value.enumerated.item[0] = value;
 764
 765	spin_unlock_irq(&h->mixer_lock);
 766
 767	return 0;
 768}  
 769
 770static int 
 771snd_harmony_captureroute_put(struct snd_kcontrol *kc, 
 772			     struct snd_ctl_elem_value *ucontrol)
 773{
 774	struct snd_harmony *h = snd_kcontrol_chip(kc);
 775	int value;
 776	int old_gain = h->st.gain;
 777	
 778	spin_lock_irq(&h->mixer_lock);
 779
 780	value = ucontrol->value.enumerated.item[0] & 1;
 781	h->st.gain &= ~HARMONY_GAIN_IS_MASK;
 782 	h->st.gain |= value << HARMONY_GAIN_IS_SHIFT;
 783
 784	snd_harmony_set_new_gain(h);
 785
 786	spin_unlock_irq(&h->mixer_lock);
 787	
 788	return h->st.gain != old_gain;
 789}
 790
 791#define HARMONY_CONTROLS	ARRAY_SIZE(snd_harmony_controls)
 792
 793#define HARMONY_VOLUME(xname, left_shift, right_shift, mask, invert) \
 794{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,                \
 795  .info = snd_harmony_mixercontrol_info,                             \
 796  .get = snd_harmony_volume_get, .put = snd_harmony_volume_put,      \
 797  .private_value = ((left_shift) | ((right_shift) << 8) |            \
 798                   ((mask) << 16) | ((invert) << 24)) }
 799
 800static const struct snd_kcontrol_new snd_harmony_controls[] = {
 801	HARMONY_VOLUME("Master Playback Volume", HARMONY_GAIN_LO_SHIFT, 
 802		       HARMONY_GAIN_RO_SHIFT, HARMONY_GAIN_OUT, 1),
 803	HARMONY_VOLUME("Capture Volume", HARMONY_GAIN_LI_SHIFT,
 804		       HARMONY_GAIN_RI_SHIFT, HARMONY_GAIN_IN, 0),
 805	HARMONY_VOLUME("Monitor Volume", HARMONY_GAIN_MA_SHIFT,
 806		       HARMONY_GAIN_MA_SHIFT, HARMONY_GAIN_MA, 1),
 807	{
 808		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 809		.name = "Input Route",
 810		.info = snd_harmony_captureroute_info,
 811		.get = snd_harmony_captureroute_get,
 812		.put = snd_harmony_captureroute_put
 813	},
 814	HARMONY_VOLUME("Internal Speaker Switch", HARMONY_GAIN_SE_SHIFT,
 815		       HARMONY_GAIN_SE_SHIFT, 1, 0),
 816	HARMONY_VOLUME("Line-Out Switch", HARMONY_GAIN_LE_SHIFT,
 817		       HARMONY_GAIN_LE_SHIFT, 1, 0),
 818	HARMONY_VOLUME("Headphones Switch", HARMONY_GAIN_HE_SHIFT,
 819		       HARMONY_GAIN_HE_SHIFT, 1, 0),
 820};
 821
 822static void
 823snd_harmony_mixer_reset(struct snd_harmony *h)
 824{
 825	harmony_mute(h);
 826	harmony_reset(h);
 827	h->st.gain = HARMONY_GAIN_DEFAULT;
 828	harmony_unmute(h);
 829}
 830
 831static int
 832snd_harmony_mixer_init(struct snd_harmony *h)
 833{
 834	struct snd_card *card;
 835	int idx, err;
 836
 837	if (snd_BUG_ON(!h))
 838		return -EINVAL;
 839	card = h->card;
 840	strcpy(card->mixername, "Harmony Gain control interface");
 841
 842	for (idx = 0; idx < HARMONY_CONTROLS; idx++) {
 843		err = snd_ctl_add(card, 
 844				  snd_ctl_new1(&snd_harmony_controls[idx], h));
 845		if (err < 0)
 846			return err;
 847	}
 848	
 849	snd_harmony_mixer_reset(h);
 850
 851	return 0;
 852}
 853
 854static int
 855snd_harmony_free(struct snd_harmony *h)
 856{
 857        if (h->gdma.addr)
 858                snd_dma_free_pages(&h->gdma);
 859        if (h->sdma.addr)
 860                snd_dma_free_pages(&h->sdma);
 861
 862	if (h->irq >= 0)
 863		free_irq(h->irq, h);
 864
 865	iounmap(h->iobase);
 866	kfree(h);
 867	return 0;
 868}
 869
 870static int
 871snd_harmony_dev_free(struct snd_device *dev)
 872{
 873	struct snd_harmony *h = dev->device_data;
 874	return snd_harmony_free(h);
 875}
 876
 877static int
 878snd_harmony_create(struct snd_card *card, 
 879		   struct parisc_device *padev, 
 880		   struct snd_harmony **rchip)
 881{
 882	int err;
 883	struct snd_harmony *h;
 884	static const struct snd_device_ops ops = {
 885		.dev_free = snd_harmony_dev_free,
 886	};
 887
 888	*rchip = NULL;
 889
 890	h = kzalloc(sizeof(*h), GFP_KERNEL);
 891	if (h == NULL)
 892		return -ENOMEM;
 893
 894	h->hpa = padev->hpa.start;
 895	h->card = card;
 896	h->dev = padev;
 897	h->irq = -1;
 898	h->iobase = ioremap(padev->hpa.start, HARMONY_SIZE);
 899	if (h->iobase == NULL) {
 900		printk(KERN_ERR PFX "unable to remap hpa 0x%lx\n",
 901		       (unsigned long)padev->hpa.start);
 902		err = -EBUSY;
 903		goto free_and_ret;
 904	}
 905		
 906	err = request_irq(padev->irq, snd_harmony_interrupt, 0,
 907			  "harmony", h);
 908	if (err) {
 909		printk(KERN_ERR PFX "could not obtain interrupt %d",
 910		       padev->irq);
 911		goto free_and_ret;
 912	}
 913	h->irq = padev->irq;
 914
 915	spin_lock_init(&h->mixer_lock);
 916	spin_lock_init(&h->lock);
 917
 918	err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, h, &ops);
 919	if (err < 0)
 920		goto free_and_ret;
 
 921
 922	*rchip = h;
 923
 924	return 0;
 925
 926free_and_ret:
 927	snd_harmony_free(h);
 928	return err;
 929}
 930
 931static int __init
 932snd_harmony_probe(struct parisc_device *padev)
 933{
 934	int err;
 935	struct snd_card *card;
 936	struct snd_harmony *h;
 937
 938	err = snd_card_new(&padev->dev, index, id, THIS_MODULE, 0, &card);
 939	if (err < 0)
 940		return err;
 941
 942	err = snd_harmony_create(card, padev, &h);
 943	if (err < 0)
 944		goto free_and_ret;
 945
 946	err = snd_harmony_pcm_init(h);
 947	if (err < 0)
 948		goto free_and_ret;
 949
 950	err = snd_harmony_mixer_init(h);
 951	if (err < 0)
 952		goto free_and_ret;
 953
 954	strcpy(card->driver, "harmony");
 955	strcpy(card->shortname, "Harmony");
 956	sprintf(card->longname, "%s at 0x%lx, irq %i",
 957		card->shortname, h->hpa, h->irq);
 958
 959	err = snd_card_register(card);
 960	if (err < 0)
 961		goto free_and_ret;
 962
 963	parisc_set_drvdata(padev, card);
 964	return 0;
 965
 966free_and_ret:
 967	snd_card_free(card);
 968	return err;
 969}
 970
 971static int __exit
 972snd_harmony_remove(struct parisc_device *padev)
 973{
 974	snd_card_free(parisc_get_drvdata(padev));
 975	return 0;
 976}
 977
 978static struct parisc_driver snd_harmony_driver __refdata = {
 979	.name = "harmony",
 980	.id_table = snd_harmony_devtable,
 981	.probe = snd_harmony_probe,
 982	.remove = __exit_p(snd_harmony_remove),
 983};
 984
 985static int __init 
 986alsa_harmony_init(void)
 987{
 988	return register_parisc_driver(&snd_harmony_driver);
 989}
 990
 991static void __exit
 992alsa_harmony_fini(void)
 993{
 994	unregister_parisc_driver(&snd_harmony_driver);
 995}
 996
 997MODULE_LICENSE("GPL");
 998MODULE_AUTHOR("Kyle McMartin <kyle@parisc-linux.org>");
 999MODULE_DESCRIPTION("Harmony sound driver");
1000
1001module_init(alsa_harmony_init);
1002module_exit(alsa_harmony_fini);