Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us