drivers/sound/sb_audio.c

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