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 static int __init amiga_audio_init(void)
 737 {
 738         return platform_driver_probe(&amiga_audio_driver, amiga_audio_probe);
 739 }
 740
 741 module_init(amiga_audio_init);
 742
 743 static void __exit amiga_audio_exit(void)
 744 {
 745         platform_driver_unregister(&amiga_audio_driver);
 746 }
 747
 748 module_exit(amiga_audio_exit);
 749
 750 MODULE_LICENSE("GPL");
 751 MODULE_ALIAS("platform:amiga-audio");