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

TOMOYO Linux Cross Reference
Linux/sound/oss/dmasound/dmasound_core.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  *  linux/sound/oss/dmasound/dmasound_core.c
  3  *
  4  *
  5  *  OSS/Free compatible Atari TT/Falcon and Amiga DMA sound driver for
  6  *  Linux/m68k
  7  *  Extended to support Power Macintosh for Linux/ppc by Paul Mackerras
  8  *
  9  *  (c) 1995 by Michael Schlueter & Michael Marte
 10  *
 11  *  Michael Schlueter (michael@duck.syd.de) did the basic structure of the VFS
 12  *  interface and the u-law to signed byte conversion.
 13  *
 14  *  Michael Marte (marte@informatik.uni-muenchen.de) did the sound queue,
 15  *  /dev/mixer, /dev/sndstat and complemented the VFS interface. He would like
 16  *  to thank:
 17  *    - Michael Schlueter for initial ideas and documentation on the MFP and
 18  *      the DMA sound hardware.
 19  *    - Therapy? for their CD 'Troublegum' which really made me rock.
 20  *
 21  *  /dev/sndstat is based on code by Hannu Savolainen, the author of the
 22  *  VoxWare family of drivers.
 23  *
 24  *  This file is subject to the terms and conditions of the GNU General Public
 25  *  License.  See the file COPYING in the main directory of this archive
 26  *  for more details.
 27  *
 28  *  History:
 29  *
 30  *      1995/8/25       First release
 31  *
 32  *      1995/9/02       Roman Hodek:
 33  *                        - Fixed atari_stram_alloc() call, the timer
 34  *                          programming and several race conditions
 35  *      1995/9/14       Roman Hodek:
 36  *                        - After some discussion with Michael Schlueter,
 37  *                          revised the interrupt disabling
 38  *                        - Slightly speeded up U8->S8 translation by using
 39  *                          long operations where possible
 40  *                        - Added 4:3 interpolation for /dev/audio
 41  *
 42  *      1995/9/20       Torsten Scherer:
 43  *                        - Fixed a bug in sq_write and changed /dev/audio
 44  *                          converting to play at 12517Hz instead of 6258Hz.
 45  *
 46  *      1995/9/23       Torsten Scherer:
 47  *                        - Changed sq_interrupt() and sq_play() to pre-program
 48  *                          the DMA for another frame while there's still one
 49  *                          running. This allows the IRQ response to be
 50  *                          arbitrarily delayed and playing will still continue.
 51  *
 52  *      1995/10/14      Guenther Kelleter, Torsten Scherer:
 53  *                        - Better support for Falcon audio (the Falcon doesn't
 54  *                          raise an IRQ at the end of a frame, but at the
 55  *                          beginning instead!). uses 'if (codec_dma)' in lots
 56  *                          of places to simply switch between Falcon and TT
 57  *                          code.
 58  *
 59  *      1995/11/06      Torsten Scherer:
 60  *                        - Started introducing a hardware abstraction scheme
 61  *                          (may perhaps also serve for Amigas?)
 62  *                        - Can now play samples at almost all frequencies by
 63  *                          means of a more generalized expand routine
 64  *                        - Takes a good deal of care to cut data only at
 65  *                          sample sizes
 66  *                        - Buffer size is now a kernel runtime option
 67  *                        - Implemented fsync() & several minor improvements
 68  *                      Guenther Kelleter:
 69  *                        - Useful hints and bug fixes
 70  *                        - Cross-checked it for Falcons
 71  *
 72  *      1996/3/9        Geert Uytterhoeven:
 73  *                        - Support added for Amiga, A-law, 16-bit little
 74  *                          endian.
 75  *                        - Unification to drivers/sound/dmasound.c.
 76  *
 77  *      1996/4/6        Martin Mitchell:
 78  *                        - Updated to 1.3 kernel.
 79  *
 80  *      1996/6/13       Topi Kanerva:
 81  *                        - Fixed things that were broken (mainly the amiga
 82  *                          14-bit routines)
 83  *                        - /dev/sndstat shows now the real hardware frequency
 84  *                        - The lowpass filter is disabled by default now
 85  *
 86  *      1996/9/25       Geert Uytterhoeven:
 87  *                        - Modularization
 88  *
 89  *      1998/6/10       Andreas Schwab:
 90  *                        - Converted to use sound_core
 91  *
 92  *      1999/12/28      Richard Zidlicky:
 93  *                        - Added support for Q40
 94  *
 95  *      2000/2/27       Geert Uytterhoeven:
 96  *                        - Clean up and split the code into 4 parts:
 97  *                            o dmasound_core: machine-independent code
 98  *                            o dmasound_atari: Atari TT and Falcon support
 99  *                            o dmasound_awacs: Apple PowerMac support
