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"); 752