kernel/sound/oss/sb_audio.c

   1 /*
   2  * sound/oss/sb_audio.c
   3  *
   4  * Audio routines for Sound Blaster compatible cards.
   5  *
   6  *
   7  * Copyright (C) by Hannu Savolainen 1993-1997
   8  *
   9  * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
  10  * Version 2 (June 1991). See the "COPYING" file distributed with this software
  11  * for more info.
  12  *
  13  * Changes
  14  *      Alan Cox        :       Formatting and clean ups
  15  *
  16  * Status
  17  *      Mostly working. Weird uart bug causing irq storms
  18  *
  19  * Daniel J. Rodriksson: Changes to make sb16 work full duplex.
  20  *                       Maybe other 16 bit cards in this code could behave
  21  *                       the same.
  22  * Chris Rankin:         Use spinlocks instead of CLI/STI
  23  */
  24
  25 #include <linux/spinlock.h>
  26
  27 #include "sound_config.h"
  28
  29 #include "sb_mixer.h"
  30 #include "sb.h"
  31
  32 #include "sb_ess.h"
  33
  34 int sb_audio_open(int dev, int mode)
  35 {
  36         sb_devc *devc = audio_devs[dev]->devc;
  37         unsigned long flags;
  38
  39         if (devc == NULL)
  40         {
  41                   printk(KERN_ERR "Sound Blaster: incomplete initialization.\n");
  42                   return -ENXIO;
  43         }
  44         if (devc->caps & SB_NO_RECORDING && mode & OPEN_READ)
  45         {
  46                 if (mode == OPEN_READ)
  47                         return -EPERM;
  48         }
  49         spin_lock_irqsave(&devc->lock, flags);
  50         if (devc->opened)
  51         {
  52                   spin_unlock_irqrestore(&devc->lock, flags);
  53                   return -EBUSY;
  54         }
  55         if (devc->dma16 != -1 && devc->dma16 != devc->dma8 && !devc->duplex)
  56         {
  57                 if (sound_open_dma(devc->dma16, "Sound Blaster 16 bit"))
  58                 {
  59                         spin_unlock_irqrestore(&devc->lock, flags);
  60                         return -EBUSY;
  61                 }
  62         }
  63         devc->opened = mode;
  64         spin_unlock_irqrestore(&devc->lock, flags);
  65
  66         devc->irq_mode = IMODE_NONE;
  67         devc->irq_mode_16 = IMODE_NONE;
  68         devc->fullduplex = devc->duplex &&
  69                 ((mode & OPEN_READ) && (mode & OPEN_WRITE));
  70         sb_dsp_reset(devc);
  71
  72         /* At first glance this check isn't enough, some ESS chips might not
  73          * have a RECLEV. However if they don't common_mixer_set will refuse
  74          * cause devc->iomap has no register mapping for RECLEV
  75          */
  76         if (devc->model == MDL_ESS) ess_mixer_reload (devc, SOUND_MIXER_RECLEV);
  77
  78         /* The ALS007 seems to require that the DSP be removed from the output */
  79         /* in order for recording to be activated properly.  This is done by   */
  80         /* setting the appropriate bits of the output control register 4ch to  */
  81         /* zero.  This code assumes that the output control registers are not  */
  82         /* used anywhere else and therefore the DSP bits are *always* ON for   */
  83         /* output and OFF for sampling.                                        */
  84
  85         if (devc->submodel == SUBMDL_ALS007)
  86         {
  87                 if (mode & OPEN_READ)
  88                         sb_setmixer(devc,ALS007_OUTPUT_CTRL2,
  89                                 sb_getmixer(devc,ALS007_OUTPUT_CTRL2) & 0xf9);
  90                 else
  91                         sb_setmixer(devc,ALS007_OUTPUT_CTRL2,
  92                                 sb_getmixer(devc,ALS007_OUTPUT_CTRL2) | 0x06);
  93         }
  94         return 0;
  95 }
  96
  97 void sb_audio_close(int dev)
  98 {
  99         sb_devc *devc = audio_devs[dev]->devc;
 100
 101         /* fix things if mmap turned off fullduplex */
 102         if(devc->duplex
 103            && !devc->fullduplex
 104            && (devc->opened & OPEN_READ) && (devc->opened & OPEN_WRITE))
 105         {
 106                 struct dma_buffparms *dmap_temp;
 107                 dmap_temp = audio_devs[dev]->dmap_out;
 108                 audio_devs[dev]->dmap_out = audio_devs[dev]->dmap_in;
 109                 audio_devs[dev]->dmap_in = dmap_temp;
 110         }
 111         audio_devs[dev]->dmap_out->dma = devc->dma8;
 112         audio_devs[dev]->dmap_in->dma = ( devc->duplex ) ?
 113                 devc->dma16 : devc->dma8;
 114
 115         if (devc->dma16 != -1 && devc->dma16 != devc->dma8 && !devc->duplex)
 116                 sound_close_dma(devc->dma16);
 117
 118         /* For ALS007, turn DSP output back on if closing the device for read */
 119
 120         if ((devc->submodel == SUBMDL_ALS007) && (devc->opened & OPEN_READ))
 121         {
 122                 sb_setmixer(devc,ALS007_OUTPUT_CTRL2,
 123                         sb_getmixer(devc,ALS007_OUTPUT_CTRL2) | 0x06);
 124         }
 125         devc->opened = 0;
 126 }
 127
 128 static void sb_set_output_parms(int dev, unsigned long buf, int nr_bytes,
 129                     int intrflag)
 130 {
 131         sb_devc *devc = audio_devs[dev]->devc;
 132
 133         if (!devc->fullduplex || devc->bits == AFMT_S16_LE)
 134         {
 135                 devc->trg_buf = buf;
 136                 devc->trg_bytes = nr_bytes;
 137                 devc->trg_intrflag = intrflag;
 138                 devc->irq_mode = IMODE_OUTPUT;
 139         }
 140         else
 141         {
 142                 devc->trg_buf_16 = buf;
 143                 devc->trg_bytes_16 = nr_bytes;
 144                 devc->trg_intrflag_16 = intrflag;
 145                 devc->irq_mode_16 = IMODE_OUTPUT;
 146         }
 147 }
 148
 149 static void sb_set_input_parms(int dev, unsigned long buf, int count, int intrflag)
 150 {
 151         sb_devc *devc = audio_devs[dev]->devc;
 152
 153         if (!devc->fullduplex || devc->bits != AFMT_S16_LE)
 154         {
 155                 devc->trg_buf = buf;
 156                 devc->trg_bytes = count;
 157                 devc->trg_intrflag = intrflag;
 158                 devc->irq_mode = IMODE_INPUT;
 159         }
 160         else
 161         {
 162                 devc->trg_buf_16 = buf;
 163                 devc->trg_bytes_16 = count;
 164                 devc->trg_intrflag_16 = intrflag;
 165                 devc->irq_mode_16 = IMODE_INPUT;
 166         }
 167 }
 168
 169 /*
 170  * SB1.x compatible routines
 171  */
 172
 173 static void sb1_audio_output_block(int dev, unsigned long buf, int nr_bytes, int intrflag)
 174 {
 175         unsigned long flags;
 176         int count = nr_bytes;
 177         sb_devc *devc = audio_devs[dev]->devc;
 178
 179         /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE); */
 180
 181         if (audio_devs[dev]->dmap_out->dma > 3)
 182                 count >>= 1;
 183         count--;
 184
 185         devc->irq_mode = IMODE_OUTPUT;
 186
 187         spin_lock_irqsave(&devc->lock, flags);
 188         if (sb_dsp_command(devc, 0x14))         /* 8 bit DAC using DMA */
 189         {
 190                 sb_dsp_command(devc, (unsigned char) (count & 0xff));
 191                 sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff));
 192         }
 193         else
 194                 printk(KERN_WARNING "Sound Blaster:  unable to start DAC.\n");
 195         spin_unlock_irqrestore(&devc->lock, flags);
 196         devc->intr_active = 1;
 197 }
 198
 199 static void sb1_audio_start_input(int dev, unsigned long buf, int nr_bytes, int intrflag)
 200 {
 201         unsigned long flags;
 202         int count = nr_bytes;
 203         sb_devc *devc = audio_devs[dev]->devc;
 204
 205         /*
 206          * Start a DMA input to the buffer pointed by dmaqtail
 207          */
 208
 209         /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_READ); */
 210
 211         if (audio_devs[dev]->dmap_out->dma > 3)
 212                 count >>= 1;
 213         count--;
 214
 215         devc->irq_mode = IMODE_INPUT;
 216
 217         spin_lock_irqsave(&devc->lock, flags);
 218         if (sb_dsp_command(devc, 0x24))         /* 8 bit ADC using DMA */
 219         {
 220                 sb_dsp_command(devc, (unsigned char) (count & 0xff));
 221                 sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff));
 222         }
 223         else
 224                 printk(KERN_ERR "Sound Blaster:  unable to start ADC.\n");
 225         spin_unlock_irqrestore(&devc->lock, flags);
 226
 227         devc->intr_active = 1;
 228 }
 229
 230 static void sb1_audio_trigger(int dev, int bits)
 231 {
 232         sb_devc *devc = audio_devs[dev]->devc;
 233
 234         bits &= devc->irq_mode;
 235
 236         if (!bits)
 237                 sb_dsp_command(devc, 0xd0);     /* Halt DMA */
 238         else
 239         {
 240                 switch (devc->irq_mode)
 241                 {
 242                         case IMODE_INPUT:
 243                                 sb1_audio_start_input(dev, devc->trg_buf, devc->trg_bytes,
 244                                                 devc->trg_intrflag);
 245                                 break;
 246
 247                         case IMODE_OUTPUT:
 248                                 sb1_audio_output_block(dev, devc->trg_buf, devc->trg_bytes,
 249                                                 devc->trg_intrflag);
 250                                 break;
 251                 }
 252         }
 253         devc->trigger_bits = bits;
 254 }
 255
 256 static int sb1_audio_prepare_for_input(int dev, int bsize, int bcount)
 257 {
 258         sb_devc *devc = audio_devs[dev]->devc;
 259         unsigned long flags;
 260
 261         spin_lock_irqsave(&devc->lock, flags);
 262         if (sb_dsp_command(devc, 0x40))
 263                 sb_dsp_command(devc, devc->tconst);
 264         sb_dsp_command(devc, DSP_CMD_SPKOFF);
 265         spin_unlock_irqrestore(&devc->lock, flags);
 266
 267         devc->trigger_bits = 0;
 268         return 0;
 269 }
 270
 271 static int sb1_audio_prepare_for_output(int dev, int bsize, int bcount)
 272 {
 273         sb_devc *devc = audio_devs[dev]->devc;
 274         unsigned long flags;
 275
 276         spin_lock_irqsave(&devc->lock, flags);
 277         if (sb_dsp_command(devc, 0x40))
 278                 sb_dsp_command(devc, devc->tconst);
 279         sb_dsp_command(devc, DSP_CMD_SPKON);
 280         spin_unlock_irqrestore(&devc->lock, flags);
 281         devc->trigger_bits = 0;
 282         return 0;
 283 }
 284
 285 static int sb1_audio_set_speed(int dev, int speed)
 286 {
 287         int max_speed = 23000;
 288         sb_devc *devc = audio_devs[dev]->devc;
 289         int tmp;
 290
 291         if (devc->opened & OPEN_READ)
 292                 max_speed = 13000;
 293
 294         if (speed > 0)
 295         {
 296                 if (speed < 4000)
 297                         speed = 4000;
 298
 299                 if (speed > max_speed)
 300                         speed = max_speed;
 301
 302                 devc->tconst = (256 - ((1000000 + speed / 2) / speed)) & 0xff;
 303                 tmp = 256 - devc->tconst;
 304                 speed = (1000000 + tmp / 2) / tmp;
 305
 306                 devc->speed = speed;
 307         }
 308         return devc->speed;
 309 }
 310
 311 static short sb1_audio_set_channels(int dev, short channels)
 312 {
 313         sb_devc *devc = audio_devs[dev]->devc;
 314         return devc->channels = 1;
 315 }
 316
 317 static unsigned int sb1_audio_set_bits(int dev, unsigned int bits)
 318 {
 319         sb_devc        *devc = audio_devs[dev]->devc;
 320         return devc->bits = 8;
 321 }
 322
 323 static void sb1_audio_halt_xfer(int dev)
 324 {
 325         unsigned long flags;
 326         sb_devc *devc = audio_devs[dev]->devc;
 327
 328         spin_lock_irqsave(&devc->lock, flags);
 329         sb_dsp_reset(devc);
 330         spin_unlock_irqrestore(&devc->lock, flags);
 331 }
 332
 333 /*
 334  * SB 2.0 and SB 2.01 compatible routines
 335  */
 336
 337 static void sb20_audio_output_block(int dev, unsigned long buf, int nr_bytes,
 338                         int intrflag)
 339 {
 340         unsigned long flags;
 341         int count = nr_bytes;
 342         sb_devc *devc = audio_devs[dev]->devc;
 343         unsigned char cmd;
 344
 345         /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE); */
 346
 347         if (audio_devs[dev]->dmap_out->dma > 3)
 348                 count >>= 1;
 349         count--;
 350
 351         devc->irq_mode = IMODE_OUTPUT;
 352
 353         spin_lock_irqsave(&devc->lock, flags);
 354         if (sb_dsp_command(devc, 0x48))         /* DSP Block size */
 355         {
 356                 sb_dsp_command(devc, (unsigned char) (count & 0xff));
 357                 sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff));
 358
 359                 if (devc->speed * devc->channels <= 23000)
 360                         cmd = 0x1c;     /* 8 bit PCM output */
 361                 else
 362                         cmd = 0x90;     /* 8 bit high speed PCM output (SB2.01/Pro) */
 363
 364                 if (!sb_dsp_command(devc, cmd))
 365                         printk(KERN_ERR "Sound Blaster:  unable to start DAC.\n");
 366         }
 367         else
 368                 printk(KERN_ERR "Sound Blaster: unable to start DAC.\n");
 369         spin_unlock_irqrestore(&devc->lock, flags);
 370         devc->intr_active = 1;
 371 }
 372
 373 static void sb20_audio_start_input(int dev, unsigned long buf, int nr_bytes, int intrflag)
 374 {
 375         unsigned long flags;
 376         int count = nr_bytes;
 377         sb_devc *devc = audio_devs[dev]->devc;
 378         unsigned char cmd;
 379
 380         /*
 381          * Start a DMA input to the buffer pointed by dmaqtail
 382          */
 383
 384         /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_READ); */
 385
 386         if (audio_devs[dev]->dmap_out->dma > 3)
 387                 count >>= 1;
 388         count--;
 389
 390         devc->irq_mode = IMODE_INPUT;
 391
 392         spin_lock_irqsave(&devc->lock, flags);
 393         if (sb_dsp_command(devc, 0x48))         /* DSP Block size */
 394         {
 395                 sb_dsp_command(devc, (unsigned char) (count & 0xff));
 396                 sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff));
 397
 398                 if (devc->speed * devc->channels <= (devc->major == 3 ? 23000 : 13000))
 399                         cmd = 0x2c;     /* 8 bit PCM input */
 400                 else
 401                         cmd = 0x98;     /* 8 bit high speed PCM input (SB2.01/Pro) */
 402
 403                 if (!sb_dsp_command(devc, cmd))
 404                         printk(KERN_ERR "Sound Blaster:  unable to start ADC.\n");
 405         }
 406         else
 407                 printk(KERN_ERR "Sound Blaster:  unable to start ADC.\n");
 408         spin_unlock_irqrestore(&devc->lock, flags);
 409         devc->intr_active = 1;
 410 }
 411
 412 static void sb20_audio_trigger(int dev, int bits)
 413 {
 414         sb_devc *devc = audio_devs[dev]->devc;
 415         bits &= devc->irq_mode;
 416
 417         if (!bits)
 418                 sb_dsp_command(devc, 0xd0);     /* Halt DMA */
 419         else
 420         {
 421                 switch (devc->irq_mode)
 422                 {
 423                         case IMODE_INPUT:
 424                                 sb20_audio_start_input(dev, devc->trg_buf, devc->trg_bytes,
 425                                                 devc->trg_intrflag);
 426                                 break;
 427
 428                         case IMODE_OUTPUT:
 429                                 sb20_audio_output_block(dev, devc->trg_buf, devc->trg_bytes,
 430                                                 devc->trg_intrflag);
 431                             break;
 432                 }
 433         }
 434         devc->trigger_bits = bits;
 435 }
 436
 437 /*
 438  * SB2.01 specific speed setup
 439  */
 440
 441 static int sb201_audio_set_speed(int dev, int speed)
 442 {
 443         sb_devc *devc = audio_devs[dev]->devc;
 444         int tmp;
 445         int s;
 446
 447         if (speed > 0)
 448         {
 449                 if (speed < 4000)
 450                         speed = 4000;
 451                 if (speed > 44100)
 452                         speed = 44100;
 453                 if (devc->opened & OPEN_READ && speed > 15000)
 454                         speed = 15000;
 455                 s = speed * devc->channels;
 456                 devc->tconst = (256 - ((1000000 + s / 2) / s)) & 0xff;
 457                 tmp = 256 - devc->tconst;
 458                 speed = ((1000000 + tmp / 2) / tmp) / devc->channels;
 459
 460                 devc->speed = speed;
 461         }
 462         return devc->speed;
 463 }
 464
 465 /*
 466  * SB Pro specific routines
 467  */
 468
 469 static int sbpro_audio_prepare_for_input(int dev, int bsize, int bcount)
 470 {                               /* For SB Pro and Jazz16 */
 471         sb_devc *devc = audio_devs[dev]->devc;
 472         unsigned long flags;
 473         unsigned char bits = 0;
 474
 475         if (devc->dma16 >= 0 && devc->dma16 != devc->dma8)
 476                 audio_devs[dev]->dmap_out->dma = audio_devs[dev]->dmap_in->dma =
 477                         devc->bits == 16 ? devc->dma16 : devc->dma8;
 478
 479         if (devc->model == MDL_JAZZ || devc->model == MDL_SMW)
 480                 if (devc->bits == AFMT_S16_LE)
 481                         bits = 0x04;    /* 16 bit mode */
 482
 483         spin_lock_irqsave(&devc->lock, flags);
 484         if (sb_dsp_command(devc, 0x40))
 485                 sb_dsp_command(devc, devc->tconst);
 486         sb_dsp_command(devc, DSP_CMD_SPKOFF);
 487         if (devc->channels == 1)
 488                 sb_dsp_command(devc, 0xa0 | bits);      /* Mono input */
 489         else
 490                 sb_dsp_command(devc, 0xa8 | bits);      /* Stereo input */
 491         spin_unlock_irqrestore(&devc->lock, flags);
 492
 493         devc->trigger_bits = 0;
 494         return 0;
 495 }
 496
 497 static int sbpro_audio_prepare_for_output(int dev, int bsize, int bcount)
 498 {                               /* For SB Pro and Jazz16 */
 499         sb_devc *devc = audio_devs[dev]->devc;
 500         unsigned long flags;
 501         unsigned char tmp;
 502         unsigned char bits = 0;
 503
 504         if (devc->dma16 >= 0 && devc->dma16 != devc->dma8)
 505                 audio_devs[dev]->dmap_out->dma = audio_devs[dev]->dmap_in->dma = devc->bits == 16 ? devc->dma16 : devc->dma8;
 506         if (devc->model == MDL_SBPRO)
 507                 sb_mixer_set_stereo(devc, devc->channels == 2);
 508
 509         spin_lock_irqsave(&devc->lock, flags);
 510         if (sb_dsp_command(devc, 0x40))
 511                 sb_dsp_command(devc, devc->tconst);
 512         sb_dsp_command(devc, DSP_CMD_SPKON);
 513
 514         if (devc->model == MDL_JAZZ || devc->model == MDL_SMW)
 515         {
 516                 if (devc->bits == AFMT_S16_LE)
 517                         bits = 0x04;    /* 16 bit mode */
 518
 519                 if (devc->channels == 1)
 520                         sb_dsp_command(devc, 0xa0 | bits);      /* Mono output */
 521                 else
 522                         sb_dsp_command(devc, 0xa8 | bits);      /* Stereo output */
 523                 spin_unlock_irqrestore(&devc->lock, flags);
 524         }
 525         else
 526         {
 527                 spin_unlock_irqrestore(&devc->lock, flags);
 528                 tmp = sb_getmixer(devc, 0x0e);
 529                 if (devc->channels == 1)
 530                         tmp &= ~0x02;
 531                 else
 532                         tmp |= 0x02;
 533                 sb_setmixer(devc, 0x0e, tmp);
 534         }
 535         devc->trigger_bits = 0;
 536         return 0;
 537 }
 538
 539 static int sbpro_audio_set_speed(int dev, int speed)
 540 {
 541         sb_devc *devc = audio_devs[dev]->devc;
 542
 543         if (speed > 0)
 544         {
 545                 if (speed < 4000)
 546                         speed = 4000;
 547                 if (speed > 44100)
 548                         speed = 44100;
 549                 if (devc->channels > 1 && speed > 22050)
 550                         speed = 22050;
 551                 sb201_audio_set_speed(dev, speed);
 552         }
 553         return devc->speed;
 554 }
 555
 556 static short sbpro_audio_set_channels(int dev, short channels)
 557 {
 558         sb_devc *devc = audio_devs[dev]->devc;
 559
 560         if (channels == 1 || channels == 2)
 561         {
 562                 if (channels != devc->channels)
 563                 {
 564                         devc->channels = channels;
 565                         if (devc->model == MDL_SBPRO && devc->channels == 2)
 566                                 sbpro_audio_set_speed(dev, devc->speed);
 567                 }
 568         }
 569         return devc->channels;
 570 }
 571
 572 static int jazz16_audio_set_speed(int dev, int speed)
 573 {
 574         sb_devc *devc = audio_devs[dev]->devc;
 575
 576         if (speed > 0)
 577         {
 578                 int tmp;
 579                 int s;
 580
 581                 if (speed < 5000)
 582                         speed = 5000;
 583                 if (speed > 44100)
 584                         speed = 44100;
 585
 586                 s = speed * devc->channels;
 587
 588                 devc->tconst = (256 - ((1000000 + s / 2) / s)) & 0xff;
 589
 590                 tmp = 256 - devc->tconst;
 591                 speed = ((1000000 + tmp / 2) / tmp) / devc->channels;
 592
 593                 devc->speed = speed;
 594         }
 595         return devc->speed;
 596 }
 597
 598 /*
 599  * SB16 specific routines
 600  */
 601
 602 static int sb16_audio_set_speed(int dev, int speed)
 603 {
 604         sb_devc *devc = audio_devs[dev]->devc;
 605         int     max_speed = devc->submodel == SUBMDL_ALS100 ? 48000 : 44100;
 606
 607         if (speed > 0)
 608         {
 609                 if (speed < 5000)
 610                         speed = 5000;
 611
 612                 if (speed > max_speed)
 613                         speed = max_speed;
 614
 615                 devc->speed = speed;
 616         }
 617         return devc->speed;
 618 }
 619
 620 static unsigned int sb16_audio_set_bits(int dev, unsigned int bits)
 621 {
 622         sb_devc *devc = audio_devs[dev]->devc;
 623
 624         if (bits != 0)
 625         {
 626                 if (bits == AFMT_U8 || bits == AFMT_S16_LE)
 627                         devc->bits = bits;
 628                 else
 629                         devc->bits = AFMT_U8;
 630         }
 631
 632         return devc->bits;
 633 }
 634
 635 static int sb16_audio_prepare_for_input(int dev, int bsize, int bcount)
 636 {
 637         sb_devc *devc = audio_devs[dev]->devc;
 638
 639         if (!devc->fullduplex)
 640         {
 641                 audio_devs[dev]->dmap_out->dma =
 642                         audio_devs[dev]->dmap_in->dma =
 643                                 devc->bits == AFMT_S16_LE ?
 644                                         devc->dma16 : devc->dma8;
 645         }
 646         else if (devc->bits == AFMT_S16_LE)
 647         {
 648                 audio_devs[dev]->dmap_out->dma = devc->dma8;
 649                 audio_devs[dev]->dmap_in->dma = devc->dma16;
 650         }
 651         else
 652         {
 653                 audio_devs[dev]->dmap_out->dma = devc->dma16;
 654                 audio_devs[dev]->dmap_in->dma = devc->dma8;
 655         }
 656
 657         devc->trigger_bits = 0;
 658         return 0;
 659 }
 660
 661 static int sb16_audio_prepare_for_output(int dev, int bsize, int bcount)
 662 {
 663         sb_devc *devc = audio_devs[dev]->devc;
 664
 665         if (!devc->fullduplex)
 666         {
 667                 audio_devs[dev]->dmap_out->dma =
 668                         audio_devs[dev]->dmap_in->dma =
 669                                 devc->bits == AFMT_S16_LE ?
 670                                         devc->dma16 : devc->dma8;
 671         }
 672         else if (devc->bits == AFMT_S16_LE)
 673         {
 674                 audio_devs[dev]->dmap_out->dma = devc->dma8;
 675                 audio_devs[dev]->dmap_in->dma = devc->dma16;
 676         }
 677         else
 678         {
 679                 audio_devs[dev]->dmap_out->dma = devc->dma16;
 680                 audio_devs[dev]->dmap_in->dma = devc->dma8;
 681         }
 682
 683         devc->trigger_bits = 0;
 684         return 0;
 685 }
 686
 687 static void sb16_audio_output_block(int dev, unsigned long buf, int count,
 688                         int intrflag)
 689 {
 690         unsigned long   flags, cnt;
 691         sb_devc        *devc = audio_devs[dev]->devc;
 692         unsigned long   bits;
 693
 694         if (!devc->fullduplex || devc->bits == AFMT_S16_LE)
 695         {
 696                 devc->irq_mode = IMODE_OUTPUT;
 697                 devc->intr_active = 1;
 698         }
 699         else
 700         {
 701                 devc->irq_mode_16 = IMODE_OUTPUT;
 702                 devc->intr_active_16 = 1;
 703         }
 704
 705         /* save value */
 706         spin_lock_irqsave(&devc->lock, flags);
 707         bits = devc->bits;
 708         if (devc->fullduplex)
 709                 devc->bits = (devc->bits == AFMT_S16_LE) ?
 710                         AFMT_U8 : AFMT_S16_LE;
 711         spin_unlock_irqrestore(&devc->lock, flags);
 712
 713         cnt = count;
 714         if (devc->bits == AFMT_S16_LE)
 715                 cnt >>= 1;
 716         cnt--;
 717
 718         spin_lock_irqsave(&devc->lock, flags);
 719
 720         /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE); */
 721
 722         sb_dsp_command(devc, 0x41);
 723         sb_dsp_command(devc, (unsigned char) ((devc->speed >> 8) & 0xff));
 724         sb_dsp_command(devc, (unsigned char) (devc->speed & 0xff));
 725
 726         sb_dsp_command(devc, (devc->bits == AFMT_S16_LE ? 0xb6 : 0xc6));
 727         sb_dsp_command(devc, ((devc->channels == 2 ? 0x20 : 0) +
 728                               (devc->bits == AFMT_S16_LE ? 0x10 : 0)));
 729         sb_dsp_command(devc, (unsigned char) (cnt & 0xff));
 730         sb_dsp_command(devc, (unsigned char) (cnt >> 8));
 731
 732         /* restore real value after all programming */
 733         devc->bits = bits;
 734         spin_unlock_irqrestore(&devc->lock, flags);
 735 }
 736
 737
 738 /*
 739  *      This fails on the Cyrix MediaGX. If you don't have the DMA enabled
 740  *      before the first sample arrives it locks up. However even if you
 741  *      do enable the DMA in time you just get DMA timeouts and missing
 742  *      interrupts and stuff, so for now I've not bothered fixing this either.
 743  */
 744
 745 static void sb16_audio_start_input(int dev, unsigned long buf, int count, int intrflag)
 746 {
 747         unsigned long   flags, cnt;
 748         sb_devc        *devc = audio_devs[dev]->devc;
 749
 750         if (!devc->fullduplex || devc->bits != AFMT_S16_LE)
 751         {
 752                 devc->irq_mode = IMODE_INPUT;
 753                 devc->intr_active = 1;
 754         }
 755         else
 756         {
 757                 devc->irq_mode_16 = IMODE_INPUT;
 758                 devc->intr_active_16 = 1;
 759         }
 760
 761         cnt = count;
 762         if (devc->bits == AFMT_S16_LE)
 763                 cnt >>= 1;
 764         cnt--;
 765
 766         spin_lock_irqsave(&devc->lock, flags);
 767
 768         /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_READ); */
 769
 770         sb_dsp_command(devc, 0x42);
 771         sb_dsp_command(devc, (unsigned char) ((devc->speed >> 8) & 0xff));
 772         sb_dsp_command(devc, (unsigned char) (devc->speed & 0xff));
 773
 774         sb_dsp_command(devc, (devc->bits == AFMT_S16_LE ? 0xbe : 0xce));
 775         sb_dsp_command(devc, ((devc->channels == 2 ? 0x20 : 0) +
 776                               (devc->bits == AFMT_S16_LE ? 0x10 : 0)));
 777         sb_dsp_command(devc, (unsigned char) (cnt & 0xff));
 778         sb_dsp_command(devc, (unsigned char) (cnt >> 8));
 779
 780         spin_unlock_irqrestore(&devc->lock, flags);
 781 }
 782
 783 static void sb16_audio_trigger(int dev, int bits)
 784 {
 785         sb_devc *devc = audio_devs[dev]->devc;
 786
 787         int bits_16 = bits & devc->irq_mode_16;
 788         bits &= devc->irq_mode;
 789
 790         if (!bits && !bits_16)
 791                 sb_dsp_command(devc, 0xd0);     /* Halt DMA */
 792         else
 793         {
 794                 if (bits)
 795                 {
 796                         switch (devc->irq_mode)
 797                         {
 798                                 case IMODE_INPUT:
 799                                         sb16_audio_start_input(dev,
 800                                                         devc->trg_buf,
 801                                                         devc->trg_bytes,
 802                                                         devc->trg_intrflag);
 803                                         break;
 804
 805                                 case IMODE_OUTPUT:
 806                                         sb16_audio_output_block(dev,
 807                                                         devc->trg_buf,
 808                                                         devc->trg_bytes,
 809                                                         devc->trg_intrflag);
 810                                         break;
 811                         }
 812                 }
 813                 if (bits_16)
 814                 {
 815                         switch (devc->irq_mode_16)
 816                         {
 817                                 case IMODE_INPUT:
 818                                         sb16_audio_start_input(dev,
 819                                                         devc->trg_buf_16,
 820                                                         devc->trg_bytes_16,
 821                                                         devc->trg_intrflag_16);
 822                                         break;
 823
 824                                 case IMODE_OUTPUT:
 825                                         sb16_audio_output_block(dev,
 826                                                         devc->trg_buf_16,
 827                                                         devc->trg_bytes_16,
 828                                                         devc->trg_intrflag_16);
 829                                         break;
 830                         }
 831                 }
 832         }
 833
 834         devc->trigger_bits = bits | bits_16;
 835 }
 836
 837 static unsigned char lbuf8[2048];
 838 static signed short *lbuf16 = (signed short *)lbuf8;
 839 #define LBUFCOPYSIZE 1024
 840 static void
 841 sb16_copy_from_user(int dev,
 842                 char *localbuf, int localoffs,
 843                 const char __user *userbuf, int useroffs,
 844                 int max_in, int max_out,
 845                 int *used, int *returned,
 846                 int len)
 847 {
 848         sb_devc       *devc = audio_devs[dev]->devc;
 849         int           i, c, p, locallen;
 850         unsigned char *buf8;
 851         signed short  *buf16;
 852
 853         /* if not duplex no conversion */
 854         if (!devc->fullduplex)
 855         {
 856                 if (copy_from_user(localbuf + localoffs,
 857                                    userbuf + useroffs, len))
 858                         return;
 859                 *used = len;
 860                 *returned = len;
 861         }
 862         else if (devc->bits == AFMT_S16_LE)
 863         {
 864                 /* 16 -> 8 */
 865                 /* max_in >> 1, max number of samples in ( 16 bits ) */
 866                 /* max_out, max number of samples out ( 8 bits ) */
 867                 /* len, number of samples that will be taken ( 16 bits )*/
 868                 /* c, count of samples remaining in buffer ( 16 bits )*/
 869                 /* p, count of samples already processed ( 16 bits )*/
 870                 len = ( (max_in >> 1) > max_out) ? max_out : (max_in >> 1);
 871                 c = len;
 872                 p = 0;
 873                 buf8 = (unsigned char *)(localbuf + localoffs);
 874                 while (c)
 875                 {
 876                         locallen = (c >= LBUFCOPYSIZE ? LBUFCOPYSIZE : c);
 877                         /* << 1 in order to get 16 bit samples */
 878                         if (copy_from_user(lbuf16,
 879                                            userbuf + useroffs + (p << 1),
 880                                            locallen << 1))
 881                                 return;
 882                         for (i = 0; i < locallen; i++)
 883                         {
 884                                 buf8[p+i] = ~((lbuf16[i] >> 8) & 0xff) ^ 0x80;
 885                         }
 886                         c -= locallen; p += locallen;
 887                 }
 888                 /* used = ( samples * 16 bits size ) */
 889                 *used =  max_in  > ( max_out << 1) ? (max_out << 1) : max_in;
 890                 /* returned = ( samples * 8 bits size ) */
 891                 *returned = len;
 892         }
 893         else
 894         {
 895                 /* 8 -> 16 */
 896                 /* max_in, max number of samples in ( 8 bits ) */
 897                 /* max_out >> 1, max number of samples out ( 16 bits ) */
 898                 /* len, number of samples that will be taken ( 8 bits )*/
 899                 /* c, count of samples remaining in buffer ( 8 bits )*/
 900                 /* p, count of samples already processed ( 8 bits )*/
 901                 len = max_in > (max_out >> 1) ? (max_out >> 1) : max_in;
 902                 c = len;
 903                 p = 0;
 904                 buf16 = (signed short *)(localbuf + localoffs);
 905                 while (c)
 906                 {
 907                         locallen = (c >= LBUFCOPYSIZE ? LBUFCOPYSIZE : c);
 908                         if (copy_from_user(lbuf8,
 909                                            userbuf+useroffs + p,
 910                                            locallen))
 911                                 return;
 912                         for (i = 0; i < locallen; i++)
 913                         {
 914                                 buf16[p+i] = (~lbuf8[i] ^ 0x80) << 8;
 915                         }
 916                         c -= locallen; p += locallen;
 917                 }
 918                 /* used = ( samples * 8 bits size ) */
 919                 *used = len;
 920                 /* returned = ( samples * 16 bits size ) */
 921                 *returned = len << 1;
 922         }
 923 }
 924
 925 static void
 926 sb16_audio_mmap(int dev)
 927 {
 928         sb_devc       *devc = audio_devs[dev]->devc;
 929         devc->fullduplex = 0;
 930 }
 931
 932 static struct audio_driver sb1_audio_driver =   /* SB1.x */
 933 {
 934         .owner                  = THIS_MODULE,
 935         .open                   = sb_audio_open,
 936         .close                  = sb_audio_close,
 937         .output_block           = sb_set_output_parms,
 938         .start_input            = sb_set_input_parms,
 939         .prepare_for_input      = sb1_audio_prepare_for_input,
 940         .prepare_for_output     = sb1_audio_prepare_for_output,
 941         .halt_io                = sb1_audio_halt_xfer,
 942         .trigger                = sb1_audio_trigger,
 943         .set_speed              = sb1_audio_set_speed,
 944         .set_bits               = sb1_audio_set_bits,
 945         .set_channels           = sb1_audio_set_channels
 946 };
 947
 948 static struct audio_driver sb20_audio_driver =  /* SB2.0 */
 949 {
 950         .owner                  = THIS_MODULE,
 951         .open                   = sb_audio_open,
 952         .close                  = sb_audio_close,
 953         .output_block           = sb_set_output_parms,
 954         .start_input            = sb_set_input_parms,
 955         .prepare_for_input      = sb1_audio_prepare_for_input,
 956         .prepare_for_output     = sb1_audio_prepare_for_output,
 957         .halt_io                = sb1_audio_halt_xfer,
 958         .trigger                = sb20_audio_trigger,
 959         .set_speed              = sb1_audio_set_speed,
 960         .set_bits               = sb1_audio_set_bits,
 961         .set_channels           = sb1_audio_set_channels
 962 };
 963
 964 static struct audio_driver sb201_audio_driver =         /* SB2.01 */
 965 {
 966         .owner                  = THIS_MODULE,
 967         .open                   = sb_audio_open,
 968         .close                  = sb_audio_close,
 969         .output_block           = sb_set_output_parms,
 970         .start_input            = sb_set_input_parms,
 971         .prepare_for_input      = sb1_audio_prepare_for_input,
 972         .prepare_for_output     = sb1_audio_prepare_for_output,
 973         .halt_io                = sb1_audio_halt_xfer,
 974         .trigger                = sb20_audio_trigger,
 975         .set_speed              = sb201_audio_set_speed,
 976         .set_bits               = sb1_audio_set_bits,
 977         .set_channels           = sb1_audio_set_channels
 978 };
 979
 980 static struct audio_driver sbpro_audio_driver =         /* SB Pro */
 981 {
 982         .owner                  = THIS_MODULE,
 983         .open                   = sb_audio_open,
 984         .close                  = sb_audio_close,
 985         .output_block           = sb_set_output_parms,
 986         .start_input            = sb_set_input_parms,
 987         .prepare_for_input      = sbpro_audio_prepare_for_input,
 988         .prepare_for_output     = sbpro_audio_prepare_for_output,
 989         .halt_io                = sb1_audio_halt_xfer,
 990         .trigger                = sb20_audio_trigger,
 991         .set_speed              = sbpro_audio_set_speed,
 992         .set_bits               = sb1_audio_set_bits,
 993         .set_channels           = sbpro_audio_set_channels
 994 };
 995
 996 static struct audio_driver jazz16_audio_driver =        /* Jazz16 and SM Wave */
 997 {
 998         .owner                  = THIS_MODULE,
 999         .open                   = sb_audio_open,
1000         .close                  = sb_audio_close,
1001         .output_block           = sb_set_output_parms,
1002         .start_input            = sb_set_input_parms,
1003         .prepare_for_input      = sbpro_audio_prepare_for_input,
1004         .prepare_for_output     = sbpro_audio_prepare_for_output,
1005         .halt_io                = sb1_audio_halt_xfer,
1006         .trigger                = sb20_audio_trigger,
1007         .set_speed              = jazz16_audio_set_speed,
1008         .set_bits               = sb16_audio_set_bits,
1009         .set_channels           = sbpro_audio_set_channels
1010 };
1011
1012 static struct audio_driver sb16_audio_driver =  /* SB16 */
1013 {
1014         .owner                  = THIS_MODULE,
1015         .open                   = sb_audio_open,
1016         .close                  = sb_audio_close,
1017         .output_block           = sb_set_output_parms,
1018         .start_input            = sb_set_input_parms,
1019         .prepare_for_input      = sb16_audio_prepare_for_input,
1020         .prepare_for_output     = sb16_audio_prepare_for_output,
1021         .halt_io                = sb1_audio_halt_xfer,
1022         .copy_user              = sb16_copy_from_user,
1023         .trigger                = sb16_audio_trigger,
1024         .set_speed              = sb16_audio_set_speed,
1025         .set_bits               = sb16_audio_set_bits,
1026         .set_channels           = sbpro_audio_set_channels,
1027         .mmap                   = sb16_audio_mmap
1028 };
1029
1030 void sb_audio_init(sb_devc * devc, char *name, struct module *owner)
1031 {
1032         int audio_flags = 0;
1033         int format_mask = AFMT_U8;
1034
1035         struct audio_driver *driver = &sb1_audio_driver;
1036
1037         switch (devc->model)
1038         {
1039                 case MDL_SB1:   /* SB1.0 or SB 1.5 */
1040                         DDB(printk("Will use standard SB1.x driver\n"));
1041                         audio_flags = DMA_HARDSTOP;
1042                         break;
1043
1044                 case MDL_SB2:
1045                         DDB(printk("Will use SB2.0 driver\n"));
1046                         audio_flags = DMA_AUTOMODE;
1047                         driver = &sb20_audio_driver;
1048                         break;
1049
1050                 case MDL_SB201:
1051                         DDB(printk("Will use SB2.01 (high speed) driver\n"));
1052                         audio_flags = DMA_AUTOMODE;
1053                         driver = &sb201_audio_driver;
1054                         break;
1055
1056                 case MDL_JAZZ:
1057                 case MDL_SMW:
1058                         DDB(printk("Will use Jazz16 driver\n"));
1059                         audio_flags = DMA_AUTOMODE;
1060                         format_mask |= AFMT_S16_LE;
1061                         driver = &jazz16_audio_driver;
1062                         break;
1063
1064                 case MDL_ESS:
1065                         DDB(printk("Will use ESS ES688/1688 driver\n"));
1066                         driver = ess_audio_init (devc, &audio_flags, &format_mask);
1067                         break;
1068
1069                 case MDL_SB16:
1070                         DDB(printk("Will use SB16 driver\n"));
1071                         audio_flags = DMA_AUTOMODE;
1072                         format_mask |= AFMT_S16_LE;
1073                         if (devc->dma8 != devc->dma16 && devc->dma16 != -1)
1074                         {
1075                                 audio_flags |= DMA_DUPLEX;
1076                                 devc->duplex = 1;
1077                         }
1078                         driver = &sb16_audio_driver;
1079                         break;
1080
1081                 default:
1082                         DDB(printk("Will use SB Pro driver\n"));
1083                         audio_flags = DMA_AUTOMODE;
1084                         driver = &sbpro_audio_driver;
1085         }
1086
1087         if (owner)
1088                         driver->owner = owner;
1089
1090         if ((devc->dev = sound_install_audiodrv(AUDIO_DRIVER_VERSION,
1091                                 name,driver, sizeof(struct audio_driver),
1092                                 audio_flags, format_mask, devc,
1093                                 devc->dma8,
1094                                 devc->duplex ? devc->dma16 : devc->dma8)) < 0)
1095         {
1096                   printk(KERN_ERR "Sound Blaster:  unable to install audio.\n");
1097                   return;
1098         }
1099         audio_devs[devc->dev]->mixer_dev = devc->my_mixerdev;
1100         audio_devs[devc->dev]->min_fragment = 5;
1101 }