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