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