sound/oss/dmasound/dmasound_q40.c

   1 /*
   2  *  linux/sound/oss/dmasound/dmasound_q40.c
   3  *
   4  *  Q40 DMA Sound Driver
   5  *
   6  *  See linux/sound/oss/dmasound/dmasound_core.c for copyright and credits
   7  *  prior to 28/01/2001
   8  *
   9  *  28/01/2001 [0.1] Iain Sandoe
  10  *                   - added versioning
  11  *                   - put in and populated the hardware_afmts field.
  12  *             [0.2] - put in SNDCTL_DSP_GETCAPS value.
  13  *             [0.3] - put in default hard/soft settings.
  14  */
  15
  16
  17 #include <linux/module.h>
  18 #include <linux/init.h>
  19 #include <linux/slab.h>
  20 #include <linux/soundcard.h>
  21 #include <linux/interrupt.h>
  22
  23 #include <linux/uaccess.h>
  24 #include <asm/q40ints.h>
  25 #include <asm/q40_master.h>
  26
  27 #include "dmasound.h"
  28
  29 #define DMASOUND_Q40_REVISION 0
  30 #define DMASOUND_Q40_EDITION 3
  31
  32 static int expand_bal;  /* Balance factor for expanding (not volume!) */
  33 static int expand_data; /* Data for expanding */
  34
  35
  36 /*** Low level stuff *********************************************************/
  37
  38
  39 static void *Q40Alloc(unsigned int size, gfp_t flags);
  40 static void Q40Free(void *, unsigned int);
  41 static int Q40IrqInit(void);
  42 #ifdef MODULE
  43 static void Q40IrqCleanUp(void);
  44 #endif
  45 static void Q40Silence(void);
  46 static void Q40Init(void);
  47 static int Q40SetFormat(int format);
  48 static int Q40SetVolume(int volume);
  49 static void Q40PlayNextFrame(int index);
  50 static void Q40Play(void);
  51 static irqreturn_t Q40StereoInterrupt(int irq, void *dummy);
  52 static irqreturn_t Q40MonoInterrupt(int irq, void *dummy);
  53 static void Q40Interrupt(void);
  54
  55
  56 /*** Mid level stuff *********************************************************/
  57
  58
  59
  60 /* userCount, frameUsed, frameLeft == byte counts */
  61 static ssize_t q40_ct_law(const u_char __user *userPtr, size_t userCount,
  62                            u_char frame[], ssize_t *frameUsed,
  63                            ssize_t frameLeft)
  64 {
  65         char *table = dmasound.soft.format == AFMT_MU_LAW ? dmasound_ulaw2dma8: dmasound_alaw2dma8;
  66         ssize_t count, used;
  67         u_char *p = (u_char *) &frame[*frameUsed];
  68
  69         used = count = min_t(size_t, userCount, frameLeft);
  70         if (copy_from_user(p,userPtr,count))
  71           return -EFAULT;
  72         while (count > 0) {
  73                 *p = table[*p]+128;
  74                 p++;
  75                 count--;
  76         }
  77         *frameUsed += used ;
  78         return used;
  79 }
  80
  81
  82 static ssize_t q40_ct_s8(const u_char __user *userPtr, size_t userCount,
  83                           u_char frame[], ssize_t *frameUsed,
  84                           ssize_t frameLeft)
  85 {
  86         ssize_t count, used;
  87         u_char *p = (u_char *) &frame[*frameUsed];
  88
  89         used = count = min_t(size_t, userCount, frameLeft);
  90         if (copy_from_user(p,userPtr,count))
  91           return -EFAULT;
  92         while (count > 0) {
  93                 *p = *p + 128;
  94                 p++;
  95                 count--;
  96         }
  97         *frameUsed += used;
  98         return used;
  99 }
 100
 101 static ssize_t q40_ct_u8(const u_char __user *userPtr, size_t userCount,
 102                           u_char frame[], ssize_t *frameUsed,
 103                           ssize_t frameLeft)
 104 {
 105         ssize_t count, used;
 106         u_char *p = (u_char *) &frame[*frameUsed];
 107
 108         used = count = min_t(size_t, userCount, frameLeft);
 109         if (copy_from_user(p,userPtr,count))
 110           return -EFAULT;
 111         *frameUsed += used;
 112         return used;
 113 }
 114
 115
 116 /* a bit too complicated to optimise right now ..*/
 117 static ssize_t q40_ctx_law(const u_char __user *userPtr, size_t userCount,
 118                             u_char frame[], ssize_t *frameUsed,
 119                             ssize_t frameLeft)
 120 {
 121         unsigned char *table = (unsigned char *)
 122                 (dmasound.soft.format == AFMT_MU_LAW ? dmasound_ulaw2dma8: dmasound_alaw2dma8);
 123         unsigned int data = expand_data;
 124         u_char *p = (u_char *) &frame[*frameUsed];
 125         int bal = expand_bal;
 126         int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
 127         int utotal, ftotal;
 128
 129         ftotal = frameLeft;
 130         utotal = userCount;
 131         while (frameLeft) {
 132                 u_char c;
 133                 if (bal < 0) {
 134                         if (userCount == 0)
 135                                 break;
 136                         if (get_user(c, userPtr++))
 137                                 return -EFAULT;
 138                         data = table[c];
 139                         data += 0x80;
 140                         userCount--;
 141                         bal += hSpeed;
 142                 }
 143                 *p++ = data;
 144                 frameLeft--;
 145                 bal -= sSpeed;
 146         }
 147         expand_bal = bal;
 148         expand_data = data;
 149         *frameUsed += (ftotal - frameLeft);
 150         utotal -= userCount;
 151         return utotal;
 152 }
 153
 154
 155 static ssize_t q40_ctx_s8(const u_char __user *userPtr, size_t userCount,
 156                            u_char frame[], ssize_t *frameUsed,
 157                            ssize_t frameLeft)
 158 {
 159         u_char *p = (u_char *) &frame[*frameUsed];
 160         unsigned int data = expand_data;
 161         int bal = expand_bal;
 162         int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
 163         int utotal, ftotal;
 164
 165
 166         ftotal = frameLeft;
 167         utotal = userCount;
 168         while (frameLeft) {
 169                 u_char c;
 170                 if (bal < 0) {
 171                         if (userCount == 0)
 172                                 break;
 173                         if (get_user(c, userPtr++))
 174                                 return -EFAULT;
 175                         data = c ;
 176                         data += 0x80;
 177                         userCount--;
 178                         bal += hSpeed;
 179                 }
 180                 *p++ = data;
 181                 frameLeft--;
 182                 bal -= sSpeed;
 183         }
 184         expand_bal = bal;
 185         expand_data = data;
 186         *frameUsed += (ftotal - frameLeft);
 187         utotal -= userCount;
 188         return utotal;
 189 }
 190
 191
 192 static ssize_t q40_ctx_u8(const u_char __user *userPtr, size_t userCount,
 193                            u_char frame[], ssize_t *frameUsed,
 194                            ssize_t frameLeft)
 195 {
 196         u_char *p = (u_char *) &frame[*frameUsed];
 197         unsigned int data = expand_data;
 198         int bal = expand_bal;
 199         int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
 200         int utotal, ftotal;
 201
 202         ftotal = frameLeft;
 203         utotal = userCount;
 204         while (frameLeft) {
 205                 u_char c;
 206                 if (bal < 0) {
 207                         if (userCount == 0)
 208                                 break;
 209                         if (get_user(c, userPtr++))
 210                                 return -EFAULT;
 211                         data = c ;
 212                         userCount--;
 213                         bal += hSpeed;
 214                 }
 215                 *p++ = data;
 216                 frameLeft--;
 217                 bal -= sSpeed;
 218         }
 219         expand_bal = bal;
 220         expand_data = data;
 221         *frameUsed += (ftotal - frameLeft) ;
 222         utotal -= userCount;
 223         return utotal;
 224 }
 225
 226 /* compressing versions */
 227 static ssize_t q40_ctc_law(const u_char __user *userPtr, size_t userCount,
 228                             u_char frame[], ssize_t *frameUsed,
 229                             ssize_t frameLeft)
 230 {
 231         unsigned char *table = (unsigned char *)
 232                 (dmasound.soft.format == AFMT_MU_LAW ? dmasound_ulaw2dma8: dmasound_alaw2dma8);
 233         unsigned int data = expand_data;
 234         u_char *p = (u_char *) &frame[*frameUsed];
 235         int bal = expand_bal;
 236         int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
 237         int utotal, ftotal;
 238
 239         ftotal = frameLeft;
 240         utotal = userCount;
 241         while (frameLeft) {
 242                 u_char c;
 243                 while(bal<0) {
 244                         if (userCount == 0)
 245                                 goto lout;
 246                         if (!(bal<(-hSpeed))) {
 247                                 if (get_user(c, userPtr))
 248                                         return -EFAULT;
 249                                 data = 0x80 + table[c];
 250                         }
 251                         userPtr++;
 252                         userCount--;
 253                         bal += hSpeed;
 254                 }
 255                 *p++ = data;
 256                 frameLeft--;
 257                 bal -= sSpeed;
 258         }
 259  lout:
 260         expand_bal = bal;
 261         expand_data = data;
 262         *frameUsed += (ftotal - frameLeft);
 263         utotal -= userCount;
 264         return utotal;
 265 }
 266
 267
 268 static ssize_t q40_ctc_s8(const u_char __user *userPtr, size_t userCount,
 269                            u_char frame[], ssize_t *frameUsed,
 270                            ssize_t frameLeft)
 271 {
 272         u_char *p = (u_char *) &frame[*frameUsed];
 273         unsigned int data = expand_data;
 274         int bal = expand_bal;
 275         int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
 276         int utotal, ftotal;
 277
 278         ftotal = frameLeft;
 279         utotal = userCount;
 280         while (frameLeft) {
 281                 u_char c;
 282                 while (bal < 0) {
 283                         if (userCount == 0)
 284                                 goto lout;
 285                         if (!(bal<(-hSpeed))) {
 286                                 if (get_user(c, userPtr))
 287                                         return -EFAULT;
 288                                 data = c + 0x80;
 289                         }
 290                         userPtr++;
 291                         userCount--;
 292                         bal += hSpeed;
 293                 }
 294                 *p++ = data;
 295                 frameLeft--;
 296                 bal -= sSpeed;
 297         }
 298  lout:
 299         expand_bal = bal;
 300         expand_data = data;
 301         *frameUsed += (ftotal - frameLeft);
 302         utotal -= userCount;
 303         return utotal;
 304 }
 305
 306
 307 static ssize_t q40_ctc_u8(const u_char __user *userPtr, size_t userCount,
 308                            u_char frame[], ssize_t *frameUsed,
 309                            ssize_t frameLeft)
 310 {
 311         u_char *p = (u_char *) &frame[*frameUsed];
 312         unsigned int data = expand_data;
 313         int bal = expand_bal;
 314         int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
 315         int utotal, ftotal;
 316
 317         ftotal = frameLeft;
 318         utotal = userCount;
 319         while (frameLeft) {
 320                 u_char c;
 321                 while (bal < 0) {
 322                         if (userCount == 0)
 323                                 goto lout;
 324                         if (!(bal<(-hSpeed))) {
 325                                 if (get_user(c, userPtr))
 326                                         return -EFAULT;
 327                                 data = c ;
 328                         }
 329                         userPtr++;
 330                         userCount--;
 331                         bal += hSpeed;
 332                 }
 333                 *p++ = data;
 334                 frameLeft--;
 335                 bal -= sSpeed;
 336         }
 337  lout:
 338         expand_bal = bal;
 339         expand_data = data;
 340         *frameUsed += (ftotal - frameLeft) ;
 341         utotal -= userCount;
 342         return utotal;
 343 }
 344
 345
 346 static TRANS transQ40Normal = {
 347         q40_ct_law, q40_ct_law, q40_ct_s8, q40_ct_u8, NULL, NULL, NULL, NULL
 348 };
 349
 350 static TRANS transQ40Expanding = {
 351         q40_ctx_law, q40_ctx_law, q40_ctx_s8, q40_ctx_u8, NULL, NULL, NULL, NULL
 352 };
 353
 354 static TRANS transQ40Compressing = {
 355         q40_ctc_law, q40_ctc_law, q40_ctc_s8, q40_ctc_u8, NULL, NULL, NULL, NULL
 356 };
 357
 358
 359 /*** Low level stuff *********************************************************/
 360
 361 static void *Q40Alloc(unsigned int size, gfp_t flags)
 362 {
 363          return kmalloc(size, flags); /* change to vmalloc */
 364 }
 365
 366 static void Q40Free(void *ptr, unsigned int size)
 367 {
 368         kfree(ptr);
 369 }
 370
 371 static int __init Q40IrqInit(void)
 372 {
 373         /* Register interrupt handler. */
 374         if (request_irq(Q40_IRQ_SAMPLE, Q40StereoInterrupt, 0,
 375                     "DMA sound", Q40Interrupt))
 376                 return 0;
 377
 378         return(1);
 379 }
 380
 381
 382 #ifdef MODULE
 383 static void Q40IrqCleanUp(void)
 384 {
 385         master_outb(0,SAMPLE_ENABLE_REG);
 386         free_irq(Q40_IRQ_SAMPLE, Q40Interrupt);
 387 }
 388 #endif /* MODULE */
 389
 390
 391 static void Q40Silence(void)
 392 {
 393         master_outb(0,SAMPLE_ENABLE_REG);
 394         *DAC_LEFT=*DAC_RIGHT=127;
 395 }
 396
 397 static char *q40_pp;
 398 static unsigned int q40_sc;
 399
 400 static void Q40PlayNextFrame(int index)
 401 {
 402         u_char *start;
 403         u_long size;
 404         u_char speed;
 405         int error;
 406
 407         /* used by Q40Play() if all doubts whether there really is something
 408          * to be played are already wiped out.
 409          */
 410         start = write_sq.buffers[write_sq.front];
 411         size = (write_sq.count == index ? write_sq.rear_size : write_sq.block_size);
 412
 413         q40_pp=start;
 414         q40_sc=size;
 415
 416         write_sq.front = (write_sq.front+1) % write_sq.max_count;
 417         write_sq.active++;
 418
 419         speed=(dmasound.hard.speed==10000 ? 0 : 1);
 420
 421         master_outb( 0,SAMPLE_ENABLE_REG);
 422         free_irq(Q40_IRQ_SAMPLE, Q40Interrupt);
 423         if (dmasound.soft.stereo)
 424                 error = request_irq(Q40_IRQ_SAMPLE, Q40StereoInterrupt, 0,
 425                                     "Q40 sound", Q40Interrupt);
 426           else
 427                 error = request_irq(Q40_IRQ_SAMPLE, Q40MonoInterrupt, 0,
 428                                     "Q40 sound", Q40Interrupt);
 429         if (error && printk_ratelimit())
 430                 pr_err("Couldn't register sound interrupt\n");
 431
 432         master_outb( speed, SAMPLE_RATE_REG);
 433         master_outb( 1,SAMPLE_CLEAR_REG);
 434         master_outb( 1,SAMPLE_ENABLE_REG);
 435 }
 436
 437 static void Q40Play(void)
 438 {
 439         unsigned long flags;
 440
 441         if (write_sq.active || write_sq.count<=0 ) {
 442                 /* There's already a frame loaded */
 443                 return;
 444         }
 445
 446         /* nothing in the queue */
 447         if (write_sq.count <= 1 && write_sq.rear_size < write_sq.block_size && !write_sq.syncing) {
 448                  /* hmmm, the only existing frame is not
 449                   * yet filled and we're not syncing?
 450                   */
 451                  return;
 452         }
 453         spin_lock_irqsave(&dmasound.lock, flags);
 454         Q40PlayNextFrame(1);
 455         spin_unlock_irqrestore(&dmasound.lock, flags);
 456 }
 457
 458 static irqreturn_t Q40StereoInterrupt(int irq, void *dummy)
 459 {
 460         spin_lock(&dmasound.lock);
 461         if (q40_sc>1){
 462             *DAC_LEFT=*q40_pp++;
 463             *DAC_RIGHT=*q40_pp++;
 464             q40_sc -=2;
 465             master_outb(1,SAMPLE_CLEAR_REG);
 466         }else Q40Interrupt();
 467         spin_unlock(&dmasound.lock);
 468         return IRQ_HANDLED;
 469 }
 470 static irqreturn_t Q40MonoInterrupt(int irq, void *dummy)
 471 {
 472         spin_lock(&dmasound.lock);
 473         if (q40_sc>0){
 474             *DAC_LEFT=*q40_pp;
 475             *DAC_RIGHT=*q40_pp++;
 476             q40_sc --;
 477             master_outb(1,SAMPLE_CLEAR_REG);
 478         }else Q40Interrupt();
 479         spin_unlock(&dmasound.lock);
 480         return IRQ_HANDLED;
 481 }
 482 static void Q40Interrupt(void)
 483 {
 484         if (!write_sq.active) {
 485                   /* playing was interrupted and sq_reset() has already cleared
 486                    * the sq variables, so better don't do anything here.
 487                    */
 488                    WAKE_UP(write_sq.sync_queue);
 489                    master_outb(0,SAMPLE_ENABLE_REG); /* better safe */
 490                    goto exit;
 491         } else write_sq.active=0;
 492         write_sq.count--;
 493         Q40Play();
 494
 495         if (q40_sc<2)
 496               { /* there was nothing to play, disable irq */
 497                 master_outb(0,SAMPLE_ENABLE_REG);
 498                 *DAC_LEFT=*DAC_RIGHT=127;
 499               }
 500         WAKE_UP(write_sq.action_queue);
 501
 502  exit:
 503         master_outb(1,SAMPLE_CLEAR_REG);
 504 }
 505
 506
 507 static void Q40Init(void)
 508 {
 509         int i, idx;
 510         const int freq[] = {10000, 20000};
 511
 512         /* search a frequency that fits into the allowed error range */
 513
 514         idx = -1;
 515         for (i = 0; i < 2; i++)
 516                 if ((100 * abs(dmasound.soft.speed - freq[i]) / freq[i]) <= catchRadius)
 517                         idx = i;
 518
 519         dmasound.hard = dmasound.soft;
 520         /*sound.hard.stereo=1;*/ /* no longer true */
 521         dmasound.hard.size=8;
 522
 523         if (idx > -1) {
 524                 dmasound.soft.speed = freq[idx];
 525                 dmasound.trans_write = &transQ40Normal;
 526         } else
 527                 dmasound.trans_write = &transQ40Expanding;
 528
 529         Q40Silence();
 530
 531         if (dmasound.hard.speed > 20200) {
 532                 /* squeeze the sound, we do that */
 533                 dmasound.hard.speed = 20000;
 534                 dmasound.trans_write = &transQ40Compressing;
 535         } else if (dmasound.hard.speed > 10000) {
 536                 dmasound.hard.speed = 20000;
 537         } else {
 538                 dmasound.hard.speed = 10000;
 539         }
 540         expand_bal = -dmasound.soft.speed;
 541 }
 542
 543
 544 static int Q40SetFormat(int format)
 545 {
 546         /* Q40 sound supports only 8bit modes */
 547
 548         switch (format) {
 549         case AFMT_QUERY:
 550                 return(dmasound.soft.format);
 551         case AFMT_MU_LAW:
 552         case AFMT_A_LAW:
 553         case AFMT_S8:
 554         case AFMT_U8:
 555                 break;
 556         default:
 557                 format = AFMT_S8;
 558         }
 559
 560         dmasound.soft.format = format;
 561         dmasound.soft.size = 8;
 562         if (dmasound.minDev == SND_DEV_DSP) {
 563                 dmasound.dsp.format = format;
 564                 dmasound.dsp.size = 8;
 565         }
 566         Q40Init();
 567
 568         return(format);
 569 }
 570
 571 static int Q40SetVolume(int volume)
 572 {
 573     return 0;
 574 }
 575
 576
 577 /*** Machine definitions *****************************************************/
 578
 579 static SETTINGS def_hard = {
 580         .format = AFMT_U8,
 581         .stereo = 0,
 582         .size   = 8,
 583         .speed  = 10000
 584 } ;
 585
 586 static SETTINGS def_soft = {
 587         .format = AFMT_U8,
 588         .stereo = 0,
 589         .size   = 8,
 590         .speed  = 8000
 591 } ;
 592
 593 static MACHINE machQ40 = {
 594         .name           = "Q40",
 595         .name2          = "Q40",
 596         .owner          = THIS_MODULE,
 597         .dma_alloc      = Q40Alloc,
 598         .dma_free       = Q40Free,
 599         .irqinit        = Q40IrqInit,
 600 #ifdef MODULE
 601         .irqcleanup     = Q40IrqCleanUp,
 602 #endif /* MODULE */
 603         .init           = Q40Init,
 604         .silence        = Q40Silence,
 605         .setFormat      = Q40SetFormat,
 606         .setVolume      = Q40SetVolume,
 607         .play           = Q40Play,
 608         .min_dsp_speed  = 10000,
 609         .version        = ((DMASOUND_Q40_REVISION<<8) | DMASOUND_Q40_EDITION),
 610         .hardware_afmts = AFMT_U8, /* h'ware-supported formats *only* here */
 611         .capabilities   = DSP_CAP_BATCH  /* As per SNDCTL_DSP_GETCAPS */
 612 };
 613
 614
 615 /*** Config & Setup **********************************************************/
 616
 617
 618 static int __init dmasound_q40_init(void)
 619 {
 620         if (MACH_IS_Q40) {
 621             dmasound.mach = machQ40;
 622             dmasound.mach.default_hard = def_hard ;
 623             dmasound.mach.default_soft = def_soft ;
 624             return dmasound_init();
 625         } else
 626             return -ENODEV;
 627 }
 628
 629 static void __exit dmasound_q40_cleanup(void)
 630 {
 631         dmasound_deinit();
 632 }
 633
 634 module_init(dmasound_q40_init);
 635 module_exit(dmasound_q40_cleanup);
 636
 637 MODULE_DESCRIPTION("Q40/Q60 sound driver");
 638 MODULE_LICENSE("GPL");