tree-wide: fix assorted typos all over the place
[linux-2.6.git] / sound / oss / dmasound / dmasound_paula.c
1 /*
2  *  linux/sound/oss/dmasound/dmasound_paula.c
3  *
4  *  Amiga `Paula' DMA Sound Driver
5  *
6  *  See linux/sound/oss/dmasound/dmasound_core.c for copyright and credits
7  *  prior to 28/01/2001
8  *
9  *  28/01/2001 [0.1] Iain Sandoe
10  *                   - added versioning
11  *                   - put in and populated the hardware_afmts field.
12  *             [0.2] - put in SNDCTL_DSP_GETCAPS value.
13  *             [0.3] - put in constraint on state buffer usage.
14  *             [0.4] - put in default hard/soft settings
15 */
16
17
18 #include <linux/module.h>
19 #include <linux/mm.h>
20 #include <linux/init.h>
21 #include <linux/ioport.h>
22 #include <linux/soundcard.h>
23 #include <linux/interrupt.h>
24
25 #include <asm/uaccess.h>
26 #include <asm/setup.h>
27 #include <asm/amigahw.h>
28 #include <asm/amigaints.h>
29 #include <asm/machdep.h>
30
31 #include "dmasound.h"
32
33 #define DMASOUND_PAULA_REVISION 0
34 #define DMASOUND_PAULA_EDITION 4
35
36 #define custom amiga_custom
37    /*
38     *   The minimum period for audio depends on htotal (for OCS/ECS/AGA)
39     *   (Imported from arch/m68k/amiga/amisound.c)
40     */
41
42 extern volatile u_short amiga_audio_min_period;
43
44
45    /*
46     *   amiga_mksound() should be able to restore the period after beeping
47     *   (Imported from arch/m68k/amiga/amisound.c)
48     */
49
50 extern u_short amiga_audio_period;
51
52
53    /*
54     *   Audio DMA masks
55     */
56
57 #define AMI_AUDIO_OFF   (DMAF_AUD0 | DMAF_AUD1 | DMAF_AUD2 | DMAF_AUD3)
58 #define AMI_AUDIO_8     (DMAF_SETCLR | DMAF_MASTER | DMAF_AUD0 | DMAF_AUD1)
59 #define AMI_AUDIO_14    (AMI_AUDIO_8 | DMAF_AUD2 | DMAF_AUD3)
60
61
62     /*
63      *  Helper pointers for 16(14)-bit sound
64      */
65
66 static int write_sq_block_size_half, write_sq_block_size_quarter;
67
68
69 /*** Low level stuff *********************************************************/
70
71
72 static void *AmiAlloc(unsigned int size, gfp_t flags);
73 static void AmiFree(void *obj, unsigned int size);
74 static int AmiIrqInit(void);
75 #ifdef MODULE
76 static void AmiIrqCleanUp(void);
77 #endif
78 static void AmiSilence(void);
79 static void AmiInit(void);
80 static int AmiSetFormat(int format);
81 static int AmiSetVolume(int volume);
82 static int AmiSetTreble(int treble);
83 static void AmiPlayNextFrame(int index);
84 static void AmiPlay(void);
85 static irqreturn_t AmiInterrupt(int irq, void *dummy);
86
87 #ifdef CONFIG_HEARTBEAT
88
89     /*
90      *  Heartbeat interferes with sound since the 7 kHz low-pass filter and the
91      *  power LED are controlled by the same line.
92      */
93
94 static void (*saved_heartbeat)(int) = NULL;
95
96 static inline void disable_heartbeat(void)
97 {
98         if (mach_heartbeat) {
99             saved_heartbeat = mach_heartbeat;
100             mach_heartbeat = NULL;
101         }
102         AmiSetTreble(dmasound.treble);
103 }
104
105 static inline void enable_heartbeat(void)
106 {
107         if (saved_heartbeat)
108             mach_heartbeat = saved_heartbeat;
109 }
110 #else /* !CONFIG_HEARTBEAT */
111 #define disable_heartbeat()     do { } while (0)
112 #define enable_heartbeat()      do { } while (0)
113 #endif /* !CONFIG_HEARTBEAT */
114
115
116 /*** Mid level stuff *********************************************************/
117
118 static void AmiMixerInit(void);
119 static int AmiMixerIoctl(u_int cmd, u_long arg);
120 static int AmiWriteSqSetup(void);
121 static int AmiStateInfo(char *buffer, size_t space);
122
123
124 /*** Translations ************************************************************/
125
126 /* ++TeSche: radically changed for new expanding purposes...
127  *
128  * These two routines now deal with copying/expanding/translating the samples
129  * from user space into our buffer at the right frequency. They take care about
130  * how much data there's actually to read, how much buffer space there is and
131  * to convert samples into the right frequency/encoding. They will only work on
132  * complete samples so it may happen they leave some bytes in the input stream
133  * if the user didn't write a multiple of the current sample size. They both
134  * return the number of bytes they've used from both streams so you may detect
135  * such a situation. Luckily all programs should be able to cope with that.
136  *
137  * I think I've optimized anything as far as one can do in plain C, all
138  * variables should fit in registers and the loops are really short. There's
139  * one loop for every possible situation. Writing a more generalized and thus
140  * parameterized loop would only produce slower code. Feel free to optimize
141  * this in assembler if you like. :)
142  *
143  * I think these routines belong here because they're not yet really hardware
144  * independent, especially the fact that the Falcon can play 16bit samples
145  * only in stereo is hardcoded in both of them!
146  *
147  * ++geert: split in even more functions (one per format)
148  */
149
150
151     /*
152      *  Native format
153      */
154
155 static ssize_t ami_ct_s8(const u_char __user *userPtr, size_t userCount,
156                          u_char frame[], ssize_t *frameUsed, ssize_t frameLeft)
157 {
158         ssize_t count, used;
159
160         if (!dmasound.soft.stereo) {
161                 void *p = &frame[*frameUsed];
162                 count = min_t(unsigned long, userCount, frameLeft) & ~1;
163                 used = count;
164                 if (copy_from_user(p, userPtr, count))
165                         return -EFAULT;
166         } else {
167                 u_char *left = &frame[*frameUsed>>1];
168                 u_char *right = left+write_sq_block_size_half;
169                 count = min_t(unsigned long, userCount, frameLeft)>>1 & ~1;
170                 used = count*2;
171                 while (count > 0) {
172                         if (get_user(*left++, userPtr++)
173                             || get_user(*right++, userPtr++))
174                                 return -EFAULT;
175                         count--;
176                 }
177         }
178         *frameUsed += used;
179         return used;
180 }
181
182
183     /*
184      *  Copy and convert 8 bit data
185      */
186
187 #define GENERATE_AMI_CT8(funcname, convsample)                          \
188 static ssize_t funcname(const u_char __user *userPtr, size_t userCount, \
189                         u_char frame[], ssize_t *frameUsed,             \
190                         ssize_t frameLeft)                              \
191 {                                                                       \
192         ssize_t count, used;                                            \
193                                                                         \
194         if (!dmasound.soft.stereo) {                                    \
195                 u_char *p = &frame[*frameUsed];                         \
196                 count = min_t(size_t, userCount, frameLeft) & ~1;       \
197                 used = count;                                           \
198                 while (count > 0) {                                     \
199                         u_char data;                                    \
200                         if (get_user(data, userPtr++))                  \
201                                 return -EFAULT;                         \
202                         *p++ = convsample(data);                        \
203                         count--;                                        \
204                 }                                                       \
205         } else {                                                        \
206                 u_char *left = &frame[*frameUsed>>1];                   \
207                 u_char *right = left+write_sq_block_size_half;          \
208                 count = min_t(size_t, userCount, frameLeft)>>1 & ~1;    \
209                 used = count*2;                                         \
210                 while (count > 0) {                                     \
211                         u_char data;                                    \
212                         if (get_user(data, userPtr++))                  \
213                                 return -EFAULT;                         \
214                         *left++ = convsample(data);                     \
215                         if (get_user(data, userPtr++))                  \
216                                 return -EFAULT;                         \
217                         *right++ = convsample(data);                    \
218                         count--;                                        \
219                 }                                                       \
220         }                                                               \
221         *frameUsed += used;                                             \
222         return used;                                                    \
223 }
224
225 #define AMI_CT_ULAW(x)  (dmasound_ulaw2dma8[(x)])
226 #define AMI_CT_ALAW(x)  (dmasound_alaw2dma8[(x)])
227 #define AMI_CT_U8(x)    ((x) ^ 0x80)
228
229 GENERATE_AMI_CT8(ami_ct_ulaw, AMI_CT_ULAW)
230 GENERATE_AMI_CT8(ami_ct_alaw, AMI_CT_ALAW)
231 GENERATE_AMI_CT8(ami_ct_u8, AMI_CT_U8)
232
233
234     /*
235      *  Copy and convert 16 bit data
236      */
237
238 #define GENERATE_AMI_CT_16(funcname, convsample)                        \
239 static ssize_t funcname(const u_char __user *userPtr, size_t userCount, \
240                         u_char frame[], ssize_t *frameUsed,             \
241                         ssize_t frameLeft)                              \
242 {                                                                       \
243         const u_short __user *ptr = (const u_short __user *)userPtr;    \
244         ssize_t count, used;                                            \
245         u_short data;                                                   \
246                                                                         \
247         if (!dmasound.soft.stereo) {                                    \
248                 u_char *high = &frame[*frameUsed>>1];                   \
249                 u_char *low = high+write_sq_block_size_half;            \
250                 count = min_t(size_t, userCount, frameLeft)>>1 & ~1;    \
251                 used = count*2;                                         \
252                 while (count > 0) {                                     \
253                         if (get_user(data, ptr++))                      \
254                                 return -EFAULT;                         \
255                         data = convsample(data);                        \
256                         *high++ = data>>8;                              \
257                         *low++ = (data>>2) & 0x3f;                      \
258                         count--;                                        \
259                 }                                                       \
260         } else {                                                        \
261                 u_char *lefth = &frame[*frameUsed>>2];                  \
262                 u_char *leftl = lefth+write_sq_block_size_quarter;      \
263                 u_char *righth = lefth+write_sq_block_size_half;        \
264                 u_char *rightl = righth+write_sq_block_size_quarter;    \
265                 count = min_t(size_t, userCount, frameLeft)>>2 & ~1;    \
266                 used = count*4;                                         \
267                 while (count > 0) {                                     \
268                         if (get_user(data, ptr++))                      \
269                                 return -EFAULT;                         \
270                         data = convsample(data);                        \
271                         *lefth++ = data>>8;                             \
272                         *leftl++ = (data>>2) & 0x3f;                    \
273                         if (get_user(data, ptr++))                      \
274                                 return -EFAULT;                         \
275                         data = convsample(data);                        \
276                         *righth++ = data>>8;                            \
277                         *rightl++ = (data>>2) & 0x3f;                   \
278                         count--;                                        \
279                 }                                                       \
280         }                                                               \
281         *frameUsed += used;                                             \
282         return used;                                                    \
283 }
284
285 #define AMI_CT_S16BE(x) (x)
286 #define AMI_CT_U16BE(x) ((x) ^ 0x8000)
287 #define AMI_CT_S16LE(x) (le2be16((x)))
288 #define AMI_CT_U16LE(x) (le2be16((x)) ^ 0x8000)
289
290 GENERATE_AMI_CT_16(ami_ct_s16be, AMI_CT_S16BE)
291 GENERATE_AMI_CT_16(ami_ct_u16be, AMI_CT_U16BE)
292 GENERATE_AMI_CT_16(ami_ct_s16le, AMI_CT_S16LE)
293 GENERATE_AMI_CT_16(ami_ct_u16le, AMI_CT_U16LE)
294
295
296 static TRANS transAmiga = {
297         .ct_ulaw        = ami_ct_ulaw,
298         .ct_alaw        = ami_ct_alaw,
299         .ct_s8          = ami_ct_s8,
300         .ct_u8          = ami_ct_u8,
301         .ct_s16be       = ami_ct_s16be,
302         .ct_u16be       = ami_ct_u16be,
303         .ct_s16le       = ami_ct_s16le,
304         .ct_u16le       = ami_ct_u16le,
305 };
306
307 /*** Low level stuff *********************************************************/
308
309 static inline void StopDMA(void)
310 {
311         custom.aud[0].audvol = custom.aud[1].audvol = 0;
312         custom.aud[2].audvol = custom.aud[3].audvol = 0;
313         custom.dmacon = AMI_AUDIO_OFF;
314         enable_heartbeat();
315 }
316
317 static void *AmiAlloc(unsigned int size, gfp_t flags)
318 {
319         return amiga_chip_alloc((long)size, "dmasound [Paula]");
320 }
321
322 static void AmiFree(void *obj, unsigned int size)
323 {
324         amiga_chip_free (obj);
325 }
326
327 static int __init AmiIrqInit(void)
328 {
329         /* turn off DMA for audio channels */
330         StopDMA();
331
332         /* Register interrupt handler. */
333         if (request_irq(IRQ_AMIGA_AUD0, AmiInterrupt, 0, "DMA sound",
334                         AmiInterrupt))
335                 return 0;
336         return 1;
337 }
338
339 #ifdef MODULE
340 static void AmiIrqCleanUp(void)
341 {
342         /* turn off DMA for audio channels */
343         StopDMA();
344         /* release the interrupt */
345         free_irq(IRQ_AMIGA_AUD0, AmiInterrupt);
346 }
347 #endif /* MODULE */
348
349 static void AmiSilence(void)
350 {
351         /* turn off DMA for audio channels */
352         StopDMA();
353 }
354
355
356 static void AmiInit(void)
357 {
358         int period, i;
359
360         AmiSilence();
361
362         if (dmasound.soft.speed)
363                 period = amiga_colorclock/dmasound.soft.speed-1;
364         else
365                 period = amiga_audio_min_period;
366         dmasound.hard = dmasound.soft;
367         dmasound.trans_write = &transAmiga;
368
369         if (period < amiga_audio_min_period) {
370                 /* we would need to squeeze the sound, but we won't do that */
371                 period = amiga_audio_min_period;
372         } else if (period > 65535) {
373                 period = 65535;
374         }
375         dmasound.hard.speed = amiga_colorclock/(period+1);
376
377         for (i = 0; i < 4; i++)
378                 custom.aud[i].audper = period;
379         amiga_audio_period = period;
380 }
381
382
383 static int AmiSetFormat(int format)
384 {
385         int size;
386
387         /* Amiga sound DMA supports 8bit and 16bit (pseudo 14 bit) modes */
388
389         switch (format) {
390         case AFMT_QUERY:
391                 return dmasound.soft.format;
392         case AFMT_MU_LAW:
393         case AFMT_A_LAW:
394         case AFMT_U8:
395         case AFMT_S8:
396                 size = 8;
397                 break;
398         case AFMT_S16_BE:
399         case AFMT_U16_BE:
400         case AFMT_S16_LE:
401         case AFMT_U16_LE:
402                 size = 16;
403                 break;
404         default: /* :-) */
405                 size = 8;
406                 format = AFMT_S8;
407         }
408
409         dmasound.soft.format = format;
410         dmasound.soft.size = size;
411         if (dmasound.minDev == SND_DEV_DSP) {
412                 dmasound.dsp.format = format;
413                 dmasound.dsp.size = dmasound.soft.size;
414         }
415         AmiInit();
416
417         return format;
418 }
419
420
421 #define VOLUME_VOXWARE_TO_AMI(v) \
422         (((v) < 0) ? 0 : ((v) > 100) ? 64 : ((v) * 64)/100)
423 #define VOLUME_AMI_TO_VOXWARE(v) ((v)*100/64)
424
425 static int AmiSetVolume(int volume)
426 {
427         dmasound.volume_left = VOLUME_VOXWARE_TO_AMI(volume & 0xff);
428         custom.aud[0].audvol = dmasound.volume_left;
429         dmasound.volume_right = VOLUME_VOXWARE_TO_AMI((volume & 0xff00) >> 8);
430         custom.aud[1].audvol = dmasound.volume_right;
431         if (dmasound.hard.size == 16) {
432                 if (dmasound.volume_left == 64 && dmasound.volume_right == 64) {
433                         custom.aud[2].audvol = 1;
434                         custom.aud[3].audvol = 1;
435                 } else {
436                         custom.aud[2].audvol = 0;
437                         custom.aud[3].audvol = 0;
438                 }
439         }
440         return VOLUME_AMI_TO_VOXWARE(dmasound.volume_left) |
441                (VOLUME_AMI_TO_VOXWARE(dmasound.volume_right) << 8);
442 }
443
444 static int AmiSetTreble(int treble)
445 {
446         dmasound.treble = treble;
447         if (treble < 50)
448                 ciaa.pra &= ~0x02;
449         else
450                 ciaa.pra |= 0x02;
451         return treble;
452 }
453
454
455 #define AMI_PLAY_LOADED         1
456 #define AMI_PLAY_PLAYING        2
457 #define AMI_PLAY_MASK           3
458
459
460 static void AmiPlayNextFrame(int index)
461 {
462         u_char *start, *ch0, *ch1, *ch2, *ch3;
463         u_long size;
464
465         /* used by AmiPlay() if all doubts whether there really is something
466          * to be played are already wiped out.
467          */
468         start = write_sq.buffers[write_sq.front];
469         size = (write_sq.count == index ? write_sq.rear_size
470                                         : write_sq.block_size)>>1;
471
472         if (dmasound.hard.stereo) {
473                 ch0 = start;
474                 ch1 = start+write_sq_block_size_half;
475                 size >>= 1;
476         } else {
477                 ch0 = start;
478                 ch1 = start;
479         }
480
481         disable_heartbeat();
482         custom.aud[0].audvol = dmasound.volume_left;
483         custom.aud[1].audvol = dmasound.volume_right;
484         if (dmasound.hard.size == 8) {
485                 custom.aud[0].audlc = (u_short *)ZTWO_PADDR(ch0);
486                 custom.aud[0].audlen = size;
487                 custom.aud[1].audlc = (u_short *)ZTWO_PADDR(ch1);
488                 custom.aud[1].audlen = size;
489                 custom.dmacon = AMI_AUDIO_8;
490         } else {
491                 size >>= 1;
492                 custom.aud[0].audlc = (u_short *)ZTWO_PADDR(ch0);
493                 custom.aud[0].audlen = size;
494                 custom.aud[1].audlc = (u_short *)ZTWO_PADDR(ch1);
495                 custom.aud[1].audlen = size;
496                 if (dmasound.volume_left == 64 && dmasound.volume_right == 64) {
497                         /* We can play pseudo 14-bit only with the maximum volume */
498                         ch3 = ch0+write_sq_block_size_quarter;
499                         ch2 = ch1+write_sq_block_size_quarter;
500                         custom.aud[2].audvol = 1;  /* we are being affected by the beeps */
501                         custom.aud[3].audvol = 1;  /* restoring volume here helps a bit */
502                         custom.aud[2].audlc = (u_short *)ZTWO_PADDR(ch2);
503                         custom.aud[2].audlen = size;
504                         custom.aud[3].audlc = (u_short *)ZTWO_PADDR(ch3);
505                         custom.aud[3].audlen = size;
506                         custom.dmacon = AMI_AUDIO_14;
507                 } else {
508                         custom.aud[2].audvol = 0;
509                         custom.aud[3].audvol = 0;
510                         custom.dmacon = AMI_AUDIO_8;
511                 }
512         }
513         write_sq.front = (write_sq.front+1) % write_sq.max_count;
514         write_sq.active |= AMI_PLAY_LOADED;
515 }
516
517
518 static void AmiPlay(void)
519 {
520         int minframes = 1;
521
522         custom.intena = IF_AUD0;
523
524         if (write_sq.active & AMI_PLAY_LOADED) {
525                 /* There's already a frame loaded */
526                 custom.intena = IF_SETCLR | IF_AUD0;
527                 return;
528         }
529
530         if (write_sq.active & AMI_PLAY_PLAYING)
531                 /* Increase threshold: frame 1 is already being played */
532                 minframes = 2;
533
534         if (write_sq.count < minframes) {
535                 /* Nothing to do */
536                 custom.intena = IF_SETCLR | IF_AUD0;
537                 return;
538         }
539
540         if (write_sq.count <= minframes &&
541             write_sq.rear_size < write_sq.block_size && !write_sq.syncing) {
542                 /* hmmm, the only existing frame is not
543                  * yet filled and we're not syncing?
544                  */
545                 custom.intena = IF_SETCLR | IF_AUD0;
546                 return;
547         }
548
549         AmiPlayNextFrame(minframes);
550
551         custom.intena = IF_SETCLR | IF_AUD0;
552 }
553
554
555 static irqreturn_t AmiInterrupt(int irq, void *dummy)
556 {
557         int minframes = 1;
558
559         custom.intena = IF_AUD0;
560
561         if (!write_sq.active) {
562                 /* Playing was interrupted and sq_reset() has already cleared
563                  * the sq variables, so better don't do anything here.
564                  */
565                 WAKE_UP(write_sq.sync_queue);
566                 return IRQ_HANDLED;
567         }
568
569         if (write_sq.active & AMI_PLAY_PLAYING) {
570                 /* We've just finished a frame */
571                 write_sq.count--;
572                 WAKE_UP(write_sq.action_queue);
573         }
574
575         if (write_sq.active & AMI_PLAY_LOADED)
576                 /* Increase threshold: frame 1 is already being played */
577                 minframes = 2;
578
579         /* Shift the flags */
580         write_sq.active = (write_sq.active<<1) & AMI_PLAY_MASK;
581
582         if (!write_sq.active)
583                 /* No frame is playing, disable audio DMA */
584                 StopDMA();
585
586         custom.intena = IF_SETCLR | IF_AUD0;
587
588         if (write_sq.count >= minframes)
589                 /* Try to play the next frame */
590                 AmiPlay();
591
592         if (!write_sq.active)
593                 /* Nothing to play anymore.
594                    Wake up a process waiting for audio output to drain. */
595                 WAKE_UP(write_sq.sync_queue);
596         return IRQ_HANDLED;
597 }
598
599 /*** Mid level stuff *********************************************************/
600
601
602 /*
603  * /dev/mixer abstraction
604  */
605
606 static void __init AmiMixerInit(void)
607 {
608         dmasound.volume_left = 64;
609         dmasound.volume_right = 64;
610         custom.aud[0].audvol = dmasound.volume_left;
611         custom.aud[3].audvol = 1;       /* For pseudo 14bit */
612         custom.aud[1].audvol = dmasound.volume_right;
613         custom.aud[2].audvol = 1;       /* For pseudo 14bit */
614         dmasound.treble = 50;
615 }
616
617 static int AmiMixerIoctl(u_int cmd, u_long arg)
618 {
619         int data;
620         switch (cmd) {
621             case SOUND_MIXER_READ_DEVMASK:
622                     return IOCTL_OUT(arg, SOUND_MASK_VOLUME | SOUND_MASK_TREBLE);
623             case SOUND_MIXER_READ_RECMASK:
624                     return IOCTL_OUT(arg, 0);
625             case SOUND_MIXER_READ_STEREODEVS:
626                     return IOCTL_OUT(arg, SOUND_MASK_VOLUME);
627             case SOUND_MIXER_READ_VOLUME:
628                     return IOCTL_OUT(arg,
629                             VOLUME_AMI_TO_VOXWARE(dmasound.volume_left) |
630                             VOLUME_AMI_TO_VOXWARE(dmasound.volume_right) << 8);
631             case SOUND_MIXER_WRITE_VOLUME:
632                     IOCTL_IN(arg, data);
633                     return IOCTL_OUT(arg, dmasound_set_volume(data));
634             case SOUND_MIXER_READ_TREBLE:
635                     return IOCTL_OUT(arg, dmasound.treble);
636             case SOUND_MIXER_WRITE_TREBLE:
637                     IOCTL_IN(arg, data);
638                     return IOCTL_OUT(arg, dmasound_set_treble(data));
639         }
640         return -EINVAL;
641 }
642
643
644 static int AmiWriteSqSetup(void)
645 {
646         write_sq_block_size_half = write_sq.block_size>>1;
647         write_sq_block_size_quarter = write_sq_block_size_half>>1;
648         return 0;
649 }
650
651
652 static int AmiStateInfo(char *buffer, size_t space)
653 {
654         int len = 0;
655         len += sprintf(buffer+len, "\tsound.volume_left = %d [0...64]\n",
656                        dmasound.volume_left);
657         len += sprintf(buffer+len, "\tsound.volume_right = %d [0...64]\n",
658                        dmasound.volume_right);
659         if (len >= space) {
660                 printk(KERN_ERR "dmasound_paula: overflowed state buffer alloc.\n") ;
661                 len = space ;
662         }
663         return len;
664 }
665
666
667 /*** Machine definitions *****************************************************/
668
669 static SETTINGS def_hard = {
670         .format = AFMT_S8,
671         .stereo = 0,
672         .size   = 8,
673         .speed  = 8000
674 } ;
675
676 static SETTINGS def_soft = {
677         .format = AFMT_U8,
678         .stereo = 0,
679         .size   = 8,
680         .speed  = 8000
681 } ;
682
683 static MACHINE machAmiga = {
684         .name           = "Amiga",
685         .name2          = "AMIGA",
686         .owner          = THIS_MODULE,
687         .dma_alloc      = AmiAlloc,
688         .dma_free       = AmiFree,
689         .irqinit        = AmiIrqInit,
690 #ifdef MODULE
691         .irqcleanup     = AmiIrqCleanUp,
692 #endif /* MODULE */
693         .init           = AmiInit,
694         .silence        = AmiSilence,
695         .setFormat      = AmiSetFormat,
696         .setVolume      = AmiSetVolume,
697         .setTreble      = AmiSetTreble,
698         .play           = AmiPlay,
699         .mixer_init     = AmiMixerInit,
700         .mixer_ioctl    = AmiMixerIoctl,
701         .write_sq_setup = AmiWriteSqSetup,
702         .state_info     = AmiStateInfo,
703         .min_dsp_speed  = 8000,
704         .version        = ((DMASOUND_PAULA_REVISION<<8) | DMASOUND_PAULA_EDITION),
705         .hardware_afmts = (AFMT_S8 | AFMT_S16_BE), /* h'ware-supported formats *only* here */
706         .capabilities   = DSP_CAP_BATCH          /* As per SNDCTL_DSP_GETCAPS */
707 };
708
709
710 /*** Config & Setup **********************************************************/
711
712
713 static int __init dmasound_paula_init(void)
714 {
715         int err;
716
717         if (MACH_IS_AMIGA && AMIGAHW_PRESENT(AMI_AUDIO)) {
718             if (!request_mem_region(CUSTOM_PHYSADDR+0xa0, 0x40,
719                                     "dmasound [Paula]"))
720                 return -EBUSY;
721             dmasound.mach = machAmiga;
722             dmasound.mach.default_hard = def_hard ;
723             dmasound.mach.default_soft = def_soft ;
724             err = dmasound_init();
725             if (err)
726                 release_mem_region(CUSTOM_PHYSADDR+0xa0, 0x40);
727             return err;
728         } else
729             return -ENODEV;
730 }
731
732 static void __exit dmasound_paula_cleanup(void)
733 {
734         dmasound_deinit();
735         release_mem_region(CUSTOM_PHYSADDR+0xa0, 0x40);
736 }
737
738 module_init(dmasound_paula_init);
739 module_exit(dmasound_paula_cleanup);
740 MODULE_LICENSE("GPL");