static char **sound_buffers = NULL;
static char **sound_read_buffers = NULL;
+static DEFINE_SPINLOCK(cs4218_lock);
+
/* Local copies of things we put in the control register. Output
* volume, like most codecs is really attenuation.
*/
*/
static volatile cbd_t *rx_base, *rx_cur, *tx_base, *tx_cur;
-MODULE_PARM(catchRadius, "i");
-MODULE_PARM(numBufs, "i");
-MODULE_PARM(bufSize, "i");
-MODULE_PARM(numreadBufs, "i");
-MODULE_PARM(readbufSize, "i");
+module_param(catchRadius, int, 0);
+module_param(numBufs, int, 0);
+module_param(bufSize, int, 0);
+module_param(numreadBufs, int, 0);
+module_param(readbufSize, int, 0);
#define arraysize(x) (sizeof(x)/sizeof(*(x)))
#define le2be16(x) (((x)<<8 & 0xff00) | ((x)>>8 & 0x00ff))
static struct cs_sound_settings sound;
-static void *CS_Alloc(unsigned int size, int flags);
+static void *CS_Alloc(unsigned int size, gfp_t flags);
static void CS_Free(void *ptr, unsigned int size);
static int CS_IrqInit(void);
#ifdef MODULE
/*** Low level stuff *********************************************************/
-static void *CS_Alloc(unsigned int size, int flags)
+static void *CS_Alloc(unsigned int size, gfp_t flags)
{
int order;
*/
cpm_free_handler(CPMVEC_SMC2);
- if (beep_buf)
- kfree(beep_buf);
+ kfree(beep_buf);
kd_mksound = orig_mksound;
}
#endif /* MODULE */
volatile cbd_t *bdp;
volatile cpm8xx_t *cp;
- save_flags(flags); cli();
+ /* Protect buffer */
+ spin_lock_irqsave(&cs4218_lock, flags);
#if 0
if (awacs_beep_state) {
/* sound takes precedence over beeps */
++sq.active;
}
- restore_flags(flags);
+ spin_unlock_irqrestore(&cs4218_lock, flags);
}
if (read_sq.active)
return;
- save_flags(flags); cli();
+ /* Protect buffer */
+ spin_lock_irqsave(&cs4218_lock, flags);
/* This is all we have to do......Just start it up.
*/
read_sq.active = 1;
- restore_flags(flags);
+ spin_unlock_irqrestore(&cs4218_lock, flags);
}
{
unsigned long flags;
- save_flags(flags); cli();
+ /* not sure if this is needed, since hardware command is #if 0'd */
+ spin_lock_irqsave(&cs4218_lock, flags);
if (beep_playing) {
#if 0
st_le16(&beep_dbdma_cmd->command, DBDMA_STOP);
#endif
beep_playing = 0;
}
- restore_flags(flags);
+ spin_unlock_irqrestore(&cs4218_lock, flags);
}
-static struct timer_list beep_timer = TIMER_INITIALIZER(cs_nosound, 0, 0);
+static DEFINE_TIMER(beep_timer, cs_nosound, 0, 0);
};
static void cs_mksound(unsigned int hz, unsigned int ticks)
return;
#endif
}
- save_flags(flags); cli();
+ /* lock while modifying beep_timer */
+ spin_lock_irqsave(&cs4218_lock, flags);
del_timer(&beep_timer);
if (ticks) {
beep_timer.expires = jiffies + ticks;
add_timer(&beep_timer);
}
if (beep_playing || sq.active || beep_buf == NULL) {
- restore_flags(flags);
+ spin_unlock_irqrestore(&cs4218_lock, flags);
return; /* too hard, sorry :-( */
}
beep_playing = 1;
#if 0
st_le16(&beep_dbdma_cmd->command, OUTPUT_MORE + BR_ALWAYS);
#endif
- restore_flags(flags);
+ spin_unlock_irqrestore(&cs4218_lock, flags);
if (hz == beep_hz_cache && beep_volume == beep_volume_cache) {
nsamples = beep_nsamples_cache;
st_le32(&beep_dbdma_cmd->phy_addr, virt_to_bus(beep_buf));
awacs_beep_state = 1;
- save_flags(flags); cli();
+ spin_lock_irqsave(&cs4218_lock, flags);
if (beep_playing) { /* i.e. haven't been terminated already */
out_le32(&awacs_txdma->control, (RUN|WAKE|FLUSH|PAUSE) << 16);
out_le32(&awacs->control,
out_le32(&awacs_txdma->cmdptr, virt_to_bus(beep_dbdma_cmd));
out_le32(&awacs_txdma->control, RUN | (RUN << 16));
}
+ spin_unlock_irqrestore(&cs4218_lock, flags);
#endif
- restore_flags(flags);
}
static MACHINE mach_cs4218 = {
static int mixer_open(struct inode *inode, struct file *file)
{
mixer.busy = 1;
- return 0;
+ return nonseekable_open(inode, file);
}
sound_set_format(AFMT_MU_LAW);
}
- return 0;
+ return nonseekable_open(inode, file);
err_out_nobusy:
if (file->f_mode & FMODE_WRITE) {
len += sprintf(buffer+len, "\tsq.active = %d sq.syncing = %d\n",
sq.active, sq.syncing);
state.len = len;
- return 0;
+ return nonseekable_open(inode, file);
}
int __init tdm8xx_sound_init(void)
{
int i, has_sound;
- uint dp_addr, dp_mem;
+ uint dp_offset;
volatile uint *sirp;
volatile cbd_t *bdp;
volatile cpm8xx_t *cp;
/* We need to allocate a transmit and receive buffer
* descriptors from dual port ram.
*/
- dp_mem = m8xx_cpm_dpalloc(sizeof(cbd_t) * numReadBufs);
- dp_addr = m8xx_cpm_dpram_offset(dp_mem);
+ dp_addr = cpm_dpalloc(sizeof(cbd_t) * numReadBufs, 8);
/* Set the physical address of the host memory
* buffers in the buffer descriptors, and the
* virtual address for us to work with.
*/
bdp = (cbd_t *)&cp->cp_dpmem[dp_addr];
- up->smc_rbase = dp_mem;
+ up->smc_rbase = dp_offset;
rx_cur = rx_base = (cbd_t *)bdp;
for (i=0; i<(numReadBufs-1); i++) {
/* Now, do the same for the transmit buffers.
*/
- dp_mem = m8xx_cpm_dpalloc(sizeof(cbd_t) * numBufs);
- dp_addr = m8xx_cpm_dpram_offset(dp_mem);
+ dp_offset = cpm_dpalloc(sizeof(cbd_t) * numBufs, 8);
bdp = (cbd_t *)&cp->cp_dpmem[dp_addr];
- up->smc_tbase = dp_mem;
+ up->smc_tbase = dp_offset;
tx_cur = tx_base = (cbd_t *)bdp;
for (i=0; i<(numBufs-1); i++) {