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