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