[PATCH] RCU: CREDITS and MAINTAINERS
[linux-2.6] / sound / oss / harmony.c
1 /*
2         sound/oss/harmony.c
3
4         This is a sound driver for ASP's and Lasi's Harmony sound chip
5         and is unlikely to be used for anything other than on a HP PA-RISC.
6
7         Harmony is found in HP 712s, 715/new and many other GSC based machines.
8         On older 715 machines you'll find the technically identical chip 
9         called 'Vivace'. Both Harmony and Vicace are supported by this driver.
10
11         Copyright 2000 (c) Linuxcare Canada, Alex deVries <alex@onefishtwo.ca>
12         Copyright 2000-2003 (c) Helge Deller <deller@gmx.de>
13         Copyright 2001 (c) Matthieu Delahaye <delahaym@esiee.fr>
14         Copyright 2001 (c) Jean-Christophe Vaugeois <vaugeoij@esiee.fr>
15         Copyright 2004 (c) Stuart Brady <sdbrady@ntlworld.com>
16
17                                 
18 TODO:
19         - fix SNDCTL_DSP_GETOSPACE and SNDCTL_DSP_GETISPACE ioctls to
20                 return the real values
21         - add private ioctl for selecting line- or microphone input
22                 (only one of them is available at the same time)
23         - add module parameters
24         - implement mmap functionality
25         - implement gain meter ?
26         - ...
27 */
28
29 #include <linux/delay.h>
30 #include <linux/errno.h>
31 #include <linux/init.h>
32 #include <linux/interrupt.h>
33 #include <linux/ioport.h>
34 #include <linux/types.h>
35 #include <linux/mm.h>
36 #include <linux/pci.h>
37
38 #include <asm/parisc-device.h>
39 #include <asm/io.h>
40
41 #include "sound_config.h"
42
43
44 #define PFX "harmony: "
45 #define HARMONY_VERSION "V0.9a"
46
47 #undef DEBUG
48 #ifdef DEBUG
49 # define DPRINTK printk 
50 #else
51 # define DPRINTK(x,...)
52 #endif
53
54
55 #define MAX_BUFS 10             /* maximum number of rotating buffers */
56 #define HARMONY_BUF_SIZE 4096   /* needs to be a multiple of PAGE_SIZE (4096)! */
57
58 #define CNTL_C          0x80000000
59 #define CNTL_ST         0x00000020
60 #define CNTL_44100      0x00000015      /* HARMONY_SR_44KHZ */
61 #define CNTL_8000       0x00000008      /* HARMONY_SR_8KHZ */
62
63 #define GAINCTL_HE      0x08000000
64 #define GAINCTL_LE      0x04000000
65 #define GAINCTL_SE      0x02000000
66
67 #define DSTATUS_PN      0x00000200
68 #define DSTATUS_RN      0x00000002
69
70 #define DSTATUS_IE      0x80000000
71
72 #define HARMONY_DF_16BIT_LINEAR 0
73 #define HARMONY_DF_8BIT_ULAW    1
74 #define HARMONY_DF_8BIT_ALAW    2
75
76 #define HARMONY_SS_MONO         0
77 #define HARMONY_SS_STEREO       1
78
79 #define HARMONY_SR_8KHZ         0x08
80 #define HARMONY_SR_16KHZ        0x09
81 #define HARMONY_SR_27KHZ        0x0A
82 #define HARMONY_SR_32KHZ        0x0B
83 #define HARMONY_SR_48KHZ        0x0E
84 #define HARMONY_SR_9KHZ         0x0F
85 #define HARMONY_SR_5KHZ         0x10
86 #define HARMONY_SR_11KHZ        0x11
87 #define HARMONY_SR_18KHZ        0x12
88 #define HARMONY_SR_22KHZ        0x13
89 #define HARMONY_SR_37KHZ        0x14
90 #define HARMONY_SR_44KHZ        0x15
91 #define HARMONY_SR_33KHZ        0x16
92 #define HARMONY_SR_6KHZ         0x17
93
94 /*
95  * Some magics numbers used to auto-detect file formats
96  */
97
98 #define HARMONY_MAGIC_8B_ULAW   1
99 #define HARMONY_MAGIC_8B_ALAW   27
100 #define HARMONY_MAGIC_16B_LINEAR 3
101 #define HARMONY_MAGIC_MONO      1
102 #define HARMONY_MAGIC_STEREO    2
103
104 /*
105  * Channels Positions in mixer register
106  */
107
108 #define GAIN_HE_SHIFT   27
109 #define GAIN_HE_MASK    ( 1 << GAIN_HE_SHIFT) 
110 #define GAIN_LE_SHIFT   26
111 #define GAIN_LE_MASK    ( 1 << GAIN_LE_SHIFT) 
112 #define GAIN_SE_SHIFT   25
113 #define GAIN_SE_MASK    ( 1 << GAIN_SE_SHIFT) 
114 #define GAIN_IS_SHIFT   24
115 #define GAIN_IS_MASK    ( 1 << GAIN_IS_SHIFT) 
116 #define GAIN_MA_SHIFT   20
117 #define GAIN_MA_MASK    ( 0x0f << GAIN_MA_SHIFT) 
118 #define GAIN_LI_SHIFT   16
119 #define GAIN_LI_MASK    ( 0x0f << GAIN_LI_SHIFT) 
120 #define GAIN_RI_SHIFT   12
121 #define GAIN_RI_MASK    ( 0x0f << GAIN_RI_SHIFT) 
122 #define GAIN_LO_SHIFT   6
123 #define GAIN_LO_MASK    ( 0x3f << GAIN_LO_SHIFT) 
124 #define GAIN_RO_SHIFT   0
125 #define GAIN_RO_MASK    ( 0x3f << GAIN_RO_SHIFT) 
126
127
128 #define MAX_OUTPUT_LEVEL  (GAIN_RO_MASK >> GAIN_RO_SHIFT)
129 #define MAX_INPUT_LEVEL   (GAIN_RI_MASK >> GAIN_RI_SHIFT)
130 #define MAX_MONITOR_LEVEL (GAIN_MA_MASK >> GAIN_MA_SHIFT)
131
132 #define MIXER_INTERNAL   SOUND_MIXER_LINE1
133 #define MIXER_LINEOUT    SOUND_MIXER_LINE2
134 #define MIXER_HEADPHONES SOUND_MIXER_LINE3
135
136 #define MASK_INTERNAL   SOUND_MASK_LINE1
137 #define MASK_LINEOUT    SOUND_MASK_LINE2
138 #define MASK_HEADPHONES SOUND_MASK_LINE3
139
140 /*
141  * Channels Mask in mixer register
142  */
143
144 #define GAIN_TOTAL_SILENCE 0x00F00FFF
145 #define GAIN_DEFAULT       0x0FF00000
146
147
148 struct harmony_hpa {
149         u8      unused000;
150         u8      id;
151         u8      teleshare_id;
152         u8      unused003;
153         u32     reset;
154         u32     cntl;
155         u32     gainctl;
156         u32     pnxtadd;
157         u32     pcuradd;
158         u32     rnxtadd;
159         u32     rcuradd;
160         u32     dstatus;
161         u32     ov;
162         u32     pio;
163         u32     unused02c;
164         u32     unused030[3];
165         u32     diag;
166 };
167
168 struct harmony_dev {
169         struct harmony_hpa *hpa;
170         struct parisc_device *dev;
171         u32 current_gain;
172         u32 dac_rate;           /* 8000 ... 48000 (Hz) */
173         u8 data_format;         /* HARMONY_DF_xx_BIT_xxx */
174         u8 sample_rate;         /* HARMONY_SR_xx_KHZ */
175         u8 stereo_select;       /* HARMONY_SS_MONO or HARMONY_SS_STEREO */
176         int format_initialized  :1;
177         int suspended_playing   :1;
178         int suspended_recording :1;
179         
180         int blocked_playing     :1;
181         int blocked_recording   :1;
182         int audio_open          :1;
183         int mixer_open          :1;
184         
185         wait_queue_head_t wq_play, wq_record;
186         int first_filled_play;  /* first buffer containing data (next to play) */
187         int nb_filled_play; 
188         int play_offset;
189         int first_filled_record;
190         int nb_filled_record;
191                 
192         int dsp_unit, mixer_unit;
193 };
194
195
196 static struct harmony_dev harmony;
197
198
199 /*
200  * Dynamic sound buffer allocation and DMA memory
201  */
202
203 struct harmony_buffer {
204         unsigned char *addr;
205         dma_addr_t dma_handle;
206         int dma_coherent;       /* Zero if dma_alloc_coherent() fails */
207         unsigned int len;
208 };
209
210 /*
211  * Harmony memory buffers
212  */
213
214 static struct harmony_buffer played_buf, recorded_buf, silent, graveyard;
215
216
217 #define CHECK_WBACK_INV_OFFSET(b,offset,len) \
218         do { if (!b.dma_coherent) \
219                 dma_cache_wback_inv((unsigned long)b.addr+offset,len); \
220         } while (0) 
221
222         
223 static int __init harmony_alloc_buffer(struct harmony_buffer *b, 
224                 unsigned int buffer_count)
225 {
226         b->len = buffer_count * HARMONY_BUF_SIZE;
227         b->addr = dma_alloc_coherent(&harmony.dev->dev, 
228                           b->len, &b->dma_handle, GFP_KERNEL|GFP_DMA);
229         if (b->addr && b->dma_handle) {
230                 b->dma_coherent = 1;
231                 DPRINTK(KERN_INFO PFX "coherent memory: 0x%lx, played_buf: 0x%lx\n",
232                                 (unsigned long)b->dma_handle, (unsigned long)b->addr);
233         } else {
234                 b->dma_coherent = 0;
235                 /* kmalloc()ed memory will HPMC on ccio machines ! */
236                 b->addr = kmalloc(b->len, GFP_KERNEL);
237                 if (!b->addr) {
238                         printk(KERN_ERR PFX "couldn't allocate memory\n");
239                         return -EBUSY;
240                 }
241                 b->dma_handle = __pa(b->addr);
242         }
243         return 0;
244 }
245
246 static void __exit harmony_free_buffer(struct harmony_buffer *b)
247 {
248         if (!b->addr)
249                 return;
250
251         if (b->dma_coherent)
252                 dma_free_coherent(&harmony.dev->dev,
253                                 b->len, b->addr, b->dma_handle);
254         else
255                 kfree(b->addr);
256
257         memset(b, 0, sizeof(*b));
258 }
259
260
261
262 /*
263  * Low-Level sound-chip programming
264  */
265
266 static void __inline__ harmony_wait_CNTL(void)
267 {
268         /* Wait until we're out of control mode */
269         while (gsc_readl(&harmony.hpa->cntl) & CNTL_C)
270                 /* wait */ ;
271 }
272
273
274 static void harmony_update_control(void) 
275 {
276         u32 default_cntl;
277         
278         /* Set CNTL */
279         default_cntl = (CNTL_C |                /* The C bit */
280                 (harmony.data_format << 6) |    /* Set the data format */
281                 (harmony.stereo_select << 5) |  /* Stereo select */
282                 (harmony.sample_rate));         /* Set sample rate */
283         harmony.format_initialized = 1;
284         
285         /* initialize CNTL */
286         gsc_writel(default_cntl, &harmony.hpa->cntl);
287 }
288
289 static void harmony_set_control(u8 data_format, u8 sample_rate, u8 stereo_select) 
290 {
291         harmony.sample_rate = sample_rate;
292         harmony.data_format = data_format;
293         harmony.stereo_select = stereo_select;
294         harmony_update_control();
295 }
296
297 static void harmony_set_rate(u8 data_rate) 
298 {
299         harmony.sample_rate = data_rate;
300         harmony_update_control();
301 }
302
303 static int harmony_detect_rate(int *freq)
304 {
305         int newrate;
306         switch (*freq) {
307         case 8000:      newrate = HARMONY_SR_8KHZ;      break;
308         case 16000:     newrate = HARMONY_SR_16KHZ;     break; 
309         case 27428:     newrate = HARMONY_SR_27KHZ;     break; 
310         case 32000:     newrate = HARMONY_SR_32KHZ;     break; 
311         case 48000:     newrate = HARMONY_SR_48KHZ;     break; 
312         case 9600:      newrate = HARMONY_SR_9KHZ;      break; 
313         case 5512:      newrate = HARMONY_SR_5KHZ;      break; 
314         case 11025:     newrate = HARMONY_SR_11KHZ;     break; 
315         case 18900:     newrate = HARMONY_SR_18KHZ;     break; 
316         case 22050:     newrate = HARMONY_SR_22KHZ;     break; 
317         case 37800:     newrate = HARMONY_SR_37KHZ;     break; 
318         case 44100:     newrate = HARMONY_SR_44KHZ;     break; 
319         case 33075:     newrate = HARMONY_SR_33KHZ;     break; 
320         case 6615:      newrate = HARMONY_SR_6KHZ;      break; 
321         default:        newrate = HARMONY_SR_8KHZ; 
322                         *freq = 8000;                   break;
323         }
324         return newrate;
325 }
326
327 static void harmony_set_format(u8 data_format) 
328 {
329         harmony.data_format = data_format;
330         harmony_update_control();
331 }
332
333 static void harmony_set_stereo(u8 stereo_select) 
334 {
335         harmony.stereo_select = stereo_select;
336         harmony_update_control();
337 }
338
339 static void harmony_disable_interrupts(void) 
340 {
341         harmony_wait_CNTL();
342         gsc_writel(0, &harmony.hpa->dstatus); 
343 }
344
345 static void harmony_enable_interrupts(void) 
346 {
347         harmony_wait_CNTL();
348         gsc_writel(DSTATUS_IE, &harmony.hpa->dstatus); 
349 }
350
351 /*
352  * harmony_silence()
353  *
354  * This subroutine fills in a buffer starting at location start and
355  * silences for length bytes.  This references the current
356  * configuration of the audio format.
357  *
358  */
359
360 static void harmony_silence(struct harmony_buffer *buffer, int start, int length) 
361 {
362         u8 silence_char;
363
364         /* Despite what you hear, silence is different in
365            different audio formats.  */
366         switch (harmony.data_format) {
367                 case HARMONY_DF_8BIT_ULAW:      silence_char = 0x55; break;
368                 case HARMONY_DF_8BIT_ALAW:      silence_char = 0xff; break;
369                 case HARMONY_DF_16BIT_LINEAR:   /* fall through */
370                 default:                        silence_char = 0;
371         }
372
373         memset(buffer->addr+start, silence_char, length);
374 }
375
376
377 static int harmony_audio_open(struct inode *inode, struct file *file)
378 {
379         if (harmony.audio_open) 
380                 return -EBUSY;
381         
382         harmony.audio_open = 1;
383         harmony.suspended_playing = harmony.suspended_recording = 1;
384         harmony.blocked_playing   = harmony.blocked_recording   = 0;
385         harmony.first_filled_play = harmony.first_filled_record = 0;
386         harmony.nb_filled_play    = harmony.nb_filled_record    = 0;
387         harmony.play_offset = 0;
388         init_waitqueue_head(&harmony.wq_play);
389         init_waitqueue_head(&harmony.wq_record);
390         
391         /* Start off in a balanced mode. */
392         harmony_set_control(HARMONY_DF_8BIT_ULAW, HARMONY_SR_8KHZ, HARMONY_SS_MONO);
393         harmony_update_control();
394         harmony.format_initialized = 0;
395
396         /* Clear out all the buffers and flush to cache */
397         harmony_silence(&played_buf, 0, HARMONY_BUF_SIZE*MAX_BUFS);
398         CHECK_WBACK_INV_OFFSET(played_buf, 0, HARMONY_BUF_SIZE*MAX_BUFS);
399         
400         return 0;
401 }
402
403 /*
404  * Release (close) the audio device.
405  */
406
407 static int harmony_audio_release(struct inode *inode, struct file *file)
408 {
409         if (!harmony.audio_open) 
410                 return -EBUSY;
411         
412         harmony.audio_open = 0;
413
414         return 0;
415 }
416
417 /*
418  * Read recorded data off the audio device.
419  */
420
421 static ssize_t harmony_audio_read(struct file *file,
422                                 char *buffer,
423                                 size_t size_count,
424                                 loff_t *ppos)
425 {
426         int total_count = (int) size_count;
427         int count = 0;
428         int buf_to_read;
429
430         while (count<total_count) {
431                 /* Wait until we're out of control mode */
432                 harmony_wait_CNTL();
433                 
434                 /* Figure out which buffer to fill in */
435                 if (harmony.nb_filled_record <= 2) {
436                         harmony.blocked_recording = 1;
437                         if (harmony.suspended_recording) {
438                                 harmony.suspended_recording = 0;
439                                 harmony_enable_interrupts();
440                         }
441                                                         
442                         interruptible_sleep_on(&harmony.wq_record);
443                         harmony.blocked_recording = 0;
444                 }
445                 
446                 if (harmony.nb_filled_record < 2)
447                         return -EBUSY;
448                 
449                 buf_to_read = harmony.first_filled_record;
450
451                 /* Copy the page to an aligned buffer */
452                 if (copy_to_user(buffer+count, recorded_buf.addr +
453                                  (HARMONY_BUF_SIZE*buf_to_read),
454                                  HARMONY_BUF_SIZE)) {
455                         count = -EFAULT;
456                         break;
457                 }
458                 
459                 harmony.nb_filled_record--;
460                 harmony.first_filled_record++;
461                 harmony.first_filled_record %= MAX_BUFS;
462                                 
463                 count += HARMONY_BUF_SIZE;
464         }
465         return count;
466 }
467
468
469
470
471 /*
472  * Here is the place where we try to recognize file format.
473  * Sun/NeXT .au files begin with the string .snd
474  * At offset 12 is specified the encoding.
475  * At offset 16 is specified speed rate
476  * At Offset 20 is specified the numbers of voices
477  */
478
479 #define four_bytes_to_u32(start) (file_header[start] << 24)|\
480                                   (file_header[start+1] << 16)|\
481                                   (file_header[start+2] << 8)|\
482                                   (file_header[start+3]);
483
484 #define test_rate(tested,real_value,harmony_value) if ((tested)<=(real_value))\
485                                                     
486
487 static int harmony_format_auto_detect(const char *buffer, int block_size)
488 {
489         u8 file_header[24];
490         u32 start_string;
491         int ret = 0;
492         
493         if (block_size>24) {
494                 if (copy_from_user(file_header, buffer, sizeof(file_header)))
495                         ret = -EFAULT;
496                         
497                 start_string = four_bytes_to_u32(0);
498                 
499                 if ((file_header[4]==0) && (start_string==0x2E736E64)) {
500                         u32 format;
501                         u32 nb_voices;
502                         u32 speed;
503                         
504                         format = four_bytes_to_u32(12);
505                         nb_voices = four_bytes_to_u32(20);
506                         speed = four_bytes_to_u32(16);
507                         
508                         switch (format) {
509                         case HARMONY_MAGIC_8B_ULAW:
510                                 harmony.data_format = HARMONY_DF_8BIT_ULAW;
511                                 break;
512                         case HARMONY_MAGIC_8B_ALAW:
513                                 harmony.data_format = HARMONY_DF_8BIT_ALAW;
514                                 break;
515                         case HARMONY_MAGIC_16B_LINEAR:
516                                 harmony.data_format = HARMONY_DF_16BIT_LINEAR;
517                                 break;
518                         default:
519                                 harmony_set_control(HARMONY_DF_16BIT_LINEAR,
520                                                 HARMONY_SR_44KHZ, HARMONY_SS_STEREO);
521                                 goto out;
522                         }
523                         switch (nb_voices) {
524                         case HARMONY_MAGIC_MONO:
525                                 harmony.stereo_select = HARMONY_SS_MONO;
526                                 break;
527                         case HARMONY_MAGIC_STEREO:
528                                 harmony.stereo_select = HARMONY_SS_STEREO;
529                                 break;
530                         default:
531                                 harmony.stereo_select = HARMONY_SS_MONO;
532                                 break;
533                         }
534                         harmony_set_rate(harmony_detect_rate(&speed));
535                         harmony.dac_rate = speed;
536                         goto out;
537                 }
538         }
539         harmony_set_control(HARMONY_DF_8BIT_ULAW, HARMONY_SR_8KHZ, HARMONY_SS_MONO);
540 out:
541         return ret;
542 }
543 #undef four_bytes_to_u32
544
545
546 static ssize_t harmony_audio_write(struct file *file,
547                                  const char *buffer,
548                                  size_t size_count,
549                                  loff_t *ppos)
550 {
551         int total_count = (int) size_count;
552         int count = 0;
553         int frame_size;
554         int buf_to_fill;
555         int fresh_buffer;
556
557         if (!harmony.format_initialized) {
558                 if (harmony_format_auto_detect(buffer, total_count))
559                         return -EFAULT;
560         }
561         
562         while (count<total_count) {
563                 /* Wait until we're out of control mode */
564                 harmony_wait_CNTL();
565
566                 /* Figure out which buffer to fill in */
567                 if (harmony.nb_filled_play+2 >= MAX_BUFS && !harmony.play_offset) {
568                         harmony.blocked_playing = 1;
569                         interruptible_sleep_on(&harmony.wq_play);
570                         harmony.blocked_playing = 0;
571                 }
572                 if (harmony.nb_filled_play+2 >= MAX_BUFS && !harmony.play_offset)
573                         return -EBUSY;
574                 
575                 
576                 buf_to_fill = (harmony.first_filled_play+harmony.nb_filled_play); 
577                 if (harmony.play_offset) {
578                         buf_to_fill--;
579                         buf_to_fill += MAX_BUFS;
580                 }
581                 buf_to_fill %= MAX_BUFS;
582                 
583                 fresh_buffer = (harmony.play_offset == 0);
584                 
585                 /* Figure out the size of the frame */
586                 if ((total_count-count) >= HARMONY_BUF_SIZE - harmony.play_offset) {
587                         frame_size = HARMONY_BUF_SIZE - harmony.play_offset;
588                 } else {
589                         frame_size = total_count - count;
590                         /* Clear out the buffer, since there we'll only be 
591                            overlaying part of the old buffer with the new one */
592                         harmony_silence(&played_buf, 
593                                 HARMONY_BUF_SIZE*buf_to_fill+frame_size+harmony.play_offset,
594                                 HARMONY_BUF_SIZE-frame_size-harmony.play_offset);
595                 }
596
597                 /* Copy the page to an aligned buffer */
598                 if (copy_from_user(played_buf.addr +(HARMONY_BUF_SIZE*buf_to_fill) + harmony.play_offset, 
599                                    buffer+count, frame_size))
600                         return -EFAULT;
601                 CHECK_WBACK_INV_OFFSET(played_buf, (HARMONY_BUF_SIZE*buf_to_fill + harmony.play_offset), 
602                                 frame_size);
603         
604                 if (fresh_buffer)
605                         harmony.nb_filled_play++;
606                 
607                 count += frame_size;
608                 harmony.play_offset += frame_size;
609                 harmony.play_offset %= HARMONY_BUF_SIZE;
610                 if (harmony.suspended_playing && (harmony.nb_filled_play>=4))
611                         harmony_enable_interrupts();
612         }
613         
614         return count;
615 }
616
617 static unsigned int harmony_audio_poll(struct file *file,
618                                      struct poll_table_struct *wait)
619 {
620         unsigned int mask = 0;
621         
622         if (file->f_mode & FMODE_READ) {
623                 if (!harmony.suspended_recording)
624                         poll_wait(file, &harmony.wq_record, wait);
625                 if (harmony.nb_filled_record)
626                         mask |= POLLIN | POLLRDNORM;
627         }
628
629         if (file->f_mode & FMODE_WRITE) {
630                 if (!harmony.suspended_playing)
631                         poll_wait(file, &harmony.wq_play, wait);
632                 if (harmony.nb_filled_play)
633                         mask |= POLLOUT | POLLWRNORM;
634         }
635
636         return mask;
637 }
638
639 static int harmony_audio_ioctl(struct inode *inode,
640                                 struct file *file,
641                                 unsigned int cmd,
642                                 unsigned long arg)
643 {
644         int ival, new_format;
645         int frag_size, frag_buf;
646         struct audio_buf_info info;
647         
648         switch (cmd) {
649         case OSS_GETVERSION:
650                 return put_user(SOUND_VERSION, (int *) arg);
651
652         case SNDCTL_DSP_GETCAPS:
653                 ival = DSP_CAP_DUPLEX;
654                 return put_user(ival, (int *) arg);
655
656         case SNDCTL_DSP_GETFMTS:
657                 ival = (AFMT_S16_BE | AFMT_MU_LAW | AFMT_A_LAW ); 
658                 return put_user(ival, (int *) arg);
659         
660         case SNDCTL_DSP_SETFMT:
661                 if (get_user(ival, (int *) arg)) 
662                         return -EFAULT;
663                 if (ival != AFMT_QUERY) {
664                         switch (ival) {
665                         case AFMT_MU_LAW:       new_format = HARMONY_DF_8BIT_ULAW; break;
666                         case AFMT_A_LAW:        new_format = HARMONY_DF_8BIT_ALAW; break;
667                         case AFMT_S16_BE:       new_format = HARMONY_DF_16BIT_LINEAR; break;
668                         default: {
669                                 DPRINTK(KERN_WARNING PFX 
670                                         "unsupported sound format 0x%04x requested.\n",
671                                         ival);
672                                 ival = AFMT_S16_BE;
673                                 return put_user(ival, (int *) arg);
674                         }
675                         }
676                         harmony_set_format(new_format);
677                         return 0;
678                 } else {
679                         switch (harmony.data_format) {
680                         case HARMONY_DF_8BIT_ULAW:      ival = AFMT_MU_LAW; break;
681                         case HARMONY_DF_8BIT_ALAW:      ival = AFMT_A_LAW;  break;
682                         case HARMONY_DF_16BIT_LINEAR:   ival = AFMT_U16_BE; break;
683                         default: ival = 0;
684                         }
685                         return put_user(ival, (int *) arg);
686                 }
687
688         case SOUND_PCM_READ_RATE:
689                 ival = harmony.dac_rate;
690                 return put_user(ival, (int *) arg);
691
692         case SNDCTL_DSP_SPEED:
693                 if (get_user(ival, (int *) arg))
694                         return -EFAULT;
695                 harmony_set_rate(harmony_detect_rate(&ival));
696                 harmony.dac_rate = ival;
697                 return put_user(ival, (int*) arg);
698
699         case SNDCTL_DSP_STEREO:
700                 if (get_user(ival, (int *) arg))
701                         return -EFAULT;
702                 if (ival != 0 && ival != 1)
703                         return -EINVAL;
704                 harmony_set_stereo(ival);
705                 return 0;
706  
707         case SNDCTL_DSP_CHANNELS:
708                 if (get_user(ival, (int *) arg))
709                         return -EFAULT;
710                 if (ival != 1 && ival != 2) {
711                         ival = harmony.stereo_select == HARMONY_SS_MONO ? 1 : 2;
712                         return put_user(ival, (int *) arg);
713                 }
714                 harmony_set_stereo(ival-1);
715                 return 0;
716
717         case SNDCTL_DSP_GETBLKSIZE:
718                 ival = HARMONY_BUF_SIZE;
719                 return put_user(ival, (int *) arg);
720                 
721         case SNDCTL_DSP_NONBLOCK:
722                 file->f_flags |= O_NONBLOCK;
723                 return 0;
724
725         case SNDCTL_DSP_RESET:
726                 if (!harmony.suspended_recording) {
727                         /* TODO: stop_recording() */
728                 }
729                 return 0;
730
731         case SNDCTL_DSP_SETFRAGMENT:
732                 if (get_user(ival, (int *)arg))
733                         return -EFAULT;
734                 frag_size = ival & 0xffff;
735                 frag_buf = (ival>>16) & 0xffff;
736                 /* TODO: We use hardcoded fragment sizes and numbers for now */
737                 frag_size = 12;  /* 4096 == 2^12 */
738                 frag_buf  = MAX_BUFS;
739                 ival = (frag_buf << 16) + frag_size;
740                 return put_user(ival, (int *) arg);
741                 
742         case SNDCTL_DSP_GETOSPACE:
743                 if (!(file->f_mode & FMODE_WRITE))
744                         return -EINVAL;
745                 info.fragstotal = MAX_BUFS;
746                 info.fragments = MAX_BUFS - harmony.nb_filled_play;
747                 info.fragsize = HARMONY_BUF_SIZE;
748                 info.bytes = info.fragments * info.fragsize;
749                 return copy_to_user((void *)arg, &info, sizeof(info)) ? -EFAULT : 0;
750
751         case SNDCTL_DSP_GETISPACE:
752                 if (!(file->f_mode & FMODE_READ))
753                         return -EINVAL;
754                 info.fragstotal = MAX_BUFS;
755                 info.fragments = /*MAX_BUFS-*/ harmony.nb_filled_record;
756                 info.fragsize = HARMONY_BUF_SIZE;
757                 info.bytes = info.fragments * info.fragsize;
758                 return copy_to_user((void *)arg, &info, sizeof(info)) ? -EFAULT : 0;
759         
760         case SNDCTL_DSP_SYNC:
761                 return 0;
762         }
763         
764         return -EINVAL;
765 }
766
767
768 /*
769  * harmony_interrupt()
770  *
771  * harmony interruption service routine
772  * 
773  */
774
775 static irqreturn_t harmony_interrupt(int irq, void *dev, struct pt_regs *regs)
776 {
777         u32 dstatus;
778         struct harmony_hpa *hpa;
779
780         /* Setup the hpa */
781         hpa = ((struct harmony_dev *)dev)->hpa;
782         harmony_wait_CNTL();
783
784         /* Read dstatus and pcuradd (the current address) */
785         dstatus = gsc_readl(&hpa->dstatus);
786         
787         /* Turn off interrupts */
788         harmony_disable_interrupts();
789         
790         /* Check if this is a request to get the next play buffer */
791         if (dstatus & DSTATUS_PN) {
792                 if (!harmony.nb_filled_play) {
793                         harmony.suspended_playing = 1;
794                         gsc_writel((unsigned long)silent.dma_handle, &hpa->pnxtadd);
795                                                 
796                         if (!harmony.suspended_recording)
797                                 harmony_enable_interrupts();
798                 } else {
799                         harmony.suspended_playing = 0;
800                         gsc_writel((unsigned long)played_buf.dma_handle + 
801                                         (HARMONY_BUF_SIZE*harmony.first_filled_play),
802                                         &hpa->pnxtadd);
803                         harmony.first_filled_play++;
804                         harmony.first_filled_play %= MAX_BUFS;
805                         harmony.nb_filled_play--;
806                         
807                         harmony_enable_interrupts();
808                 }
809                 
810                 if (harmony.blocked_playing)
811                         wake_up_interruptible(&harmony.wq_play);
812         }
813         
814         /* Check if we're being asked to fill in a recording buffer */
815         if (dstatus & DSTATUS_RN) {
816                 if((harmony.nb_filled_record+2>=MAX_BUFS) || harmony.suspended_recording)
817                 {
818                         harmony.nb_filled_record = 0;
819                         harmony.first_filled_record = 0;
820                         harmony.suspended_recording = 1;
821                         gsc_writel((unsigned long)graveyard.dma_handle, &hpa->rnxtadd);
822                         if (!harmony.suspended_playing)
823                                 harmony_enable_interrupts();
824                 } else {
825                         int buf_to_fill;
826                         buf_to_fill = (harmony.first_filled_record+harmony.nb_filled_record) % MAX_BUFS;
827                         CHECK_WBACK_INV_OFFSET(recorded_buf, HARMONY_BUF_SIZE*buf_to_fill, HARMONY_BUF_SIZE);
828                         gsc_writel((unsigned long)recorded_buf.dma_handle +
829                                         HARMONY_BUF_SIZE*buf_to_fill,
830                                         &hpa->rnxtadd);
831                         harmony.nb_filled_record++;
832                         harmony_enable_interrupts();
833                 }
834
835                 if (harmony.blocked_recording && harmony.nb_filled_record>3)
836                         wake_up_interruptible(&harmony.wq_record);
837         }
838         return IRQ_HANDLED;
839 }
840
841 /*
842  * Sound playing functions
843  */
844
845 static struct file_operations harmony_audio_fops = {
846         .owner          = THIS_MODULE,
847         .llseek         = no_llseek,
848         .read           = harmony_audio_read,
849         .write          = harmony_audio_write,
850         .poll           = harmony_audio_poll,
851         .ioctl          = harmony_audio_ioctl,
852         .open           = harmony_audio_open,
853         .release        = harmony_audio_release,
854 };
855
856 static int harmony_audio_init(void)
857 {
858         /* Request that IRQ */
859         if (request_irq(harmony.dev->irq, harmony_interrupt, 0 ,"harmony", &harmony)) {
860                 printk(KERN_ERR PFX "Error requesting irq %d.\n", harmony.dev->irq);
861                 return -EFAULT;
862         }
863
864         harmony.dsp_unit = register_sound_dsp(&harmony_audio_fops, -1);
865         if (harmony.dsp_unit < 0) {
866                 printk(KERN_ERR PFX "Error registering dsp\n");
867                 free_irq(harmony.dev->irq, &harmony);
868                 return -EFAULT;
869         }
870         
871         /* Clear the buffers so you don't end up with crap in the buffers. */ 
872         harmony_silence(&played_buf, 0, HARMONY_BUF_SIZE*MAX_BUFS);
873
874         /* Make sure this makes it to cache */
875         CHECK_WBACK_INV_OFFSET(played_buf, 0, HARMONY_BUF_SIZE*MAX_BUFS);
876
877         /* Clear out the silent buffer and flush to cache */
878         harmony_silence(&silent, 0, HARMONY_BUF_SIZE);
879         CHECK_WBACK_INV_OFFSET(silent, 0, HARMONY_BUF_SIZE);
880         
881         harmony.audio_open = 0;
882         
883         return 0;
884 }
885
886
887 /*
888  * mixer functions 
889  */
890
891 static void harmony_mixer_set_gain(void)
892 {
893         harmony_wait_CNTL();
894         gsc_writel(harmony.current_gain, &harmony.hpa->gainctl);
895 }
896
897 /* 
898  *  Read gain of selected channel.
899  *  The OSS rate is from 0 (silent) to 100 -> need some conversions
900  *
901  *  The harmony gain are attenuation for output and monitor gain.
902  *                   is amplifaction for input gain
903  */
904 #define to_harmony_level(level,max) ((level)*max/100)
905 #define to_oss_level(level,max) ((level)*100/max)
906
907 static int harmony_mixer_get_level(int channel)
908 {
909         int left_level;
910         int right_level;
911
912         switch (channel) {
913                 case SOUND_MIXER_VOLUME:
914                         left_level  = (harmony.current_gain & GAIN_LO_MASK) >> GAIN_LO_SHIFT;
915                         right_level = (harmony.current_gain & GAIN_RO_MASK) >> GAIN_RO_SHIFT;
916                         left_level  = to_oss_level(MAX_OUTPUT_LEVEL - left_level, MAX_OUTPUT_LEVEL);
917                         right_level = to_oss_level(MAX_OUTPUT_LEVEL - right_level, MAX_OUTPUT_LEVEL);
918                         return (right_level << 8)+left_level;
919                         
920                 case SOUND_MIXER_IGAIN:
921                         left_level = (harmony.current_gain & GAIN_LI_MASK) >> GAIN_LI_SHIFT;
922                         right_level= (harmony.current_gain & GAIN_RI_MASK) >> GAIN_RI_SHIFT;
923                         left_level = to_oss_level(left_level, MAX_INPUT_LEVEL);
924                         right_level= to_oss_level(right_level, MAX_INPUT_LEVEL);
925                         return (right_level << 8)+left_level;
926                         
927                 case SOUND_MIXER_MONITOR:
928                         left_level = (harmony.current_gain & GAIN_MA_MASK) >> GAIN_MA_SHIFT;
929                         left_level = to_oss_level(MAX_MONITOR_LEVEL-left_level, MAX_MONITOR_LEVEL);
930                         return (left_level << 8)+left_level;
931         }
932         return -EINVAL;
933 }
934
935
936
937 /*
938  * Some conversions for the same reasons.
939  * We give back the new real value(s) due to
940  * the rescale.
941  */
942
943 static int harmony_mixer_set_level(int channel, int value)
944 {
945         int left_level;
946         int right_level;
947         int new_left_level;
948         int new_right_level;
949
950         right_level = (value & 0x0000ff00) >> 8;
951         left_level = value & 0x000000ff;
952         if (right_level > 100) right_level = 100;
953         if (left_level > 100) left_level = 100;
954   
955         switch (channel) {
956                 case SOUND_MIXER_VOLUME:
957                         right_level = to_harmony_level(100-right_level, MAX_OUTPUT_LEVEL);
958                         left_level  = to_harmony_level(100-left_level, MAX_OUTPUT_LEVEL);
959                         new_right_level = to_oss_level(MAX_OUTPUT_LEVEL - right_level, MAX_OUTPUT_LEVEL);
960                         new_left_level  = to_oss_level(MAX_OUTPUT_LEVEL - left_level, MAX_OUTPUT_LEVEL);
961                         harmony.current_gain = (harmony.current_gain & ~(GAIN_LO_MASK | GAIN_RO_MASK)) 
962                                         | (left_level << GAIN_LO_SHIFT) | (right_level << GAIN_RO_SHIFT);
963                         harmony_mixer_set_gain();
964                         return (new_right_level << 8) + new_left_level;
965                         
966                 case SOUND_MIXER_IGAIN:
967                         right_level = to_harmony_level(right_level, MAX_INPUT_LEVEL);
968                         left_level  = to_harmony_level(left_level, MAX_INPUT_LEVEL);
969                         new_right_level = to_oss_level(right_level, MAX_INPUT_LEVEL);
970                         new_left_level  = to_oss_level(left_level, MAX_INPUT_LEVEL);
971                         harmony.current_gain = (harmony.current_gain & ~(GAIN_LI_MASK | GAIN_RI_MASK))
972                                         | (left_level << GAIN_LI_SHIFT) | (right_level << GAIN_RI_SHIFT);
973                         harmony_mixer_set_gain();
974                         return (new_right_level << 8) + new_left_level;
975         
976                 case SOUND_MIXER_MONITOR:
977                         left_level = to_harmony_level(100-left_level, MAX_MONITOR_LEVEL);
978                         new_left_level = to_oss_level(MAX_MONITOR_LEVEL-left_level, MAX_MONITOR_LEVEL);
979                         harmony.current_gain = (harmony.current_gain & ~GAIN_MA_MASK) | (left_level << GAIN_MA_SHIFT);
980                         harmony_mixer_set_gain();
981                         return (new_left_level << 8) + new_left_level;
982         }
983
984         return -EINVAL;
985 }
986
987 #undef to_harmony_level
988 #undef to_oss_level
989
990 /* 
991  * Return the selected input device (mic or line)
992  */
993
994 static int harmony_mixer_get_recmask(void) 
995 {
996         int current_input_line;
997         
998         current_input_line = (harmony.current_gain & GAIN_IS_MASK) 
999                                     >> GAIN_IS_SHIFT;
1000         if (current_input_line) 
1001                 return SOUND_MASK_MIC;
1002
1003         return SOUND_MASK_LINE;
1004 }
1005
1006 /*
1007  * Set the input (only one at time, arbitrary priority to line in)
1008  */
1009
1010 static int harmony_mixer_set_recmask(int recmask)
1011 {
1012         int new_input_line;
1013         int new_input_mask;
1014         int current_input_line;
1015         
1016         current_input_line = (harmony.current_gain & GAIN_IS_MASK)
1017                                     >> GAIN_IS_SHIFT;
1018         if ((current_input_line && ((recmask & SOUND_MASK_LINE) || !(recmask & SOUND_MASK_MIC))) ||
1019                 (!current_input_line && ((recmask & SOUND_MASK_LINE) && !(recmask & SOUND_MASK_MIC)))) {
1020                 new_input_line = 0;
1021                 new_input_mask = SOUND_MASK_LINE;
1022         } else {
1023                 new_input_line = 1;
1024                 new_input_mask = SOUND_MASK_MIC;
1025         }
1026         harmony.current_gain = ((harmony.current_gain & ~GAIN_IS_MASK) | 
1027                                 (new_input_line << GAIN_IS_SHIFT ));
1028         harmony_mixer_set_gain();
1029         return new_input_mask;
1030 }
1031
1032
1033 /* 
1034  * give the active outlines
1035  */
1036
1037 static int harmony_mixer_get_outmask(void)
1038 {
1039         int outmask = 0;
1040         
1041         if (harmony.current_gain & GAIN_SE_MASK) outmask |= MASK_INTERNAL;
1042         if (harmony.current_gain & GAIN_LE_MASK) outmask |= MASK_LINEOUT;
1043         if (harmony.current_gain & GAIN_HE_MASK) outmask |= MASK_HEADPHONES;
1044         
1045         return outmask;
1046 }
1047
1048
1049 static int harmony_mixer_set_outmask(int outmask)
1050 {
1051         if (outmask & MASK_INTERNAL) 
1052                 harmony.current_gain |= GAIN_SE_MASK;
1053         else 
1054                 harmony.current_gain &= ~GAIN_SE_MASK;
1055         
1056         if (outmask & MASK_LINEOUT) 
1057                 harmony.current_gain |= GAIN_LE_MASK;
1058         else 
1059                 harmony.current_gain &= ~GAIN_LE_MASK;
1060         
1061         if (outmask & MASK_HEADPHONES) 
1062                 harmony.current_gain |= GAIN_HE_MASK; 
1063         else 
1064                 harmony.current_gain &= ~GAIN_HE_MASK;
1065         
1066         harmony_mixer_set_gain();
1067
1068         return (outmask & (MASK_INTERNAL | MASK_LINEOUT | MASK_HEADPHONES));
1069 }
1070
1071 /*
1072  * This code is inspired from sb_mixer.c
1073  */
1074
1075 static int harmony_mixer_ioctl(struct inode * inode, struct file * file,
1076                 unsigned int cmd, unsigned long arg)
1077 {
1078         int val;
1079         int ret;
1080
1081         if (cmd == SOUND_MIXER_INFO) {
1082                 mixer_info info;
1083                 memset(&info, 0, sizeof(info));
1084                 strncpy(info.id, "harmony", sizeof(info.id)-1);
1085                 strncpy(info.name, "Harmony audio", sizeof(info.name)-1);
1086                 info.modify_counter = 1; /* ? */
1087                 if (copy_to_user((void *)arg, &info, sizeof(info)))
1088                         return -EFAULT;
1089                 return 0;
1090         }
1091         
1092         if (cmd == OSS_GETVERSION)
1093                 return put_user(SOUND_VERSION, (int *)arg);
1094
1095         /* read */
1096         val = 0;
1097         if (_SIOC_DIR(cmd) & _SIOC_WRITE)
1098                 if (get_user(val, (int *)arg))
1099                         return -EFAULT;
1100
1101         switch (cmd) {
1102         case MIXER_READ(SOUND_MIXER_CAPS):
1103                 ret = SOUND_CAP_EXCL_INPUT;
1104                 break;
1105         case MIXER_READ(SOUND_MIXER_STEREODEVS):
1106                 ret = SOUND_MASK_VOLUME | SOUND_MASK_IGAIN;
1107                 break;
1108                 
1109         case MIXER_READ(SOUND_MIXER_RECMASK):
1110                 ret = SOUND_MASK_MIC | SOUND_MASK_LINE;
1111                 break;
1112         case MIXER_READ(SOUND_MIXER_DEVMASK):
1113                 ret = SOUND_MASK_VOLUME | SOUND_MASK_IGAIN |
1114                         SOUND_MASK_MONITOR;
1115                 break;
1116         case MIXER_READ(SOUND_MIXER_OUTMASK):
1117                 ret = MASK_INTERNAL | MASK_LINEOUT |
1118                         MASK_HEADPHONES;
1119                 break;
1120                 
1121         case MIXER_WRITE(SOUND_MIXER_RECSRC):
1122                 ret = harmony_mixer_set_recmask(val);
1123                 break;
1124         case MIXER_READ(SOUND_MIXER_RECSRC):
1125                 ret = harmony_mixer_get_recmask();
1126                 break;
1127               
1128         case MIXER_WRITE(SOUND_MIXER_OUTSRC):
1129                 ret = harmony_mixer_set_outmask(val);
1130                 break;
1131         case MIXER_READ(SOUND_MIXER_OUTSRC):
1132                 ret = harmony_mixer_get_outmask();
1133                 break;
1134         
1135         case MIXER_WRITE(SOUND_MIXER_VOLUME):
1136         case MIXER_WRITE(SOUND_MIXER_IGAIN):
1137         case MIXER_WRITE(SOUND_MIXER_MONITOR):
1138                 ret = harmony_mixer_set_level(cmd & 0xff, val);
1139                 break;
1140
1141         case MIXER_READ(SOUND_MIXER_VOLUME):
1142         case MIXER_READ(SOUND_MIXER_IGAIN):
1143         case MIXER_READ(SOUND_MIXER_MONITOR):
1144                 ret = harmony_mixer_get_level(cmd & 0xff);
1145                 break;
1146
1147         default:
1148                 return -EINVAL;
1149         }
1150
1151         if (put_user(ret, (int *)arg))
1152                 return -EFAULT;
1153         return 0;
1154 }
1155
1156
1157 static int harmony_mixer_open(struct inode *inode, struct file *file)
1158 {
1159         if (harmony.mixer_open) 
1160                 return -EBUSY;
1161         harmony.mixer_open = 1;
1162         return 0;
1163 }
1164
1165 static int harmony_mixer_release(struct inode *inode, struct file *file)
1166 {
1167         if (!harmony.mixer_open) 
1168                 return -EBUSY;
1169         harmony.mixer_open = 0;
1170         return 0;
1171 }
1172
1173 static struct file_operations harmony_mixer_fops = {
1174         .owner          = THIS_MODULE,
1175         .llseek         = no_llseek,
1176         .open           = harmony_mixer_open,
1177         .release        = harmony_mixer_release,
1178         .ioctl          = harmony_mixer_ioctl,
1179 };
1180
1181
1182 /*
1183  * Mute all the output and reset Harmony.
1184  */
1185
1186 static void __init harmony_mixer_reset(void)
1187 {
1188         harmony.current_gain = GAIN_TOTAL_SILENCE;
1189         harmony_mixer_set_gain();
1190         harmony_wait_CNTL();
1191         gsc_writel(1, &harmony.hpa->reset);
1192         mdelay(50);             /* wait 50 ms */
1193         gsc_writel(0, &harmony.hpa->reset);
1194         harmony.current_gain = GAIN_DEFAULT;
1195         harmony_mixer_set_gain();
1196 }
1197
1198 static int __init harmony_mixer_init(void)
1199 {
1200         /* Register the device file operations */
1201         harmony.mixer_unit = register_sound_mixer(&harmony_mixer_fops, -1);
1202         if (harmony.mixer_unit < 0) {
1203                 printk(KERN_WARNING PFX "Error Registering Mixer Driver\n");
1204                 return -EFAULT;
1205         }
1206   
1207         harmony_mixer_reset();
1208         harmony.mixer_open = 0;
1209         
1210         return 0;
1211 }
1212
1213
1214
1215 /* 
1216  * This is the callback that's called by the inventory hardware code 
1217  * if it finds a match to the registered driver. 
1218  */
1219 static int __devinit
1220 harmony_driver_probe(struct parisc_device *dev)
1221 {
1222         u8      id;
1223         u8      rev;
1224         u32     cntl;
1225         int     ret;
1226
1227         if (harmony.hpa) {
1228                 /* We only support one Harmony at this time */
1229                 printk(KERN_ERR PFX "driver already registered\n");
1230                 return -EBUSY;
1231         }
1232
1233         if (!dev->irq) {
1234                 printk(KERN_ERR PFX "no irq found\n");
1235                 return -ENODEV;
1236         }
1237
1238         /* Set the HPA of harmony */
1239         harmony.hpa = (struct harmony_hpa *)dev->hpa.start;
1240         harmony.dev = dev;
1241
1242         /* Grab the ID and revision from the device */
1243         id = gsc_readb(&harmony.hpa->id);
1244         if ((id | 1) != 0x15) {
1245                 printk(KERN_WARNING PFX "wrong harmony id 0x%02x\n", id);
1246                 return -EBUSY;
1247         }
1248         cntl = gsc_readl(&harmony.hpa->cntl);
1249         rev = (cntl>>20) & 0xff;
1250
1251         printk(KERN_INFO "Lasi Harmony Audio driver " HARMONY_VERSION ", "
1252                         "h/w id %i, rev. %i at 0x%lx, IRQ %i\n",
1253                         id, rev, dev->hpa.start, harmony.dev->irq);
1254         
1255         /* Make sure the control bit isn't set, although I don't think it 
1256            ever is. */
1257         if (cntl & CNTL_C) {
1258                 printk(KERN_WARNING PFX "CNTL busy\n");
1259                 harmony.hpa = 0;
1260                 return -EBUSY;
1261         }
1262
1263         /* Initialize the memory buffers */
1264         if (harmony_alloc_buffer(&played_buf, MAX_BUFS) || 
1265             harmony_alloc_buffer(&recorded_buf, MAX_BUFS) ||
1266             harmony_alloc_buffer(&graveyard, 1) ||
1267             harmony_alloc_buffer(&silent, 1)) {
1268                 ret = -EBUSY;
1269                 goto out_err;
1270         }
1271
1272         /* Initialize /dev/mixer and /dev/audio  */
1273         if ((ret=harmony_mixer_init())) 
1274                 goto out_err;
1275         if ((ret=harmony_audio_init())) 
1276                 goto out_err;
1277
1278         return 0;
1279
1280 out_err:
1281         harmony.hpa = 0;
1282         harmony_free_buffer(&played_buf);
1283         harmony_free_buffer(&recorded_buf);
1284         harmony_free_buffer(&graveyard);
1285         harmony_free_buffer(&silent);
1286         return ret;
1287 }
1288
1289
1290 static struct parisc_device_id harmony_tbl[] = {
1291  /* { HPHW_FIO, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0007A }, Bushmaster/Flounder */
1292  { HPHW_FIO, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0007B }, /* 712/715 Audio */
1293  { HPHW_FIO, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0007E }, /* Pace Audio */
1294  { HPHW_FIO, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0007F }, /* Outfield / Coral II */
1295  { 0, }
1296 };
1297
1298 MODULE_DEVICE_TABLE(parisc, harmony_tbl);
1299
1300 static struct parisc_driver harmony_driver = {
1301         .name           = "Lasi Harmony",
1302         .id_table       = harmony_tbl,
1303         .probe          = harmony_driver_probe,
1304 };
1305
1306 static int __init init_harmony(void)
1307 {
1308         return register_parisc_driver(&harmony_driver);
1309 }
1310
1311 static void __exit cleanup_harmony(void)
1312 {
1313         free_irq(harmony.dev->irq, &harmony);
1314         unregister_sound_mixer(harmony.mixer_unit);
1315         unregister_sound_dsp(harmony.dsp_unit);
1316         harmony_free_buffer(&played_buf);
1317         harmony_free_buffer(&recorded_buf);
1318         harmony_free_buffer(&graveyard);
1319         harmony_free_buffer(&silent);
1320         unregister_parisc_driver(&harmony_driver);
1321 }
1322
1323
1324 MODULE_AUTHOR("Alex DeVries <alex@onefishtwo.ca>");
1325 MODULE_DESCRIPTION("Harmony sound driver");
1326 MODULE_LICENSE("GPL");
1327
1328 module_init(init_harmony);
1329 module_exit(cleanup_harmony);
1330