100  *                            o dmasound_paula: Amiga support
101  *
102  *      2000/3/25       Geert Uytterhoeven:
103  *                        - Integration of dmasound_q40
104  *                        - Small clean ups
105  *
106  *      2001/01/26 [1.0] Iain Sandoe
107  *                        - make /dev/sndstat show revision & edition info.
108  *                        - since dmasound.mach.sq_setup() can fail on pmac
109  *                          its type has been changed to int and the returns
110  *                          are checked.
111  *                 [1.1]  - stop missing translations from being called.
112  *      2001/02/08 [1.2]  - remove unused translation tables & move machine-
113  *                          specific tables to low-level.
114  *                        - return correct info. for SNDCTL_DSP_GETFMTS.
115  *                 [1.3]  - implement SNDCTL_DSP_GETCAPS fully.
116  *                 [1.4]  - make /dev/sndstat text length usage deterministic.
117  *                        - make /dev/sndstat call to low-level
118  *                          dmasound.mach.state_info() pass max space to ll driver.
119  *                        - tidy startup banners and output info.
120  *                 [1.5]  - tidy up a little (removed some unused #defines in
121  *                          dmasound.h)
122  *                        - fix up HAS_RECORD conditionalisation.
123  *                        - add record code in places it is missing...
124  *                        - change buf-sizes to bytes to allow < 1kb for pmac
125  *                          if user param entry is < 256 the value is taken to
126  *                          be in kb > 256 is taken to be in bytes.
127  *                        - make default buff/frag params conditional on
128  *                          machine to allow smaller values for pmac.
129  *                        - made the ioctls, read & write comply with the OSS
130  *                          rules on setting params.
131  *                        - added parsing of _setup() params for record.
132  *      2001/04/04 [1.6]  - fix bug where sample rates higher than maximum were
133  *                          being reported as OK.
134  *                        - fix open() to return -EBUSY as per OSS doc. when
135  *                          audio is in use - this is independent of O_NOBLOCK.
136  *                        - fix bug where SNDCTL_DSP_POST was blocking.
137  */
138 
139  /* Record capability notes 30/01/2001:
140   * At present these observations apply only to pmac LL driver (the only one
141   * that can do record, at present).  However, if other LL drivers for machines
142   * with record are added they may apply.
143   *
144   * The fragment parameters for the record and play channels are separate.
145   * However, if the driver is opened O_RDWR there is no way (in the current OSS
146   * API) to specify their values independently for the record and playback
147   * channels.  Since the only common factor between the input & output is the
148   * sample rate (on pmac) it should be possible to open /dev/dspX O_WRONLY and
149   * /dev/dspY O_RDONLY.  The input & output channels could then have different
150   * characteristics (other than the first that sets sample rate claiming the
151   * right to set it for ever).  As it stands, the format, channels, number of
152   * bits & sample rate are assumed to be common.  In the future perhaps these
153   * should be the responsibility of the LL driver - and then if a card really
154   * does not share items between record & playback they can be specified
155   * separately.
156 */
157 
158 /* Thread-safeness of shared_resources notes: 31/01/2001
159  * If the user opens O_RDWR and then splits record & play between two threads
160  * both of which inherit the fd - and then starts changing things from both
161  * - we will have difficulty telling.
162  *
163  * It's bad application coding - but ...
164  * TODO: think about how to sort this out... without bogging everything down in
165  * semaphores.
166  *
167  * Similarly, the OSS spec says "all changes to parameters must be between
168  * open() and the first read() or write(). - and a bit later on (by
169  * implication) "between SNDCTL_DSP_RESET and the first read() or write() after
170  * it".  If the app is multi-threaded and this rule is broken between threads
171  * we will have trouble spotting it - and the fault will be rather obscure :-(
172  *
173  * We will try and put out at least a kmsg if we see it happen... but I think
174  * it will be quite hard to trap it with an -EXXX return... because we can't
175  * see the fault until after the damage is done.
176 */
177 
178 #include <linux/module.h>
179 #include <linux/slab.h>
180 #include <linux/sound.h>
181 #include <linux/init.h>
182 #include <linux/soundcard.h>
183 #include <linux/poll.h>
184 #include <linux/mutex.h>
185 
186 #include <asm/uaccess.h>
187 
188 #include "dmasound.h"
189 
190 #define DMASOUND_CORE_REVISION 1
191 #define DMASOUND_CORE_EDITION 6
192 
193     /*
194      *  Declarations
195      */
196 
197 static DEFINE_MUTEX(dmasound_core_mutex);
198 int dmasound_catchRadius = 0;
199 module_param(dmasound_catchRadius, int, 0);
200 
201 static unsigned int numWriteBufs = DEFAULT_N_BUFFERS;
202 module_param(numWriteBufs, int, 0);
203 static unsigned int writeBufSize = DEFAULT_BUFF_SIZE ;  /* in bytes */
204 module_param(writeBufSize, int, 0);
205 
206 MODULE_LICENSE("GPL");
207 
208 #ifdef MODULE
209 static int sq_unit = -1;
210 static int mixer_unit = -1;
211 static int state_unit = -1;
212 static int irq_installed;
213 #endif /* MODULE */
214 
215 /* control over who can modify resources shared between play/record */
216 static fmode_t shared_resource_owner;
217 static int shared_resources_initialised;
218 
219     /*
220      *  Mid level stuff
221      */
222 
223 struct sound_settings dmasound = {
224         .lock = __SPIN_LOCK_UNLOCKED(dmasound.lock)
225 };
226 
227 static inline void sound_silence(void)
228 {
229         dmasound.mach.silence(); /* _MUST_ stop DMA */
230 }
231 
232 static inline int sound_set_format(int format)
233 {
234         return dmasound.mach.setFormat(format);
235 }
236 
237 
238 static int sound_set_speed(int speed)
239 {
240         if (speed < 0)
241                 return dmasound.soft.speed;
242 
243         /* trap out-of-range speed settings.
244            at present we allow (arbitrarily) low rates - using soft
245            up-conversion - but we can't allow > max because there is
246            no soft down-conversion.
247         */
248         if (dmasound.mach.max_dsp_speed &&
249            (speed > dmasound.mach.max_dsp_speed))
250                 speed = dmasound.mach.max_dsp_speed ;
251 
252         dmasound.soft.speed = speed;
253 
254         if (dmasound.minDev == SND_DEV_DSP)
255                 dmasound.dsp.speed = dmasound.soft.speed;
256 
257         return dmasound.soft.speed;
258 }
259 
260 static int sound_set_stereo(int stereo)
261 {
262         if (stereo < 0)
263                 return dmasound.soft.stereo;
264 
265         stereo = !!stereo;    /* should be 0 or 1 now */
266 
267         dmasound.soft.stereo = stereo;
268         if (dmasound.minDev == SND_DEV_DSP)
269                 dmasound.dsp.stereo = stereo;
270 
271         return stereo;
272 }
273 
274 static ssize_t sound_copy_translate(TRANS *trans, const u_char __user *userPtr,
275                                     size_t userCount, u_char frame[],
276                                     ssize_t *frameUsed, ssize_t frameLeft)
277 {
278         ssize_t (*ct_func)(const u_char __user *, size_t, u_char *, ssize_t *, ssize_t);
279 
280         switch (dmasound.soft.format) {
281             case AFMT_MU_LAW:
282                 ct_func = trans->ct_ulaw;
283                 break;
284             case AFMT_A_LAW:
285                 ct_func = trans->ct_alaw;
286                 break;
287             case AFMT_S8:
288                 ct_func = trans->ct_s8;
289                 break;
290             case AFMT_U8:
291                 ct_func = trans->ct_u8;
292                 break;
293             case AFMT_S16_BE:
294                 ct_func = trans->ct_s16be;
295                 break;
296             case AFMT_U16_BE:
297                 ct_func = trans->ct_u16be;
298                 break;
299             case AFMT_S16_LE:
300                 ct_func = trans->ct_s16le;
301                 break;
302             case AFMT_U16_LE:
303                 ct_func = trans->ct_u16le;
304                 break;
305             default:
306                 return 0;
307         }
308         /* if the user has requested a non-existent translation don't try
309            to call it but just return 0 bytes moved
310         */
311         if (ct_func)
312                 return ct_func(userPtr, userCount, frame, frameUsed, frameLeft);
313         return 0;
314 }
315 
316     /*
317      *  /dev/mixer abstraction
318      */
319 
320 static struct {
321     int busy;
322     int modify_counter;
323 } mixer;
324 
325 static int mixer_open(struct inode *inode, struct file *file)
326 {
327         mutex_lock(&dmasound_core_mutex);
328         if (!try_module_get(dmasound.mach.owner)) {
329                 mutex_unlock(&dmasound_core_mutex);
330                 return -ENODEV;
331         }
332         mixer.busy = 1;
333         mutex_unlock(&dmasound_core_mutex);
334         return 0;
335 }
336 
337 static int mixer_release(struct inode *inode, struct file *file)
338 {
339         mutex_lock(&dmasound_core_mutex);
340         mixer.busy = 0;
341         module_put(dmasound.mach.owner);
342         mutex_unlock(&dmasound_core_mutex);
343         return 0;
344 }
345 
346 static int mixer_ioctl(struct file *file, u_int cmd, u_long arg)
347 {
348         if (_SIOC_DIR(cmd) & _SIOC_WRITE)
349             mixer.modify_counter++;
350         switch (cmd) {
351             case OSS_GETVERSION:
352                 return IOCTL_OUT(arg, SOUND_VERSION);
353             case SOUND_MIXER_INFO:
354                 {
355                     mixer_info info;
356                     memset(&info, 0, sizeof(info));
357                     strlcpy(info.id, dmasound.mach.name2, sizeof(info.id));
358                     strlcpy(info.name, dmasound.mach.name2, sizeof(info.name));
359                     info.modify_counter = mixer.modify_counter;
360                     if (copy_to_user((void __user *)arg, &info, sizeof(info)))
361                             return -EFAULT;
362                     return 0;
363                 }
364         }
365         if (dmasound.mach.mixer_ioctl)
366             return dmasound.mach.mixer_ioctl(cmd, arg);
367         return -EINVAL;
368 }
369 
370 static long mixer_unlocked_ioctl(struct file *file, u_int cmd, u_long arg)
371 {
372         int ret;
373 
374         mutex_lock(&dmasound_core_mutex);
375         ret = mixer_ioctl(file, cmd, arg);
376         mutex_unlock(&dmasound_core_mutex);
377 
378         return ret;
379 }
380 
381 static const struct file_operations mixer_fops =
382 {
383         .owner          = THIS_MODULE,
384         .llseek         = no_llseek,
385         .unlocked_ioctl = mixer_unlocked_ioctl,
386         .open           = mixer_open,
387         .release        = mixer_release,
388 };
389 
390 static void mixer_init(void)
391 {
392 #ifndef MODULE
393         int mixer_unit;
394 #endif
395         mixer_unit = register_sound_mixer(&mixer_fops, -1);
396         if (mixer_unit < 0)
397                 return;
398 
399         mixer.busy = 0;
400         dmasound.treble = 0;
401         dmasound.bass = 0;
402         if (dmasound.mach.mixer_init)
403             dmasound.mach.mixer_init();
404 }
405 
406 
407     /*
408      *  Sound queue stuff, the heart of the driver
409      */
410 
411 struct sound_queue dmasound_write_sq;
412 static void sq_reset_output(void) ;
413 
414 static int sq_allocate_buffers(struct sound_queue *sq, int num, int size)
415 {
416         int i;
417 
418         if (sq->buffers)
419                 return 0;
420         sq->numBufs = num;
421         sq->bufSize = size;
422         sq->buffers = kmalloc (num * sizeof(char *), GFP_KERNEL);
423         if (!sq->buffers)
424                 return -ENOMEM;
425         for (i = 0; i < num; i++) {
426                 sq->buffers[i] = dmasound.mach.dma_alloc(size, GFP_KERNEL);
427                 if (!sq->buffers[i]) {
428                         while (i--)
429                                 dmasound.mach.dma_free(sq->buffers[i], size);
430                         kfree(sq->buffers);
431                         sq->buffers = NULL;
432                         return -ENOMEM;
433                 }
434         }
435         return 0;
436 }
437 
438 static void sq_release_buffers(struct sound_queue *sq)
439 {
440         int i;
441 
442         if (sq->buffers) {
443                 for (i = 0; i < sq->numBufs; i++)
444                         dmasound.mach.dma_free(sq->buffers[i], sq->bufSize);
445                 kfree(sq->buffers);
446                 sq->buffers = NULL;
447         }
448 }
449 
450 
451 static int sq_setup(struct sound_queue *sq)
452 {
453         int (*setup_func)(void) = NULL;
454         int hard_frame ;
455 
456         if (sq->locked) { /* are we already set? - and not changeable */
457 #ifdef DEBUG_DMASOUND
458 printk("dmasound_core: tried to sq_setup a locked queue\n") ;
459 #endif
460                 return -EINVAL ;
461         }
462         sq->locked = 1 ; /* don't think we have a race prob. here _check_ */
463 
464         /* make sure that the parameters are set up
465            This should have been done already...
466         */
467 
468         dmasound.mach.init();
469 
470         /* OK.  If the user has set fragment parameters explicitly, then we
471            should leave them alone... as long as they are valid.
472            Invalid user fragment params can occur if we allow the whole buffer
473            to be used when the user requests the fragments sizes (with no soft
474            x-lation) and then the user subsequently sets a soft x-lation that
475            requires increased internal buffering.
476 
477            Othwerwise (if the user did not set them) OSS says that we should
478            select frag params on the basis of 0.5 s output & 0.1 s input
479            latency. (TODO.  For now we will copy in the defaults.)
480         */
481 
482         if (sq->user_frags <= 0) {
483                 sq->max_count = sq->numBufs ;
484                 sq->max_active = sq->numBufs ;
485                 sq->block_size = sq->bufSize;
486                 /* set up the user info */
487                 sq->user_frags = sq->numBufs ;
488                 sq->user_frag_size = sq->bufSize ;
489                 sq->user_frag_size *=
490                         (dmasound.soft.size * (dmasound.soft.stereo+1) ) ;
491                 sq->user_frag_size /=
492                         (dmasound.hard.size * (dmasound.hard.stereo+1) ) ;
493         } else {
494                 /* work out requested block size */
495                 sq->block_size = sq->user_frag_size ;
496                 sq->block_size *=
497                         (dmasound.hard.size * (dmasound.hard.stereo+1) ) ;
498                 sq->block_size /=
499                         (dmasound.soft.size * (dmasound.soft.stereo+1) ) ;
500                 /* the user wants to write frag-size chunks */
501                 sq->block_size *= dmasound.hard.speed ;
502                 sq->block_size /= dmasound.soft.speed ;
503                 /* this only works for size values which are powers of 2 */
504                 hard_frame =
505                         (dmasound.hard.size * (dmasound.hard.stereo+1))/8 ;
506                 sq->block_size +=  (hard_frame - 1) ;
507                 sq->block_size &= ~(hard_frame - 1) ; /* make sure we are aligned */
508                 /* let's just check for obvious mistakes */
509                 if ( sq->block_size <= 0 || sq->block_size > sq->bufSize) {
510 #ifdef DEBUG_DMASOUND
511 printk("dmasound_core: invalid frag size (user set %d)\n", sq->user_frag_size) ;
512 #endif
513                         sq->block_size = sq->bufSize ;
514                 }
515                 if ( sq->user_frags <= sq->numBufs ) {
516                         sq->max_count = sq->user_frags ;
517                         /* if user has set max_active - then use it */
518                         sq->max_active = (sq->max_active <= sq->max_count) ?
519                                 sq->max_active : sq->max_count ;
520                 } else {
521 #ifdef DEBUG_DMASOUND
522 printk("dmasound_core: invalid frag count (user set %d)\n", sq->user_frags) ;
523 #endif
524                         sq->max_count =
525                         sq->max_active = sq->numBufs ;
526                 }
527         }
528         sq->front = sq->count = sq->rear_size = 0;
529         sq->syncing = 0;
530         sq->active = 0;
531 
532         if (sq == &write_sq) {
533             sq->rear = -1;
534             setup_func = dmasound.mach.write_sq_setup;
535         }
536         if (setup_func)
537             return setup_func();
538         return 0 ;
539 }
540 
541 static inline void sq_play(void)
542 {
543         dmasound.mach.play();
544 }
545 
546 static ssize_t sq_write(struct file *file, const char __user *src, size_t uLeft,
547                         loff_t *ppos)
548 {
549         ssize_t uWritten = 0;
550         u_char *dest;
551         ssize_t uUsed = 0, bUsed, bLeft;
552         unsigned long flags ;
553 
554         /* ++TeSche: Is something like this necessary?
555          * Hey, that's an honest question! Or does any other part of the
556          * filesystem already checks this situation? I really don't know.
557          */
558         if (uLeft == 0)
559                 return 0;
560 
561         /* implement any changes we have made to the soft/hard params.
562            this is not satisfactory really, all we have done up to now is to
563            say what we would like - there hasn't been any real checking of capability
564         */
565 
566         if (shared_resources_initialised == 0) {
567                 dmasound.mach.init() ;
568                 shared_resources_initialised = 1 ;
569         }
570 
571         /* set up the sq if it is not already done. This may seem a dumb place
572            to do it - but it is what OSS requires.  It means that write() can
573            return memory allocation errors.  To avoid this possibility use the
574            GETBLKSIZE or GETOSPACE ioctls (after you've fiddled with all the
575            params you want to change) - these ioctls also force the setup.
576         */
577 
578         if (write_sq.locked == 0) {
579                 if ((uWritten = sq_setup(&write_sq)) < 0) return uWritten ;
580                 uWritten = 0 ;
581         }
582 
583 /* FIXME: I think that this may be the wrong behaviour when we get strapped
584         for time and the cpu is close to being (or actually) behind in sending data.
585         - because we've lost the time that the N samples, already in the buffer,
586         would have given us to get here with the next lot from the user.
587 */
588         /* The interrupt doesn't start to play the last, incomplete frame.
589          * Thus we can append to it without disabling the interrupts! (Note
590          * also that write_sq.rear isn't affected by the interrupt.)
591          */
592 
593         /* as of 1.6 this behaviour changes if SNDCTL_DSP_POST has been issued:
594            this will mimic the behaviour of syncing and allow the sq_play() to
595            queue a partial fragment.  Since sq_play() may/will be called from
596            the IRQ handler - at least on Pmac we have to deal with it.
597            The strategy - possibly not optimum - is to kill _POST status if we
598            get here.  This seems, at least, reasonable - in the sense that POST
599            is supposed to indicate that we might not write before the queue
600            is drained - and if we get here in time then it does not apply.
601         */
602 
603         spin_lock_irqsave(&dmasound.lock, flags);
604         write_sq.syncing &= ~2 ; /* take out POST status */
605         spin_unlock_irqrestore(&dmasound.lock, flags);
606 
607         if (write_sq.count > 0 &&
608             (bLeft = write_sq.block_size-write_sq.rear_size) > 0) {
609                 dest = write_sq.buffers[write_sq.rear];
610                 bUsed = write_sq.rear_size;
611                 uUsed = sound_copy_translate(dmasound.trans_write, src, uLeft,
612                                              dest, &bUsed, bLeft);
613                 if (uUsed <= 0)
614                         return uUsed;
615                 src += uUsed;
616                 uWritten += uUsed;
617                 uLeft = (uUsed <= uLeft) ? (uLeft - uUsed) : 0 ; /* paranoia */
618                 write_sq.rear_size = bUsed;
619         }
620 
621         while (uLeft) {
622                 DEFINE_WAIT(wait);
623 
624                 while (write_sq.count >= write_sq.max_active) {
625                         prepare_to_wait(&write_sq.action_queue, &wait, TASK_INTERRUPTIBLE);
626                         sq_play();
627                         if (write_sq.non_blocking) {
628                                 finish_wait(&write_sq.action_queue, &wait);
629                                 return uWritten > 0 ? uWritten : -EAGAIN;
630                         }
631                         if (write_sq.count < write_sq.max_active)
632                                 break;
633 
634                         schedule_timeout(HZ);
635                         if (signal_pending(current)) {
636                                 finish_wait(&write_sq.action_queue, &wait);
637                                 return uWritten > 0 ? uWritten : -EINTR;
638                         }
639                 }
640 
641                 finish_wait(&write_sq.action_queue, &wait);
642 
643                 /* Here, we can avoid disabling the interrupt by first
644                  * copying and translating the data, and then updating
645                  * the write_sq variables. Until this is done, the interrupt
646                  * won't see the new frame and we can work on it
647                  * undisturbed.
648                  */
649 
650                 dest = write_sq.buffers[(write_sq.rear+1) % write_sq.max_count];
651                 bUsed = 0;
652                 bLeft = write_sq.block_size;
653                 uUsed = sound_copy_translate(dmasound.trans_write, src, uLeft,
654                                              dest, &bUsed, bLeft);
655                 if (uUsed <= 0)
656                         break;
657                 src += uUsed;
658                 uWritten += uUsed;
659                 uLeft = (uUsed <= uLeft) ? (uLeft - uUsed) : 0 ; /* paranoia */
660                 if (bUsed) {
661                         write_sq.rear = (write_sq.rear+1) % write_sq.max_count;
662                         write_sq.rear_size = bUsed;
663                         write_sq.count++;
664                 }
665         } /* uUsed may have been 0 */
666 
667         sq_play();
668 
669         return uUsed < 0? uUsed: uWritten;
670 }
671 
672 static unsigned int sq_poll(struct file *file, struct poll_table_struct *wait)
673 {
674         unsigned int mask = 0;
675         int retVal;
676         
677         if (write_sq.locked == 0) {
678                 if ((retVal = sq_setup(&write_sq)) < 0)
679                         return retVal;
680                 return 0;
681         }
682         if (file->f_mode & FMODE_WRITE )
683                 poll_wait(file, &write_sq.action_queue, wait);
684         if (file->f_mode & FMODE_WRITE)
685                 if (write_sq.count < write_sq.max_active || write_sq.block_size - write_sq.rear_size > 0)
686                         mask |= POLLOUT | POLLWRNORM;
687         return mask;
688 
689 }
690 
691 static inline void sq_init_waitqueue(struct sound_queue *sq)
692 {
693         init_waitqueue_head(&sq->action_queue);
694         init_waitqueue_head(&sq->open_queue);
695         init_waitqueue_head(&sq->sync_queue);
696         sq->busy = 0;
697 }
698 
699 #if 0 /* blocking open() */
700 static inline void sq_wake_up(struct sound_queue *sq, struct file *file,
701                               fmode_t mode)
702 {
703         if (file->f_mode & mode) {
704                 sq->busy = 0; /* CHECK: IS THIS OK??? */
705                 WAKE_UP(sq->open_queue);
706         }
707 }
708 #endif
709 
710 static int sq_open2(struct sound_queue *sq, struct file *file, fmode_t mode,
711                     int numbufs, int bufsize)
712 {
713         int rc = 0;
714 
715         if (file->f_mode & mode) {
716                 if (sq->busy) {
717 #if 0 /* blocking open() */
718                         rc = -EBUSY;
719                         if (file->f_flags & O_NONBLOCK)
720                                 return rc;
721                         rc = -EINTR;
722                         if (wait_event_interruptible(sq->open_queue, !sq->busy))
723                                 return rc;
724                         rc = 0;
725 #else
726                         /* OSS manual says we will return EBUSY regardless
727                            of O_NOBLOCK.
728                         */
729                         return -EBUSY ;
730 #endif
731                 }
732                 sq->busy = 1; /* Let's play spot-the-race-condition */
733 
734                 /* allocate the default number & size of buffers.
735                    (i.e. specified in _setup() or as module params)
736                    can't be changed at the moment - but _could_ be perhaps
737                    in the setfragments ioctl.
738                 */
739                 if (( rc = sq_allocate_buffers(sq, numbufs, bufsize))) {
740 #if 0 /* blocking open() */
741                         sq_wake_up(sq, file, mode);
742 #else
743                         sq->busy = 0 ;
744 #endif
745                         return rc;
746                 }
747 
748                 sq->non_blocking = file->f_flags & O_NONBLOCK;
749         }
750         return rc;
751 }
752 
753 #define write_sq_init_waitqueue()       sq_init_waitqueue(&write_sq)
754 #if 0 /* blocking open() */
755 #define write_sq_wake_up(file)          sq_wake_up(&write_sq, file, FMODE_WRITE)
756 #endif
757 #define write_sq_release_buffers()      sq_release_buffers(&write_sq)
758 #define write_sq_open(file)     \
759         sq_open2(&write_sq, file, FMODE_WRITE, numWriteBufs, writeBufSize )
760 
761 static int sq_open(struct inode *inode, struct file *file)
762 {
763         int rc;
764 
765         mutex_lock(&dmasound_core_mutex);
766         if (!try_module_get(dmasound.mach.owner)) {
767                 mutex_unlock(&dmasound_core_mutex);
768                 return -ENODEV;
769         }
770 
771         rc = write_sq_open(file); /* checks the f_mode */
772         if (rc)
773                 goto out;
774         if (file->f_mode & FMODE_READ) {
775                 /* TODO: if O_RDWR, release any resources grabbed by write part */
776                 rc = -ENXIO ; /* I think this is what is required by open(2) */
777                 goto out;
778         }
779 
780         if (dmasound.mach.sq_open)
781             dmasound.mach.sq_open(file->f_mode);
782 
783         /* CHECK whether this is sensible - in the case that dsp0 could be opened
784           O_RDONLY and dsp1 could be opened O_WRONLY
785         */
786 
787         dmasound.minDev = iminor(inode) & 0x0f;
788 
789         /* OK. - we should make some attempt at consistency. At least the H'ware
790            options should be set with a valid mode.  We will make it that the LL
791            driver must supply defaults for hard & soft params.
792         */
793 
794         if (shared_resource_owner == 0) {
795                 /* you can make this AFMT_U8/mono/8K if you want to mimic old
796                    OSS behaviour - while we still have soft translations ;-) */
797                 dmasound.soft = dmasound.mach.default_soft ;
798                 dmasound.dsp = dmasound.mach.default_soft ;
799                 dmasound.hard = dmasound.mach.default_hard ;
800         }
801 
802 #ifndef DMASOUND_STRICT_OSS_COMPLIANCE
803         /* none of the current LL drivers can actually do this "native" at the moment
804            OSS does not really require us to supply /dev/audio if we can't do it.
805         */
806         if (dmasound.minDev == SND_DEV_AUDIO) {
807                 sound_set_speed(8000);
808                 sound_set_stereo(0);
809                 sound_set_format(AFMT_MU_LAW);
810         }
811 #endif
812         mutex_unlock(&dmasound_core_mutex);
813         return 0;
814  out:
815         module_put(dmasound.mach.owner);
816         mutex_unlock(&dmasound_core_mutex);
817         return rc;
818 }
819 
820 static void sq_reset_output(void)
821 {
822         sound_silence(); /* this _must_ stop DMA, we might be about to lose the buffers */
823         write_sq.active = 0;
824         write_sq.count = 0;
825         write_sq.rear_size = 0;
826         /* write_sq.front = (write_sq.rear+1) % write_sq.max_count;*/
827         write_sq.front = 0 ;
828         write_sq.rear = -1 ; /* same as for set-up */
829 
830         /* OK - we can unlock the parameters and fragment settings */
831         write_sq.locked = 0 ;
832         write_sq.user_frags = 0 ;
833         write_sq.user_frag_size = 0 ;
834 }
835 
836 static void sq_reset(void)
837 {
838         sq_reset_output() ;
839         /* we could consider resetting the shared_resources_owner here... but I
840            think it is probably still rather non-obvious to application writer
841         */
842 
843         /* we release everything else though */
844         shared_resources_initialised = 0 ;
845 }
846 
847 static int sq_fsync(void)
848 {
849         int rc = 0;
850         int timeout = 5;
851 
852         write_sq.syncing |= 1;
853         sq_play();      /* there may be an incomplete frame waiting */
854 
855         while (write_sq.active) {
856                 wait_event_interruptible_timeout(write_sq.sync_queue,
857                                                  !write_sq.active, HZ);
858                 if (signal_pending(current)) {
859                         /* While waiting for audio output to drain, an
860                          * interrupt occurred.  Stop audio output immediately
861                          * and clear the queue. */
862                         sq_reset_output();
863                         rc = -EINTR;
864                         break;
865                 }
866                 if (!--timeout) {
867                         printk(KERN_WARNING "dmasound: Timeout draining output\n");
868                         sq_reset_output();
869                         rc = -EIO;
870                         break;
871                 }
872         }
873 
874         /* flag no sync regardless of whether we had a DSP_POST or not */
875         write_sq.syncing = 0 ;
876         return rc;
877 }
878 
879 static int sq_release(struct inode *inode, struct file *file)
880 {
881         int rc = 0;
882 
883         mutex_lock(&dmasound_core_mutex);
884 
885         if (file->f_mode & FMODE_WRITE) {
886                 if (write_sq.busy)
887                         rc = sq_fsync();
888 
889                 sq_reset_output() ; /* make sure dma is stopped and all is quiet */
890                 write_sq_release_buffers();
891                 write_sq.busy = 0;
892         }
893 
894         if (file->f_mode & shared_resource_owner) { /* it's us that has them */
895                 shared_resource_owner = 0 ;
896                 shared_resources_initialised = 0 ;
897                 dmasound.hard = dmasound.mach.default_hard ;
898         }
899 
900         module_put(dmasound.mach.owner);
901 
902 #if 0 /* blocking open() */
903         /* Wake up a process waiting for the queue being released.
904          * Note: There may be several processes waiting for a call
905          * to open() returning. */
906 
907         /* Iain: hmm I don't understand this next comment ... */
908         /* There is probably a DOS atack here. They change the mode flag. */
909         /* XXX add check here,*/
910         read_sq_wake_up(file); /* checks f_mode */
911         write_sq_wake_up(file); /* checks f_mode */
912 #endif /* blocking open() */
913 
914         mutex_unlock(&dmasound_core_mutex);
915 
916         return rc;
917 }
918 
919 /* here we see if we have a right to modify format, channels, size and so on
920    if no-one else has claimed it already then we do...
921 
922    TODO: We might change this to mask O_RDWR such that only one or the other channel
923    is the owner - if we have problems.
924 */
925 
926 static int shared_resources_are_mine(fmode_t md)
927 {
928         if (shared_resource_owner)
929                 return (shared_resource_owner & md) != 0;
930         else {
931                 shared_resource_owner = md ;
932                 return 1 ;
933         }
934 }
935 
936 /* if either queue is locked we must deny the right to change shared params
937 */
938 
939 static int queues_are_quiescent(void)
940 {
941         if (write_sq.locked)
942                 return 0 ;
943         return 1 ;
944 }
945 
946 /* check and set a queue's fragments per user's wishes...
947    we will check against the pre-defined literals and the actual sizes.
948    This is a bit fraught - because soft translations can mess with our
949    buffer requirements *after* this call - OSS says "call setfrags first"
950 */
951 
952 /* It is possible to replace all the -EINVAL returns with an override that
953    just puts the allowable value in.  This may be what many OSS apps require
954 */
955 
956 static int set_queue_frags(struct sound_queue *sq, int bufs, int size)
957 {
958         if (sq->locked) {
959 #ifdef DEBUG_DMASOUND
960 printk("dmasound_core: tried to set_queue_frags on a locked queue\n") ;
961 #endif
962                 return -EINVAL ;
963         }
964 
965         if ((size < MIN_FRAG_SIZE) || (size > MAX_FRAG_SIZE))
966                 return -EINVAL ;
967         size = (1<<size) ; /* now in bytes */
968         if (size > sq->bufSize)
969                 return -EINVAL ; /* this might still not work */
970 
971         if (bufs <= 0)
972                 return -EINVAL ;
973         if (bufs > sq->numBufs) /* the user is allowed say "don't care" with 0x7fff */
974                 bufs = sq->numBufs ;
975 
976         /* there is, currently, no way to specify max_active separately
977            from max_count.  This could be a LL driver issue - I guess
978            if there is a requirement for these values to be different then
979           we will have to pass that info. up to this level.
980         */
981         sq->user_frags =
982         sq->max_active = bufs ;
983         sq->user_frag_size = size ;
984 
985         return 0 ;
986 }
987 
988 static int sq_ioctl(struct file *file, u_int cmd, u_long arg)
989 {
990         int val, result;
991         u_long fmt;
992         int data;
993         int size, nbufs;
994         audio_buf_info info;
995 
996         switch (cmd) {
997         case SNDCTL_DSP_RESET:
998                 sq_reset();
999                 return 0;
1000                 break ;
1001         case SNDCTL_DSP_GETFMTS:
1002                 fmt = dmasound.mach.hardware_afmts ; /* this is what OSS says.. */
1003                 return IOCTL_OUT(arg, fmt);
1004                 break ;
1005         case SNDCTL_DSP_GETBLKSIZE:
1006                 /* this should tell the caller about bytes that the app can
1007                    read/write - the app doesn't care about our internal buffers.
1008                    We force sq_setup() here as per OSS 1.1 (which should
1009                    compute the values necessary).
1010                    Since there is no mechanism to specify read/write separately, for
1011                    fds opened O_RDWR, the write_sq values will, arbitrarily, overwrite
1012                    the read_sq ones.
1013                 */
1014                 size = 0 ;
1015                 if (file->f_mode & FMODE_WRITE) {
1016                         if ( !write_sq.locked )
1017                                 sq_setup(&write_sq) ;
1018                         size = write_sq.user_frag_size ;
1019                 }
1020                 return IOCTL_OUT(arg, size);
1021                 break ;
1022         case SNDCTL_DSP_POST:
1023                 /* all we are going to do is to tell the LL that any
1024                    partial frags can be queued for output.
1025                    The LL will have to clear this flag when last output
1026                    is queued.
1027                 */
1028                 write_sq.syncing |= 0x2 ;
1029                 sq_play() ;
1030                 return 0 ;
1031         case SNDCTL_DSP_SYNC:
1032                 /* This call, effectively, has the same behaviour as SNDCTL_DSP_RESET
1033                    except that it waits for output to finish before resetting
1034                    everything - read, however, is killed immediately.
1035                 */
1036                 result = 0 ;
1037                 if (file->f_mode & FMODE_WRITE) {
1038                         result = sq_fsync();
1039                         sq_reset_output() ;
1040                 }
1041                 /* if we are the shared resource owner then release them */
1042                 if (file->f_mode & shared_resource_owner)
1043                         shared_resources_initialised = 0 ;
1044                 return result ;
1045                 break ;
1046         case SOUND_PCM_READ_RATE:
1047                 return IOCTL_OUT(arg, dmasound.soft.speed);
1048         case SNDCTL_DSP_SPEED:
1049                 /* changing this on the fly will have weird effects on the sound.
1050                    Where there are rate conversions implemented in soft form - it
1051                    will cause the _ctx_xxx() functions to be substituted.
1052                    However, there doesn't appear to be any reason to dis-allow it from
1053                    a driver pov.
1054                 */
1055                 if (shared_resources_are_mine(file->f_mode)) {
1056                         IOCTL_IN(arg, data);
1057                         data = sound_set_speed(data) ;
1058                         shared_resources_initialised = 0 ;
1059                         return IOCTL_OUT(arg, data);
1060                 } else
1061                         return -EINVAL ;
1062                 break ;
1063         /* OSS says these next 4 actions are undefined when the device is
1064            busy/active - we will just return -EINVAL.
1065            To be allowed to change one - (a) you have to own the right
1066             (b) the queue(s) must be quiescent
1067         */
1068         case SNDCTL_DSP_STEREO:
1069                 if (shared_resources_are_mine(file->f_mode) &&
1070                     queues_are_quiescent()) {
1071                         IOCTL_IN(arg, data);
1072                         shared_resources_initialised = 0 ;
1073                         return IOCTL_OUT(arg, sound_set_stereo(data));
1074                 } else
1075                         return -EINVAL ;
1076                 break ;
1077         case SOUND_PCM_WRITE_CHANNELS:
1078                 if (shared_resources_are_mine(file->f_mode) &&
1079                     queues_are_quiescent()) {
1080                         IOCTL_IN(arg, data);
1081                         /* the user might ask for 20 channels, we will return 1 or 2 */
1082                         shared_resources_initialised = 0 ;
1083                         return IOCTL_OUT(arg, sound_set_stereo(data-1)+1);
1084                 } else
1085                         return -EINVAL ;
1086                 break ;
1087         case SNDCTL_DSP_SETFMT:
1088                 if (shared_resources_are_mine(file->f_mode) &&
1089                     queues_are_quiescent()) {
1090                         int format;
1091                         IOCTL_IN(arg, data);
1092                         shared_resources_initialised = 0 ;
1093                         format = sound_set_format(data);
1094                         result = IOCTL_OUT(arg, format);
1095                         if (result < 0)
1096                                 return result;
1097                         if (format != data && data != AFMT_QUERY)
1098                                 return -EINVAL;
1099                         return 0;
1100                 } else
1101                         return -EINVAL ;
1102         case SNDCTL_DSP_SUBDIVIDE:
1103                 return -EINVAL ;
1104         case SNDCTL_DSP_SETFRAGMENT:
1105                 /* we can do this independently for the two queues - with the
1106                    proviso that for fds opened O_RDWR we cannot separate the
1107                    actions and both queues will be set per the last call.
1108                    NOTE: this does *NOT* actually set the queue up - merely
1109                    registers our intentions.
1110                 */
1111                 IOCTL_IN(arg, data);
1112                 result = 0 ;
1113                 nbufs = (data >> 16) & 0x7fff ; /* 0x7fff is 'use maximum' */
1114                 size = data & 0xffff;
1115                 if (file->f_mode & FMODE_WRITE) {
1116                         result = set_queue_frags(&write_sq, nbufs, size) ;
1117                         if (result)
1118                                 return result ;
1119                 }
1120                 /* NOTE: this return value is irrelevant - OSS specifically says that
1121                    the value is 'random' and that the user _must_ check the actual
1122                    frags values using SNDCTL_DSP_GETBLKSIZE or similar */
1123                 return IOCTL_OUT(arg, data);
1124                 break ;
1125         case SNDCTL_DSP_GETOSPACE:
1126                 /*
1127                 */
1128                 if (file->f_mode & FMODE_WRITE) {
1129                         if ( !write_sq.locked )
1130                                 sq_setup(&write_sq) ;
1131                         info.fragments = write_sq.max_active - write_sq.count;
1132                         info.fragstotal = write_sq.max_active;
1133                         info.fragsize = write_sq.user_frag_size;
1134                         info.bytes = info.fragments * info.fragsize;
1135                         if (copy_to_user((void __user *)arg, &info, sizeof(info)))
1136                                 return -EFAULT;
1137                         return 0;
1138                 } else
1139                         return -EINVAL ;
1140                 break ;
1141         case SNDCTL_DSP_GETCAPS:
1142                 val = dmasound.mach.capabilities & 0xffffff00;
1143                 return IOCTL_OUT(arg,val);
1144 
1145         default:
1146                 return mixer_ioctl(file, cmd, arg);
1147         }
1148         return -EINVAL;
1149 }
1150 
1151 static long sq_unlocked_ioctl(struct file *file, u_int cmd, u_long arg)
1152 {
1153         int ret;
1154 
1155         mutex_lock(&dmasound_core_mutex);
1156         ret = sq_ioctl(file, cmd, arg);
1157         mutex_unlock(&dmasound_core_mutex);
1158 
1159         return ret;
1160 }
1161 
1162 static const struct file_operations sq_fops =
1163 {
1164         .owner          = THIS_MODULE,
1165         .llseek         = no_llseek,
1166         .write          = sq_write,
1167         .poll           = sq_poll,
1168         .unlocked_ioctl = sq_unlocked_ioctl,
1169         .open           = sq_open,
1170         .release        = sq_release,
1171 };
1172 
1173 static int sq_init(void)
1174 {
1175         const struct file_operations *fops = &sq_fops;
1176 #ifndef MODULE
1177         int sq_unit;
1178 #endif
1179 
1180         sq_unit = register_sound_dsp(fops, -1);
1181         if (sq_unit < 0) {
1182                 printk(KERN_ERR "dmasound_core: couldn't register fops\n") ;
1183                 return sq_unit ;
1184         }
1185 
1186         write_sq_init_waitqueue();
1187 
1188         /* These parameters will be restored for every clean open()
1189          * in the case of multiple open()s (e.g. dsp0 & dsp1) they
1190          * will be set so long as the shared resources have no owner.
1191          */
1192 
1193         if (shared_resource_owner == 0) {
1194                 dmasound.soft = dmasound.mach.default_soft ;
1195                 dmasound.hard = dmasound.mach.default_hard ;
1196                 dmasound.dsp = dmasound.mach.default_soft ;
1197                 shared_resources_initialised = 0 ;
1198         }
1199         return 0 ;
1200 }
1201 
1202 
1203     /*
1204      *  /dev/sndstat
1205      */
1206 
1207 /* we allow more space for record-enabled because there are extra output lines.
1208    the number here must include the amount we are prepared to give to the low-level
1209    driver.
1210 */
1211 
1212 #define STAT_BUFF_LEN 768
1213 
1214 /* this is how much space we will allow the low-level driver to use
1215    in the stat buffer.  Currently, 2 * (80 character line + <NL>).
1216    We do not police this (it is up to the ll driver to be honest).
1217 */
1218 
1219 #define LOW_LEVEL_STAT_ALLOC 162
1220 
1221 static struct {
1222     int busy;
1223     char buf[STAT_BUFF_LEN];    /* state.buf should not overflow! */
1224     int len, ptr;
1225 } state;
1226 
1227 /* publish this function for use by low-level code, if required */
1228 
1229 static char *get_afmt_string(int afmt)
1230 {
1231         switch(afmt) {
1232             case AFMT_MU_LAW:
1233                 return "mu-law";
1234                 break;
1235             case AFMT_A_LAW:
1236                 return "A-law";
1237                 break;
1238             case AFMT_U8:
1239                 return "unsigned 8 bit";
1240                 break;
1241             case AFMT_S8:
1242                 return "signed 8 bit";
1243                 break;
1244             case AFMT_S16_BE:
1245                 return "signed 16 bit BE";
1246                 break;
1247             case AFMT_U16_BE:
1248                 return "unsigned 16 bit BE";
1249                 break;
1250             case AFMT_S16_LE:
1251                 return "signed 16 bit LE";
1252                 break;
1253             case AFMT_U16_LE:
1254                 return "unsigned 16 bit LE";
1255                 break;
1256             case 0:
1257                 return "format not set" ;
1258                 break ;
1259             default:
1260                 break ;
1261         }
1262         return "ERROR: Unsupported AFMT_XXXX code" ;
1263 }
1264 
1265 static int state_open(struct inode *inode, struct file *file)
1266 {
1267         char *buffer = state.buf;
1268         int len = 0;
1269         int ret;
1270 
1271         mutex_lock(&dmasound_core_mutex);
1272         ret = -EBUSY;
1273         if (state.busy)
1274                 goto out;
1275 
1276         ret = -ENODEV;
1277         if (!try_module_get(dmasound.mach.owner))
1278                 goto out;
1279 
1280         state.ptr = 0;
1281         state.busy = 1;
1282 
1283         len += sprintf(buffer+len, "%sDMA sound driver rev %03d :\n",
1284                 dmasound.mach.name, (DMASOUND_CORE_REVISION<<4) +
1285                 ((dmasound.mach.version>>8) & 0x0f));
1286         len += sprintf(buffer+len,
1287                 "Core driver edition %02d.%02d : %s driver edition %02d.%02d\n",
1288                 DMASOUND_CORE_REVISION, DMASOUND_CORE_EDITION, dmasound.mach.name2,
1289                 (dmasound.mach.version >> 8), (dmasound.mach.version & 0xff)) ;
1290 
1291         /* call the low-level module to fill in any stat info. that it has
1292            if present.  Maximum buffer usage is specified.
1293         */
1294 
1295         if (dmasound.mach.state_info)
1296                 len += dmasound.mach.state_info(buffer+len,
1297                         (size_t) LOW_LEVEL_STAT_ALLOC) ;
1298 
1299         /* make usage of the state buffer as deterministic as poss.
1300            exceptional conditions could cause overrun - and this is flagged as
1301            a kernel error.
1302         */
1303 
1304         /* formats and settings */
1305 
1306         len += sprintf(buffer+len,"\t\t === Formats & settings ===\n") ;
1307         len += sprintf(buffer+len,"Parameter %20s%20s\n","soft","hard") ;
1308         len += sprintf(buffer+len,"Format   :%20s%20s\n",
1309                 get_afmt_string(dmasound.soft.format),
1310                 get_afmt_string(dmasound.hard.format));
1311 
1312         len += sprintf(buffer+len,"Samp Rate:%14d s/sec%14d s/sec\n",
1313                        dmasound.soft.speed, dmasound.hard.speed);
1314 
1315         len += sprintf(buffer+len,"Channels :%20s%20s\n",
1316                        dmasound.soft.stereo ? "stereo" : "mono",
1317                        dmasound.hard.stereo ? "stereo" : "mono" );
1318 
1319         /* sound queue status */
1320 
1321         len += sprintf(buffer+len,"\t\t === Sound Queue status ===\n");
1322         len += sprintf(buffer+len,"Allocated:%8s%6s\n","Buffers","Size") ;
1323         len += sprintf(buffer+len,"%9s:%8d%6d\n",
1324                 "write", write_sq.numBufs, write_sq.bufSize) ;
1325         len += sprintf(buffer+len,
1326                 "Current  : MaxFrg FragSiz MaxAct Frnt Rear "
1327                 "Cnt RrSize A B S L  xruns\n") ;
1328         len += sprintf(buffer+len,"%9s:%7d%8d%7d%5d%5d%4d%7d%2d%2d%2d%2d%7d\n",
1329                 "write", write_sq.max_count, write_sq.block_size,
1330                 write_sq.max_active, write_sq.front, write_sq.rear,
1331                 write_sq.count, write_sq.rear_size, write_sq.active,
1332                 write_sq.busy, write_sq.syncing, write_sq.locked, write_sq.xruns) ;
1333 #ifdef DEBUG_DMASOUND
1334 printk("dmasound: stat buffer used %d bytes\n", len) ;
1335 #endif
1336 
1337         if (len >= STAT_BUFF_LEN)
1338                 printk(KERN_ERR "dmasound_core: stat buffer overflowed!\n");
1339 
1340         state.len = len;
1341         ret = 0;
1342 out:
1343         mutex_unlock(&dmasound_core_mutex);
1344         return ret;
1345 }
1346 
1347 static int state_release(struct inode *inode, struct file *file)
1348 {
1349         mutex_lock(&dmasound_core_mutex);
1350         state.busy = 0;
1351         module_put(dmasound.mach.owner);
1352         mutex_unlock(&dmasound_core_mutex);
1353         return 0;
1354 }
1355 
1356 static ssize_t state_read(struct file *file, char __user *buf, size_t count,
1357                           loff_t *ppos)
1358 {
1359         int n = state.len - state.ptr;
1360         if (n > count)
1361                 n = count;
1362         if (n <= 0)
1363                 return 0;
1364         if (copy_to_user(buf, &state.buf[state.ptr], n))
1365                 return -EFAULT;
1366         state.ptr += n;
1367         return n;
1368 }
1369 
1370 static const struct file_operations state_fops = {
1371         .owner          = THIS_MODULE,
1372         .llseek         = no_llseek,
1373         .read           = state_read,
1374         .open           = state_open,
1375         .release        = state_release,
1376 };
1377 
1378 static int state_init(void)
1379 {
1380 #ifndef MODULE
1381         int state_unit;
1382 #endif
1383         state_unit = register_sound_special(&state_fops, SND_DEV_STATUS);
1384         if (state_unit < 0)
1385                 return state_unit ;
1386         state.busy = 0;
1387         return 0 ;
1388 }
1389 
1390 
1391     /*
1392      *  Config & Setup
1393      *
1394      *  This function is called by _one_ chipset-specific driver
1395      */
1396 
1397 int dmasound_init(void)
1398 {
1399         int res ;
1400 #ifdef MODULE
1401         if (irq_installed)
1402                 return -EBUSY;
1403 #endif
1404 
1405         /* Set up sound queue, /dev/audio and /dev/dsp. */
1406 
1407         /* Set default settings. */
1408         if ((res = sq_init()) < 0)
1409                 return res ;
1410 
1411         /* Set up /dev/sndstat. */
1412         if ((res = state_init()) < 0)
1413                 return res ;
1414 
1415         /* Set up /dev/mixer. */
1416         mixer_init();
1417 
1418         if (!dmasound.mach.irqinit()) {
1419                 printk(KERN_ERR "DMA sound driver: Interrupt initialization failed\n");
1420                 return -ENODEV;
1421         }
1422 #ifdef MODULE
1423         irq_installed = 1;
1424 #endif
1425 
1426         printk(KERN_INFO "%s DMA sound driver rev %03d installed\n",
1427                 dmasound.mach.name, (DMASOUND_CORE_REVISION<<4) +
1428                 ((dmasound.mach.version>>8) & 0x0f));
1429         printk(KERN_INFO
1430                 "Core driver edition %02d.%02d : %s driver edition %02d.%02d\n",
1431                 DMASOUND_CORE_REVISION, DMASOUND_CORE_EDITION, dmasound.mach.name2,
1432                 (dmasound.mach.version >> 8), (dmasound.mach.version & 0xff)) ;
1433         printk(KERN_INFO "Write will use %4d fragments of %7d bytes as default\n",
1434                 numWriteBufs, writeBufSize) ;
1435         return 0;
1436 }
1437 
1438 #ifdef MODULE
1439 
1440 void dmasound_deinit(void)
1441 {
1442         if (irq_installed) {
1443                 sound_silence();
1444                 dmasound.mach.irqcleanup();
1445                 irq_installed = 0;
1446         }
1447 
1448         write_sq_release_buffers();
1449 
1450         if (mixer_unit >= 0)
1451                 unregister_sound_mixer(mixer_unit);
1452         if (state_unit >= 0)
1453                 unregister_sound_special(state_unit);
1454         if (sq_unit >= 0)
1455                 unregister_sound_dsp(sq_unit);
1456 }
1457 
1458 #else /* !MODULE */
1459 
1460 static int dmasound_setup(char *str)
1461 {
1462         int ints[6], size;
1463 
1464         str = get_options(str, ARRAY_SIZE(ints), ints);
1465 
1466         /* check the bootstrap parameter for "dmasound=" */
1467 
1468         /* FIXME: other than in the most naive of cases there is no sense in these
1469          *        buffers being other than powers of two.  This is not checked yet.
1470          */
1471 
1472         switch (ints[0]) {
1473         case 3:
1474                 if ((ints[3] < 0) || (ints[3] > MAX_CATCH_RADIUS))
1475                         printk("dmasound_setup: invalid catch radius, using default = %d\n", catchRadius);
1476                 else
1477                         catchRadius = ints[3];
1478                 /* fall through */
1479         case 2:
1480                 if (ints[1] < MIN_BUFFERS)
1481                         printk("dmasound_setup: invalid number of buffers, using default = %d\n", numWriteBufs);
1482                 else
1483                         numWriteBufs = ints[1];
1484                 /* fall through */
1485         case 1:
1486                 if ((size = ints[2]) < 256) /* check for small buffer specs */
1487                         size <<= 10 ;
1488                 if (size < MIN_BUFSIZE || size > MAX_BUFSIZE)
1489                         printk("dmasound_setup: invalid write buffer size, using default = %d\n", writeBufSize);
1490                 else
1491                         writeBufSize = size;
1492         case 0:
1493                 break;
1494         default:
1495                 printk("dmasound_setup: invalid number of arguments\n");
1496                 return 0;
1497         }
1498         return 1;
1499 }
1500 
1501 __setup("dmasound=", dmasound_setup);
1502 
1503 #endif /* !MODULE */
1504 
1505     /*
1506      *  Conversion tables
1507      */
1508 
1509 #ifdef HAS_8BIT_TABLES
1510 /* 8 bit mu-law */
1511 
1512 char dmasound_ulaw2dma8[] = {
1513         -126,   -122,   -118,   -114,   -110,   -106,   -102,   -98,
1514         -94,    -90,    -86,    -82,    -78,    -74,    -70,    -66,
1515         -63,    -61,    -59,    -57,    -55,    -53,    -51,    -49,
1516         -47,    -45,    -43,    -41,    -39,    -37,    -35,    -33,
1517         -31,    -30,    -29,    -28,    -27,    -26,    -25,    -24,
1518         -23,    -22,    -21,    -20,    -19,    -18,    -17,    -16,
1519         -16,    -15,    -15,    -14,    -14,    -13,    -13,    -12,
1520         -12,    -11,    -11,    -10,    -10,    -9,     -9,     -8,
1521         -8,     -8,     -7,     -7,     -7,     -7,     -6,     -6,
1522         -6,     -6,     -5,     -5,     -5,     -5,     -4,     -4,
1523         -4,     -4,     -4,     -4,     -3,     -3,     -3,     -3,
1524         -3,     -3,     -3,     -3,     -2,     -2,     -2,     -2,
1525         -2,     -2,     -2,     -2,     -2,     -2,     -2,     -2,
1526         -1,     -1,     -1,     -1,     -1,     -1,     -1,     -1,
1527         -1,     -1,     -1,     -1,     -1,     -1,     -1,     -1,
1528         -1,     -1,     -1,     -1,     -1,     -1,     -1,     0,
1529         125,    121,    117,    113,    109,    105,    101,    97,
1530         93,     89,     85,     81,     77,     73,     69,     65,
1531         62,     60,     58,     56,     54,     52,     50,     48,
1532         46,     44,     42,     40,     38,     36,     34,     32,
1533         30,     29,     28,     27,     26,     25,     24,     23,
1534         22,     21,     20,     19,     18,     17,     16,     15,
1535         15,     14,     14,     13,     13,     12,     12,     11,
1536         11,     10,     10,     9,      9,      8,      8,      7,
1537         7,      7,      6,      6,      6,      6,      5,      5,
1538         5,      5,      4,      4,      4,      4,      3,      3,
1539         3,      3,      3,      3,      2,      2,      2,      2,
1540         2,      2,      2,      2,      1,      1,      1,      1,
1541         1,      1,      1,      1,      1,      1,      1,      1,
1542         0,      0,      0,      0,      0,      0,      0,      0,
1543         0,      0,      0,      0,      0,      0,      0,      0,
1544         0,      0,      0,      0,      0,      0,      0,      0
1545 };
1546 
1547 /* 8 bit A-law */
1548 
1549 char dmasound_alaw2dma8[] = {
1550         -22,    -21,    -24,    -23,    -18,    -17,    -20,    -19,
1551         -30,    -29,    -32,    -31,    -26,    -25,    -28,    -27,
1552         -11,    -11,    -12,    -12,    -9,     -9,     -10,    -10,
1553         -15,    -15,    -16,    -16,    -13,    -13,    -14,    -14,
1554         -86,    -82,    -94,    -90,    -70,    -66,    -78,    -74,
1555         -118,   -114,   -126,   -122,   -102,   -98,    -110,   -106,
1556         -43,    -41,    -47,    -45,    -35,    -33,    -39,    -37,
1557         -59,    -57,    -63,    -61,    -51,    -49,    -55,    -53,
1558         -2,     -2,     -2,     -2,     -2,     -2,     -2,     -2,
1559         -2,     -2,     -2,     -2,     -2,     -2,     -2,     -2,
1560         -1,     -1,     -1,     -1,     -1,     -1,     -1,     -1,
1561         -1,     -1,     -1,     -1,     -1,     -1,     -1,     -1,
1562         -6,     -6,     -6,     -6,     -5,     -5,     -5,     -5,
1563         -8,     -8,     -8,     -8,     -7,     -7,     -7,     -7,
1564         -3,     -3,     -3,     -3,     -3,     -3,     -3,     -3,
1565         -4,     -4,     -4,     -4,     -4,     -4,     -4,     -4,
1566         21,     20,     23,     22,     17,     16,     19,     18,
1567         29,     28,     31,     30,     25,     24,     27,     26,
1568         10,     10,     11,     11,     8,      8,      9,      9,
1569         14,     14,     15,     15,     12,     12,     13,     13,
1570         86,     82,     94,     90,     70,     66,     78,     74,
1571         118,    114,    126,    122,    102,    98,     110,    106,
1572         43,     41,     47,     45,     35,     33,     39,     37,
1573         59,     57,     63,     61,     51,     49,     55,     53,
1574         1,      1,      1,      1,      1,      1,      1,      1,
1575         1,      1,      1,      1,      1,      1,      1,      1,
1576         0,      0,      0,      0,      0,      0,      0,      0,
1577         0,      0,      0,      0,      0,      0,      0,      0,
1578         5,      5,      5,      5,      4,      4,      4,      4,
1579         7,      7,      7,      7,      6,      6,      6,      6,
1580         2,      2,      2,      2,      2,      2,      2,      2,
1581         3,      3,      3,      3,      3,      3,      3,      3
1582 };
1583 #endif /* HAS_8BIT_TABLES */
1584 
1585     /*
1586      *  Visible symbols for modules
1587      */
1588 
1589 EXPORT_SYMBOL(dmasound);
1590 EXPORT_SYMBOL(dmasound_init);
1591 #ifdef MODULE
1592 EXPORT_SYMBOL(dmasound_deinit);
1593 #endif
1594 EXPORT_SYMBOL(dmasound_write_sq);
1595 EXPORT_SYMBOL(dmasound_catchRadius);
1596 #ifdef HAS_8BIT_TABLES
1597 EXPORT_SYMBOL(dmasound_ulaw2dma8);
1598 EXPORT_SYMBOL(dmasound_alaw2dma8);
1599 #endif
1600 

~ [ 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