~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/oss/sb_audio.c

Version: ~ [ linux-5.11 ] ~ [ linux-5.10.17 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.99 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.176 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.221 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.257 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.257 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp