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