sound/oss/dmasound/dmasound_q40.c

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