static void __exit sa1111_uda1341_exit(void)
{
unregister_sound_dsp(audio_dev_id);
unregister_sound_mixer(mixer_dev_id);
sa1100_free_dma(output_stream.dma_ch);
sa1100_free_dma(input_stream.dma_ch);
l3_detach_client(&uda1341);
}
/*
* usbctl_init()
* Module load time. Allocate dma and interrupt resources. Setup /proc fs
* entry. Leave UDC disabled.
*/
int usbctl_init( void )
{
int retval = 0;
// Disable UDC
UDC_set( Ser0UDCCR, UDCCR_UDD);
memset( &usbd_info, 0, sizeof( usbd_info ) );
if (!port_changed_buf) {
port_changed_buf = kmalloc(1, GFP_ATOMIC);
}
if (!desc_buf) {
desc_buf = kmalloc(USB_BUFSIZ, GFP_ATOMIC);
}
/* setup rx dma */
retval = sa1100_request_dma(DMA_Ser0UDCRd, "USB receive", NULL, NULL, &usbd_info.dmach_rx);
if (retval) {
printk("[%lu]%sunable to register for rx dma rc=%d\n", (jiffies-start_time)*10, pszctl, retval );
goto err_rx_dma;
}
/* setup tx dma */
retval = sa1100_request_dma(DMA_Ser0UDCWr, "USB transmit", NULL, NULL, &usbd_info.dmach_tx);
if (retval) {
printk("[%lu]%sunable to register for tx dma rc=%d\n", (jiffies-start_time)*10,pszctl,retval);
goto err_tx_dma;
}
/* now allocate the IRQ. */
retval = request_irq(IRQ_Ser0UDC, udc_int_hndlr, SA_INTERRUPT, "SA USB core", NULL);
if (retval) {
printk("[%lu]%sCouldn't request USB irq rc=%d\n", (jiffies-start_time)*10,pszctl, retval);
goto err_irq;
}
return 0;
err_irq:
sa1100_free_dma(usbd_info.dmach_tx);
usbd_info.dmach_tx = 0;
err_tx_dma:
sa1100_free_dma(usbd_info.dmach_rx);
usbd_info.dmach_rx = 0;
err_rx_dma:
return retval;
}
/*
* usbctl_exit()
* Release DMA and interrupt resources
*/
void usbctl_exit( void )
{
// Disable UDC
UDC_set( Ser0UDCCR, UDCCR_UDD);
sa1100_free_dma(usbd_info.dmach_rx);
sa1100_free_dma(usbd_info.dmach_tx);
free_irq(IRQ_Ser0UDC, NULL);
if (desc_buf) {
kfree(desc_buf);
}
if (port_changed_buf) {
kfree(port_changed_buf);
}
}
static int audio_release(struct inode *inode, struct file *file)
{
audio_state_t *state = (audio_state_t *)file->private_data;
DPRINTK("audio_release\n");
down(&state->sem);
if (file->f_mode & FMODE_READ) {
if (state->tx_spinning) {
sa1100_dma_set_spin(state->output_stream->dma_ch, 0, 0);
state->tx_spinning = 0;
}
audio_clear_buf(state->input_stream);
if (!state->skip_dma_init) {
sa1100_free_dma(state->input_stream->dma_ch);
if (state->need_tx_for_rx && !state->wr_ref)
sa1100_free_dma(state->output_stream->dma_ch);
}
state->rd_ref = 0;
}
if (file->f_mode & FMODE_WRITE) {
audio_sync(file);
audio_clear_buf(state->output_stream);
if (!state->skip_dma_init)
if (!state->need_tx_for_rx || !state->rd_ref)
sa1100_free_dma(state->output_stream->dma_ch);
state->wr_ref = 0;
}
if (!AUDIO_ACTIVE(state)) {
if (state->hw_shutdown)
state->hw_shutdown(state->data);
#ifdef CONFIG_PM
pm_unregister(state->pm_dev);
#endif
}
up(&state->sem);
return 0;
}
static int sa1100_irda_stop(struct net_device *dev)
{
struct sa1100_irda *si = dev->priv;
disable_irq(dev->irq);
sa1100_irda_shutdown(si);
/*
* If we have been doing DMA receive, make sure we
* tidy that up cleanly.
*/
if (si->rxskb) {
pci_unmap_single(NULL, si->rxbuf_dma, HPSIR_MAX_RXLEN,
PCI_DMA_FROMDEVICE);
dev_kfree_skb(si->rxskb);
si->rxskb = NULL;
}
/* Stop IrLAP */
if (si->irlap) {
irlap_close(si->irlap);
si->irlap = NULL;
}
netif_stop_queue(dev);
si->open = 0;
/*
* Free resources
*/
sa1100_free_dma(si->txdma);
sa1100_free_dma(si->rxdma);
free_irq(dev->irq, dev);
sa1100_set_power(si, 0);
MOD_DEC_USE_COUNT;
return 0;
}
static int __init sa1111_uda1341_init(void)
{
struct uda1341_cfg cfg;
int ret;
if ( !( (machine_is_assabet() && machine_has_neponset()) ||
machine_is_jornada720() ))
return -ENODEV;
ret = l3_attach_client(&uda1341, "l3-sa1111", "uda1341");
if (ret)
goto out;
/* Acquire and initialize DMA */
ret = sa1111_sac_request_dma(&output_stream.dma_ch, "SA1111 audio out",
SA1111_SAC_XMT_CHANNEL);
if (ret < 0)
goto release_l3;
ret = sa1111_sac_request_dma(&input_stream.dma_ch, "SA1111 audio in",
SA1111_SAC_RCV_CHANNEL);
if (ret < 0)
goto release_dma;
cfg.fs = 256;
cfg.format = FMT_I2S;
l3_command(&uda1341, L3_UDA1341_CONFIGURE, &cfg);
/* register devices */
audio_dev_id = register_sound_dsp(&sa1111_audio_fops, -1);
mixer_dev_id = register_sound_mixer(&uda1341_mixer_fops, -1);
printk(KERN_INFO "SA1111 UDA1341 audio driver initialized\n");
return 0;
release_dma:
sa1100_free_dma(output_stream.dma_ch);
release_l3:
l3_detach_client(&uda1341);
out:
return ret;
}
static int sa1100_irda_start(struct net_device *dev)
{
struct sa1100_irda *si = dev->priv;
int err;
si->speed = 9600;
err = request_irq(dev->irq, sa1100_irda_irq, 0, dev->name, dev);
if (err)
goto err_irq;
err = sa1100_request_dma(DMA_Ser2HSSPRd, "IrDA receive",
NULL, NULL, &si->rxdma);
if (err)
goto err_rx_dma;
err = sa1100_request_dma(DMA_Ser2HSSPWr, "IrDA transmit",
sa1100_irda_txdma_irq, dev, &si->txdma);
if (err)
goto err_tx_dma;
/*
* The interrupt must remain disabled for now.
*/
disable_irq(dev->irq);
/*
* Setup the serial port for the specified speed.
*/
err = sa1100_irda_startup(si);
if (err)
goto err_startup;
/*
* Open a new IrLAP layer instance.
*/
si->irlap = irlap_open(dev, &si->qos, "sa1100");
err = -ENOMEM;
if (!si->irlap)
goto err_irlap;
/*
* Now enable the interrupt and start the queue
*/
si->open = 1;
sa1100_set_power(si, power_level); /* low power mode */
enable_irq(dev->irq);
netif_start_queue(dev);
return 0;
err_irlap:
si->open = 0;
sa1100_irda_shutdown(si);
err_startup:
sa1100_free_dma(si->txdma);
err_tx_dma:
sa1100_free_dma(si->rxdma);
err_rx_dma:
free_irq(dev->irq, dev);
err_irq:
return err;
}
int sa1100_audio_attach(struct inode *inode, struct file *file,
audio_state_t *state)
{
int err, need_tx_dma;
DPRINTK("audio_open\n");
down(&state->sem);
/* access control */
err = -ENODEV;
if ((file->f_mode & FMODE_WRITE) && !state->output_stream)
goto out;
if ((file->f_mode & FMODE_READ) && !state->input_stream)
goto out;
err = -EBUSY;
if ((file->f_mode & FMODE_WRITE) && state->wr_ref)
goto out;
if ((file->f_mode & FMODE_READ) && state->rd_ref)
goto out;
err = -EINVAL;
if ((file->f_mode & FMODE_READ) && state->need_tx_for_rx && !state->output_stream)
goto out;
/* request DMA channels */
if (state->skip_dma_init)
goto skip_dma;
need_tx_dma = ((file->f_mode & FMODE_WRITE) ||
((file->f_mode & FMODE_READ) && state->need_tx_for_rx));
if (state->wr_ref || (state->rd_ref && state->need_tx_for_rx))
need_tx_dma = 0;
if (need_tx_dma) {
err = sa1100_request_dma(&state->output_stream->dma_ch,
state->output_id,
state->output_dma);
if (err)
goto out;
}
if (file->f_mode & FMODE_READ) {
err = sa1100_request_dma(&state->input_stream->dma_ch,
state->input_id,
state->input_dma);
if (err) {
if (need_tx_dma)
sa1100_free_dma(state->output_stream->dma_ch);
goto out;
}
}
skip_dma:
/* now complete initialisation */
if (!AUDIO_ACTIVE(state)) {
if (state->hw_init)
state->hw_init(state->data);
#ifdef CONFIG_PM
state->pm_dev = pm_register(PM_SYS_DEV, 0, audio_pm_callback);
if (state->pm_dev)
state->pm_dev->data = state;
#endif
}
if ((file->f_mode & FMODE_WRITE)) {
state->wr_ref = 1;
audio_clear_buf(state->output_stream);
state->output_stream->fragsize = AUDIO_FRAGSIZE_DEFAULT;
state->output_stream->nbfrags = AUDIO_NBFRAGS_DEFAULT;
state->output_stream->mapped = 0;
sa1100_dma_set_callback(state->output_stream->dma_ch,
audio_dmaout_done_callback);
init_waitqueue_head(&state->output_stream->wq);
}
if (file->f_mode & FMODE_READ) {
state->rd_ref = 1;
audio_clear_buf(state->input_stream);
state->input_stream->fragsize = AUDIO_FRAGSIZE_DEFAULT;
state->input_stream->nbfrags = AUDIO_NBFRAGS_DEFAULT;
state->input_stream->mapped = 0;
sa1100_dma_set_callback(state->input_stream->dma_ch,
audio_dmain_done_callback);
init_waitqueue_head(&state->input_stream->wq);
}
file->private_data = state;
file->f_op->release = audio_release;
file->f_op->write = audio_write;
file->f_op->read = audio_read;
file->f_op->mmap = audio_mmap;
file->f_op->poll = audio_poll;
file->f_op->ioctl = audio_ioctl;
file->f_op->llseek = audio_llseek;
err = 0;
out:
up(&state->sem);
return err;
}
