sound/oss/dmasound/dmasound

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

DEFINITIONS
