URL
https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k
[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [sbus/] [audio/] [audio.c] - Rev 1765
Compare with Previous | Blame | View Log
/* $Id: audio.c,v 1.1.1.1 2004-04-15 02:07:33 phoenix Exp $ * drivers/sbus/audio/audio.c * * Copyright 1996 Thomas K. Dyas (tdyas@noc.rutgers.edu) * Copyright 1997,1998,1999 Derrick J. Brashear (shadow@dementia.org) * Copyright 1997 Brent Baccala (baccala@freesoft.org) * * Mixer code adapted from code contributed by and * Copyright 1998 Michael Mraka (michael@fi.muni.cz) * and with fixes from Michael Shuey (shuey@ecn.purdue.edu) * The mixer code cheats; Sparc hardware doesn't generally allow independent * line control, and this fakes it badly. * * SNDCTL_DSP_SETFMT based on code contributed by * Ion Badulescu (ionut@moisil.cs.columbia.edu) * * This is the audio midlayer that sits between the VFS character * devices and the low-level audio hardware device drivers. */ #include <linux/config.h> #include <linux/module.h> #include <linux/errno.h> #include <linux/fs.h> #include <linux/kernel.h> #include <linux/sched.h> #include <linux/smp_lock.h> #include <linux/mm.h> #include <linux/tqueue.h> #include <linux/major.h> #include <linux/slab.h> #include <linux/interrupt.h> #include <linux/init.h> #include <linux/soundcard.h> #include <linux/devfs_fs_kernel.h> #include <linux/delay.h> #include <linux/poll.h> #include <asm/pgtable.h> #include <asm/uaccess.h> #include <asm/audioio.h> #undef __AUDIO_DEBUG #define __AUDIO_ERROR #undef __AUDIO_TRACE #undef __AUDIO_OSSDEBUG #ifdef __AUDIO_DEBUG #define dprintk(x) printk x #else #define dprintk(x) #endif #ifdef __AUDIO_OSSDEBUG #define oprintk(x) printk x #else #define oprintk(x) #endif #ifdef __AUDIO_ERROR #define eprintk(x) printk x #else #define eprintk(x) #endif #ifdef __AUDIO_TRACE #define tprintk(x) printk x #else #define tprintk(x) #endif static short lis_get_elist_ent( strevent_t *list, pid_t pid ); static int lis_add_to_elist( strevent_t **list, pid_t pid, short events ); static int lis_del_from_elist( strevent_t **list, pid_t pid, short events ); static void lis_free_elist( strevent_t **list); static void kill_procs( struct strevent *elist, int sig, short e); static struct sparcaudio_driver *drivers[SPARCAUDIO_MAX_DEVICES]; static devfs_handle_t devfs_handle; void sparcaudio_output_done(struct sparcaudio_driver * drv, int status) { /* If !status, just restart current output. * If status & 1, a buffer is finished; make it available again. * If status & 2, a buffer was claimed for DMA and is still in use. * * The playing_count for non-DMA hardware should never be non-zero. * Value of status for non-DMA hardware should always be 1. */ if (status & 1) { if (drv->playing_count) { drv->playing_count--; } else { drv->output_count--; drv->output_size -= drv->output_sizes[drv->output_front]; if (drv->output_notify[drv->output_front] == 1) { drv->output_eof++; drv->output_notify[drv->output_front] = 0; kill_procs(drv->sd_siglist,SIGPOLL,S_MSG); } drv->output_front = (drv->output_front + 1) % drv->num_output_buffers; } } if (status & 2) { drv->output_count--; drv->playing_count++; drv->output_size -= drv->output_sizes[drv->output_front]; if (drv->output_notify[drv->output_front] == 1) { drv->output_eof++; drv->output_notify[drv->output_front] = 0; kill_procs(drv->sd_siglist,SIGPOLL,S_MSG); } drv->output_front = (drv->output_front + 1) % drv->num_output_buffers; } /* If we've played everything go inactive. */ if ((drv->output_count < 1) && (drv->playing_count < 1)) drv->output_active = 0; /* If we got back a buffer, see if anyone wants to write to it */ if ((status & 1) || ((drv->output_count + drv->playing_count) < drv->num_output_buffers)) { wake_up_interruptible(&drv->output_write_wait); } /* If the output queue is empty, shut down the driver. */ if ((drv->output_count < 1) && (drv->playing_count < 1)) { kill_procs(drv->sd_siglist,SIGPOLL,S_MSG); /* Stop the lowlevel driver from outputing. */ /* drv->ops->stop_output(drv); Should not be necessary -- DJB 5/25/98 */ drv->output_active = 0; /* Wake up any waiting writers or syncers and return. */ wake_up_interruptible(&drv->output_write_wait); wake_up_interruptible(&drv->output_drain_wait); return; } /* Start next block of output if we have it */ if (drv->output_count > 0) { drv->ops->start_output(drv, drv->output_buffers[drv->output_front], drv->output_sizes[drv->output_front]); drv->output_active = 1; } else { drv->output_active = 0; } } void sparcaudio_input_done(struct sparcaudio_driver * drv, int status) { /* Deal with the weird case here */ if (drv->duplex == 2) { if (drv->input_count < drv->num_input_buffers) drv->input_count++; drv->ops->start_input(drv, drv->input_buffers[drv->input_front], drv->input_buffer_size); wake_up_interruptible(&drv->input_read_wait); return; } /* If status % 2, they filled a buffer for us. * If status & 2, they took a buffer from us. */ if ((status % 2) == 1) { drv->input_count++; drv->recording_count--; drv->input_size+=drv->input_buffer_size; } if (status > 1) { drv->recording_count++; drv->input_front = (drv->input_front + 1) % drv->num_input_buffers; } dprintk(("f%d r%d c%d u%d\n", drv->input_front, drv->input_rear, drv->input_count, drv->recording_count)); /* If the input queue is full, shutdown the driver. */ if ((drv->input_count + drv->recording_count) == drv->num_input_buffers) { kill_procs(drv->sd_siglist,SIGPOLL,S_MSG); /* Stop the lowlevel driver from inputing. */ drv->ops->stop_input(drv); drv->input_active = 0; } else { /* Otherwise, give the driver the next buffer. */ drv->ops->start_input(drv, drv->input_buffers[drv->input_front], drv->input_buffer_size); } /* Wake up any tasks that are waiting. */ wake_up_interruptible(&drv->input_read_wait); } /* * VFS layer interface */ static unsigned int sparcaudio_poll(struct file *file, poll_table * wait) { unsigned int mask = 0; struct inode *inode = file->f_dentry->d_inode; struct sparcaudio_driver *drv = drivers[(MINOR(inode->i_rdev) >> SPARCAUDIO_DEVICE_SHIFT)]; poll_wait(file, &drv->input_read_wait, wait); poll_wait(file, &drv->output_write_wait, wait); if (((!file->f_flags & O_NONBLOCK) && drv->input_count) || (drv->input_size > drv->buffer_size)) { mask |= POLLIN | POLLRDNORM; } if ((drv->output_count + drv->playing_count) < (drv->num_output_buffers)) { mask |= POLLOUT | POLLWRNORM; } return mask; } static ssize_t sparcaudio_read(struct file * file, char *buf, size_t count, loff_t *ppos) { struct inode *inode = file->f_dentry->d_inode; struct sparcaudio_driver *drv = drivers[(MINOR(inode->i_rdev) >> SPARCAUDIO_DEVICE_SHIFT)]; int bytes_to_copy, bytes_read = 0, err; if (! (file->f_mode & FMODE_READ)) return -EINVAL; if ((file->f_flags & O_NONBLOCK) && (drv->input_size < count)) return -EAGAIN; while (count > 0) { if (drv->input_count == 0) { /* This *should* never happen. */ if (file->f_flags & O_NONBLOCK) { printk("Warning: audio input leak!\n"); return -EAGAIN; } interruptible_sleep_on(&drv->input_read_wait); if (signal_pending(current)) return -EINTR; } bytes_to_copy = drv->input_buffer_size - drv->input_offset; if (bytes_to_copy > count) bytes_to_copy = count; err = verify_area(VERIFY_WRITE, buf, bytes_to_copy); if (err) return err; copy_to_user(buf, drv->input_buffers[drv->input_rear]+drv->input_offset, bytes_to_copy); drv->input_offset += bytes_to_copy; drv->input_size -= bytes_to_copy; buf += bytes_to_copy; count -= bytes_to_copy; bytes_read += bytes_to_copy; if (drv->input_offset >= drv->input_buffer_size) { drv->input_rear = (drv->input_rear + 1) % drv->num_input_buffers; drv->input_count--; drv->input_offset = 0; } /* If we're in "loop audio" mode, try waking up the other side * in case they're waiting for us to eat a block. */ if (drv->duplex == 2) wake_up_interruptible(&drv->output_write_wait); } return bytes_read; } static void sparcaudio_sync_output(struct sparcaudio_driver * drv) { unsigned long flags; /* If the low-level driver is not active, activate it. */ save_and_cli(flags); if ((!drv->output_active) && (drv->output_count > 0)) { drv->ops->start_output(drv, drv->output_buffers[drv->output_front], drv->output_sizes[drv->output_front]); drv->output_active = 1; } restore_flags(flags); } static ssize_t sparcaudio_write(struct file * file, const char *buf, size_t count, loff_t *ppos) { struct inode *inode = file->f_dentry->d_inode; struct sparcaudio_driver *drv = drivers[(MINOR(inode->i_rdev) >> SPARCAUDIO_DEVICE_SHIFT)]; int bytes_written = 0, bytes_to_copy, err; if (! (file->f_mode & FMODE_WRITE)) return -EINVAL; /* A signal they want notification when this is processed. Too bad * sys_write doesn't tell us unless you patch it, in 2.0 kernels. */ if (count == 0) { #ifndef notdef drv->output_eof++; kill_procs(drv->sd_siglist,SIGPOLL,S_MSG); #else /* Nice code, but the world isn't ready yet... */ drv->output_notify[drv->output_rear] = 1; #endif } /* Loop until all output is written to device. */ while (count > 0) { /* Check to make sure that an output buffer is available. */ if (drv->num_output_buffers == (drv->output_count+drv->playing_count)) { /* We need buffers, so... */ sparcaudio_sync_output(drv); if (file->f_flags & O_NONBLOCK) return -EAGAIN; interruptible_sleep_on(&drv->output_write_wait); if (signal_pending(current)) return bytes_written > 0 ? bytes_written : -EINTR; } /* No buffers were freed. Go back to sleep */ if (drv->num_output_buffers == (drv->output_count+drv->playing_count)) continue; /* Deal with the weird case of a reader in the write area by trying to * let them keep ahead of us... Go to sleep until they start servicing. */ if ((drv->duplex == 2) && (drv->flags & SDF_OPEN_READ) && (drv->output_rear == drv->input_rear) && (drv->input_count > 0)) { if (file->f_flags & O_NONBLOCK) return -EAGAIN; interruptible_sleep_on(&drv->output_write_wait); if (signal_pending(current)) return bytes_written > 0 ? bytes_written : -EINTR; } /* Determine how much we can copy in this iteration. */ bytes_to_copy = count; if (bytes_to_copy > drv->output_buffer_size - drv->output_offset) bytes_to_copy = drv->output_buffer_size - drv->output_offset; err = verify_area(VERIFY_READ, buf, bytes_to_copy); if (err) return err; copy_from_user(drv->output_buffers[drv->output_rear]+drv->output_offset, buf, bytes_to_copy); /* Update the queue pointers. */ buf += bytes_to_copy; count -= bytes_to_copy; bytes_written += bytes_to_copy; /* A block can get orphaned in a flush and not cleaned up. */ if (drv->output_offset) drv->output_sizes[drv->output_rear] += bytes_to_copy; else drv->output_sizes[drv->output_rear] = bytes_to_copy; drv->output_notify[drv->output_rear] = 0; if (drv->output_sizes[drv->output_rear] == drv->output_buffer_size) { drv->output_rear = (drv->output_rear + 1) % drv->num_output_buffers; drv->output_count++; drv->output_offset = 0; } else { drv->output_offset += bytes_to_copy; } drv->output_size += bytes_to_copy; } sparcaudio_sync_output(drv); /* Return the number of bytes written to the caller. */ return bytes_written; } /* Add these in as new devices are supported. Belongs in audioio.h, actually */ #define MONO_DEVICES (SOUND_MASK_SPEAKER | SOUND_MASK_MIC) static int sparcaudio_mixer_ioctl(struct inode * inode, struct file * file, unsigned int cmd, unsigned int *arg) { struct sparcaudio_driver *drv = drivers[(MINOR(inode->i_rdev) >> SPARCAUDIO_DEVICE_SHIFT)]; unsigned long i = 0, j = 0, l = 0, m = 0; unsigned int k = 0; if (_SIOC_DIR(cmd) & _SIOC_WRITE) drv->mixer_modify_counter++; if(cmd == SOUND_MIXER_INFO) { audio_device_t tmp; mixer_info info; int retval = -EINVAL; if(drv->ops->sunaudio_getdev) { drv->ops->sunaudio_getdev(drv, &tmp); memset(&info, 0, sizeof(info)); strncpy(info.id, tmp.name, sizeof(info.id)); strncpy(info.name, "Sparc Audio", sizeof(info.name)); info.modify_counter = drv->mixer_modify_counter; if(copy_to_user((char *)arg, &info, sizeof(info))) retval = -EFAULT; else retval = 0; } return retval; } switch (cmd) { case SOUND_MIXER_WRITE_RECLEV: if (get_user(k, (int *)arg)) return -EFAULT; iretry: oprintk(("setting input volume (0x%x)", k)); if (drv->ops->get_input_channels) j = drv->ops->get_input_channels(drv); if (drv->ops->get_input_volume) l = drv->ops->get_input_volume(drv); if (drv->ops->get_input_balance) m = drv->ops->get_input_balance(drv); i = OSS_TO_GAIN(k); j = OSS_TO_BAL(k); oprintk((" for stereo to do %d (bal %d):", i, j)); if (drv->ops->set_input_volume) drv->ops->set_input_volume(drv, i); if (drv->ops->set_input_balance) drv->ops->set_input_balance(drv, j); case SOUND_MIXER_READ_RECLEV: if (drv->ops->get_input_volume) i = drv->ops->get_input_volume(drv); if (drv->ops->get_input_balance) j = drv->ops->get_input_balance(drv); oprintk((" got (0x%x)\n", BAL_TO_OSS(i,j))); i = BAL_TO_OSS(i,j); /* Try to be reasonable about volume changes */ if ((cmd == SOUND_MIXER_WRITE_RECLEV) && (i != k) && (i == BAL_TO_OSS(l,m))) { k += (OSS_LEFT(k) > OSS_LEFT(i)) ? 256 : -256; k += (OSS_RIGHT(k) > OSS_RIGHT(i)) ? 1 : -1; oprintk((" try 0x%x\n", k)); goto iretry; } return put_user(i, (int *)arg); case SOUND_MIXER_WRITE_VOLUME: if (get_user(k, (int *)arg)) return -EFAULT; if (drv->ops->get_output_muted && drv->ops->set_output_muted) { i = drv->ops->get_output_muted(drv); if ((k == 0) || ((i == 0) && (OSS_LEFT(k) < 100))) drv->ops->set_output_muted(drv, 1); else drv->ops->set_output_muted(drv, 0); } case SOUND_MIXER_READ_VOLUME: if (drv->ops->get_output_muted) i = drv->ops->get_output_muted(drv); k = 0x6464 * (1 - i); return put_user(k, (int *)arg); case SOUND_MIXER_WRITE_PCM: if (get_user(k, (int *)arg)) return -EFAULT; oretry: oprintk(("setting output volume (0x%x)\n", k)); if (drv->ops->get_output_channels) j = drv->ops->get_output_channels(drv); if (drv->ops->get_output_volume) l = drv->ops->get_output_volume(drv); if (drv->ops->get_output_balance) m = drv->ops->get_output_balance(drv); oprintk((" started as (0x%x)\n", BAL_TO_OSS(l,m))); i = OSS_TO_GAIN(k); j = OSS_TO_BAL(k); oprintk((" for stereo to %d (bal %d)\n", i, j)); if (drv->ops->set_output_volume) drv->ops->set_output_volume(drv, i); if (drv->ops->set_output_balance) drv->ops->set_output_balance(drv, j); case SOUND_MIXER_READ_PCM: if (drv->ops->get_output_volume) i = drv->ops->get_output_volume(drv); if (drv->ops->get_output_balance) j = drv->ops->get_output_balance(drv); oprintk((" got 0x%x\n", BAL_TO_OSS(i,j))); i = BAL_TO_OSS(i,j); /* Try to be reasonable about volume changes */ if ((cmd == SOUND_MIXER_WRITE_PCM) && (i != k) && (i == BAL_TO_OSS(l,m))) { k += (OSS_LEFT(k) > OSS_LEFT(i)) ? 256 : -256; k += (OSS_RIGHT(k) > OSS_RIGHT(i)) ? 1 : -1; oprintk((" try 0x%x\n", k)); goto oretry; } return put_user(i, (int *)arg); case SOUND_MIXER_READ_SPEAKER: k = OSS_PORT_AUDIO(drv, AUDIO_SPEAKER); return put_user(k, (int *)arg); case SOUND_MIXER_READ_MIC: k = OSS_IPORT_AUDIO(drv, AUDIO_MICROPHONE); return put_user(k, (int *)arg); case SOUND_MIXER_READ_CD: k = OSS_IPORT_AUDIO(drv, AUDIO_CD); return put_user(k, (int *)arg); case SOUND_MIXER_READ_LINE: k = OSS_IPORT_AUDIO(drv, AUDIO_LINE_IN); return put_user(k, (int *)arg); case SOUND_MIXER_READ_LINE1: k = OSS_PORT_AUDIO(drv, AUDIO_HEADPHONE); return put_user(k, (int *)arg); case SOUND_MIXER_READ_LINE2: k = OSS_PORT_AUDIO(drv, AUDIO_LINE_OUT); return put_user(k, (int *)arg); case SOUND_MIXER_WRITE_MIC: case SOUND_MIXER_WRITE_CD: case SOUND_MIXER_WRITE_LINE: case SOUND_MIXER_WRITE_LINE1: case SOUND_MIXER_WRITE_LINE2: case SOUND_MIXER_WRITE_SPEAKER: if (get_user(k, (int *)arg)) return -EFAULT; OSS_TWIDDLE_IPORT(drv, cmd, SOUND_MIXER_WRITE_LINE, AUDIO_LINE_IN, k); OSS_TWIDDLE_IPORT(drv, cmd, SOUND_MIXER_WRITE_MIC, AUDIO_MICROPHONE, k); OSS_TWIDDLE_IPORT(drv, cmd, SOUND_MIXER_WRITE_CD, AUDIO_CD, k); OSS_TWIDDLE_PORT(drv, cmd, SOUND_MIXER_WRITE_SPEAKER, AUDIO_SPEAKER, k); OSS_TWIDDLE_PORT(drv, cmd, SOUND_MIXER_WRITE_LINE1, AUDIO_HEADPHONE, k); OSS_TWIDDLE_PORT(drv, cmd, SOUND_MIXER_WRITE_LINE2, AUDIO_LINE_OUT, k); return put_user(k, (int *)arg); case SOUND_MIXER_READ_RECSRC: if (drv->ops->get_input_port) i = drv->ops->get_input_port(drv); /* only one should ever be selected */ if (i & AUDIO_CD) j = SOUND_MASK_CD; if (i & AUDIO_LINE_IN) j = SOUND_MASK_LINE; if (i & AUDIO_MICROPHONE) j = SOUND_MASK_MIC; return put_user(j, (int *)arg); case SOUND_MIXER_WRITE_RECSRC: if (!drv->ops->set_input_port) return -EINVAL; if (get_user(k, (int *)arg)) return -EFAULT; /* only one should ever be selected */ if (k & SOUND_MASK_CD) j = AUDIO_CD; if (k & SOUND_MASK_LINE) j = AUDIO_LINE_IN; if (k & SOUND_MASK_MIC) j = AUDIO_MICROPHONE; oprintk(("setting inport to %d\n", j)); i = drv->ops->set_input_port(drv, j); return put_user(i, (int *)arg); case SOUND_MIXER_READ_RECMASK: if (drv->ops->get_input_ports) i = drv->ops->get_input_ports(drv); /* what do we support? */ if (i & AUDIO_MICROPHONE) j |= SOUND_MASK_MIC; if (i & AUDIO_LINE_IN) j |= SOUND_MASK_LINE; if (i & AUDIO_CD) j |= SOUND_MASK_CD; return put_user(j, (int *)arg); case SOUND_MIXER_READ_CAPS: /* mixer capabilities */ i = SOUND_CAP_EXCL_INPUT; return put_user(i, (int *)arg); case SOUND_MIXER_READ_DEVMASK: /* all supported devices */ if (drv->ops->get_input_ports) i = drv->ops->get_input_ports(drv); /* what do we support? */ if (i & AUDIO_MICROPHONE) j |= SOUND_MASK_MIC; if (i & AUDIO_LINE_IN) j |= SOUND_MASK_LINE; if (i & AUDIO_CD) j |= SOUND_MASK_CD; if (drv->ops->get_output_ports) i = drv->ops->get_output_ports(drv); if (i & AUDIO_SPEAKER) j |= SOUND_MASK_SPEAKER; if (i & AUDIO_HEADPHONE) j |= SOUND_MASK_LINE1; if (i & AUDIO_LINE_OUT) j |= SOUND_MASK_LINE2; j |= SOUND_MASK_VOLUME; case SOUND_MIXER_READ_STEREODEVS: /* what supports stereo */ j |= SOUND_MASK_PCM|SOUND_MASK_RECLEV; if (cmd == SOUND_MIXER_READ_STEREODEVS) j &= ~(MONO_DEVICES); return put_user(j, (int *)arg); default: return -EINVAL; }; } /* AUDIO_SETINFO uses these to set values if possible. */ static __inline__ int __sparcaudio_if_set_do(struct sparcaudio_driver *drv, int (*set_function)(struct sparcaudio_driver *, int), int (*get_function)(struct sparcaudio_driver *), unsigned int value) { if (set_function && Modify(value)) return (int) set_function(drv, value); else if (get_function) return (int) get_function(drv); else return 0; } static __inline__ int __sparcaudio_if_setc_do(struct sparcaudio_driver *drv, int (*set_function)(struct sparcaudio_driver *, int), int (*get_function)(struct sparcaudio_driver *), unsigned char value) { if (set_function && Modifyc(value)) return (char) set_function(drv, (int)value); else if (get_function) return (char) get_function(drv); else return 0; } /* I_FLUSH, I_{G,S}ETSIG, I_NREAD provided for SunOS compatibility * * I must admit I'm quite ashamed of the state of the ioctl handling, * but I do have several optimizations which I'm planning. -- DJB */ static int sparcaudio_ioctl(struct inode * inode, struct file * file, unsigned int cmd, unsigned long arg) { int retval = 0, i, j, k; int minor = MINOR(inode->i_rdev); struct audio_info ainfo; audio_buf_info binfo; count_info cinfo; struct sparcaudio_driver *drv = drivers[(minor >> SPARCAUDIO_DEVICE_SHIFT)]; switch (minor & 0xf) { case SPARCAUDIO_MIXER_MINOR: return sparcaudio_mixer_ioctl(inode, file, cmd, (unsigned int *)arg); case SPARCAUDIO_DSP16_MINOR: case SPARCAUDIO_DSP_MINOR: case SPARCAUDIO_AUDIO_MINOR: case SPARCAUDIO_AUDIOCTL_MINOR: /* According to the OSS prog int, you can mixer ioctl /dev/dsp */ if (_IOC_TYPE(cmd) == 'M') return sparcaudio_mixer_ioctl(inode, file, cmd, (unsigned int *)arg); switch (cmd) { case I_GETSIG: case I_GETSIG_SOLARIS: j = (int) lis_get_elist_ent(drv->sd_siglist,current->pid); put_user(j, (int *)arg); retval = drv->input_count; break; case I_SETSIG: case I_SETSIG_SOLARIS: if ((minor & 0xf) == SPARCAUDIO_AUDIOCTL_MINOR) { if (!arg) { if (lis_del_from_elist(&(drv->sd_siglist), current->pid,S_ALL)) { retval = -EINVAL; } else if (!drv->sd_siglist) { drv->sd_sigflags=0; } } else if (lis_add_to_elist(&(drv->sd_siglist), current->pid, (short)arg)) { retval = -EAGAIN; } else { ((drv->sd_sigflags) |= (arg)); } } break; case I_NREAD: case I_NREAD_SOLARIS: /* According to the Solaris man page, this copies out * the size of the first streams buffer and returns * the number of streams messages on the read queue as * as its retval. (streamio(7I)) This should work. */ j = (drv->input_count > 0) ? drv->input_buffer_size : 0; put_user(j, (int *)arg); retval = drv->input_count; break; /* A poor substitute until we do true resizable buffers. */ case SNDCTL_DSP_GETISPACE: binfo.fragstotal = drv->num_input_buffers; binfo.fragments = drv->num_input_buffers - (drv->input_count + drv->recording_count); binfo.fragsize = drv->input_buffer_size; binfo.bytes = binfo.fragments*binfo.fragsize; retval = verify_area(VERIFY_WRITE, (int *)arg, sizeof(binfo)); if (retval) break; copy_to_user(&((char *)arg)[0], (char *)&binfo, sizeof(binfo)); break; case SNDCTL_DSP_GETOSPACE: binfo.fragstotal = drv->num_output_buffers; binfo.fragments = drv->num_output_buffers - (drv->output_count + drv->playing_count + (drv->output_offset ? 1 : 0)); binfo.fragsize = drv->output_buffer_size; binfo.bytes = binfo.fragments*binfo.fragsize + (drv->output_buffer_size - drv->output_offset); retval = verify_area(VERIFY_WRITE, (int *)arg, sizeof(binfo)); if (retval) break; copy_to_user(&((char *)arg)[0], (char *)&binfo, sizeof(binfo)); break; case SNDCTL_DSP_GETIPTR: case SNDCTL_DSP_GETOPTR: /* int bytes (number of bytes read/written since last) * int blocks (number of frags read/wrote since last call) * int ptr (current position of dma in buffer) */ retval = 0; cinfo.bytes = 0; cinfo.ptr = 0; cinfo.blocks = 0; cinfo.bytes += cinfo.ptr; retval = verify_area(VERIFY_WRITE, (int *)arg, sizeof(cinfo)); if (retval) break; copy_to_user(&((char *)arg)[0], (char *)&cinfo, sizeof(cinfo)); break; case SNDCTL_DSP_SETFRAGMENT: /* XXX Small hack to get ESD/Enlightenment to work. --DaveM */ retval = 0; break; case SNDCTL_DSP_SUBDIVIDE: /* I don't understand what I need to do yet. */ retval = -EINVAL; break; case SNDCTL_DSP_SETTRIGGER: /* This may not be 100% correct */ if ((arg & PCM_ENABLE_INPUT) && drv->ops->get_input_pause && drv->ops->set_input_pause) { if (drv->ops->get_input_pause(drv)) drv->ops->set_input_pause(drv, 0); } else { if (!drv->ops->get_input_pause(drv)) drv->ops->set_input_pause(drv, 1); } if ((arg & PCM_ENABLE_OUTPUT) && drv->ops->get_output_pause && drv->ops->set_output_pause) { if (drv->ops->get_output_pause(drv)) drv->ops->set_output_pause(drv, 0); } else { if (!drv->ops->get_output_pause(drv)) drv->ops->set_output_pause(drv, 1); } break; case SNDCTL_DSP_GETTRIGGER: j = 0; if (drv->ops->get_input_pause) { if (drv->ops->get_input_pause(drv)) j = PCM_ENABLE_INPUT; } if (drv->ops->get_output_pause) { if (drv->ops->get_output_pause(drv)) j |= PCM_ENABLE_OUTPUT; } put_user(j, (int *)arg); break; case SNDCTL_DSP_GETBLKSIZE: j = drv->input_buffer_size; put_user(j, (int *)arg); break; case SNDCTL_DSP_SPEED: if ((!drv->ops->set_output_rate) && (!drv->ops->set_input_rate)) { retval = -EINVAL; break; } get_user(i, (int *)arg) tprintk(("setting speed to %d\n", i)); drv->ops->set_input_rate(drv, i); drv->ops->set_output_rate(drv, i); j = drv->ops->get_output_rate(drv); put_user(j, (int *)arg); break; case SNDCTL_DSP_GETCAPS: /* All Sparc audio hardware is full duplex. * 4231 supports DMA pointer reading, 7930 is byte at a time. * Pause functionality emulates trigger */ j = DSP_CAP_DUPLEX | DSP_CAP_TRIGGER | DSP_CAP_REALTIME; put_user(j, (int *)arg); break; case SNDCTL_DSP_GETFMTS: if (drv->ops->get_formats) { j = drv->ops->get_formats(drv); put_user(j, (int *)arg); } else { retval = -EINVAL; } break; case SNDCTL_DSP_SETFMT: /* need to decode into encoding, precision */ get_user(i, (int *)arg); /* handle special case here */ if (i == AFMT_QUERY) { j = drv->ops->get_output_encoding(drv); k = drv->ops->get_output_precision(drv); if (j == AUDIO_ENCODING_DVI) { i = AFMT_IMA_ADPCM; } else if (k == 8) { switch (j) { case AUDIO_ENCODING_ULAW: i = AFMT_MU_LAW; break; case AUDIO_ENCODING_ALAW: i = AFMT_A_LAW; break; case AUDIO_ENCODING_LINEAR8: i = AFMT_U8; break; }; } else if (k == 16) { switch (j) { case AUDIO_ENCODING_LINEAR: i = AFMT_S16_BE; break; case AUDIO_ENCODING_LINEARLE: i = AFMT_S16_LE; break; }; } put_user(i, (int *)arg); break; } /* Without these there's no point in trying */ if (!drv->ops->set_input_precision || !drv->ops->set_input_encoding || !drv->ops->set_output_precision || !drv->ops->set_output_encoding) { eprintk(("missing set routines: failed\n")); retval = -EINVAL; break; } if (drv->ops->get_formats) { if (!(drv->ops->get_formats(drv) & i)) { dprintk(("format not supported\n")); return -EINVAL; } } switch (i) { case AFMT_S16_LE: ainfo.record.precision = ainfo.play.precision = 16; ainfo.record.encoding = ainfo.play.encoding = AUDIO_ENCODING_LINEARLE; break; case AFMT_S16_BE: ainfo.record.precision = ainfo.play.precision = 16; ainfo.record.encoding = ainfo.play.encoding = AUDIO_ENCODING_LINEAR; break; case AFMT_MU_LAW: ainfo.record.precision = ainfo.play.precision = 8; ainfo.record.encoding = ainfo.play.encoding = AUDIO_ENCODING_ULAW; break; case AFMT_A_LAW: ainfo.record.precision = ainfo.play.precision = 8; ainfo.record.encoding = ainfo.play.encoding = AUDIO_ENCODING_ALAW; break; case AFMT_U8: ainfo.record.precision = ainfo.play.precision = 8; ainfo.record.encoding = ainfo.play.encoding = AUDIO_ENCODING_LINEAR8; break; }; tprintk(("setting fmt to enc %d pr %d\n", ainfo.play.encoding, ainfo.play.precision)); if ((drv->ops->set_input_precision(drv, ainfo.record.precision) < 0) || (drv->ops->set_output_precision(drv, ainfo.play.precision) < 0) || (drv->ops->set_input_encoding(drv, ainfo.record.encoding) < 0) || (drv->ops->set_output_encoding(drv, ainfo.play.encoding) < 0)) { dprintk(("setting format: failed\n")); return -EINVAL; } put_user(i, (int *)arg); break; case SNDCTL_DSP_CHANNELS: if ((!drv->ops->set_output_channels) && (!drv->ops->set_input_channels)) { retval = -EINVAL; break; } get_user(i, (int *)arg); drv->ops->set_input_channels(drv, i); drv->ops->set_output_channels(drv, i); i = drv->ops->get_output_channels(drv); put_user(i, (int *)arg); break; case SNDCTL_DSP_STEREO: if ((!drv->ops->set_output_channels) && (!drv->ops->set_input_channels)) { retval = -EINVAL; break; } get_user(i, (int *)arg); drv->ops->set_input_channels(drv, (i + 1)); drv->ops->set_output_channels(drv, (i + 1)); i = ((drv->ops->get_output_channels(drv)) - 1); put_user(i, (int *)arg); break; case SNDCTL_DSP_POST: case SNDCTL_DSP_SYNC: case AUDIO_DRAIN: /* Deal with weirdness so we can fill buffers */ if (drv->output_offset) { drv->output_offset = 0; drv->output_rear = (drv->output_rear + 1) % drv->num_output_buffers; drv->output_count++; } if (drv->output_count > 0) { sparcaudio_sync_output(drv); /* Only pause for DRAIN/SYNC, not POST */ if (cmd != SNDCTL_DSP_POST) { interruptible_sleep_on(&drv->output_drain_wait); retval = (signal_pending(current)) ? -EINTR : 0; } } break; case I_FLUSH: case I_FLUSH_SOLARIS: if (((unsigned int)arg == FLUSHW) || ((unsigned int)arg == FLUSHRW)) { if (file->f_mode & FMODE_WRITE) { sparcaudio_sync_output(drv); if (drv->output_active) { wake_up_interruptible(&drv->output_write_wait); drv->ops->stop_output(drv); } drv->output_offset = 0; drv->output_active = 0; drv->output_front = 0; drv->output_rear = 0; drv->output_count = 0; drv->output_size = 0; drv->playing_count = 0; drv->output_eof = 0; } } if (((unsigned int)arg == FLUSHR) || ((unsigned int)arg == FLUSHRW)) { if (drv->input_active && (file->f_mode & FMODE_READ)) { wake_up_interruptible(&drv->input_read_wait); drv->ops->stop_input(drv); drv->input_active = 0; drv->input_front = 0; drv->input_rear = 0; drv->input_count = 0; drv->input_size = 0; drv->input_offset = 0; drv->recording_count = 0; } if ((file->f_mode & FMODE_READ) && (drv->flags & SDF_OPEN_READ)) { if (drv->duplex == 2) drv->input_count = drv->output_count; drv->ops->start_input(drv, drv->input_buffers[drv->input_front], drv->input_buffer_size); drv->input_active = 1; } } if (((unsigned int)arg == FLUSHW) || ((unsigned int)arg == FLUSHRW)) { if ((file->f_mode & FMODE_WRITE) && !(drv->flags & SDF_OPEN_WRITE)) { kill_procs(drv->sd_siglist,SIGPOLL,S_MSG); sparcaudio_sync_output(drv); } } break; case SNDCTL_DSP_RESET: case AUDIO_FLUSH: if (drv->output_active && (file->f_mode & FMODE_WRITE)) { wake_up_interruptible(&drv->output_write_wait); drv->ops->stop_output(drv); drv->output_active = 0; drv->output_front = 0; drv->output_rear = 0; drv->output_count = 0; drv->output_size = 0; drv->playing_count = 0; drv->output_offset = 0; drv->output_eof = 0; } if (drv->input_active && (file->f_mode & FMODE_READ)) { wake_up_interruptible(&drv->input_read_wait); drv->ops->stop_input(drv); drv->input_active = 0; drv->input_front = 0; drv->input_rear = 0; drv->input_count = 0; drv->input_size = 0; drv->input_offset = 0; drv->recording_count = 0; } if ((file->f_mode & FMODE_READ) && !(drv->flags & SDF_OPEN_READ)) { drv->ops->start_input(drv, drv->input_buffers[drv->input_front], drv->input_buffer_size); drv->input_active = 1; } if ((file->f_mode & FMODE_WRITE) && !(drv->flags & SDF_OPEN_WRITE)) { sparcaudio_sync_output(drv); } break; case AUDIO_GETDEV: if (drv->ops->sunaudio_getdev) { audio_device_t tmp; retval = verify_area(VERIFY_WRITE, (void *)arg, sizeof(audio_device_t)); if (!retval) drv->ops->sunaudio_getdev(drv, &tmp); copy_to_user((audio_device_t *)arg, &tmp, sizeof(tmp)); } else { retval = -EINVAL; } break; case AUDIO_GETDEV_SUNOS: if (drv->ops->sunaudio_getdev_sunos) { int tmp = drv->ops->sunaudio_getdev_sunos(drv); retval = verify_area(VERIFY_WRITE, (void *)arg, sizeof(int)); if (!retval) copy_to_user((int *)arg, &tmp, sizeof(tmp)); } else { retval = -EINVAL; } break; case AUDIO_GETINFO: AUDIO_INITINFO(&ainfo); if (drv->ops->get_input_rate) ainfo.record.sample_rate = drv->ops->get_input_rate(drv); else ainfo.record.sample_rate = (8000); if (drv->ops->get_input_channels) ainfo.record.channels = drv->ops->get_input_channels(drv); else ainfo.record.channels = (1); if (drv->ops->get_input_precision) ainfo.record.precision = drv->ops->get_input_precision(drv); else ainfo.record.precision = (8); if (drv->ops->get_input_encoding) ainfo.record.encoding = drv->ops->get_input_encoding(drv); else ainfo.record.encoding = (AUDIO_ENCODING_ULAW); if (drv->ops->get_input_volume) ainfo.record.gain = drv->ops->get_input_volume(drv); else ainfo.record.gain = (0); if (drv->ops->get_input_port) ainfo.record.port = drv->ops->get_input_port(drv); else ainfo.record.port = (0); if (drv->ops->get_input_ports) ainfo.record.avail_ports = drv->ops->get_input_ports(drv); else ainfo.record.avail_ports = (0); /* To make e.g. vat happy, we let them think they control this */ ainfo.record.buffer_size = drv->buffer_size; if (drv->ops->get_input_samples) ainfo.record.samples = drv->ops->get_input_samples(drv); else ainfo.record.samples = 0; /* This is undefined in the record context in Solaris */ ainfo.record.eof = 0; if (drv->ops->get_input_pause) ainfo.record.pause = drv->ops->get_input_pause(drv); else ainfo.record.pause = 0; if (drv->ops->get_input_error) ainfo.record.error = (unsigned char) drv->ops->get_input_error(drv); else ainfo.record.error = 0; ainfo.record.waiting = 0; if (drv->ops->get_input_balance) ainfo.record.balance = (unsigned char) drv->ops->get_input_balance(drv); else ainfo.record.balance = (unsigned char)(AUDIO_MID_BALANCE); ainfo.record.minordev = 4 + (minor << SPARCAUDIO_DEVICE_SHIFT); ainfo.record.open = (drv->flags & SDF_OPEN_READ); ainfo.record.active = 0; if (drv->ops->get_output_rate) ainfo.play.sample_rate = drv->ops->get_output_rate(drv); else ainfo.play.sample_rate = (8000); if (drv->ops->get_output_channels) ainfo.play.channels = drv->ops->get_output_channels(drv); else ainfo.play.channels = (1); if (drv->ops->get_output_precision) ainfo.play.precision = drv->ops->get_output_precision(drv); else ainfo.play.precision = (8); if (drv->ops->get_output_encoding) ainfo.play.encoding = drv->ops->get_output_encoding(drv); else ainfo.play.encoding = (AUDIO_ENCODING_ULAW); if (drv->ops->get_output_volume) ainfo.play.gain = drv->ops->get_output_volume(drv); else ainfo.play.gain = (0); if (drv->ops->get_output_port) ainfo.play.port = drv->ops->get_output_port(drv); else ainfo.play.port = (0); if (drv->ops->get_output_ports) ainfo.play.avail_ports = drv->ops->get_output_ports(drv); else ainfo.play.avail_ports = (0); /* This is not defined in the play context in Solaris */ ainfo.play.buffer_size = 0; if (drv->ops->get_output_samples) ainfo.play.samples = drv->ops->get_output_samples(drv); else ainfo.play.samples = 0; ainfo.play.eof = drv->output_eof; if (drv->ops->get_output_pause) ainfo.play.pause = drv->ops->get_output_pause(drv); else ainfo.play.pause = 0; if (drv->ops->get_output_error) ainfo.play.error = (unsigned char)drv->ops->get_output_error(drv); else ainfo.play.error = 0; ainfo.play.waiting = waitqueue_active(&drv->open_wait); if (drv->ops->get_output_balance) ainfo.play.balance = (unsigned char)drv->ops->get_output_balance(drv); else ainfo.play.balance = (unsigned char)(AUDIO_MID_BALANCE); ainfo.play.minordev = 4 + (minor << SPARCAUDIO_DEVICE_SHIFT); ainfo.play.open = (drv->flags & SDF_OPEN_WRITE); ainfo.play.active = drv->output_active; if (drv->ops->get_monitor_volume) ainfo.monitor_gain = drv->ops->get_monitor_volume(drv); else ainfo.monitor_gain = (0); if (drv->ops->get_output_muted) ainfo.output_muted = (unsigned char)drv->ops->get_output_muted(drv); else ainfo.output_muted = (unsigned char)(0); retval = verify_area(VERIFY_WRITE, (void *)arg, sizeof(struct audio_info)); if (retval < 0) break; copy_to_user((struct audio_info *)arg, &ainfo, sizeof(ainfo)); break; case AUDIO_SETINFO: { audio_info_t curinfo, newinfo; if (verify_area(VERIFY_READ, (audio_info_t *)arg, sizeof(audio_info_t))) { dprintk(("verify_area failed\n")); return -EINVAL; } copy_from_user(&ainfo, (audio_info_t *)arg, sizeof(audio_info_t)); /* Without these there's no point in trying */ if (!drv->ops->get_input_precision || !drv->ops->get_input_channels || !drv->ops->get_input_rate || !drv->ops->get_input_encoding || !drv->ops->get_output_precision || !drv->ops->get_output_channels || !drv->ops->get_output_rate || !drv->ops->get_output_encoding) { eprintk(("missing get routines: failed\n")); retval = -EINVAL; break; } /* Do bounds checking for things which always apply. * Follow with enforcement of basic tenets of certain * encodings. Everything over and above generic is * enforced by the driver, which can assume that * Martian cases are taken care of here. */ if (Modify(ainfo.play.gain) && ((ainfo.play.gain > AUDIO_MAX_GAIN) || (ainfo.play.gain < AUDIO_MIN_GAIN))) { /* Need to differentiate this from e.g. the above error */ eprintk(("play gain bounds: failed %d\n", ainfo.play.gain)); retval = -EINVAL; break; } if (Modify(ainfo.record.gain) && ((ainfo.record.gain > AUDIO_MAX_GAIN) || (ainfo.record.gain < AUDIO_MIN_GAIN))) { eprintk(("rec gain bounds: failed %d\n", ainfo.record.gain)); retval = -EINVAL; break; } if (Modify(ainfo.monitor_gain) && ((ainfo.monitor_gain > AUDIO_MAX_GAIN) || (ainfo.monitor_gain < AUDIO_MIN_GAIN))) { eprintk(("monitor gain bounds: failed\n")); retval = -EINVAL; break; } /* Don't need to check less than zero on these */ if (Modifyc(ainfo.play.balance) && (ainfo.play.balance > AUDIO_RIGHT_BALANCE)) { eprintk(("play balance bounds: %d failed\n", (int)ainfo.play.balance)); retval = -EINVAL; break; } if (Modifyc(ainfo.record.balance) && (ainfo.record.balance > AUDIO_RIGHT_BALANCE)) { eprintk(("rec balance bounds: failed\n")); retval = -EINVAL; break; } /* If any of these changed, record them all, then make * changes atomically. If something fails, back it all out. */ if (Modify(ainfo.record.precision) || Modify(ainfo.record.sample_rate) || Modify(ainfo.record.channels) || Modify(ainfo.record.encoding) || Modify(ainfo.play.precision) || Modify(ainfo.play.sample_rate) || Modify(ainfo.play.channels) || Modify(ainfo.play.encoding)) { /* If they're trying to change something we * have no routine for, they lose. */ if ((!drv->ops->set_input_encoding && Modify(ainfo.record.encoding)) || (!drv->ops->set_input_rate && Modify(ainfo.record.sample_rate)) || (!drv->ops->set_input_precision && Modify(ainfo.record.precision)) || (!drv->ops->set_input_channels && Modify(ainfo.record.channels))) { eprintk(("rec set no routines: failed\n")); retval = -EINVAL; break; } curinfo.record.encoding = drv->ops->get_input_encoding(drv); curinfo.record.sample_rate = drv->ops->get_input_rate(drv); curinfo.record.precision = drv->ops->get_input_precision(drv); curinfo.record.channels = drv->ops->get_input_channels(drv); newinfo.record.encoding = Modify(ainfo.record.encoding) ? ainfo.record.encoding : curinfo.record.encoding; newinfo.record.sample_rate = Modify(ainfo.record.sample_rate) ? ainfo.record.sample_rate : curinfo.record.sample_rate; newinfo.record.precision = Modify(ainfo.record.precision) ? ainfo.record.precision : curinfo.record.precision; newinfo.record.channels = Modify(ainfo.record.channels) ? ainfo.record.channels : curinfo.record.channels; switch (newinfo.record.encoding) { case AUDIO_ENCODING_ALAW: case AUDIO_ENCODING_ULAW: if (newinfo.record.precision != 8) { eprintk(("rec law precision bounds: " "failed\n")); retval = -EINVAL; break; } if (newinfo.record.channels != 1) { eprintk(("rec law channel bounds: " "failed\n")); retval = -EINVAL; break; } break; case AUDIO_ENCODING_LINEAR: case AUDIO_ENCODING_LINEARLE: if (newinfo.record.precision != 16) { eprintk(("rec lin precision bounds: " "failed\n")); retval = -EINVAL; break; } if (newinfo.record.channels != 1 && newinfo.record.channels != 2) { eprintk(("rec lin channel bounds: " "failed\n")); retval = -EINVAL; break; } break; case AUDIO_ENCODING_LINEAR8: if (newinfo.record.precision != 8) { eprintk(("rec lin8 precision bounds: " "failed\n")); retval = -EINVAL; break; } if (newinfo.record.channels != 1 && newinfo.record.channels != 2) { eprintk(("rec lin8 channel bounds: " "failed\n")); retval = -EINVAL; break; } }; if (retval < 0) break; /* If they're trying to change something we * have no routine for, they lose. */ if ((!drv->ops->set_output_encoding && Modify(ainfo.play.encoding)) || (!drv->ops->set_output_rate && Modify(ainfo.play.sample_rate)) || (!drv->ops->set_output_precision && Modify(ainfo.play.precision)) || (!drv->ops->set_output_channels && Modify(ainfo.play.channels))) { eprintk(("play set no routine: failed\n")); retval = -EINVAL; break; } curinfo.play.encoding = drv->ops->get_output_encoding(drv); curinfo.play.sample_rate = drv->ops->get_output_rate(drv); curinfo.play.precision = drv->ops->get_output_precision(drv); curinfo.play.channels = drv->ops->get_output_channels(drv); newinfo.play.encoding = Modify(ainfo.play.encoding) ? ainfo.play.encoding : curinfo.play.encoding; newinfo.play.sample_rate = Modify(ainfo.play.sample_rate) ? ainfo.play.sample_rate : curinfo.play.sample_rate; newinfo.play.precision = Modify(ainfo.play.precision) ? ainfo.play.precision : curinfo.play.precision; newinfo.play.channels = Modify(ainfo.play.channels) ? ainfo.play.channels : curinfo.play.channels; switch (newinfo.play.encoding) { case AUDIO_ENCODING_ALAW: case AUDIO_ENCODING_ULAW: if (newinfo.play.precision != 8) { eprintk(("play law precision bounds: " "failed\n")); retval = -EINVAL; break; } if (newinfo.play.channels != 1) { eprintk(("play law channel bounds: " "failed\n")); retval = -EINVAL; break; } break; case AUDIO_ENCODING_LINEAR: case AUDIO_ENCODING_LINEARLE: if (newinfo.play.precision != 16) { eprintk(("play lin precision bounds: " "failed\n")); retval = -EINVAL; break; } if (newinfo.play.channels != 1 && newinfo.play.channels != 2) { eprintk(("play lin channel bounds: " "failed\n")); retval = -EINVAL; break; } break; case AUDIO_ENCODING_LINEAR8: if (newinfo.play.precision != 8) { eprintk(("play lin8 precision bounds: " "failed\n")); retval = -EINVAL; break; } if (newinfo.play.channels != 1 && newinfo.play.channels != 2) { eprintk(("play lin8 channel bounds: " "failed\n")); retval = -EINVAL; break; } }; if (retval < 0) break; /* If we got this far, we're at least sane with * respect to generics. Try the changes. */ if ((drv->ops->set_input_channels && (drv->ops->set_input_channels(drv, newinfo.record.channels) < 0)) || (drv->ops->set_output_channels && (drv->ops->set_output_channels(drv, newinfo.play.channels) < 0)) || (drv->ops->set_input_rate && (drv->ops->set_input_rate(drv, newinfo.record.sample_rate) < 0)) || (drv->ops->set_output_rate && (drv->ops->set_output_rate(drv, newinfo.play.sample_rate) < 0)) || (drv->ops->set_input_precision && (drv->ops->set_input_precision(drv, newinfo.record.precision) < 0)) || (drv->ops->set_output_precision && (drv->ops->set_output_precision(drv, newinfo.play.precision) < 0)) || (drv->ops->set_input_encoding && (drv->ops->set_input_encoding(drv, newinfo.record.encoding) < 0)) || (drv->ops->set_output_encoding && (drv->ops->set_output_encoding(drv, newinfo.play.encoding) < 0))) { dprintk(("setting format: failed\n")); /* Pray we can set it all back. If not, uh... */ if (drv->ops->set_input_channels) drv->ops->set_input_channels(drv, curinfo.record.channels); if (drv->ops->set_output_channels) drv->ops->set_output_channels(drv, curinfo.play.channels); if (drv->ops->set_input_rate) drv->ops->set_input_rate(drv, curinfo.record.sample_rate); if (drv->ops->set_output_rate) drv->ops->set_output_rate(drv, curinfo.play.sample_rate); if (drv->ops->set_input_precision) drv->ops->set_input_precision(drv, curinfo.record.precision); if (drv->ops->set_output_precision) drv->ops->set_output_precision(drv, curinfo.play.precision); if (drv->ops->set_input_encoding) drv->ops->set_input_encoding(drv, curinfo.record.encoding); if (drv->ops->set_output_encoding) drv->ops->set_output_encoding(drv, curinfo.play.encoding); retval = -EINVAL; break; } } if (retval < 0) break; newinfo.record.balance = __sparcaudio_if_setc_do(drv, drv->ops->set_input_balance, drv->ops->get_input_balance, ainfo.record.balance); newinfo.play.balance = __sparcaudio_if_setc_do(drv, drv->ops->set_output_balance, drv->ops->get_output_balance, ainfo.play.balance); newinfo.record.error = __sparcaudio_if_setc_do(drv, drv->ops->set_input_error, drv->ops->get_input_error, ainfo.record.error); newinfo.play.error = __sparcaudio_if_setc_do(drv, drv->ops->set_output_error, drv->ops->get_output_error, ainfo.play.error); newinfo.output_muted = __sparcaudio_if_setc_do(drv, drv->ops->set_output_muted, drv->ops->get_output_muted, ainfo.output_muted); newinfo.record.gain = __sparcaudio_if_set_do(drv, drv->ops->set_input_volume, drv->ops->get_input_volume, ainfo.record.gain); newinfo.play.gain = __sparcaudio_if_set_do(drv, drv->ops->set_output_volume, drv->ops->get_output_volume, ainfo.play.gain); newinfo.record.port = __sparcaudio_if_set_do(drv, drv->ops->set_input_port, drv->ops->get_input_port, ainfo.record.port); newinfo.play.port = __sparcaudio_if_set_do(drv, drv->ops->set_output_port, drv->ops->get_output_port, ainfo.play.port); newinfo.record.samples = __sparcaudio_if_set_do(drv, drv->ops->set_input_samples, drv->ops->get_input_samples, ainfo.record.samples); newinfo.play.samples = __sparcaudio_if_set_do(drv, drv->ops->set_output_samples, drv->ops->get_output_samples, ainfo.play.samples); newinfo.monitor_gain = __sparcaudio_if_set_do(drv, drv->ops->set_monitor_volume, drv->ops->get_monitor_volume, ainfo.monitor_gain); if (Modify(ainfo.record.buffer_size)) { /* Should sanity check this */ newinfo.record.buffer_size = ainfo.record.buffer_size; drv->buffer_size = ainfo.record.buffer_size; } else { newinfo.record.buffer_size = drv->buffer_size; } if (Modify(ainfo.play.eof)) { ainfo.play.eof = newinfo.play.eof; newinfo.play.eof = drv->output_eof; drv->output_eof = ainfo.play.eof; } else { newinfo.play.eof = drv->output_eof; } if (drv->flags & SDF_OPEN_READ) { newinfo.record.pause = __sparcaudio_if_setc_do(drv, drv->ops->set_input_pause, drv->ops->get_input_pause, ainfo.record.pause); } else if (drv->ops->get_input_pause) { newinfo.record.pause = drv->ops->get_input_pause(drv); } else { newinfo.record.pause = 0; } if (drv->flags & SDF_OPEN_WRITE) { newinfo.play.pause = __sparcaudio_if_setc_do(drv, drv->ops->set_output_pause, drv->ops->get_output_pause, ainfo.play.pause); } else if (drv->ops->get_output_pause) { newinfo.play.pause = drv->ops->get_output_pause(drv); } else { newinfo.play.pause = 0; } retval = verify_area(VERIFY_WRITE, (void *)arg, sizeof(struct audio_info)); /* Even if we fail, if we made changes let's try notification */ if (!retval) copy_to_user((struct audio_info *)arg, &newinfo, sizeof(newinfo)); #ifdef REAL_AUDIO_SIGNALS kill_procs(drv->sd_siglist,SIGPOLL,S_MSG); #endif break; } default: if (drv->ops->ioctl) retval = drv->ops->ioctl(inode,file,cmd,arg,drv); else retval = -EINVAL; }; break; case SPARCAUDIO_STATUS_MINOR: eprintk(("status minor not yet implemented\n")); retval = -EINVAL; default: eprintk(("unknown minor device number\n")); retval = -EINVAL; } return retval; } static struct file_operations sparcaudioctl_fops = { owner: THIS_MODULE, poll: sparcaudio_poll, ioctl: sparcaudio_ioctl, }; static int sparcaudio_open(struct inode * inode, struct file * file) { int minor = MINOR(inode->i_rdev); struct sparcaudio_driver *drv = drivers[(minor >> SPARCAUDIO_DEVICE_SHIFT)]; int err; /* A low-level audio driver must exist. */ if (!drv) return -ENODEV; #ifdef S_ZERO_WR /* This is how 2.0 ended up dealing with 0 len writes */ inode->i_flags |= S_ZERO_WR; #endif switch (minor & 0xf) { case SPARCAUDIO_AUDIOCTL_MINOR: file->f_op = &sparcaudioctl_fops; break; case SPARCAUDIO_DSP16_MINOR: case SPARCAUDIO_DSP_MINOR: case SPARCAUDIO_AUDIO_MINOR: /* If the driver is busy, then wait to get through. */ retry_open: if (file->f_mode & FMODE_READ && drv->flags & SDF_OPEN_READ) { if (file->f_flags & O_NONBLOCK) return -EBUSY; /* If something is now waiting, signal control device */ kill_procs(drv->sd_siglist,SIGPOLL,S_MSG); interruptible_sleep_on(&drv->open_wait); if (signal_pending(current)) return -EINTR; goto retry_open; } if (file->f_mode & FMODE_WRITE && drv->flags & SDF_OPEN_WRITE) { if (file->f_flags & O_NONBLOCK) return -EBUSY; /* If something is now waiting, signal control device */ kill_procs(drv->sd_siglist,SIGPOLL,S_MSG); interruptible_sleep_on(&drv->open_wait); if (signal_pending(current)) return -EINTR; goto retry_open; } /* Allow the low-level driver to initialize itself. */ if (drv->ops->open) { err = drv->ops->open(inode,file,drv); if (err < 0) return err; } /* Mark the driver as locked for read and/or write. */ if (file->f_mode & FMODE_READ) { drv->input_offset = 0; drv->input_front = 0; drv->input_rear = 0; drv->input_count = 0; drv->input_size = 0; drv->recording_count = 0; /* Clear pause */ if (drv->ops->set_input_pause) drv->ops->set_input_pause(drv, 0); drv->ops->start_input(drv, drv->input_buffers[drv->input_front], drv->input_buffer_size); drv->input_active = 1; drv->flags |= SDF_OPEN_READ; } if (file->f_mode & FMODE_WRITE) { drv->output_offset = 0; drv->output_eof = 0; drv->playing_count = 0; drv->output_size = 0; drv->output_front = 0; drv->output_rear = 0; drv->output_count = 0; drv->output_active = 0; /* Clear pause */ if (drv->ops->set_output_pause) drv->ops->set_output_pause(drv, 0); drv->flags |= SDF_OPEN_WRITE; } break; case SPARCAUDIO_MIXER_MINOR: file->f_op = &sparcaudioctl_fops; break; default: return -ENXIO; }; /* From the dbri driver: * SunOS 5.5.1 audio(7I) man page says: * "Upon the initial open() of the audio device, the driver * will reset the data format of the device to the default * state of 8-bit, 8KHz, mono u-law data." * * Of course, we only do this for /dev/audio, and assume * OSS semantics on /dev/dsp */ if ((minor & 0xf) == SPARCAUDIO_AUDIO_MINOR) { if (file->f_mode & FMODE_WRITE) { if (drv->ops->set_output_channels) drv->ops->set_output_channels(drv, 1); if (drv->ops->set_output_encoding) drv->ops->set_output_encoding(drv, AUDIO_ENCODING_ULAW); if (drv->ops->set_output_rate) drv->ops->set_output_rate(drv, 8000); } if (file->f_mode & FMODE_READ) { if (drv->ops->set_input_channels) drv->ops->set_input_channels(drv, 1); if (drv->ops->set_input_encoding) drv->ops->set_input_encoding(drv, AUDIO_ENCODING_ULAW); if (drv->ops->set_input_rate) drv->ops->set_input_rate(drv, 8000); } } /* Success! */ return 0; } static int sparcaudio_release(struct inode * inode, struct file * file) { struct sparcaudio_driver *drv = drivers[(MINOR(inode->i_rdev) >> SPARCAUDIO_DEVICE_SHIFT)]; lock_kernel(); if (file->f_mode & FMODE_READ) { /* Stop input */ drv->ops->stop_input(drv); drv->input_active = 0; } if (file->f_mode & FMODE_WRITE) { /* Anything in the queue? */ if (drv->output_offset) { drv->output_offset = 0; drv->output_rear = (drv->output_rear + 1) % drv->num_output_buffers; drv->output_count++; } sparcaudio_sync_output(drv); /* Wait for any output still in the queue to be played. */ if ((drv->output_count > 0) || (drv->playing_count > 0)) interruptible_sleep_on(&drv->output_drain_wait); /* Force any output to be stopped. */ drv->ops->stop_output(drv); drv->output_active = 0; drv->playing_count = 0; drv->output_eof = 0; } /* Let the low-level driver do any release processing. */ if (drv->ops->release) drv->ops->release(inode,file,drv); if (file->f_mode & FMODE_READ) drv->flags &= ~(SDF_OPEN_READ); if (file->f_mode & FMODE_WRITE) drv->flags &= ~(SDF_OPEN_WRITE); /* Status changed. Signal control device */ kill_procs(drv->sd_siglist,SIGPOLL,S_MSG); wake_up_interruptible(&drv->open_wait); unlock_kernel(); return 0; } static struct file_operations sparcaudio_fops = { owner: THIS_MODULE, llseek: no_llseek, read: sparcaudio_read, write: sparcaudio_write, poll: sparcaudio_poll, ioctl: sparcaudio_ioctl, open: sparcaudio_open, release: sparcaudio_release, }; static struct { unsigned short minor; char *name; umode_t mode; } dev_list[] = { { SPARCAUDIO_MIXER_MINOR, "mixer", S_IWUSR | S_IRUGO }, { SPARCAUDIO_DSP_MINOR, "dsp", S_IWUGO | S_IRUSR | S_IRGRP }, { SPARCAUDIO_AUDIO_MINOR, "audio", S_IWUGO | S_IRUSR | S_IRGRP }, { SPARCAUDIO_DSP16_MINOR, "dspW", S_IWUGO | S_IRUSR | S_IRGRP }, { SPARCAUDIO_STATUS_MINOR, "status", S_IRUGO }, { SPARCAUDIO_AUDIOCTL_MINOR, "audioctl", S_IRUGO } }; static void sparcaudio_mkname (char *buf, char *name, int dev) { if (dev) sprintf (buf, "%s%d", name, dev); else sprintf (buf, "%s", name); } int register_sparcaudio_driver(struct sparcaudio_driver *drv, int duplex) { int i, dev; unsigned short minor; char name_buf[32]; /* If we've used up SPARCAUDIO_MAX_DEVICES, fail */ for (dev = 0; dev < SPARCAUDIO_MAX_DEVICES; dev++) { if (drivers[dev] == NULL) break; } if (drivers[dev]) return -EIO; /* Ensure that the driver has a proper operations structure. */ if (!drv->ops || !drv->ops->start_output || !drv->ops->stop_output || !drv->ops->start_input || !drv->ops->stop_input) return -EINVAL; /* Register ourselves with devfs */ for (i=0; i < sizeof (dev_list) / sizeof (*dev_list); i++) { sparcaudio_mkname (name_buf, dev_list[i].name, dev); minor = (dev << SPARCAUDIO_DEVICE_SHIFT) | dev_list[i].minor; devfs_register (devfs_handle, name_buf, DEVFS_FL_NONE, SOUND_MAJOR, minor, S_IFCHR | dev_list[i].mode, &sparcaudio_fops, NULL); } /* Setup the circular queues of output and input buffers * * Each buffer is a single page, but output buffers might * be partially filled (by a write with count < output_buffer_size), * so each output buffer also has a paired output size. * * Input buffers, on the other hand, always fill completely, * so we don't need input counts - each contains input_buffer_size * bytes of audio data. * * TODO: Make number of input/output buffers tunable parameters */ init_waitqueue_head(&drv->open_wait); init_waitqueue_head(&drv->output_write_wait); init_waitqueue_head(&drv->output_drain_wait); init_waitqueue_head(&drv->input_read_wait); drv->num_output_buffers = 8; drv->output_buffer_size = (4096 * 2); drv->playing_count = 0; drv->output_offset = 0; drv->output_eof = 0; drv->output_front = 0; drv->output_rear = 0; drv->output_count = 0; drv->output_active = 0; drv->output_buffers = kmalloc(drv->num_output_buffers * sizeof(__u8 *), GFP_KERNEL); drv->output_sizes = kmalloc(drv->num_output_buffers * sizeof(size_t), GFP_KERNEL); drv->output_notify = kmalloc(drv->num_output_buffers * sizeof(char), GFP_KERNEL); if (!drv->output_buffers || !drv->output_sizes || !drv->output_notify) goto kmalloc_failed1; drv->output_buffer = kmalloc((drv->output_buffer_size * drv->num_output_buffers), GFP_KERNEL); if (!drv->output_buffer) goto kmalloc_failed2; /* Allocate the pages for each output buffer. */ for (i = 0; i < drv->num_output_buffers; i++) { drv->output_buffers[i] = (void *)(drv->output_buffer + (i * drv->output_buffer_size)); drv->output_sizes[i] = 0; drv->output_notify[i] = 0; } /* Setup the circular queue of input buffers. */ drv->num_input_buffers = 8; drv->input_buffer_size = (4096 * 2); drv->recording_count = 0; drv->input_front = 0; drv->input_rear = 0; drv->input_count = 0; drv->input_offset = 0; drv->input_size = 0; drv->input_active = 0; drv->input_buffers = kmalloc(drv->num_input_buffers * sizeof(__u8 *), GFP_KERNEL); drv->input_sizes = kmalloc(drv->num_input_buffers * sizeof(size_t), GFP_KERNEL); if (!drv->input_buffers || !drv->input_sizes) goto kmalloc_failed3; /* Allocate the pages for each input buffer. */ if (duplex == 1) { drv->input_buffer = kmalloc((drv->input_buffer_size * drv->num_input_buffers), GFP_DMA); if (!drv->input_buffer) goto kmalloc_failed4; for (i = 0; i < drv->num_input_buffers; i++) drv->input_buffers[i] = (void *)(drv->input_buffer + (i * drv->input_buffer_size)); } else { if (duplex == 2) { drv->input_buffer = drv->output_buffer; drv->input_buffer_size = drv->output_buffer_size; drv->num_input_buffers = drv->num_output_buffers; for (i = 0; i < drv->num_input_buffers; i++) drv->input_buffers[i] = drv->output_buffers[i]; } else { for (i = 0; i < drv->num_input_buffers; i++) drv->input_buffers[i] = NULL; } } /* Take note of our duplexity */ drv->duplex = duplex; /* Ensure that the driver is marked as not being open. */ drv->flags = 0; MOD_INC_USE_COUNT; /* Take driver slot, note which we took */ drv->index = dev; drivers[dev] = drv; return 0; kmalloc_failed4: kfree(drv->input_buffer); kmalloc_failed3: if (drv->input_sizes) kfree(drv->input_sizes); if (drv->input_buffers) kfree(drv->input_buffers); i = drv->num_output_buffers; kmalloc_failed2: kfree(drv->output_buffer); kmalloc_failed1: if (drv->output_buffers) kfree(drv->output_buffers); if (drv->output_sizes) kfree(drv->output_sizes); if (drv->output_notify) kfree(drv->output_notify); return -ENOMEM; } int unregister_sparcaudio_driver(struct sparcaudio_driver *drv, int duplex) { devfs_handle_t de; int i; char name_buf[32]; /* Figure out which driver is unregistering */ if (drivers[drv->index] != drv) return -EIO; /* Deallocate the queue of output buffers. */ kfree(drv->output_buffer); kfree(drv->output_buffers); kfree(drv->output_sizes); kfree(drv->output_notify); /* Deallocate the queue of input buffers. */ if (duplex == 1) { kfree(drv->input_buffer); kfree(drv->input_sizes); } kfree(drv->input_buffers); if (&(drv->sd_siglist) != NULL) lis_free_elist( &(drv->sd_siglist) ); /* Unregister ourselves with devfs */ for (i=0; i < sizeof (dev_list) / sizeof (*dev_list); i++) { sparcaudio_mkname (name_buf, dev_list[i].name, drv->index); de = devfs_find_handle (devfs_handle, name_buf, 0, 0, DEVFS_SPECIAL_CHR, 0); devfs_unregister (de); } MOD_DEC_USE_COUNT; /* Null the appropriate driver */ drivers[drv->index] = NULL; return 0; } EXPORT_SYMBOL(register_sparcaudio_driver); EXPORT_SYMBOL(unregister_sparcaudio_driver); EXPORT_SYMBOL(sparcaudio_output_done); EXPORT_SYMBOL(sparcaudio_input_done); static int __init sparcaudio_init(void) { /* Register our character device driver with the VFS. */ if (devfs_register_chrdev(SOUND_MAJOR, "sparcaudio", &sparcaudio_fops)) return -EIO; devfs_handle = devfs_mk_dir (NULL, "sound", NULL); return 0; } static void __exit sparcaudio_exit(void) { devfs_unregister_chrdev(SOUND_MAJOR, "sparcaudio"); devfs_unregister (devfs_handle); } module_init(sparcaudio_init); module_exit(sparcaudio_exit); MODULE_LICENSE("GPL"); /* * Code from Linux Streams, Copyright 1995 by * Graham Wheeler, Francisco J. Ballesteros, Denis Froschauer * and available under GPL */ static int lis_add_to_elist( strevent_t **list, pid_t pid, short events ) { strevent_t *ev = NULL; if (*list != NULL) { for (ev = (*list)->se_next; ev != *list && ev->se_pid < pid; ev = ev->se_next) ; } if (ev == NULL || ev == *list) { /* no slot for pid in list */ ev = (strevent_t *) kmalloc(sizeof(strevent_t), GFP_KERNEL); if (ev == NULL) return(-ENOMEM); if (!*list) { /* create dummy head node */ strevent_t *hd; hd = (strevent_t *) kmalloc(sizeof(strevent_t), GFP_KERNEL); if (hd == NULL) { kfree(ev); return(-ENOMEM); } (*list = hd)->se_pid = 0; hd->se_next = hd->se_prev = hd; /* empty list */ } /* link node last in the list */ ev->se_prev = (*list)->se_prev; (*list)->se_prev->se_next = ev; ((*list)->se_prev = ev)->se_next = *list; ev->se_pid = pid; ev->se_evs = 0; } else if (ev->se_pid != pid) { /* link node in the middle of the list */ strevent_t *new; new = (strevent_t *) kmalloc(sizeof(strevent_t), GFP_KERNEL); if (new == NULL) return -ENOMEM; new->se_prev = ev->se_prev; new->se_next = ev; ev->se_prev->se_next = new; ev->se_prev = new; ev = new; /* use new element */ ev->se_pid = pid; ev->se_evs = 0; } ev->se_evs |= events; return 0; } static int lis_del_from_elist( strevent_t **list, pid_t pid, short events ) { strevent_t *ev = NULL; if (*list != NULL) { for (ev = (*list)->se_next; ev != *list && ev->se_pid < pid; ev = ev->se_next) ; } if (ev == NULL || ev == *list || ev->se_pid != pid) return 1; if ((ev->se_evs &= ~events) == 0) { /* unlink */ if (ev->se_next) /* should always be true */ ev->se_next->se_prev = ev->se_prev; if (ev->se_prev) /* should always be true */ ev->se_prev->se_next = ev->se_next; kfree(ev); } return 0; } static void lis_free_elist( strevent_t **list ) { strevent_t *ev; strevent_t *nxt; for (ev = *list; ev != NULL; ) { nxt = ev->se_next; kfree(ev); ev = nxt; if (ev == *list) break; /* all done */ } *list = NULL; } static short lis_get_elist_ent( strevent_t *list, pid_t pid ) { strevent_t *ev = NULL; if (list == NULL) return 0; for(ev = list->se_next ; ev != list && ev->se_pid < pid; ev = ev->se_next) ; if (ev != list && ev->se_pid == pid) return ev->se_evs; else return 0; } static void kill_procs( struct strevent *elist, int sig, short e) { strevent_t *ev; int res; if (elist) { for(ev = elist->se_next ; ev != elist; ev = ev->se_next) if ((ev->se_evs & e) != 0) { res = kill_proc(ev->se_pid, SIGPOLL, 1); if (res < 0) { if (res == -3) { lis_del_from_elist(&elist, ev->se_pid, S_ALL); continue; } dprintk(("kill_proc: errno %d\n",res)); } } } } /* * Overrides for Emacs so that we follow Linus's tabbing style. * Emacs will notice this stuff at the end of the file and automatically * adjust the settings for this buffer only. This must remain at the end * of the file. * --------------------------------------------------------------------------- * Local variables: * c-indent-level: 4 * c-brace-imaginary-offset: 0 * c-brace-offset: -4 * c-argdecl-indent: 4 * c-label-offset: -4 * c-continued-statement-offset: 4 * c-continued-brace-offset: 0 * indent-tabs-mode: nil * tab-width: 8 * End: */