1 /* 2 * linux/sound/oss/dmasound/dmasound_atari.c 3 * 4 * Atari TT and Falcon 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 * 01/02/2001 [0.3] - put in default hard/soft settings. 14 */ 15 16 17 #include <linux/module.h> 18 #include <linux/kernel.h> 19 #include <linux/init.h> 20 #include <linux/soundcard.h> 21 #include <linux/mm.h> 22 #include <linux/spinlock.h> 23 #include <linux/interrupt.h> 24 25 #include <asm/uaccess.h> 26 #include <asm/atariints.h> 27 #include <asm/atari_stram.h> 28 29 #include "dmasound.h" 30 31 #define DMASOUND_ATARI_REVISION 0 32 #define DMASOUND_ATARI_EDITION 3 33 34 extern void atari_microwire_cmd(int cmd); 35 36 static int is_falcon; 37 static int write_sq_ignore_int; /* ++TeSche: used for Falcon */ 38 39 static int expand_bal; /* Balance factor for expanding (not volume!) */ 40 static int expand_data; /* Data for expanding */ 41 42 43 /*** Translations ************************************************************/ 44 45 46 /* ++TeSche: radically changed for new expanding purposes... 47 * 48 * These two routines now deal with copying/expanding/translating the samples 49 * from user space into our buffer at the right frequency. They take care about 50 * how much data there's actually to read, how much buffer space there is and 51 * to convert samples into the right frequency/encoding. They will only work on 52 * complete samples so it may happen they leave some bytes in the input stream 53 * if the user didn't write a multiple of the current sample size. They both 54 * return the number of bytes they've used from both streams so you may detect 55 * such a situation. Luckily all programs should be able to cope with that. 56 * 57 * I think I've optimized anything as far as one can do in plain C, all 58 * variables should fit in registers and the loops are really short. There's 59 * one loop for every possible situation. Writing a more generalized and thus 60 * parameterized loop would only produce slower code. Feel free to optimize 61 * this in assembler if you like. :) 62 * 63 * I think these routines belong here because they're not yet really hardware 64 * independent, especially the fact that the Falcon can play 16bit samples 65 * only in stereo is hardcoded in both of them! 66 * 67 * ++geert: split in even more functions (one per format) 68 */ 69 70 static ssize_t ata_ct_law(const u_char __user *userPtr, size_t userCount, 71 u_char frame[], ssize_t *frameUsed, 72 ssize_t frameLeft); 73 static ssize_t ata_ct_s8(const u_char __user *userPtr, size_t userCount, 74 u_char frame[], ssize_t *frameUsed, 75 ssize_t frameLeft); 76 static ssize_t ata_ct_u8(const u_char __user *userPtr, size_t userCount, 77 u_char frame[], ssize_t *frameUsed, 78 ssize_t frameLeft); 79 static ssize_t ata_ct_s16be(const u_char __user *userPtr, size_t userCount, 80 u_char frame[], ssize_t *frameUsed, 81 ssize_t frameLeft); 82 static ssize_t ata_ct_u16be(const u_char __user *userPtr, size_t userCount, 83 u_char frame[], ssize_t *frameUsed, 84 ssize_t frameLeft); 85 static ssize_t ata_ct_s16le(const u_char __user *userPtr, size_t userCount, 86 u_char frame[], ssize_t *frameUsed, 87 ssize_t frameLeft); 88 static ssize_t ata_ct_u16le(const u_char __user *userPtr, size_t userCount, 89 u_char frame[], ssize_t *frameUsed, 90 ssize_t frameLeft); 91 static ssize_t ata_ctx_law(const u_char __user *userPtr, size_t userCount, 92 u_char frame[], ssize_t *frameUsed, 93 ssize_t frameLeft); 94 static ssize_t ata_ctx_s8(const u_char __user *userPtr, size_t userCount, 95 u_char frame[], ssize_t *frameUsed, 96 ssize_t frameLeft); 97 static ssize_t ata_ctx_u8(const u_char __user *userPtr, size_t userCount, 98 u_char frame[], ssize_t *frameUsed, 99 ssize_t frameLeft); 100 static ssize_t ata_ctx_s16be(const u_char __user *userPtr, size_t userCount, 101 u_char frame[], ssize_t *frameUsed, 102 ssize_t frameLeft); 103 static ssize_t ata_ctx_u16be(const u_char __user *userPtr, size_t userCount, 104 u_char frame[], ssize_t *frameUsed, 105 ssize_t frameLeft); 106 static ssize_t ata_ctx_s16le(const u_char __user *userPtr, size_t userCount, 107 u_char frame[], ssize_t *frameUsed, 108 ssize_t frameLeft); 109 static ssize_t ata_ctx_u16le(const u_char __user *userPtr, size_t userCount, 110 u_char frame[], ssize_t *frameUsed, 111 ssize_t frameLeft); 112 113 114 /*** Low level stuff *********************************************************/ 115 116 117 static void *AtaAlloc(unsigned int size, gfp_t flags); 118 static void AtaFree(void *, unsigned int size); 119 static int AtaIrqInit(void); 120 #ifdef MODULE 121 static void AtaIrqCleanUp(void); 122 #endif /* MODULE */ 123 static int AtaSetBass(int bass); 124 static int AtaSetTreble(int treble); 125 static void TTSilence(void); 126 static void TTInit(void); 127 static int TTSetFormat(int format); 128 static int TTSetVolume(int volume); 129 static int TTSetGain(int gain); 130 static void FalconSilence(void); 131 static void FalconInit(void); 132 static int FalconSetFormat(int format); 133 static int FalconSetVolume(int volume); 134 static void AtaPlayNextFrame(int index); 135 static void AtaPlay(void); 136 static irqreturn_t AtaInterrupt(int irq, void *dummy); 137 138 /*** Mid level stuff *********************************************************/ 139 140 static void TTMixerInit(void); 141 static void FalconMixerInit(void); 142 static int AtaMixerIoctl(u_int cmd, u_long arg); 143 static int TTMixerIoctl(u_int cmd, u_long arg); 144 static int FalconMixerIoctl(u_int cmd, u_long arg); 145 static int AtaWriteSqSetup(void); 146 static int AtaSqOpen(mode_t mode); 147 static int TTStateInfo(char *buffer, size_t space); 148 static int FalconStateInfo(char *buffer, size_t space); 149 150 151 /*** Translations ************************************************************/ 152 153 154 static ssize_t ata_ct_law(const u_char __user *userPtr, size_t userCount, 155 u_char frame[], ssize_t *frameUsed, 156 ssize_t frameLeft) 157 { 158 char *table = dmasound.soft.format == AFMT_MU_LAW ? dmasound_ulaw2dma8 159 : dmasound_alaw2dma8; 160 ssize_t count, used; 161 u_char *p = &frame[*frameUsed]; 162 163 count = min_t(unsigned long, userCount, frameLeft); 164 if (dmasound.soft.stereo) 165 count &= ~1; 166 used = count; 167 while (count > 0) { 168 u_char data; 169 if (get_user(data, userPtr++)) 170 return -EFAULT; 171 *p++ = table[data]; 172 count--; 173 } 174 *frameUsed += used; 175 return used; 176 } 177 178 179 static ssize_t ata_ct_s8(const u_char __user *userPtr, size_t userCount, 180 u_char frame[], ssize_t *frameUsed, 181 ssize_t frameLeft) 182 { 183 ssize_t count, used; 184 void *p = &frame[*frameUsed]; 185 186 count = min_t(unsigned long, userCount, frameLeft); 187 if (dmasound.soft.stereo) 188 count &= ~1; 189 used = count; 190 if (copy_from_user(p, userPtr, count)) 191 return -EFAULT; 192 *frameUsed += used; 193 return used; 194 } 195 196 197 static ssize_t ata_ct_u8(const u_char __user *userPtr, size_t userCount, 198 u_char frame[], ssize_t *frameUsed, 199 ssize_t frameLeft) 200 { 201 ssize_t count, used; 202 203 if (!dmasound.soft.stereo) { 204 u_char *p = &frame[*frameUsed]; 205 count = min_t(unsigned long, userCount, frameLeft); 206 used = count; 207 while (count > 0) { 208 u_char data; 209 if (get_user(data, userPtr++)) 210 return -EFAULT; 211 *p++ = data ^ 0x80; 212 count--; 213 } 214 } else { 215 u_short *p = (u_short *)&frame[*frameUsed]; 216 count = min_t(unsigned long, userCount, frameLeft)>>1; 217 used = count*2; 218 while (count > 0) { 219 u_short data; 220 if (get_user(data, (u_short __user *)userPtr)) 221 return -EFAULT; 222 userPtr += 2; 223 *p++ = data ^ 0x8080; 224 count--; 225 } 226 } 227 *frameUsed += used; 228 return used; 229 } 230 231 232 static ssize_t ata_ct_s16be(const u_char __user *userPtr, size_t userCount, 233 u_char frame[], ssize_t *frameUsed, 234 ssize_t frameLeft) 235 { 236 ssize_t count, used; 237 238 if (!dmasound.soft.stereo) { 239 u_short *p = (u_short *)&frame[*frameUsed]; 240 count = min_t(unsigned long, userCount, frameLeft)>>1; 241 used = count*2; 242 while (count > 0) { 243 u_short data; 244 if (get_user(data, (u_short __user *)userPtr)) 245 return -EFAULT; 246 userPtr += 2; 247 *p++ = data; 248 *p++ = data; 249 count--; 250 } 251 *frameUsed += used*2; 252 } else { 253 void *p = (u_short *)&frame[*frameUsed]; 254 count = min_t(unsigned long, userCount, frameLeft) & ~3; 255 used = count; 256 if (copy_from_user(p, userPtr, count)) 257 return -EFAULT; 258 *frameUsed += used; 259 } 260 return used; 261 } 262 263 264 static ssize_t ata_ct_u16be(const u_char __user *userPtr, size_t userCount, 265 u_char frame[], ssize_t *frameUsed, 266 ssize_t frameLeft) 267 { 268 ssize_t count, used; 269 270 if (!dmasound.soft.stereo) { 271 u_short *p = (u_short *)&frame[*frameUsed]; 272 count = min_t(unsigned long, userCount, frameLeft)>>1; 273 used = count*2; 274 while (count > 0) { 275 u_short data; 276 if (get_user(data, (u_short __user *)userPtr)) 277 return -EFAULT; 278 userPtr += 2; 279 data ^= 0x8000; 280 *p++ = data; 281 *p++ = data; 282 count--; 283 } 284 *frameUsed += used*2; 285 } else { 286 u_long *p = (u_long *)&frame[*frameUsed]; 287 count = min_t(unsigned long, userCount, frameLeft)>>2; 288 used = count*4; 289 while (count > 0) { 290 u_int data; 291 if (get_user(data, (u_int __user *)userPtr)) 292 return -EFAULT; 293 userPtr += 4; 294 *p++ = data ^ 0x80008000; 295 count--; 296 } 297 *frameUsed += used; 298 } 299 return used; 300 } 301 302 303 static ssize_t ata_ct_s16le(const u_char __user *userPtr, size_t userCount, 304 u_char frame[], ssize_t *frameUsed, 305 ssize_t frameLeft) 306 { 307 ssize_t count, used; 308 309 count = frameLeft; 310 if (!dmasound.soft.stereo) { 311 u_short *p = (u_short *)&frame[*frameUsed]; 312 count = min_t(unsigned long, userCount, frameLeft)>>1; 313 used = count*2; 314 while (count > 0) { 315 u_short data; 316 if (get_user(data, (u_short __user *)userPtr)) 317 return -EFAULT; 318 userPtr += 2; 319 data = le2be16(data); 320 *p++ = data; 321 *p++ = data; 322 count--; 323 } 324 *frameUsed += used*2; 325 } else { 326 u_long *p = (u_long *)&frame[*frameUsed]; 327 count = min_t(unsigned long, userCount, frameLeft)>>2; 328 used = count*4; 329 while (count > 0) { 330 u_long data; 331 if (get_user(data, (u_int __user *)userPtr)) 332 return -EFAULT; 333 userPtr += 4; 334 data = le2be16dbl(data); 335 *p++ = data; 336 count--; 337 } 338 *frameUsed += used; 339 } 340 return used; 341 } 342 343 344 static ssize_t ata_ct_u16le(const u_char __user *userPtr, size_t userCount, 345 u_char frame[], ssize_t *frameUsed, 346 ssize_t frameLeft) 347 { 348 ssize_t count, used; 349 350 count = frameLeft; 351 if (!dmasound.soft.stereo) { 352 u_short *p = (u_short *)&frame[*frameUsed]; 353 count = min_t(unsigned long, userCount, frameLeft)>>1; 354 used = count*2; 355 while (count > 0) { 356 u_short data; 357 if (get_user(data, (u_short __user *)userPtr)) 358 return -EFAULT; 359 userPtr += 2; 360 data = le2be16(data) ^ 0x8000; 361 *p++ = data; 362 *p++ = data; 363 } 364 *frameUsed += used*2; 365 } else { 366 u_long *p = (u_long *)&frame[*frameUsed]; 367 count = min_t(unsigned long, userCount, frameLeft)>>2; 368 used = count; 369 while (count > 0) { 370 u_long data; 371 if (get_user(data, (u_int __user *)userPtr)) 372 return -EFAULT; 373 userPtr += 4; 374 data = le2be16dbl(data) ^ 0x80008000; 375 *p++ = data; 376 count--; 377 } 378 *frameUsed += used; 379 } 380 return used; 381 } 382 383 384 static ssize_t ata_ctx_law(const u_char __user *userPtr, size_t userCount, 385 u_char frame[], ssize_t *frameUsed, 386 ssize_t frameLeft) 387 { 388 char *table = dmasound.soft.format == AFMT_MU_LAW ? dmasound_ulaw2dma8 389 : dmasound_alaw2dma8; 390 /* this should help gcc to stuff everything into registers */ 391 long bal = expand_bal; 392 long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed; 393 ssize_t used, usedf; 394 395 used = userCount; 396 usedf = frameLeft; 397 if (!dmasound.soft.stereo) { 398 u_char *p = &frame[*frameUsed]; 399 u_char data = expand_data; 400 while (frameLeft) { 401 u_char c; 402 if (bal < 0) { 403 if (!userCount) 404 break; 405 if (get_user(c, userPtr++)) 406 return -EFAULT; 407 data = table[c]; 408 userCount--; 409 bal += hSpeed; 410 } 411 *p++ = data; 412 frameLeft--; 413 bal -= sSpeed; 414 } 415 expand_data = data; 416 } else { 417 u_short *p = (u_short *)&frame[*frameUsed]; 418 u_short data = expand_data; 419 while (frameLeft >= 2) { 420 u_char c; 421 if (bal < 0) { 422 if (userCount < 2) 423 break; 424 if (get_user(c, userPtr++)) 425 return -EFAULT; 426 data = table[c] << 8; 427 if (get_user(c, userPtr++)) 428 return -EFAULT; 429 data |= table[c]; 430 userCount -= 2; 431 bal += hSpeed; 432 } 433 *p++ = data; 434 frameLeft -= 2; 435 bal -= sSpeed; 436 } 437 expand_data = data; 438 } 439 expand_bal = bal; 440 used -= userCount; 441 *frameUsed += usedf-frameLeft; 442 return used; 443 } 444 445 446 static ssize_t ata_ctx_s8(const u_char __user *userPtr, size_t userCount, 447 u_char frame[], ssize_t *frameUsed, 448 ssize_t frameLeft) 449 { 450 /* this should help gcc to stuff everything into registers */ 451 long bal = expand_bal; 452 long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed; 453 ssize_t used, usedf; 454 455 used = userCount; 456 usedf = frameLeft; 457 if (!dmasound.soft.stereo) { 458 u_char *p = &frame[*frameUsed]; 459 u_char data = expand_data; 460 while (frameLeft) { 461 if (bal < 0) { 462 if (!userCount) 463 break; 464 if (get_user(data, userPtr++)) 465 return -EFAULT; 466 userCount--; 467 bal += hSpeed; 468 } 469 *p++ = data; 470 frameLeft--; 471 bal -= sSpeed; 472 } 473 expand_data = data; 474 } else { 475 u_short *p = (u_short *)&frame[*frameUsed]; 476 u_short data = expand_data; 477 while (frameLeft >= 2) { 478 if (bal < 0) { 479 if (userCount < 2) 480 break; 481 if (get_user(data, (u_short __user *)userPtr)) 482 return -EFAULT; 483 userPtr += 2; 484 userCount -= 2; 485 bal += hSpeed; 486 } 487 *p++ = data; 488 frameLeft -= 2; 489 bal -= sSpeed; 490 } 491 expand_data = data; 492 } 493 expand_bal = bal; 494 used -= userCount; 495 *frameUsed += usedf-frameLeft; 496 return used; 497 } 498 499 500 static ssize_t ata_ctx_u8(const u_char __user *userPtr, size_t userCount, 501 u_char frame[], ssize_t *frameUsed, 502 ssize_t frameLeft) 503 { 504 /* this should help gcc to stuff everything into registers */ 505 long bal = expand_bal; 506 long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed; 507 ssize_t used, usedf; 508 509 used = userCount; 510 usedf = frameLeft; 511 if (!dmasound.soft.stereo) { 512 u_char *p = &frame[*frameUsed]; 513 u_char data = expand_data; 514 while (frameLeft) { 515 if (bal < 0) { 516 if (!userCount) 517 break; 518 if (get_user(data, userPtr++)) 519 return -EFAULT; 520 data ^= 0x80; 521 userCount--; 522 bal += hSpeed; 523 } 524 *p++ = data; 525 frameLeft--; 526 bal -= sSpeed; 527 } 528 expand_data = data; 529 } else { 530 u_short *p = (u_short *)&frame[*frameUsed]; 531 u_short data = expand_data; 532 while (frameLeft >= 2) { 533 if (bal < 0) { 534 if (userCount < 2) 535 break; 536 if (get_user(data, (u_short __user *)userPtr)) 537 return -EFAULT; 538 userPtr += 2; 539 data ^= 0x8080; 540 userCount -= 2; 541 bal += hSpeed; 542 } 543 *p++ = data; 544 frameLeft -= 2; 545 bal -= sSpeed; 546 } 547 expand_data = data; 548 } 549 expand_bal = bal; 550 used -= userCount; 551 *frameUsed += usedf-frameLeft; 552 return used; 553 } 554 555 556 static ssize_t ata_ctx_s16be(const u_char __user *userPtr, size_t userCount, 557 u_char frame[], ssize_t *frameUsed, 558 ssize_t frameLeft) 559 { 560 /* this should help gcc to stuff everything into registers */ 561 long bal = expand_bal; 562 long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed; 563 ssize_t used, usedf; 564 565 used = userCount; 566 usedf = frameLeft; 567 if (!dmasound.soft.stereo) { 568 u_short *p = (u_short *)&frame[*frameUsed]; 569 u_short data = expand_data; 570 while (frameLeft >= 4) { 571 if (bal < 0) { 572 if (userCount < 2) 573 break; 574 if (get_user(data, (u_short __user *)userPtr)) 575 return -EFAULT; 576 userPtr += 2; 577 userCount -= 2; 578 bal += hSpeed; 579 } 580 *p++ = data; 581 *p++ = data; 582 frameLeft -= 4; 583 bal -= sSpeed; 584 } 585 expand_data = data; 586 } else { 587 u_long *p = (u_long *)&frame[*frameUsed]; 588 u_long data = expand_data; 589 while (frameLeft >= 4) { 590 if (bal < 0) { 591 if (userCount < 4) 592 break; 593 if (get_user(data, (u_int __user *)userPtr)) 594 return -EFAULT; 595 userPtr += 4; 596 userCount -= 4; 597 bal += hSpeed; 598 } 599 *p++ = data; 600 frameLeft -= 4; 601 bal -= sSpeed; 602 } 603 expand_data = data; 604 } 605 expand_bal = bal; 606 used -= userCount; 607 *frameUsed += usedf-frameLeft; 608 return used; 609 } 610 611 612 static ssize_t ata_ctx_u16be(const u_char __user *userPtr, size_t userCount, 613 u_char frame[], ssize_t *frameUsed, 614 ssize_t frameLeft) 615 { 616 /* this should help gcc to stuff everything into registers */ 617 long bal = expand_bal; 618 long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed; 619 ssize_t used, usedf; 620 621 used = userCount; 622 usedf = frameLeft; 623 if (!dmasound.soft.stereo) { 624 u_short *p = (u_short *)&frame[*frameUsed]; 625 u_short data = expand_data; 626 while (frameLeft >= 4) { 627 if (bal < 0) { 628 if (userCount < 2) 629 break; 630 if (get_user(data, (u_short __user *)userPtr)) 631 return -EFAULT; 632 userPtr += 2; 633 data ^= 0x8000; 634 userCount -= 2; 635 bal += hSpeed; 636 } 637 *p++ = data; 638 *p++ = data; 639 frameLeft -= 4; 640 bal -= sSpeed; 641 } 642 expand_data = data; 643 } else { 644 u_long *p = (u_long *)&frame[*frameUsed]; 645 u_long data = expand_data; 646 while (frameLeft >= 4) { 647 if (bal < 0) { 648 if (userCount < 4) 649 break; 650 if (get_user(data, (u_int __user *)userPtr)) 651 return -EFAULT; 652 userPtr += 4; 653 data ^= 0x80008000; 654 userCount -= 4; 655 bal += hSpeed; 656 } 657 *p++ = data; 658 frameLeft -= 4; 659 bal -= sSpeed; 660 } 661 expand_data = data; 662 } 663 expand_bal = bal; 664 used -= userCount; 665 *frameUsed += usedf-frameLeft; 666 return used; 667 } 668 669 670 static ssize_t ata_ctx_s16le(const u_char __user *userPtr, size_t userCount, 671 u_char frame[], ssize_t *frameUsed, 672 ssize_t frameLeft) 673 { 674 /* this should help gcc to stuff everything into registers */ 675 long bal = expand_bal; 676 long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed; 677 ssize_t used, usedf; 678 679 used = userCount; 680 usedf = frameLeft; 681 if (!dmasound.soft.stereo) { 682 u_short *p = (u_short *)&frame[*frameUsed]; 683 u_short data = expand_data; 684 while (frameLeft >= 4) { 685 if (bal < 0) { 686 if (userCount < 2) 687 break; 688 if (get_user(data, (u_short __user *)userPtr)) 689 return -EFAULT; 690 userPtr += 2; 691 data = le2be16(data); 692 userCount -= 2; 693 bal += hSpeed; 694 } 695 *p++ = data; 696 *p++ = data; 697 frameLeft -= 4; 698 bal -= sSpeed; 699 } 700 expand_data = data; 701 } else { 702 u_long *p = (u_long *)&frame[*frameUsed]; 703 u_long data = expand_data; 704 while (frameLeft >= 4) { 705 if (bal < 0) { 706 if (userCount < 4) 707 break; 708 if (get_user(data, (u_int __user *)userPtr)) 709 return -EFAULT; 710 userPtr += 4; 711 data = le2be16dbl(data); 712 userCount -= 4; 713 bal += hSpeed; 714 } 715 *p++ = data; 716 frameLeft -= 4; 717 bal -= sSpeed; 718 } 719 expand_data = data; 720 } 721 expand_bal = bal; 722 used -= userCount; 723 *frameUsed += usedf-frameLeft; 724 return used; 725 } 726 727 728 static ssize_t ata_ctx_u16le(const u_char __user *userPtr, size_t userCount, 729 u_char frame[], ssize_t *frameUsed, 730 ssize_t frameLeft) 731 { 732 /* this should help gcc to stuff everything into registers */ 733 long bal = expand_bal; 734 long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed; 735 ssize_t used, usedf; 736 737 used = userCount; 738 usedf = frameLeft; 739 if (!dmasound.soft.stereo) { 740 u_short *p = (u_short *)&frame[*frameUsed]; 741 u_short data = expand_data; 742 while (frameLeft >= 4) { 743 if (bal < 0) { 744 if (userCount < 2) 745 break; 746 if (get_user(data, (u_short __user *)userPtr)) 747 return -EFAULT; 748 userPtr += 2; 749 data = le2be16(data) ^ 0x8000; 750 userCount -= 2; 751 bal += hSpeed; 752 } 753 *p++ = data; 754 *p++ = data; 755 frameLeft -= 4; 756 bal -= sSpeed; 757 } 758 expand_data = data; 759 } else { 760 u_long *p = (u_long *)&frame[*frameUsed]; 761 u_long data = expand_data; 762 while (frameLeft >= 4) { 763 if (bal < 0) { 764 if (userCount < 4) 765 break; 766 if (get_user(data, (u_int __user *)userPtr)) 767 return -EFAULT; 768 userPtr += 4; 769 data = le2be16dbl(data) ^ 0x80008000; 770 userCount -= 4; 771 bal += hSpeed; 772 } 773 *p++ = data; 774 frameLeft -= 4; 775 bal -= sSpeed; 776 } 777 expand_data = data; 778 } 779 expand_bal = bal; 780 used -= userCount; 781 *frameUsed += usedf-frameLeft; 782 return used; 783 } 784 785 786 static TRANS transTTNormal = { 787 .ct_ulaw = ata_ct_law, 788 .ct_alaw = ata_ct_law, 789 .ct_s8 = ata_ct_s8, 790 .ct_u8 = ata_ct_u8, 791 }; 792 793 static TRANS transTTExpanding = { 794 .ct_ulaw = ata_ctx_law, 795 .ct_alaw = ata_ctx_law, 796 .ct_s8 = ata_ctx_s8, 797 .ct_u8 = ata_ctx_u8, 798 }; 799 800 static TRANS transFalconNormal = { 801 .ct_ulaw = ata_ct_law, 802 .ct_alaw = ata_ct_law, 803 .ct_s8 = ata_ct_s8, 804 .ct_u8 = ata_ct_u8, 805 .ct_s16be = ata_ct_s16be, 806 .ct_u16be = ata_ct_u16be, 807 .ct_s16le = ata_ct_s16le, 808 .ct_u16le = ata_ct_u16le 809 }; 810 811 static TRANS transFalconExpanding = { 812 .ct_ulaw = ata_ctx_law, 813 .ct_alaw = ata_ctx_law, 814 .ct_s8 = ata_ctx_s8, 815 .ct_u8 = ata_ctx_u8, 816 .ct_s16be = ata_ctx_s16be, 817 .ct_u16be = ata_ctx_u16be, 818 .ct_s16le = ata_ctx_s16le, 819 .ct_u16le = ata_ctx_u16le, 820 }; 821 822 823 /*** Low level stuff *********************************************************/ 824 825 826 827 /* 828 * Atari (TT/Falcon) 829 */ 830 831 static void *AtaAlloc(unsigned int size, gfp_t flags) 832 { 833 return atari_stram_alloc(size, "dmasound"); 834 } 835 836 static void AtaFree(void *obj, unsigned int size) 837 { 838 atari_stram_free( obj ); 839 } 840 841 static int __init AtaIrqInit(void) 842 { 843 /* Set up timer A. Timer A 844 will receive a signal upon end of playing from the sound 845 hardware. Furthermore Timer A is able to count events 846 and will cause an interrupt after a programmed number 847 of events. So all we need to keep the music playing is 848 to provide the sound hardware with new data upon 849 an interrupt from timer A. */ 850 mfp.tim_ct_a = 0; /* ++roman: Stop timer before programming! */ 851 mfp.tim_dt_a = 1; /* Cause interrupt after first event. */ 852 mfp.tim_ct_a = 8; /* Turn on event counting. */ 853 /* Register interrupt handler. */ 854 request_irq(IRQ_MFP_TIMA, AtaInterrupt, IRQ_TYPE_SLOW, "DMA sound", 855 AtaInterrupt); 856 mfp.int_en_a |= 0x20; /* Turn interrupt on. */ 857 mfp.int_mk_a |= 0x20; 858 return 1; 859 } 860 861 #ifdef MODULE 862 static void AtaIrqCleanUp(void) 863 { 864 mfp.tim_ct_a = 0; /* stop timer */ 865 mfp.int_en_a &= ~0x20; /* turn interrupt off */ 866 free_irq(IRQ_MFP_TIMA, AtaInterrupt); 867 } 868 #endif /* MODULE */ 869 870 871 #define TONE_VOXWARE_TO_DB(v) \ 872 (((v) < 0) ? -12 : ((v) > 100) ? 12 : ((v) - 50) * 6 / 25) 873 #define TONE_DB_TO_VOXWARE(v) (((v) * 25 + ((v) > 0 ? 5 : -5)) / 6 + 50) 874 875 876 static int AtaSetBass(int bass) 877 { 878 dmasound.bass = TONE_VOXWARE_TO_DB(bass); 879 atari_microwire_cmd(MW_LM1992_BASS(dmasound.bass)); 880 return TONE_DB_TO_VOXWARE(dmasound.bass); 881 } 882 883 884 static int AtaSetTreble(int treble) 885 { 886 dmasound.treble = TONE_VOXWARE_TO_DB(treble); 887 atari_microwire_cmd(MW_LM1992_TREBLE(dmasound.treble)); 888 return TONE_DB_TO_VOXWARE(dmasound.treble); 889 } 890 891 892 893 /* 894 * TT 895 */ 896 897 898 static void TTSilence(void) 899 { 900 tt_dmasnd.ctrl = DMASND_CTRL_OFF; 901 atari_microwire_cmd(MW_LM1992_PSG_HIGH); /* mix in PSG signal 1:1 */ 902 } 903 904 905 static void TTInit(void) 906 { 907 int mode, i, idx; 908 const int freq[4] = {50066, 25033, 12517, 6258}; 909 910 /* search a frequency that fits into the allowed error range */ 911 912 idx = -1; 913 for (i = 0; i < ARRAY_SIZE(freq); i++) 914 /* this isn't as much useful for a TT than for a Falcon, but 915 * then it doesn't hurt very much to implement it for a TT too. 916 */ 917 if ((100 * abs(dmasound.soft.speed - freq[i]) / freq[i]) < catchRadius) 918 idx = i; 919 if (idx > -1) { 920 dmasound.soft.speed = freq[idx]; 921 dmasound.trans_write = &transTTNormal; 922 } else 923 dmasound.trans_write = &transTTExpanding; 924 925 TTSilence(); 926 dmasound.hard = dmasound.soft; 927 928 if (dmasound.hard.speed > 50066) { 929 /* we would need to squeeze the sound, but we won't do that */ 930 dmasound.hard.speed = 50066; 931 mode = DMASND_MODE_50KHZ; 932 dmasound.trans_write = &transTTNormal; 933 } else if (dmasound.hard.speed > 25033) { 934 dmasound.hard.speed = 50066; 935 mode = DMASND_MODE_50KHZ; 936 } else if (dmasound.hard.speed > 12517) { 937 dmasound.hard.speed = 25033; 938 mode = DMASND_MODE_25KHZ; 939 } else if (dmasound.hard.speed > 6258) { 940 dmasound.hard.speed = 12517; 941 mode = DMASND_MODE_12KHZ; 942 } else { 943 dmasound.hard.speed = 6258; 944 mode = DMASND_MODE_6KHZ; 945 } 946 947 tt_dmasnd.mode = (dmasound.hard.stereo ? 948 DMASND_MODE_STEREO : DMASND_MODE_MONO) | 949 DMASND_MODE_8BIT | mode; 950 951 expand_bal = -dmasound.soft.speed; 952 } 953 954 955 static int TTSetFormat(int format) 956 { 957 /* TT sound DMA supports only 8bit modes */ 958 959 switch (format) { 960 case AFMT_QUERY: 961 return dmasound.soft.format; 962 case AFMT_MU_LAW: 963 case AFMT_A_LAW: 964 case AFMT_S8: 965 case AFMT_U8: 966 break; 967 default: 968 format = AFMT_S8; 969 } 970 971 dmasound.soft.format = format; 972 dmasound.soft.size = 8; 973 if (dmasound.minDev == SND_DEV_DSP) { 974 dmasound.dsp.format = format; 975 dmasound.dsp.size = 8; 976 } 977 TTInit(); 978 979 return format; 980 } 981 982 983 #define VOLUME_VOXWARE_TO_DB(v) \ 984 (((v) < 0) ? -40 : ((v) > 100) ? 0 : ((v) * 2) / 5 - 40) 985 #define VOLUME_DB_TO_VOXWARE(v) ((((v) + 40) * 5 + 1) / 2) 986 987 988 static int TTSetVolume(int volume) 989 { 990 dmasound.volume_left = VOLUME_VOXWARE_TO_DB(volume & 0xff); 991 atari_microwire_cmd(MW_LM1992_BALLEFT(dmasound.volume_left)); 992 dmasound.volume_right = VOLUME_VOXWARE_TO_DB((volume & 0xff00) >> 8); 993 atari_microwire_cmd(MW_LM1992_BALRIGHT(dmasound.volume_right)); 994 return VOLUME_DB_TO_VOXWARE(dmasound.volume_left) | 995 (VOLUME_DB_TO_VOXWARE(dmasound.volume_right) << 8); 996 } 997 998 999 #define GAIN_VOXWARE_TO_DB(v) \ 1000 (((v) < 0) ? -80 : ((v) > 100) ? 0 : ((v) * 4) / 5 - 80) 1001 #define GAIN_DB_TO_VOXWARE(v) ((((v) + 80) * 5 + 1) / 4) 1002 1003 static int TTSetGain(int gain) 1004 { 1005 dmasound.gain = GAIN_VOXWARE_TO_DB(gain); 1006 atari_microwire_cmd(MW_LM1992_VOLUME(dmasound.gain)); 1007 return GAIN_DB_TO_VOXWARE(dmasound.gain); 1008 } 1009 1010 1011 1012 /* 1013 * Falcon 1014 */ 1015 1016 1017 static void FalconSilence(void) 1018 { 1019 /* stop playback, set sample rate 50kHz for PSG sound */ 1020 tt_dmasnd.ctrl = DMASND_CTRL_OFF; 1021 tt_dmasnd.mode = DMASND_MODE_50KHZ | DMASND_MODE_STEREO | DMASND_MODE_8BIT; 1022 tt_dmasnd.int_div = 0; /* STE compatible divider */ 1023 tt_dmasnd.int_ctrl = 0x0; 1024 tt_dmasnd.cbar_src = 0x0000; /* no matrix inputs */ 1025 tt_dmasnd.cbar_dst = 0x0000; /* no matrix outputs */ 1026 tt_dmasnd.dac_src = 1; /* connect ADC to DAC, disconnect matrix */ 1027 tt_dmasnd.adc_src = 3; /* ADC Input = PSG */ 1028 } 1029 1030 1031 static void FalconInit(void) 1032 { 1033 int divider, i, idx; 1034 const int freq[8] = {49170, 32780, 24585, 19668, 16390, 12292, 9834, 8195}; 1035 1036 /* search a frequency that fits into the allowed error range */ 1037 1038 idx = -1; 1039 for (i = 0; i < ARRAY_SIZE(freq); i++) 1040 /* if we will tolerate 3% error 8000Hz->8195Hz (2.38%) would 1041 * be playable without expanding, but that now a kernel runtime 1042 * option 1043 */ 1044 if ((100 * abs(dmasound.soft.speed - freq[i]) / freq[i]) < catchRadius) 1045 idx = i; 1046 if (idx > -1) { 1047 dmasound.soft.speed = freq[idx]; 1048 dmasound.trans_write = &transFalconNormal; 1049 } else 1050 dmasound.trans_write = &transFalconExpanding; 1051 1052 FalconSilence(); 1053 dmasound.hard = dmasound.soft; 1054 1055 if (dmasound.hard.size == 16) { 1056 /* the Falcon can play 16bit samples only in stereo */ 1057 dmasound.hard.stereo = 1; 1058 } 1059 1060 if (dmasound.hard.speed > 49170) { 1061 /* we would need to squeeze the sound, but we won't do that */ 1062 dmasound.hard.speed = 49170; 1063 divider = 1; 1064 dmasound.trans_write = &transFalconNormal; 1065 } else if (dmasound.hard.speed > 32780) { 1066 dmasound.hard.speed = 49170; 1067 divider = 1; 1068 } else if (dmasound.hard.speed > 24585) { 1069 dmasound.hard.speed = 32780; 1070 divider = 2; 1071 } else if (dmasound.hard.speed > 19668) { 1072 dmasound.hard.speed = 24585; 1073 divider = 3; 1074 } else if (dmasound.hard.speed > 16390) { 1075 dmasound.hard.speed = 19668; 1076 divider = 4; 1077 } else if (dmasound.hard.speed > 12292) { 1078 dmasound.hard.speed = 16390; 1079 divider = 5; 1080 } else if (dmasound.hard.speed > 9834) { 1081 dmasound.hard.speed = 12292; 1082 divider = 7; 1083 } else if (dmasound.hard.speed > 8195) { 1084 dmasound.hard.speed = 9834; 1085 divider = 9; 1086 } else { 1087 dmasound.hard.speed = 8195; 1088 divider = 11; 1089 } 1090 tt_dmasnd.int_div = divider; 1091 1092 /* Setup Falcon sound DMA for playback */ 1093 tt_dmasnd.int_ctrl = 0x4; /* Timer A int at play end */ 1094 tt_dmasnd.track_select = 0x0; /* play 1 track, track 1 */ 1095 tt_dmasnd.cbar_src = 0x0001; /* DMA(25MHz) --> DAC */ 1096 tt_dmasnd.cbar_dst = 0x0000; 1097 tt_dmasnd.rec_track_select = 0; 1098 tt_dmasnd.dac_src = 2; /* connect matrix to DAC */ 1099 tt_dmasnd.adc_src = 0; /* ADC Input = Mic */ 1100 1101 tt_dmasnd.mode = (dmasound.hard.stereo ? 1102 DMASND_MODE_STEREO : DMASND_MODE_MONO) | 1103 ((dmasound.hard.size == 8) ? 1104 DMASND_MODE_8BIT : DMASND_MODE_16BIT) | 1105 DMASND_MODE_6KHZ; 1106 1107 expand_bal = -dmasound.soft.speed; 1108 } 1109 1110 1111 static int FalconSetFormat(int format) 1112 { 1113 int size; 1114 /* Falcon sound DMA supports 8bit and 16bit modes */ 1115 1116 switch (format) { 1117 case AFMT_QUERY: 1118 return dmasound.soft.format; 1119 case AFMT_MU_LAW: 1120 case AFMT_A_LAW: 1121 case AFMT_U8: 1122 case AFMT_S8: 1123 size = 8; 1124 break; 1125 case AFMT_S16_BE: 1126 case AFMT_U16_BE: 1127 case AFMT_S16_LE: 1128 case AFMT_U16_LE: 1129 size = 16; 1130 break; 1131 default: /* :-) */ 1132 size = 8; 1133 format = AFMT_S8; 1134 } 1135 1136 dmasound.soft.format = format; 1137 dmasound.soft.size = size; 1138 if (dmasound.minDev == SND_DEV_DSP) { 1139 dmasound.dsp.format = format; 1140 dmasound.dsp.size = dmasound.soft.size; 1141 } 1142 1143 FalconInit(); 1144 1145 return format; 1146 } 1147 1148 1149 /* This is for the Falcon output *attenuation* in 1.5dB steps, 1150 * i.e. output level from 0 to -22.5dB in -1.5dB steps. 1151 */ 1152 #define VOLUME_VOXWARE_TO_ATT(v) \ 1153 ((v) < 0 ? 15 : (v) > 100 ? 0 : 15 - (v) * 3 / 20) 1154 #define VOLUME_ATT_TO_VOXWARE(v) (100 - (v) * 20 / 3) 1155 1156 1157 static int FalconSetVolume(int volume) 1158 { 1159 dmasound.volume_left = VOLUME_VOXWARE_TO_ATT(volume & 0xff); 1160 dmasound.volume_right = VOLUME_VOXWARE_TO_ATT((volume & 0xff00) >> 8); 1161 tt_dmasnd.output_atten = dmasound.volume_left << 8 | dmasound.volume_right << 4; 1162 return VOLUME_ATT_TO_VOXWARE(dmasound.volume_left) | 1163 VOLUME_ATT_TO_VOXWARE(dmasound.volume_right) << 8; 1164 } 1165 1166 1167 static void AtaPlayNextFrame(int index) 1168 { 1169 char *start, *end; 1170 1171 /* used by AtaPlay() if all doubts whether there really is something 1172 * to be played are already wiped out. 1173 */ 1174 start = write_sq.buffers[write_sq.front]; 1175 end = start+((write_sq.count == index) ? write_sq.rear_size 1176 : write_sq.block_size); 1177 /* end might not be a legal virtual address. */ 1178 DMASNDSetEnd(virt_to_phys(end - 1) + 1); 1179 DMASNDSetBase(virt_to_phys(start)); 1180 /* Since only an even number of samples per frame can 1181 be played, we might lose one byte here. (TO DO) */ 1182 write_sq.front = (write_sq.front+1) % write_sq.max_count; 1183 write_sq.active++; 1184 tt_dmasnd.ctrl = DMASND_CTRL_ON | DMASND_CTRL_REPEAT; 1185 } 1186 1187 1188 static void AtaPlay(void) 1189 { 1190 /* ++TeSche: Note that write_sq.active is no longer just a flag but 1191 * holds the number of frames the DMA is currently programmed for 1192 * instead, may be 0, 1 (currently being played) or 2 (pre-programmed). 1193 * 1194 * Changes done to write_sq.count and write_sq.active are a bit more 1195 * subtle again so now I must admit I also prefer disabling the irq 1196 * here rather than considering all possible situations. But the point 1197 * is that disabling the irq doesn't have any bad influence on this 1198 * version of the driver as we benefit from having pre-programmed the 1199 * DMA wherever possible: There's no need to reload the DMA at the 1200 * exact time of an interrupt but only at some time while the 1201 * pre-programmed frame is playing! 1202 */ 1203 atari_disable_irq(IRQ_MFP_TIMA); 1204 1205 if (write_sq.active == 2 || /* DMA is 'full' */ 1206 write_sq.count <= 0) { /* nothing to do */ 1207 atari_enable_irq(IRQ_MFP_TIMA); 1208 return; 1209 } 1210 1211 if (write_sq.active == 0) { 1212 /* looks like there's nothing 'in' the DMA yet, so try 1213 * to put two frames into it (at least one is available). 1214 */ 1215 if (write_sq.count == 1 && 1216 write_sq.rear_size < write_sq.block_size && 1217 !write_sq.syncing) { 1218 /* hmmm, the only existing frame is not 1219 * yet filled and we're not syncing? 1220 */ 1221 atari_enable_irq(IRQ_MFP_TIMA); 1222 return; 1223 } 1224 AtaPlayNextFrame(1); 1225 if (write_sq.count == 1) { 1226 /* no more frames */ 1227 atari_enable_irq(IRQ_MFP_TIMA); 1228 return; 1229 } 1230 if (write_sq.count == 2 && 1231 write_sq.rear_size < write_sq.block_size && 1232 !write_sq.syncing) { 1233 /* hmmm, there were two frames, but the second 1234 * one is not yet filled and we're not syncing? 1235 */ 1236 atari_enable_irq(IRQ_MFP_TIMA); 1237 return; 1238 } 1239 AtaPlayNextFrame(2); 1240 } else { 1241 /* there's already a frame being played so we may only stuff 1242 * one new into the DMA, but even if this may be the last 1243 * frame existing the previous one is still on write_sq.count. 1244 */ 1245 if (write_sq.count == 2 && 1246 write_sq.rear_size < write_sq.block_size && 1247 !write_sq.syncing) { 1248 /* hmmm, the only existing frame is not 1249 * yet filled and we're not syncing? 1250 */ 1251 atari_enable_irq(IRQ_MFP_TIMA); 1252 return; 1253 } 1254 AtaPlayNextFrame(2); 1255 } 1256 atari_enable_irq(IRQ_MFP_TIMA); 1257 } 1258 1259 1260 static irqreturn_t AtaInterrupt(int irq, void *dummy) 1261 { 1262 #if 0 1263 /* ++TeSche: if you should want to test this... */ 1264 static int cnt; 1265 if (write_sq.active == 2) 1266 if (++cnt == 10) { 1267 /* simulate losing an interrupt */ 1268 cnt = 0; 1269 return IRQ_HANDLED; 1270 } 1271 #endif 1272 spin_lock(&dmasound.lock); 1273 if (write_sq_ignore_int && is_falcon) { 1274 /* ++TeSche: Falcon only: ignore first irq because it comes 1275 * immediately after starting a frame. after that, irqs come 1276 * (almost) like on the TT. 1277 */ 1278 write_sq_ignore_int = 0; 1279 return IRQ_HANDLED; 1280 } 1281 1282 if (!write_sq.active) { 1283 /* playing was interrupted and sq_reset() has already cleared 1284 * the sq variables, so better don't do anything here. 1285 */ 1286 WAKE_UP(write_sq.sync_queue); 1287 return IRQ_HANDLED; 1288 } 1289 1290 /* Probably ;) one frame is finished. Well, in fact it may be that a 1291 * pre-programmed one is also finished because there has been a long 1292 * delay in interrupt delivery and we've completely lost one, but 1293 * there's no way to detect such a situation. In such a case the last 1294 * frame will be played more than once and the situation will recover 1295 * as soon as the irq gets through. 1296 */ 1297 write_sq.count--; 1298 write_sq.active--; 1299 1300 if (!write_sq.active) { 1301 tt_dmasnd.ctrl = DMASND_CTRL_OFF; 1302 write_sq_ignore_int = 1; 1303 } 1304 1305 WAKE_UP(write_sq.action_queue); 1306 /* At least one block of the queue is free now 1307 so wake up a writing process blocked because 1308 of a full queue. */ 1309 1310 if ((write_sq.active != 1) || (write_sq.count != 1)) 1311 /* We must be a bit carefully here: write_sq.count indicates the 1312 * number of buffers used and not the number of frames to be 1313 * played. If write_sq.count==1 and write_sq.active==1 that 1314 * means the only remaining frame was already programmed 1315 * earlier (and is currently running) so we mustn't call 1316 * AtaPlay() here, otherwise we'll play one frame too much. 1317 */ 1318 AtaPlay(); 1319 1320 if (!write_sq.active) WAKE_UP(write_sq.sync_queue); 1321 /* We are not playing after AtaPlay(), so there 1322 is nothing to play any more. Wake up a process 1323 waiting for audio output to drain. */ 1324 spin_unlock(&dmasound.lock); 1325 return IRQ_HANDLED; 1326 } 1327 1328 1329 /*** Mid level stuff *********************************************************/ 1330 1331 1332 /* 1333 * /dev/mixer abstraction 1334 */ 1335 1336 #define RECLEVEL_VOXWARE_TO_GAIN(v) \ 1337 ((v) < 0 ? 0 : (v) > 100 ? 15 : (v) * 3 / 20) 1338 #define RECLEVEL_GAIN_TO_VOXWARE(v) (((v) * 20 + 2) / 3) 1339 1340 1341 static void __init TTMixerInit(void) 1342 { 1343 atari_microwire_cmd(MW_LM1992_VOLUME(0)); 1344 dmasound.volume_left = 0; 1345 atari_microwire_cmd(MW_LM1992_BALLEFT(0)); 1346 dmasound.volume_right = 0; 1347 atari_microwire_cmd(MW_LM1992_BALRIGHT(0)); 1348 atari_microwire_cmd(MW_LM1992_TREBLE(0)); 1349 atari_microwire_cmd(MW_LM1992_BASS(0)); 1350 } 1351 1352 static void __init FalconMixerInit(void) 1353 { 1354 dmasound.volume_left = (tt_dmasnd.output_atten & 0xf00) >> 8; 1355 dmasound.volume_right = (tt_dmasnd.output_atten & 0xf0) >> 4; 1356 } 1357 1358 static int AtaMixerIoctl(u_int cmd, u_long arg) 1359 { 1360 int data; 1361 unsigned long flags; 1362 switch (cmd) { 1363 case SOUND_MIXER_READ_SPEAKER: 1364 if (is_falcon || MACH_IS_TT) { 1365 int porta; 1366 spin_lock_irqsave(&dmasound.lock, flags); 1367 sound_ym.rd_data_reg_sel = 14; 1368 porta = sound_ym.rd_data_reg_sel; 1369 spin_unlock_irqrestore(&dmasound.lock, flags); 1370 return IOCTL_OUT(arg, porta & 0x40 ? 0 : 100); 1371 } 1372 break; 1373 case SOUND_MIXER_WRITE_VOLUME: 1374 IOCTL_IN(arg, data); 1375 return IOCTL_OUT(arg, dmasound_set_volume(data)); 1376 case SOUND_MIXER_WRITE_SPEAKER: 1377 if (is_falcon || MACH_IS_TT) { 1378 int porta; 1379 IOCTL_IN(arg, data); 1380 spin_lock_irqsave(&dmasound.lock, flags); 1381 sound_ym.rd_data_reg_sel = 14; 1382 porta = (sound_ym.rd_data_reg_sel & ~0x40) | 1383 (data < 50 ? 0x40 : 0); 1384 sound_ym.wd_data = porta; 1385 spin_unlock_irqrestore(&dmasound.lock, flags); 1386 return IOCTL_OUT(arg, porta & 0x40 ? 0 : 100); 1387 } 1388 } 1389 return -EINVAL; 1390 } 1391 1392 1393 static int TTMixerIoctl(u_int cmd, u_long arg) 1394 { 1395 int data; 1396 switch (cmd) { 1397 case SOUND_MIXER_READ_RECMASK: 1398 return IOCTL_OUT(arg, 0); 1399 case SOUND_MIXER_READ_DEVMASK: 1400 return IOCTL_OUT(arg, 1401 SOUND_MASK_VOLUME | SOUND_MASK_TREBLE | SOUND_MASK_BASS | 1402 (MACH_IS_TT ? SOUND_MASK_SPEAKER : 0)); 1403 case SOUND_MIXER_READ_STEREODEVS: 1404 return IOCTL_OUT(arg, SOUND_MASK_VOLUME); 1405 case SOUND_MIXER_READ_VOLUME: 1406 return IOCTL_OUT(arg, 1407 VOLUME_DB_TO_VOXWARE(dmasound.volume_left) | 1408 (VOLUME_DB_TO_VOXWARE(dmasound.volume_right) << 8)); 1409 case SOUND_MIXER_READ_BASS: 1410 return IOCTL_OUT(arg, TONE_DB_TO_VOXWARE(dmasound.bass)); 1411 case SOUND_MIXER_READ_TREBLE: 1412 return IOCTL_OUT(arg, TONE_DB_TO_VOXWARE(dmasound.treble)); 1413 case SOUND_MIXER_READ_OGAIN: 1414 return IOCTL_OUT(arg, GAIN_DB_TO_VOXWARE(dmasound.gain)); 1415 case SOUND_MIXER_WRITE_BASS: 1416 IOCTL_IN(arg, data); 1417 return IOCTL_OUT(arg, dmasound_set_bass(data)); 1418 case SOUND_MIXER_WRITE_TREBLE: 1419 IOCTL_IN(arg, data); 1420 return IOCTL_OUT(arg, dmasound_set_treble(data)); 1421 case SOUND_MIXER_WRITE_OGAIN: 1422 IOCTL_IN(arg, data); 1423 return IOCTL_OUT(arg, dmasound_set_gain(data)); 1424 } 1425 return AtaMixerIoctl(cmd, arg); 1426 } 1427 1428 static int FalconMixerIoctl(u_int cmd, u_long arg) 1429 { 1430 int data; 1431 switch (cmd) { 1432 case SOUND_MIXER_READ_RECMASK: 1433 return IOCTL_OUT(arg, SOUND_MASK_MIC); 1434 case SOUND_MIXER_READ_DEVMASK: 1435 return IOCTL_OUT(arg, SOUND_MASK_VOLUME | SOUND_MASK_MIC | SOUND_MASK_SPEAKER); 1436 case SOUND_MIXER_READ_STEREODEVS: 1437 return IOCTL_OUT(arg, SOUND_MASK_VOLUME | SOUND_MASK_MIC); 1438 case SOUND_MIXER_READ_VOLUME: 1439 return IOCTL_OUT(arg, 1440 VOLUME_ATT_TO_VOXWARE(dmasound.volume_left) | 1441 VOLUME_ATT_TO_VOXWARE(dmasound.volume_right) << 8); 1442 case SOUND_MIXER_READ_CAPS: 1443 return IOCTL_OUT(arg, SOUND_CAP_EXCL_INPUT); 1444 case SOUND_MIXER_WRITE_MIC: 1445 IOCTL_IN(arg, data); 1446 tt_dmasnd.input_gain = 1447 RECLEVEL_VOXWARE_TO_GAIN(data & 0xff) << 4 | 1448 RECLEVEL_VOXWARE_TO_GAIN(data >> 8 & 0xff); 1449 /* fall thru, return set value */ 1450 case SOUND_MIXER_READ_MIC: 1451 return IOCTL_OUT(arg, 1452 RECLEVEL_GAIN_TO_VOXWARE(tt_dmasnd.input_gain >> 4 & 0xf) | 1453 RECLEVEL_GAIN_TO_VOXWARE(tt_dmasnd.input_gain & 0xf) << 8); 1454 } 1455 return AtaMixerIoctl(cmd, arg); 1456 } 1457 1458 static int AtaWriteSqSetup(void) 1459 { 1460 write_sq_ignore_int = 0; 1461 return 0 ; 1462 } 1463 1464 static int AtaSqOpen(mode_t mode) 1465 { 1466 write_sq_ignore_int = 1; 1467 return 0 ; 1468 } 1469 1470 static int TTStateInfo(char *buffer, size_t space) 1471 { 1472 int len = 0; 1473 len += sprintf(buffer+len, "\tvol left %ddB [-40... 0]\n", 1474 dmasound.volume_left); 1475 len += sprintf(buffer+len, "\tvol right %ddB [-40... 0]\n", 1476 dmasound.volume_right); 1477 len += sprintf(buffer+len, "\tbass %ddB [-12...+12]\n", 1478 dmasound.bass); 1479 len += sprintf(buffer+len, "\ttreble %ddB [-12...+12]\n", 1480 dmasound.treble); 1481 if (len >= space) { 1482 printk(KERN_ERR "dmasound_atari: overflowed state buffer alloc.\n") ; 1483 len = space ; 1484 } 1485 return len; 1486 } 1487 1488 static int FalconStateInfo(char *buffer, size_t space) 1489 { 1490 int len = 0; 1491 len += sprintf(buffer+len, "\tvol left %ddB [-22.5 ... 0]\n", 1492 dmasound.volume_left); 1493 len += sprintf(buffer+len, "\tvol right %ddB [-22.5 ... 0]\n", 1494 dmasound.volume_right); 1495 if (len >= space) { 1496 printk(KERN_ERR "dmasound_atari: overflowed state buffer alloc.\n") ; 1497 len = space ; 1498 } 1499 return len; 1500 } 1501 1502 1503 /*** Machine definitions *****************************************************/ 1504 1505 static SETTINGS def_hard_falcon = { 1506 .format = AFMT_S8, 1507 .stereo = 0, 1508 .size = 8, 1509 .speed = 8195 1510 } ; 1511 1512 static SETTINGS def_hard_tt = { 1513 .format = AFMT_S8, 1514 .stereo = 0, 1515 .size = 8, 1516 .speed = 12517 1517 } ; 1518 1519 static SETTINGS def_soft = { 1520 .format = AFMT_U8, 1521 .stereo = 0, 1522 .size = 8, 1523 .speed = 8000 1524 } ; 1525 1526 static MACHINE machTT = { 1527 .name = "Atari", 1528 .name2 = "TT", 1529 .owner = THIS_MODULE, 1530 .dma_alloc = AtaAlloc, 1531 .dma_free = AtaFree, 1532 .irqinit = AtaIrqInit, 1533 #ifdef MODULE 1534 .irqcleanup = AtaIrqCleanUp, 1535 #endif /* MODULE */ 1536 .init = TTInit, 1537 .silence = TTSilence, 1538 .setFormat = TTSetFormat, 1539 .setVolume = TTSetVolume, 1540 .setBass = AtaSetBass, 1541 .setTreble = AtaSetTreble, 1542 .setGain = TTSetGain, 1543 .play = AtaPlay, 1544 .mixer_init = TTMixerInit, 1545 .mixer_ioctl = TTMixerIoctl, 1546 .write_sq_setup = AtaWriteSqSetup, 1547 .sq_open = AtaSqOpen, 1548 .state_info = TTStateInfo, 1549 .min_dsp_speed = 6258, 1550 .version = ((DMASOUND_ATARI_REVISION<<8) | DMASOUND_ATARI_EDITION), 1551 .hardware_afmts = AFMT_S8, /* h'ware-supported formats *only* here */ 1552 .capabilities = DSP_CAP_BATCH /* As per SNDCTL_DSP_GETCAPS */ 1553 }; 1554 1555 static MACHINE machFalcon = { 1556 .name = "Atari", 1557 .name2 = "FALCON", 1558 .dma_alloc = AtaAlloc, 1559 .dma_free = AtaFree, 1560 .irqinit = AtaIrqInit, 1561 #ifdef MODULE 1562 .irqcleanup = AtaIrqCleanUp, 1563 #endif /* MODULE */ 1564 .init = FalconInit, 1565 .silence = FalconSilence, 1566 .setFormat = FalconSetFormat, 1567 .setVolume = FalconSetVolume, 1568 .setBass = AtaSetBass, 1569 .setTreble = AtaSetTreble, 1570 .play = AtaPlay, 1571 .mixer_init = FalconMixerInit, 1572 .mixer_ioctl = FalconMixerIoctl, 1573 .write_sq_setup = AtaWriteSqSetup, 1574 .sq_open = AtaSqOpen, 1575 .state_info = FalconStateInfo, 1576 .min_dsp_speed = 8195, 1577 .version = ((DMASOUND_ATARI_REVISION<<8) | DMASOUND_ATARI_EDITION), 1578 .hardware_afmts = (AFMT_S8 | AFMT_S16_BE), /* h'ware-supported formats *only* here */ 1579 .capabilities = DSP_CAP_BATCH /* As per SNDCTL_DSP_GETCAPS */ 1580 }; 1581 1582 1583 /*** Config & Setup **********************************************************/ 1584 1585 1586 static int __init dmasound_atari_init(void) 1587 { 1588 if (MACH_IS_ATARI && ATARIHW_PRESENT(PCM_8BIT)) { 1589 if (ATARIHW_PRESENT(CODEC)) { 1590 dmasound.mach = machFalcon; 1591 dmasound.mach.default_soft = def_soft ; 1592 dmasound.mach.default_hard = def_hard_falcon ; 1593 is_falcon = 1; 1594 } else if (ATARIHW_PRESENT(MICROWIRE)) { 1595 dmasound.mach = machTT; 1596 dmasound.mach.default_soft = def_soft ; 1597 dmasound.mach.default_hard = def_hard_tt ; 1598 is_falcon = 0; 1599 } else 1600 return -ENODEV; 1601 if ((mfp.int_en_a & mfp.int_mk_a & 0x20) == 0) 1602 return dmasound_init(); 1603 else { 1604 printk("DMA sound driver: Timer A interrupt already in use\n"); 1605 return -EBUSY; 1606 } 1607 } 1608 return -ENODEV; 1609 } 1610 1611 static void __exit dmasound_atari_cleanup(void) 1612 { 1613 dmasound_deinit(); 1614 } 1615 1616 module_init(dmasound_atari_init); 1617 module_exit(dmasound_atari_cleanup); 1618 MODULE_LICENSE("GPL"); 1619