dmasound_core.c

   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#include <linux/sched/signal.h>
 186
 187#include <linux/uaccess.h>
 188
 189#include "dmasound.h"
 190
 191#define DMASOUND_CORE_REVISION 1
 192#define DMASOUND_CORE_EDITION 6
 193
 194    /*
 195     *  Declarations
 196     */
 197
 198static DEFINE_MUTEX(dmasound_core_mutex);
 199int dmasound_catchRadius = 0;
 200module_param(dmasound_catchRadius, int, 0);
 201
 202static unsigned int numWriteBufs = DEFAULT_N_BUFFERS;
 203module_param(numWriteBufs, int, 0);
 204static unsigned int writeBufSize = DEFAULT_BUFF_SIZE ;	/* in bytes */
 205module_param(writeBufSize, int, 0);
 206
 207MODULE_DESCRIPTION("Atari/Amiga/Q40 core DMA sound driver");
 208MODULE_LICENSE("GPL");
 209
 210static int sq_unit = -1;
 211static int mixer_unit = -1;
 212static int state_unit = -1;
 213static int irq_installed;
 214
 215/* control over who can modify resources shared between play/record */
 216static fmode_t shared_resource_owner;
 217static int shared_resources_initialised;
 218
 219    /*
 220     *  Mid level stuff
 221     */
 222
 223struct sound_settings dmasound = {
 224	.lock = __SPIN_LOCK_UNLOCKED(dmasound.lock)
 225};
 226
 227static inline void sound_silence(void)
 228{
 229	dmasound.mach.silence(); /* _MUST_ stop DMA */
 230}
 231
 232static inline int sound_set_format(int format)
 233{
 234	return dmasound.mach.setFormat(format);
 235}
 236
 237
 238static 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
 260static 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
 274static 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
 320static struct {
 321    int busy;
 322    int modify_counter;
 323} mixer;
 324
 325static 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
 337static 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
 346static 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		    strscpy(info.id, dmasound.mach.name2, sizeof(info.id));
 358		    strscpy(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
 370static 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
 381static const struct file_operations mixer_fops =
 382{
 383	.owner		= THIS_MODULE,
 384	.unlocked_ioctl	= mixer_unlocked_ioctl,
 385	.compat_ioctl	= compat_ptr_ioctl,
 386	.open		= mixer_open,
 387	.release	= mixer_release,
 388};
 389
 390static void mixer_init(void)
 391{
 392	mixer_unit = register_sound_mixer(&mixer_fops, -1);
 393	if (mixer_unit < 0)
 394		return;
 395
 396	mixer.busy = 0;
 397	dmasound.treble = 0;
 398	dmasound.bass = 0;
 399	if (dmasound.mach.mixer_init)
 400	    dmasound.mach.mixer_init();
 401}
 402
 403
 404    /*
 405     *  Sound queue stuff, the heart of the driver
 406     */
 407
 408struct sound_queue dmasound_write_sq;
 409static void sq_reset_output(void) ;
 410
 411static int sq_allocate_buffers(struct sound_queue *sq, int num, int size)
 412{
 413	int i;
 414
 415	if (sq->buffers)
 416		return 0;
 417	sq->numBufs = num;
 418	sq->bufSize = size;
 419	sq->buffers = kmalloc_array (num, sizeof(char *), GFP_KERNEL);
 420	if (!sq->buffers)
 421		return -ENOMEM;
 422	for (i = 0; i < num; i++) {
 423		sq->buffers[i] = dmasound.mach.dma_alloc(size, GFP_KERNEL);
 424		if (!sq->buffers[i]) {
 425			while (i--)
 426				dmasound.mach.dma_free(sq->buffers[i], size);
 427			kfree(sq->buffers);
 428			sq->buffers = NULL;
 429			return -ENOMEM;
 430		}
 431	}
 432	return 0;
 433}
 434
 435static void sq_release_buffers(struct sound_queue *sq)
 436{
 437	int i;
 438
 439	if (sq->buffers) {
 440		for (i = 0; i < sq->numBufs; i++)
 441			dmasound.mach.dma_free(sq->buffers[i], sq->bufSize);
 442		kfree(sq->buffers);
 443		sq->buffers = NULL;
 444	}
 445}
 446
 447
 448static int sq_setup(struct sound_queue *sq)
 449{
 450	int (*setup_func)(void) = NULL;
 451	int hard_frame ;
 452
 453	if (sq->locked) { /* are we already set? - and not changeable */
 454#ifdef DEBUG_DMASOUND
 455printk("dmasound_core: tried to sq_setup a locked queue\n") ;
 456#endif
 457		return -EINVAL ;
 458	}
 459	sq->locked = 1 ; /* don't think we have a race prob. here _check_ */
 460
 461	/* make sure that the parameters are set up
 462	   This should have been done already...
 463	*/
 464
 465	dmasound.mach.init();
 466
 467	/* OK.  If the user has set fragment parameters explicitly, then we
 468	   should leave them alone... as long as they are valid.
 469	   Invalid user fragment params can occur if we allow the whole buffer
 470	   to be used when the user requests the fragments sizes (with no soft
 471	   x-lation) and then the user subsequently sets a soft x-lation that
 472	   requires increased internal buffering.
 473
 474	   Othwerwise (if the user did not set them) OSS says that we should
 475	   select frag params on the basis of 0.5 s output & 0.1 s input
 476	   latency. (TODO.  For now we will copy in the defaults.)
 477	*/
 478
 479	if (sq->user_frags <= 0) {
 480		sq->max_count = sq->numBufs ;
 481		sq->max_active = sq->numBufs ;
 482		sq->block_size = sq->bufSize;
 483		/* set up the user info */
 484		sq->user_frags = sq->numBufs ;
 485		sq->user_frag_size = sq->bufSize ;
 486		sq->user_frag_size *=
 487			(dmasound.soft.size * (dmasound.soft.stereo+1) ) ;
 488		sq->user_frag_size /=
 489			(dmasound.hard.size * (dmasound.hard.stereo+1) ) ;
 490	} else {
 491		/* work out requested block size */
 492		sq->block_size = sq->user_frag_size ;
 493		sq->block_size *=
 494			(dmasound.hard.size * (dmasound.hard.stereo+1) ) ;
 495		sq->block_size /=
 496			(dmasound.soft.size * (dmasound.soft.stereo+1) ) ;
 497		/* the user wants to write frag-size chunks */
 498		sq->block_size *= dmasound.hard.speed ;
 499		sq->block_size /= dmasound.soft.speed ;
 500		/* this only works for size values which are powers of 2 */
 501		hard_frame =
 502			(dmasound.hard.size * (dmasound.hard.stereo+1))/8 ;
 503		sq->block_size +=  (hard_frame - 1) ;
 504		sq->block_size &= ~(hard_frame - 1) ; /* make sure we are aligned */
 505		/* let's just check for obvious mistakes */
 506		if ( sq->block_size <= 0 || sq->block_size > sq->bufSize) {
 507#ifdef DEBUG_DMASOUND
 508printk("dmasound_core: invalid frag size (user set %d)\n", sq->user_frag_size) ;
 509#endif
 510			sq->block_size = sq->bufSize ;
 511		}
 512		if ( sq->user_frags <= sq->numBufs ) {
 513			sq->max_count = sq->user_frags ;
 514			/* if user has set max_active - then use it */
 515			sq->max_active = (sq->max_active <= sq->max_count) ?
 516				sq->max_active : sq->max_count ;
 517		} else {
 518#ifdef DEBUG_DMASOUND
 519printk("dmasound_core: invalid frag count (user set %d)\n", sq->user_frags) ;
 520#endif
 521			sq->max_count =
 522			sq->max_active = sq->numBufs ;
 523		}
 524	}
 525	sq->front = sq->count = sq->rear_size = 0;
 526	sq->syncing = 0;
 527	sq->active = 0;
 528
 529	if (sq == &write_sq) {
 530	    sq->rear = -1;
 531	    setup_func = dmasound.mach.write_sq_setup;
 532	}
 533	if (setup_func)
 534	    return setup_func();
 535	return 0 ;
 536}
 537
 538static inline void sq_play(void)
 539{
 540	dmasound.mach.play();
 541}
 542
 543static ssize_t sq_write(struct file *file, const char __user *src, size_t uLeft,
 544			loff_t *ppos)
 545{
 546	ssize_t uWritten = 0;
 547	u_char *dest;
 548	ssize_t uUsed = 0, bUsed, bLeft;
 549	unsigned long flags ;
 550
 551	/* ++TeSche: Is something like this necessary?
 552	 * Hey, that's an honest question! Or does any other part of the
 553	 * filesystem already checks this situation? I really don't know.
 554	 */
 555	if (uLeft == 0)
 556		return 0;
 557
 558	/* implement any changes we have made to the soft/hard params.
 559	   this is not satisfactory really, all we have done up to now is to
 560	   say what we would like - there hasn't been any real checking of capability
 561	*/
 562
 563	if (shared_resources_initialised == 0) {
 564		dmasound.mach.init() ;
 565		shared_resources_initialised = 1 ;
 566	}
 567
 568	/* set up the sq if it is not already done. This may seem a dumb place
 569	   to do it - but it is what OSS requires.  It means that write() can
 570	   return memory allocation errors.  To avoid this possibility use the
 571	   GETBLKSIZE or GETOSPACE ioctls (after you've fiddled with all the
 572	   params you want to change) - these ioctls also force the setup.
 573	*/
 574
 575	if (write_sq.locked == 0) {
 576		if ((uWritten = sq_setup(&write_sq)) < 0) return uWritten ;
 577		uWritten = 0 ;
 578	}
 579
 580/* FIXME: I think that this may be the wrong behaviour when we get strapped
 581	for time and the cpu is close to being (or actually) behind in sending data.
 582	- because we've lost the time that the N samples, already in the buffer,
 583	would have given us to get here with the next lot from the user.
 584*/
 585	/* The interrupt doesn't start to play the last, incomplete frame.
 586	 * Thus we can append to it without disabling the interrupts! (Note
 587	 * also that write_sq.rear isn't affected by the interrupt.)
 588	 */
 589
 590	/* as of 1.6 this behaviour changes if SNDCTL_DSP_POST has been issued:
 591	   this will mimic the behaviour of syncing and allow the sq_play() to
 592	   queue a partial fragment.  Since sq_play() may/will be called from
 593	   the IRQ handler - at least on Pmac we have to deal with it.
 594	   The strategy - possibly not optimum - is to kill _POST status if we
 595	   get here.  This seems, at least, reasonable - in the sense that POST
 596	   is supposed to indicate that we might not write before the queue
 597	   is drained - and if we get here in time then it does not apply.
 598	*/
 599
 600	spin_lock_irqsave(&dmasound.lock, flags);
 601	write_sq.syncing &= ~2 ; /* take out POST status */
 602	spin_unlock_irqrestore(&dmasound.lock, flags);
 603
 604	if (write_sq.count > 0 &&
 605	    (bLeft = write_sq.block_size-write_sq.rear_size) > 0) {
 606		dest = write_sq.buffers[write_sq.rear];
 607		bUsed = write_sq.rear_size;
 608		uUsed = sound_copy_translate(dmasound.trans_write, src, uLeft,
 609					     dest, &bUsed, bLeft);
 610		if (uUsed <= 0)
 611			return uUsed;
 612		src += uUsed;
 613		uWritten += uUsed;
 614		uLeft = (uUsed <= uLeft) ? (uLeft - uUsed) : 0 ; /* paranoia */
 615		write_sq.rear_size = bUsed;
 616	}
 617
 618	while (uLeft) {
 619		DEFINE_WAIT(wait);
 620
 621		while (write_sq.count >= write_sq.max_active) {
 622			prepare_to_wait(&write_sq.action_queue, &wait, TASK_INTERRUPTIBLE);
 623			sq_play();
 624			if (write_sq.non_blocking) {
 625				finish_wait(&write_sq.action_queue, &wait);
 626				return uWritten > 0 ? uWritten : -EAGAIN;
 627			}
 628			if (write_sq.count < write_sq.max_active)
 629				break;
 630
 631			schedule_timeout(HZ);
 632			if (signal_pending(current)) {
 633				finish_wait(&write_sq.action_queue, &wait);
 634				return uWritten > 0 ? uWritten : -EINTR;
 635			}
 636		}
 637
 638		finish_wait(&write_sq.action_queue, &wait);
 639
 640		/* Here, we can avoid disabling the interrupt by first
 641		 * copying and translating the data, and then updating
 642		 * the write_sq variables. Until this is done, the interrupt
 643		 * won't see the new frame and we can work on it
 644		 * undisturbed.
 645		 */
 646
 647		dest = write_sq.buffers[(write_sq.rear+1) % write_sq.max_count];
 648		bUsed = 0;
 649		bLeft = write_sq.block_size;
 650		uUsed = sound_copy_translate(dmasound.trans_write, src, uLeft,
 651					     dest, &bUsed, bLeft);
 652		if (uUsed <= 0)
 653			break;
 654		src += uUsed;
 655		uWritten += uUsed;
 656		uLeft = (uUsed <= uLeft) ? (uLeft - uUsed) : 0 ; /* paranoia */
 657		if (bUsed) {
 658			write_sq.rear = (write_sq.rear+1) % write_sq.max_count;
 659			write_sq.rear_size = bUsed;
 660			write_sq.count++;
 661		}
 662	} /* uUsed may have been 0 */
 663
 664	sq_play();
 665
 666	return uUsed < 0? uUsed: uWritten;
 667}
 668
 669static __poll_t sq_poll(struct file *file, struct poll_table_struct *wait)
 670{
 671	__poll_t mask = 0;
 672	int retVal;
 673	
 674	if (write_sq.locked == 0) {
 675		if ((retVal = sq_setup(&write_sq)) < 0)
 676			return retVal;
 677		return 0;
 678	}
 679	if (file->f_mode & FMODE_WRITE )
 680		poll_wait(file, &write_sq.action_queue, wait);
 681	if (file->f_mode & FMODE_WRITE)
 682		if (write_sq.count < write_sq.max_active || write_sq.block_size - write_sq.rear_size > 0)
 683			mask |= EPOLLOUT | EPOLLWRNORM;
 684	return mask;
 685
 686}
 687
 688static inline void sq_init_waitqueue(struct sound_queue *sq)
 689{
 690	init_waitqueue_head(&sq->action_queue);
 691	init_waitqueue_head(&sq->open_queue);
 692	init_waitqueue_head(&sq->sync_queue);
 693	sq->busy = 0;
 694}
 695
 696#if 0 /* blocking open() */
 697static inline void sq_wake_up(struct sound_queue *sq, struct file *file,
 698			      fmode_t mode)
 699{
 700	if (file->f_mode & mode) {
 701		sq->busy = 0; /* CHECK: IS THIS OK??? */
 702		WAKE_UP(sq->open_queue);
 703	}
 704}
 705#endif
 706
 707static int sq_open2(struct sound_queue *sq, struct file *file, fmode_t mode,
 708		    int numbufs, int bufsize)
 709{
 710	int rc = 0;
 711
 712	if (file->f_mode & mode) {
 713		if (sq->busy) {
 714#if 0 /* blocking open() */
 715			rc = -EBUSY;
 716			if (file->f_flags & O_NONBLOCK)
 717				return rc;
 718			rc = -EINTR;
 719			if (wait_event_interruptible(sq->open_queue, !sq->busy))
 720				return rc;
 721			rc = 0;
 722#else
 723			/* OSS manual says we will return EBUSY regardless
 724			   of O_NOBLOCK.
 725			*/
 726			return -EBUSY ;
 727#endif
 728		}
 729		sq->busy = 1; /* Let's play spot-the-race-condition */
 730
 731		/* allocate the default number & size of buffers.
 732		   (i.e. specified in _setup() or as module params)
 733		   can't be changed at the moment - but _could_ be perhaps
 734		   in the setfragments ioctl.
 735		*/
 736		if (( rc = sq_allocate_buffers(sq, numbufs, bufsize))) {
 737#if 0 /* blocking open() */
 738			sq_wake_up(sq, file, mode);
 739#else
 740			sq->busy = 0 ;
 741#endif
 742			return rc;
 743		}
 744
 745		sq->non_blocking = file->f_flags & O_NONBLOCK;
 746	}
 747	return rc;
 748}
 749
 750#define write_sq_init_waitqueue()	sq_init_waitqueue(&write_sq)
 751#if 0 /* blocking open() */
 752#define write_sq_wake_up(file)		sq_wake_up(&write_sq, file, FMODE_WRITE)
 753#endif
 754#define write_sq_release_buffers()	sq_release_buffers(&write_sq)
 755#define write_sq_open(file)	\
 756	sq_open2(&write_sq, file, FMODE_WRITE, numWriteBufs, writeBufSize )
 757
 758static int sq_open(struct inode *inode, struct file *file)
 759{
 760	int rc;
 761
 762	mutex_lock(&dmasound_core_mutex);
 763	if (!try_module_get(dmasound.mach.owner)) {
 764		mutex_unlock(&dmasound_core_mutex);
 765		return -ENODEV;
 766	}
 767
 768	rc = write_sq_open(file); /* checks the f_mode */
 769	if (rc)
 770		goto out;
 771	if (file->f_mode & FMODE_READ) {
 772		/* TODO: if O_RDWR, release any resources grabbed by write part */
 773		rc = -ENXIO ; /* I think this is what is required by open(2) */
 774		goto out;
 775	}
 776
 777	if (dmasound.mach.sq_open)
 778	    dmasound.mach.sq_open(file->f_mode);
 779
 780	/* CHECK whether this is sensible - in the case that dsp0 could be opened
 781	  O_RDONLY and dsp1 could be opened O_WRONLY
 782	*/
 783
 784	dmasound.minDev = iminor(inode) & 0x0f;
 785
 786	/* OK. - we should make some attempt at consistency. At least the H'ware
 787	   options should be set with a valid mode.  We will make it that the LL
 788	   driver must supply defaults for hard & soft params.
 789	*/
 790
 791	if (shared_resource_owner == 0) {
 792		/* you can make this AFMT_U8/mono/8K if you want to mimic old
 793		   OSS behaviour - while we still have soft translations ;-) */
 794		dmasound.soft = dmasound.mach.default_soft ;
 795		dmasound.dsp = dmasound.mach.default_soft ;
 796		dmasound.hard = dmasound.mach.default_hard ;
 797	}
 798
 799#ifndef DMASOUND_STRICT_OSS_COMPLIANCE
 800	/* none of the current LL drivers can actually do this "native" at the moment
 801	   OSS does not really require us to supply /dev/audio if we can't do it.
 802	*/
 803	if (dmasound.minDev == SND_DEV_AUDIO) {
 804		sound_set_speed(8000);
 805		sound_set_stereo(0);
 806		sound_set_format(AFMT_MU_LAW);
 807	}
 808#endif
 809	mutex_unlock(&dmasound_core_mutex);
 810	return 0;
 811 out:
 812	module_put(dmasound.mach.owner);
 813	mutex_unlock(&dmasound_core_mutex);
 814	return rc;
 815}
 816
 817static void sq_reset_output(void)
 818{
 819	sound_silence(); /* this _must_ stop DMA, we might be about to lose the buffers */
 820	write_sq.active = 0;
 821	write_sq.count = 0;
 822	write_sq.rear_size = 0;
 823	/* write_sq.front = (write_sq.rear+1) % write_sq.max_count;*/
 824	write_sq.front = 0 ;
 825	write_sq.rear = -1 ; /* same as for set-up */
 826
 827	/* OK - we can unlock the parameters and fragment settings */
 828	write_sq.locked = 0 ;
 829	write_sq.user_frags = 0 ;
 830	write_sq.user_frag_size = 0 ;
 831}
 832
 833static void sq_reset(void)
 834{
 835	sq_reset_output() ;
 836	/* we could consider resetting the shared_resources_owner here... but I
 837	   think it is probably still rather non-obvious to application writer
 838	*/
 839
 840	/* we release everything else though */
 841	shared_resources_initialised = 0 ;
 842}
 843
 844static int sq_fsync(void)
 845{
 846	int rc = 0;
 847	int timeout = 5;
 848
 849	write_sq.syncing |= 1;
 850	sq_play();	/* there may be an incomplete frame waiting */
 851
 852	while (write_sq.active) {
 853		wait_event_interruptible_timeout(write_sq.sync_queue,
 854						 !write_sq.active, HZ);
 855		if (signal_pending(current)) {
 856			/* While waiting for audio output to drain, an
 857			 * interrupt occurred.  Stop audio output immediately
 858			 * and clear the queue. */
 859			sq_reset_output();
 860			rc = -EINTR;
 861			break;
 862		}
 863		if (!--timeout) {
 864			printk(KERN_WARNING "dmasound: Timeout draining output\n");
 865			sq_reset_output();
 866			rc = -EIO;
 867			break;
 868		}
 869	}
 870
 871	/* flag no sync regardless of whether we had a DSP_POST or not */
 872	write_sq.syncing = 0 ;
 873	return rc;
 874}
 875
 876static int sq_release(struct inode *inode, struct file *file)
 877{
 878	int rc = 0;
 879
 880	mutex_lock(&dmasound_core_mutex);
 881
 882	if (file->f_mode & FMODE_WRITE) {
 883		if (write_sq.busy)
 884			rc = sq_fsync();
 885
 886		sq_reset_output() ; /* make sure dma is stopped and all is quiet */
 887		write_sq_release_buffers();
 888		write_sq.busy = 0;
 889	}
 890
 891	if (file->f_mode & shared_resource_owner) { /* it's us that has them */
 892		shared_resource_owner = 0 ;
 893		shared_resources_initialised = 0 ;
 894		dmasound.hard = dmasound.mach.default_hard ;
 895	}
 896
 897	module_put(dmasound.mach.owner);
 898
 899#if 0 /* blocking open() */
 900	/* Wake up a process waiting for the queue being released.
 901	 * Note: There may be several processes waiting for a call
 902	 * to open() returning. */
 903
 904	/* Iain: hmm I don't understand this next comment ... */
 905	/* There is probably a DOS atack here. They change the mode flag. */
 906	/* XXX add check here,*/
 907	read_sq_wake_up(file); /* checks f_mode */
 908	write_sq_wake_up(file); /* checks f_mode */
 909#endif /* blocking open() */
 910
 911	mutex_unlock(&dmasound_core_mutex);
 912
 913	return rc;
 914}
 915
 916/* here we see if we have a right to modify format, channels, size and so on
 917   if no-one else has claimed it already then we do...
 918
 919   TODO: We might change this to mask O_RDWR such that only one or the other channel
 920   is the owner - if we have problems.
 921*/
 922
 923static int shared_resources_are_mine(fmode_t md)
 924{
 925	if (shared_resource_owner)
 926		return (shared_resource_owner & md) != 0;
 927	else {
 928		shared_resource_owner = md ;
 929		return 1 ;
 930	}
 931}
 932
 933/* if either queue is locked we must deny the right to change shared params
 934*/
 935
 936static int queues_are_quiescent(void)
 937{
 938	if (write_sq.locked)
 939		return 0 ;
 940	return 1 ;
 941}
 942
 943/* check and set a queue's fragments per user's wishes...
 944   we will check against the pre-defined literals and the actual sizes.
 945   This is a bit fraught - because soft translations can mess with our
 946   buffer requirements *after* this call - OSS says "call setfrags first"
 947*/
 948
 949/* It is possible to replace all the -EINVAL returns with an override that
 950   just puts the allowable value in.  This may be what many OSS apps require
 951*/
 952
 953static int set_queue_frags(struct sound_queue *sq, int bufs, int size)
 954{
 955	if (sq->locked) {
 956#ifdef DEBUG_DMASOUND
 957printk("dmasound_core: tried to set_queue_frags on a locked queue\n") ;
 958#endif
 959		return -EINVAL ;
 960	}
 961
 962	if ((size < MIN_FRAG_SIZE) || (size > MAX_FRAG_SIZE))
 963		return -EINVAL ;
 964	size = (1<<size) ; /* now in bytes */
 965	if (size > sq->bufSize)
 966		return -EINVAL ; /* this might still not work */
 967
 968	if (bufs <= 0)
 969		return -EINVAL ;
 970	if (bufs > sq->numBufs) /* the user is allowed say "don't care" with 0x7fff */
 971		bufs = sq->numBufs ;
 972
 973	/* there is, currently, no way to specify max_active separately
 974	   from max_count.  This could be a LL driver issue - I guess
 975	   if there is a requirement for these values to be different then
 976	  we will have to pass that info. up to this level.
 977	*/
 978	sq->user_frags =
 979	sq->max_active = bufs ;
 980	sq->user_frag_size = size ;
 981
 982	return 0 ;
 983}
 984
 985static int sq_ioctl(struct file *file, u_int cmd, u_long arg)
 986{
 987	int val, result;
 988	u_long fmt;
 989	int data;
 990	int size, nbufs;
 991	audio_buf_info info;
 992
 993	switch (cmd) {
 994	case SNDCTL_DSP_RESET:
 995		sq_reset();
 996		return 0;
 997	case SNDCTL_DSP_GETFMTS:
 998		fmt = dmasound.mach.hardware_afmts ; /* this is what OSS says.. */
 999		return IOCTL_OUT(arg, fmt);
1000	case SNDCTL_DSP_GETBLKSIZE:
1001		/* this should tell the caller about bytes that the app can
1002		   read/write - the app doesn't care about our internal buffers.
1003		   We force sq_setup() here as per OSS 1.1 (which should
1004		   compute the values necessary).
1005		   Since there is no mechanism to specify read/write separately, for
1006		   fds opened O_RDWR, the write_sq values will, arbitrarily, overwrite
1007		   the read_sq ones.
1008		*/
1009		size = 0 ;
1010		if (file->f_mode & FMODE_WRITE) {
1011			if ( !write_sq.locked )
1012				sq_setup(&write_sq) ;
1013			size = write_sq.user_frag_size ;
1014		}
1015		return IOCTL_OUT(arg, size);
1016	case SNDCTL_DSP_POST:
1017		/* all we are going to do is to tell the LL that any
1018		   partial frags can be queued for output.
1019		   The LL will have to clear this flag when last output
1020		   is queued.
1021		*/
1022		write_sq.syncing |= 0x2 ;
1023		sq_play() ;
1024		return 0 ;
1025	case SNDCTL_DSP_SYNC:
1026		/* This call, effectively, has the same behaviour as SNDCTL_DSP_RESET
1027		   except that it waits for output to finish before resetting
1028		   everything - read, however, is killed immediately.
1029		*/
1030		result = 0 ;
1031		if (file->f_mode & FMODE_WRITE) {
1032			result = sq_fsync();
1033			sq_reset_output() ;
1034		}
1035		/* if we are the shared resource owner then release them */
1036		if (file->f_mode & shared_resource_owner)
1037			shared_resources_initialised = 0 ;
1038		return result ;
1039	case SOUND_PCM_READ_RATE:
1040		return IOCTL_OUT(arg, dmasound.soft.speed);
1041	case SNDCTL_DSP_SPEED:
1042		/* changing this on the fly will have weird effects on the sound.
1043		   Where there are rate conversions implemented in soft form - it
1044		   will cause the _ctx_xxx() functions to be substituted.
1045		   However, there doesn't appear to be any reason to dis-allow it from
1046		   a driver pov.
1047		*/
1048		if (shared_resources_are_mine(file->f_mode)) {
1049			IOCTL_IN(arg, data);
1050			data = sound_set_speed(data) ;
1051			shared_resources_initialised = 0 ;
1052			return IOCTL_OUT(arg, data);
1053		} else
1054			return -EINVAL ;
1055		break ;
1056	/* OSS says these next 4 actions are undefined when the device is
1057	   busy/active - we will just return -EINVAL.
1058	   To be allowed to change one - (a) you have to own the right
1059	    (b) the queue(s) must be quiescent
1060	*/
1061	case SNDCTL_DSP_STEREO:
1062		if (shared_resources_are_mine(file->f_mode) &&
1063		    queues_are_quiescent()) {
1064			IOCTL_IN(arg, data);
1065			shared_resources_initialised = 0 ;
1066			return IOCTL_OUT(arg, sound_set_stereo(data));
1067		} else
1068			return -EINVAL ;
1069		break ;
1070	case SOUND_PCM_WRITE_CHANNELS:
1071		if (shared_resources_are_mine(file->f_mode) &&
1072		    queues_are_quiescent()) {
1073			IOCTL_IN(arg, data);
1074			/* the user might ask for 20 channels, we will return 1 or 2 */
1075			shared_resources_initialised = 0 ;
1076			return IOCTL_OUT(arg, sound_set_stereo(data-1)+1);
1077		} else
1078			return -EINVAL ;
1079		break ;
1080	case SNDCTL_DSP_SETFMT:
1081		if (shared_resources_are_mine(file->f_mode) &&
1082		    queues_are_quiescent()) {
1083		    	int format;
1084			IOCTL_IN(arg, data);
1085			shared_resources_initialised = 0 ;
1086			format = sound_set_format(data);
1087			result = IOCTL_OUT(arg, format);
1088			if (result < 0)
1089				return result;
1090			if (format != data && data != AFMT_QUERY)
1091				return -EINVAL;
1092			return 0;
1093		} else
1094			return -EINVAL ;
1095	case SNDCTL_DSP_SUBDIVIDE:
1096		return -EINVAL ;
1097	case SNDCTL_DSP_SETFRAGMENT:
1098		/* we can do this independently for the two queues - with the
1099		   proviso that for fds opened O_RDWR we cannot separate the
1100		   actions and both queues will be set per the last call.
1101		   NOTE: this does *NOT* actually set the queue up - merely
1102		   registers our intentions.
1103		*/
1104		IOCTL_IN(arg, data);
1105		result = 0 ;
1106		nbufs = (data >> 16) & 0x7fff ; /* 0x7fff is 'use maximum' */
1107		size = data & 0xffff;
1108		if (file->f_mode & FMODE_WRITE) {
1109			result = set_queue_frags(&write_sq, nbufs, size) ;
1110			if (result)
1111				return result ;
1112		}
1113		/* NOTE: this return value is irrelevant - OSS specifically says that
1114		   the value is 'random' and that the user _must_ check the actual
1115		   frags values using SNDCTL_DSP_GETBLKSIZE or similar */
1116		return IOCTL_OUT(arg, data);
1117	case SNDCTL_DSP_GETOSPACE:
1118		/*
1119		*/
1120		if (file->f_mode & FMODE_WRITE) {
1121			if ( !write_sq.locked )
1122				sq_setup(&write_sq) ;
1123			info.fragments = write_sq.max_active - write_sq.count;
1124			info.fragstotal = write_sq.max_active;
1125			info.fragsize = write_sq.user_frag_size;
1126			info.bytes = info.fragments * info.fragsize;
1127			if (copy_to_user((void __user *)arg, &info, sizeof(info)))
1128				return -EFAULT;
1129			return 0;
1130		} else
1131			return -EINVAL ;
1132		break ;
1133	case SNDCTL_DSP_GETCAPS:
1134		val = dmasound.mach.capabilities & 0xffffff00;
1135		return IOCTL_OUT(arg,val);
1136
1137	default:
1138		return mixer_ioctl(file, cmd, arg);
1139	}
1140	return -EINVAL;
1141}
1142
1143static long sq_unlocked_ioctl(struct file *file, u_int cmd, u_long arg)
1144{
1145	int ret;
1146
1147	mutex_lock(&dmasound_core_mutex);
1148	ret = sq_ioctl(file, cmd, arg);
1149	mutex_unlock(&dmasound_core_mutex);
1150
1151	return ret;
1152}
1153
1154static const struct file_operations sq_fops =
1155{
1156	.owner		= THIS_MODULE,
1157	.write		= sq_write,
1158	.poll		= sq_poll,
1159	.unlocked_ioctl	= sq_unlocked_ioctl,
1160	.compat_ioctl	= compat_ptr_ioctl,
1161	.open		= sq_open,
1162	.release	= sq_release,
1163};
1164
1165static int sq_init(void)
1166{
1167	const struct file_operations *fops = &sq_fops;
1168
1169	sq_unit = register_sound_dsp(fops, -1);
1170	if (sq_unit < 0) {
1171		printk(KERN_ERR "dmasound_core: couldn't register fops\n") ;
1172		return sq_unit ;
1173	}
1174
1175	write_sq_init_waitqueue();
1176
1177	/* These parameters will be restored for every clean open()
1178	 * in the case of multiple open()s (e.g. dsp0 & dsp1) they
1179	 * will be set so long as the shared resources have no owner.
1180	 */
1181
1182	if (shared_resource_owner == 0) {
1183		dmasound.soft = dmasound.mach.default_soft ;
1184		dmasound.hard = dmasound.mach.default_hard ;
1185		dmasound.dsp = dmasound.mach.default_soft ;
1186		shared_resources_initialised = 0 ;
1187	}
1188	return 0 ;
1189}
1190
1191
1192    /*
1193     *  /dev/sndstat
1194     */
1195
1196/* we allow more space for record-enabled because there are extra output lines.
1197   the number here must include the amount we are prepared to give to the low-level
1198   driver.
1199*/
1200
1201#define STAT_BUFF_LEN 768
1202
1203/* this is how much space we will allow the low-level driver to use
1204   in the stat buffer.  Currently, 2 * (80 character line + <NL>).
1205   We do not police this (it is up to the ll driver to be honest).
1206*/
1207
1208#define LOW_LEVEL_STAT_ALLOC 162
1209
1210static struct {
1211    int busy;
1212    char buf[STAT_BUFF_LEN];	/* state.buf should not overflow! */
1213    int len, ptr;
1214} state;
1215
1216/* publish this function for use by low-level code, if required */
1217
1218static char *get_afmt_string(int afmt)
1219{
1220        switch(afmt) {
1221            case AFMT_MU_LAW:
1222                return "mu-law";
1223            case AFMT_A_LAW:
1224                return "A-law";
1225            case AFMT_U8:
1226                return "unsigned 8 bit";
1227            case AFMT_S8:
1228                return "signed 8 bit";
1229            case AFMT_S16_BE:
1230                return "signed 16 bit BE";
1231            case AFMT_U16_BE:
1232                return "unsigned 16 bit BE";
1233            case AFMT_S16_LE:
1234                return "signed 16 bit LE";
1235            case AFMT_U16_LE:
1236                return "unsigned 16 bit LE";
1237	    case 0:
1238		return "format not set" ;
1239            default:
1240                break ;
1241        }
1242        return "ERROR: Unsupported AFMT_XXXX code" ;
1243}
1244
1245static int state_open(struct inode *inode, struct file *file)
1246{
1247	char *buffer = state.buf;
1248	int len = 0;
1249	int ret;
1250
1251	mutex_lock(&dmasound_core_mutex);
1252	ret = -EBUSY;
1253	if (state.busy)
1254		goto out;
1255
1256	ret = -ENODEV;
1257	if (!try_module_get(dmasound.mach.owner))
1258		goto out;
1259
1260	state.ptr = 0;
1261	state.busy = 1;
1262
1263	len += sprintf(buffer+len, "%sDMA sound driver rev %03d :\n",
1264		dmasound.mach.name, (DMASOUND_CORE_REVISION<<4) +
1265		((dmasound.mach.version>>8) & 0x0f));
1266	len += sprintf(buffer+len,
1267		"Core driver edition %02d.%02d : %s driver edition %02d.%02d\n",
1268		DMASOUND_CORE_REVISION, DMASOUND_CORE_EDITION, dmasound.mach.name2,
1269		(dmasound.mach.version >> 8), (dmasound.mach.version & 0xff)) ;
1270
1271	/* call the low-level module to fill in any stat info. that it has
1272	   if present.  Maximum buffer usage is specified.
1273	*/
1274
1275	if (dmasound.mach.state_info)
1276		len += dmasound.mach.state_info(buffer+len,
1277			(size_t) LOW_LEVEL_STAT_ALLOC) ;
1278
1279	/* make usage of the state buffer as deterministic as poss.
1280	   exceptional conditions could cause overrun - and this is flagged as
1281	   a kernel error.
1282	*/
1283
1284	/* formats and settings */
1285
1286	len += sprintf(buffer+len,"\t\t === Formats & settings ===\n") ;
1287	len += sprintf(buffer+len,"Parameter %20s%20s\n","soft","hard") ;
1288	len += sprintf(buffer+len,"Format   :%20s%20s\n",
1289		get_afmt_string(dmasound.soft.format),
1290		get_afmt_string(dmasound.hard.format));
1291
1292	len += sprintf(buffer+len,"Samp Rate:%14d s/sec%14d s/sec\n",
1293		       dmasound.soft.speed, dmasound.hard.speed);
1294
1295	len += sprintf(buffer+len,"Channels :%20s%20s\n",
1296		       dmasound.soft.stereo ? "stereo" : "mono",
1297		       dmasound.hard.stereo ? "stereo" : "mono" );
1298
1299	/* sound queue status */
1300
1301	len += sprintf(buffer+len,"\t\t === Sound Queue status ===\n");
1302	len += sprintf(buffer+len,"Allocated:%8s%6s\n","Buffers","Size") ;
1303	len += sprintf(buffer+len,"%9s:%8d%6d\n",
1304		"write", write_sq.numBufs, write_sq.bufSize) ;
1305	len += sprintf(buffer+len,
1306		"Current  : MaxFrg FragSiz MaxAct Frnt Rear "
1307		"Cnt RrSize A B S L  xruns\n") ;
1308	len += sprintf(buffer+len,"%9s:%7d%8d%7d%5d%5d%4d%7d%2d%2d%2d%2d%7d\n",
1309		"write", write_sq.max_count, write_sq.block_size,
1310		write_sq.max_active, write_sq.front, write_sq.rear,
1311		write_sq.count, write_sq.rear_size, write_sq.active,
1312		write_sq.busy, write_sq.syncing, write_sq.locked, write_sq.xruns) ;
1313#ifdef DEBUG_DMASOUND
1314printk("dmasound: stat buffer used %d bytes\n", len) ;
1315#endif
1316
1317	if (len >= STAT_BUFF_LEN)
1318		printk(KERN_ERR "dmasound_core: stat buffer overflowed!\n");
1319
1320	state.len = len;
1321	ret = 0;
1322out:
1323	mutex_unlock(&dmasound_core_mutex);
1324	return ret;
1325}
1326
1327static int state_release(struct inode *inode, struct file *file)
1328{
1329	mutex_lock(&dmasound_core_mutex);
1330	state.busy = 0;
1331	module_put(dmasound.mach.owner);
1332	mutex_unlock(&dmasound_core_mutex);
1333	return 0;
1334}
1335
1336static ssize_t state_read(struct file *file, char __user *buf, size_t count,
1337			  loff_t *ppos)
1338{
1339	int n = state.len - state.ptr;
1340	if (n > count)
1341		n = count;
1342	if (n <= 0)
1343		return 0;
1344	if (copy_to_user(buf, &state.buf[state.ptr], n))
1345		return -EFAULT;
1346	state.ptr += n;
1347	return n;
1348}
1349
1350static const struct file_operations state_fops = {
1351	.owner		= THIS_MODULE,
1352	.read		= state_read,
1353	.open		= state_open,
1354	.release	= state_release,
1355};
1356
1357static int state_init(void)
1358{
1359	state_unit = register_sound_special(&state_fops, SND_DEV_STATUS);
1360	if (state_unit < 0)
1361		return state_unit ;
1362	state.busy = 0;
1363	return 0 ;
1364}
1365
1366
1367    /*
1368     *  Config & Setup
1369     *
1370     *  This function is called by _one_ chipset-specific driver
1371     */
1372
1373int dmasound_init(void)
1374{
1375	int res ;
1376
1377	if (irq_installed)
1378		return -EBUSY;
1379
1380	/* Set up sound queue, /dev/audio and /dev/dsp. */
1381
1382	/* Set default settings. */
1383	if ((res = sq_init()) < 0)
1384		return res ;
1385
1386	/* Set up /dev/sndstat. */
1387	if ((res = state_init()) < 0)
1388		return res ;
1389
1390	/* Set up /dev/mixer. */
1391	mixer_init();
1392
1393	if (!dmasound.mach.irqinit()) {
1394		printk(KERN_ERR "DMA sound driver: Interrupt initialization failed\n");
1395		return -ENODEV;
1396	}
1397	irq_installed = 1;
1398
1399	printk(KERN_INFO "%s DMA sound driver rev %03d installed\n",
1400		dmasound.mach.name, (DMASOUND_CORE_REVISION<<4) +
1401		((dmasound.mach.version>>8) & 0x0f));
1402	printk(KERN_INFO
1403		"Core driver edition %02d.%02d : %s driver edition %02d.%02d\n",
1404		DMASOUND_CORE_REVISION, DMASOUND_CORE_EDITION, dmasound.mach.name2,
1405		(dmasound.mach.version >> 8), (dmasound.mach.version & 0xff)) ;
1406	printk(KERN_INFO "Write will use %4d fragments of %7d bytes as default\n",
1407		numWriteBufs, writeBufSize) ;
1408	return 0;
1409}
1410
1411void dmasound_deinit(void)
1412{
1413	if (irq_installed) {
1414		sound_silence();
1415		dmasound.mach.irqcleanup();
1416		irq_installed = 0;
1417	}
1418
1419	write_sq_release_buffers();
1420
1421	if (mixer_unit >= 0)
1422		unregister_sound_mixer(mixer_unit);
1423	if (state_unit >= 0)
1424		unregister_sound_special(state_unit);
1425	if (sq_unit >= 0)
1426		unregister_sound_dsp(sq_unit);
1427}
1428
1429static int __maybe_unused dmasound_setup(char *str)
1430{
1431	int ints[6], size;
1432
1433	str = get_options(str, ARRAY_SIZE(ints), ints);
1434
1435	/* check the bootstrap parameter for "dmasound=" */
1436
1437	/* FIXME: other than in the most naive of cases there is no sense in these
1438	 *	  buffers being other than powers of two.  This is not checked yet.
1439	 */
1440
1441	switch (ints[0]) {
1442	case 3:
1443		if ((ints[3] < 0) || (ints[3] > MAX_CATCH_RADIUS))
1444			printk("dmasound_setup: invalid catch radius, using default = %d\n", catchRadius);
1445		else
1446			catchRadius = ints[3];
1447		fallthrough;
1448	case 2:
1449		if (ints[1] < MIN_BUFFERS)
1450			printk("dmasound_setup: invalid number of buffers, using default = %d\n", numWriteBufs);
1451		else
1452			numWriteBufs = ints[1];
1453		fallthrough;
1454	case 1:
1455		if ((size = ints[2]) < 256) /* check for small buffer specs */
1456			size <<= 10 ;
1457                if (size < MIN_BUFSIZE || size > MAX_BUFSIZE)
1458                        printk("dmasound_setup: invalid write buffer size, using default = %d\n", writeBufSize);
1459                else
1460                        writeBufSize = size;
1461	case 0:
1462		break;
1463	default:
1464		printk("dmasound_setup: invalid number of arguments\n");
1465		return 0;
1466	}
1467	return 1;
1468}
1469
1470__setup("dmasound=", dmasound_setup);
1471
1472    /*
1473     *  Conversion tables
1474     */
1475
1476#ifdef HAS_8BIT_TABLES
1477/* 8 bit mu-law */
1478
1479char dmasound_ulaw2dma8[] = {
1480	-126,	-122,	-118,	-114,	-110,	-106,	-102,	-98,
1481	-94,	-90,	-86,	-82,	-78,	-74,	-70,	-66,
1482	-63,	-61,	-59,	-57,	-55,	-53,	-51,	-49,
1483	-47,	-45,	-43,	-41,	-39,	-37,	-35,	-33,
1484	-31,	-30,	-29,	-28,	-27,	-26,	-25,	-24,
1485	-23,	-22,	-21,	-20,	-19,	-18,	-17,	-16,
1486	-16,	-15,	-15,	-14,	-14,	-13,	-13,	-12,
1487	-12,	-11,	-11,	-10,	-10,	-9,	-9,	-8,
1488	-8,	-8,	-7,	-7,	-7,	-7,	-6,	-6,
1489	-6,	-6,	-5,	-5,	-5,	-5,	-4,	-4,
1490	-4,	-4,	-4,	-4,	-3,	-3,	-3,	-3,
1491	-3,	-3,	-3,	-3,	-2,	-2,	-2,	-2,
1492	-2,	-2,	-2,	-2,	-2,	-2,	-2,	-2,
1493	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,
1494	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,
1495	-1,	-1,	-1,	-1,	-1,	-1,	-1,	0,
1496	125,	121,	117,	113,	109,	105,	101,	97,
1497	93,	89,	85,	81,	77,	73,	69,	65,
1498	62,	60,	58,	56,	54,	52,	50,	48,
1499	46,	44,	42,	40,	38,	36,	34,	32,
1500	30,	29,	28,	27,	26,	25,	24,	23,
1501	22,	21,	20,	19,	18,	17,	16,	15,
1502	15,	14,	14,	13,	13,	12,	12,	11,
1503	11,	10,	10,	9,	9,	8,	8,	7,
1504	7,	7,	6,	6,	6,	6,	5,	5,
1505	5,	5,	4,	4,	4,	4,	3,	3,
1506	3,	3,	3,	3,	2,	2,	2,	2,
1507	2,	2,	2,	2,	1,	1,	1,	1,
1508	1,	1,	1,	1,	1,	1,	1,	1,
1509	0,	0,	0,	0,	0,	0,	0,	0,
1510	0,	0,	0,	0,	0,	0,	0,	0,
1511	0,	0,	0,	0,	0,	0,	0,	0
1512};
1513
1514/* 8 bit A-law */
1515
1516char dmasound_alaw2dma8[] = {
1517	-22,	-21,	-24,	-23,	-18,	-17,	-20,	-19,
1518	-30,	-29,	-32,	-31,	-26,	-25,	-28,	-27,
1519	-11,	-11,	-12,	-12,	-9,	-9,	-10,	-10,
1520	-15,	-15,	-16,	-16,	-13,	-13,	-14,	-14,
1521	-86,	-82,	-94,	-90,	-70,	-66,	-78,	-74,
1522	-118,	-114,	-126,	-122,	-102,	-98,	-110,	-106,
1523	-43,	-41,	-47,	-45,	-35,	-33,	-39,	-37,
1524	-59,	-57,	-63,	-61,	-51,	-49,	-55,	-53,
1525	-2,	-2,	-2,	-2,	-2,	-2,	-2,	-2,
1526	-2,	-2,	-2,	-2,	-2,	-2,	-2,	-2,
1527	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,
1528	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,
1529	-6,	-6,	-6,	-6,	-5,	-5,	-5,	-5,
1530	-8,	-8,	-8,	-8,	-7,	-7,	-7,	-7,
1531	-3,	-3,	-3,	-3,	-3,	-3,	-3,	-3,
1532	-4,	-4,	-4,	-4,	-4,	-4,	-4,	-4,
1533	21,	20,	23,	22,	17,	16,	19,	18,
1534	29,	28,	31,	30,	25,	24,	27,	26,
1535	10,	10,	11,	11,	8,	8,	9,	9,
1536	14,	14,	15,	15,	12,	12,	13,	13,
1537	86,	82,	94,	90,	70,	66,	78,	74,
1538	118,	114,	126,	122,	102,	98,	110,	106,
1539	43,	41,	47,	45,	35,	33,	39,	37,
1540	59,	57,	63,	61,	51,	49,	55,	53,
1541	1,	1,	1,	1,	1,	1,	1,	1,
1542	1,	1,	1,	1,	1,	1,	1,	1,
1543	0,	0,	0,	0,	0,	0,	0,	0,
1544	0,	0,	0,	0,	0,	0,	0,	0,
1545	5,	5,	5,	5,	4,	4,	4,	4,
1546	7,	7,	7,	7,	6,	6,	6,	6,
1547	2,	2,	2,	2,	2,	2,	2,	2,
1548	3,	3,	3,	3,	3,	3,	3,	3
1549};
1550#endif /* HAS_8BIT_TABLES */
1551
1552    /*
1553     *  Visible symbols for modules
1554     */
1555
1556EXPORT_SYMBOL(dmasound);
1557EXPORT_SYMBOL(dmasound_init);
1558EXPORT_SYMBOL(dmasound_deinit);
1559EXPORT_SYMBOL(dmasound_write_sq);
1560EXPORT_SYMBOL(dmasound_catchRadius);
1561#ifdef HAS_8BIT_TABLES
1562EXPORT_SYMBOL(dmasound_ulaw2dma8);
1563EXPORT_SYMBOL(dmasound_alaw2dma8);
1564#endif