sound/oss/dmasound/dmasound_atari.c

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