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