/*
* When an ifconfig is issued which changes the device flag to include
* IFF_UP this function is called. It is only called when the change
* occurs, not when the interface remains up. The function grabs the interrupt
* resources and registers IrDA interrupt service routines, requests for DMA
* channels, configures the DMA channel. It then initializes the IOMUX
* registers to configure the pins for IrDA signals and finally initializes the
* various IrDA registers and enables the port for reception.
*
* @param dev net device structure that is being opened
*
* @return The function returns 0 for a successful open and non-zero value
* on failure.
*/
static int mxc_irda_start(struct net_device *dev)
{
struct mxc_irda *si = netdev_priv(dev);
int err;
si->speed = 9600;
err = request_irq(si->uart_irq, mxc_irda_irq, 0, dev->name, dev);
if (err) {
dev_err(si->dev, "%s:Failed to request the IRQ\n",
__FUNCTION__);
return err;
}
/*
* The interrupt must remain disabled for now.
*/
disable_irq(si->uart_irq);
/* Setup the serial port port for the initial speed. */
err = mxc_irda_startup(si);
if (err) {
goto err_startup;
}
/* Open a new IrLAP layer instance. */
si->irlap = irlap_open(dev, &si->qos, "mxc_irda");
err = -ENOMEM;
if (!si->irlap) {
goto err_irlap;
}
si->open = 1;
si->suspend = 0;
/* Now enable the interrupt and start the queue */
enable_irq(si->uart_irq);
netif_start_queue(dev);
return 0;
err_irlap:
si->open = 0;
mxc_irda_shutdown(si);
err_startup:
free_irq(si->uart_irq, dev);
return err;
}
static int au1k_irda_start(struct net_device *dev)
{
struct au1k_private *aup = netdev_priv(dev);
char hwname[32];
int retval;
retval = au1k_init(dev);
if (retval) {
printk(KERN_ERR "%s: error in au1k_init\n", dev->name);
return retval;
}
retval = request_irq(aup->irq_tx, &au1k_irda_interrupt, 0,
dev->name, dev);
if (retval) {
printk(KERN_ERR "%s: unable to get IRQ %d\n",
dev->name, dev->irq);
return retval;
}
retval = request_irq(aup->irq_rx, &au1k_irda_interrupt, 0,
dev->name, dev);
if (retval) {
free_irq(aup->irq_tx, dev);
printk(KERN_ERR "%s: unable to get IRQ %d\n",
dev->name, dev->irq);
return retval;
}
/* Give self a hardware name */
sprintf(hwname, "Au1000 SIR/FIR");
aup->irlap = irlap_open(dev, &aup->qos, hwname);
netif_start_queue(dev);
/* int enable */
irda_write(aup, IR_CONFIG_2, irda_read(aup, IR_CONFIG_2) | IR_IEN);
/* power up */
au1k_irda_plat_set_phy_mode(aup, AU1000_IRDA_PHY_MODE_SIR);
aup->timer.expires = RUN_AT((3 * HZ));
aup->timer.data = (unsigned long)dev;
return 0;
}
static int au1k_irda_start(struct net_device *dev)
{
int retval;
char hwname[32];
struct au1k_private *aup = (struct au1k_private *) dev->priv;
MOD_INC_USE_COUNT;
if ((retval = au1k_init(dev))) {
printk(KERN_ERR "%s: error in au1k_init\n", dev->name);
MOD_DEC_USE_COUNT;
return retval;
}
if ((retval = request_irq(AU1000_IRDA_TX_INT, &au1k_irda_interrupt,
0, dev->name, dev))) {
printk(KERN_ERR "%s: unable to get IRQ %d\n",
dev->name, dev->irq);
MOD_DEC_USE_COUNT;
return retval;
}
if ((retval = request_irq(AU1000_IRDA_RX_INT, &au1k_irda_interrupt,
0, dev->name, dev))) {
free_irq(AU1000_IRDA_TX_INT, dev);
printk(KERN_ERR "%s: unable to get IRQ %d\n",
dev->name, dev->irq);
MOD_DEC_USE_COUNT;
return retval;
}
/* Give self a hardware name */
sprintf(hwname, "Au1000 SIR/FIR");
aup->irlap = irlap_open(dev, &aup->qos, hwname);
netif_start_queue(dev);
writel(read_ir_reg(IR_CONFIG_2) | 1<<8, IR_CONFIG_2); /* int enable */
aup->timer.expires = RUN_AT((3*HZ));
aup->timer.data = (unsigned long)dev;
return 0;
}
static int bfin_sir_open(struct net_device *dev)
{
struct bfin_sir_self *self = netdev_priv(dev);
struct bfin_sir_port *port = self->sir_port;
int err;
self->newspeed = 0;
self->speed = 9600;
spin_lock_init(&self->lock);
err = bfin_sir_startup(port, dev);
if (err)
goto err_startup;
bfin_sir_set_speed(port, 9600);
self->irlap = irlap_open(dev, &self->qos, DRIVER_NAME);
if (!self->irlap) {
err = -ENOMEM;
goto err_irlap;
}
INIT_WORK(&self->work, bfin_sir_send_work);
/*
* Now enable the interrupt then start the queue
*/
self->open = 1;
bfin_sir_enable_rx(port);
netif_start_queue(dev);
return 0;
err_irlap:
self->open = 0;
bfin_sir_shutdown(port, dev);
err_startup:
return err;
}
static int pxa_irda_start(struct net_device *dev)
{
struct pxa_irda *si = netdev_priv(dev);
int err;
si->speed = 9600;
err = request_irq(IRQ_STUART, pxa_irda_sir_irq, 0, dev->name, dev);
if (err)
goto err_irq1;
err = request_irq(IRQ_ICP, pxa_irda_fir_irq, 0, dev->name, dev);
if (err)
goto err_irq2;
/*
* The interrupt must remain disabled for now.
*/
disable_irq(IRQ_STUART);
disable_irq(IRQ_ICP);
err = -EBUSY;
si->rxdma = pxa_request_dma("FICP_RX",DMA_PRIO_LOW, pxa_irda_fir_dma_rx_irq, dev);
if (si->rxdma < 0)
goto err_rx_dma;
si->txdma = pxa_request_dma("FICP_TX",DMA_PRIO_LOW, pxa_irda_fir_dma_tx_irq, dev);
if (si->txdma < 0)
goto err_tx_dma;
err = -ENOMEM;
si->dma_rx_buff = dma_alloc_coherent(si->dev, IRDA_FRAME_SIZE_LIMIT,
&si->dma_rx_buff_phy, GFP_KERNEL );
if (!si->dma_rx_buff)
goto err_dma_rx_buff;
si->dma_tx_buff = dma_alloc_coherent(si->dev, IRDA_FRAME_SIZE_LIMIT,
&si->dma_tx_buff_phy, GFP_KERNEL );
if (!si->dma_tx_buff)
goto err_dma_tx_buff;
/* Setup the serial port for the initial speed. */
pxa_irda_startup(si);
/*
* Open a new IrLAP layer instance.
*/
si->irlap = irlap_open(dev, &si->qos, "pxa");
err = -ENOMEM;
if (!si->irlap)
goto err_irlap;
/*
* Now enable the interrupt and start the queue
*/
enable_irq(IRQ_STUART);
enable_irq(IRQ_ICP);
netif_start_queue(dev);
printk(KERN_DEBUG "pxa_ir: irda driver opened\n");
return 0;
err_irlap:
pxa_irda_shutdown(si);
dma_free_coherent(si->dev, IRDA_FRAME_SIZE_LIMIT, si->dma_tx_buff, si->dma_tx_buff_phy);
err_dma_tx_buff:
dma_free_coherent(si->dev, IRDA_FRAME_SIZE_LIMIT, si->dma_rx_buff, si->dma_rx_buff_phy);
err_dma_rx_buff:
pxa_free_dma(si->txdma);
err_tx_dma:
pxa_free_dma(si->rxdma);
err_rx_dma:
free_irq(IRQ_ICP, dev);
err_irq2:
free_irq(IRQ_STUART, dev);
err_irq1:
return err;
}
/*
* Function kingsun_net_open (dev)
*
* Network device is taken up. Usually this is done by "ifconfig irda0 up"
*/
static int kingsun_net_open(struct net_device *netdev)
{
struct kingsun_cb *kingsun = netdev_priv(netdev);
int err = -ENOMEM;
char hwname[16];
/* At this point, urbs are NULL, and skb is NULL (see kingsun_probe) */
kingsun->receiving = 0;
/* Initialize for SIR to copy data directly into skb. */
kingsun->rx_buff.in_frame = FALSE;
kingsun->rx_buff.state = OUTSIDE_FRAME;
kingsun->rx_buff.truesize = IRDA_SKB_MAX_MTU;
kingsun->rx_buff.skb = dev_alloc_skb(IRDA_SKB_MAX_MTU);
if (!kingsun->rx_buff.skb)
goto free_mem;
skb_reserve(kingsun->rx_buff.skb, 1);
kingsun->rx_buff.head = kingsun->rx_buff.skb->data;
do_gettimeofday(&kingsun->rx_time);
kingsun->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
if (!kingsun->rx_urb)
goto free_mem;
kingsun->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
if (!kingsun->tx_urb)
goto free_mem;
/*
* Now that everything should be initialized properly,
* Open new IrLAP layer instance to take care of us...
*/
sprintf(hwname, "usb#%d", kingsun->usbdev->devnum);
kingsun->irlap = irlap_open(netdev, &kingsun->qos, hwname);
if (!kingsun->irlap) {
dev_err(&kingsun->usbdev->dev, "irlap_open failed\n");
goto free_mem;
}
/* Start first reception */
usb_fill_int_urb(kingsun->rx_urb, kingsun->usbdev,
usb_rcvintpipe(kingsun->usbdev, kingsun->ep_in),
kingsun->in_buf, kingsun->max_rx,
kingsun_rcv_irq, kingsun, 1);
kingsun->rx_urb->status = 0;
err = usb_submit_urb(kingsun->rx_urb, GFP_KERNEL);
if (err) {
dev_err(&kingsun->usbdev->dev,
"first urb-submit failed: %d\n", err);
goto close_irlap;
}
netif_start_queue(netdev);
/* Situation at this point:
- all work buffers allocated
- urbs allocated and ready to fill
- max rx packet known (in max_rx)
- unwrap state machine initialized, in state outside of any frame
- receive request in progress
- IrLAP layer started, about to hand over packets to send
*/
return 0;
close_irlap:
irlap_close(kingsun->irlap);
free_mem:
if (kingsun->tx_urb) {
usb_free_urb(kingsun->tx_urb);
kingsun->tx_urb = NULL;
}
if (kingsun->rx_urb) {
usb_free_urb(kingsun->rx_urb);
kingsun->rx_urb = NULL;
}
if (kingsun->rx_buff.skb) {
kfree_skb(kingsun->rx_buff.skb);
kingsun->rx_buff.skb = NULL;
kingsun->rx_buff.head = NULL;
}
return err;
}
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;
}
static int omap1610_irda_start(struct net_device *dev)
{
struct omap1610_irda *si = dev->priv;
int err;
unsigned long flags = 0;
#ifdef CONFIG_MACH_OMAP_H3
u8 ioExpanderVal = 0;
#endif
__ECHO_IN;
si->speed = 9600;
err = request_irq(dev->irq, omap1610_irda_irq, 0, dev->name, dev);
if (err)
goto err_irq;
/*
* The interrupt must remain disabled for now.
*/
disable_irq(dev->irq);
/* Request DMA channels for IrDA hardware */
if (omap_request_dma(OMAP_DMA_UART3_RX, "IrDA Rx DMA",
(void *)omap1610_irda_rx_dma_callback,
dev, &(si->rx_dma_channel))) {
printk(KERN_ERR "Failed to request IrDA Rx DMA \n");
goto err_irq;
}
if (omap_request_dma(OMAP_DMA_UART3_TX, "IrDA Tx DMA",
(void *)omap1610_irda_tx_dma_callback,
dev, &(si->tx_dma_channel))) {
printk(KERN_ERR "Failed to request IrDA Tx DMA \n");
goto err_irq;
}
/* Allocate TX and RX buffers for DMA channels */
si->rx_buf_dma_virt =
dma_alloc_coherent(NULL, 4096, &(si->rx_buf_dma_phys), flags);
si->tx_buf_dma_virt =
dma_alloc_coherent(NULL, 4096, &(si->tx_buf_dma_phys), flags);
/*
* Setup the serial port for the specified config.
*/
#if CONFIG_MACH_OMAP_H3
if ((err = read_gpio_expa(&ioExpanderVal, 0x26))) {
printk(KERN_ERR "Error reading from I/O EXPANDER \n");
return err;
}
ioExpanderVal |= 0x40; /* 'P6' Enable IRDA_TX and IRDA_RX */
if ((err = write_gpio_expa(ioExpanderVal, 0x26))) {
printk(KERN_ERR "Error writing to I/O EXPANDER \n");
return err;
}
#endif
err = omap1610_irda_startup(dev);
if (err)
goto err_startup;
omap1610_irda_set_speed(dev, si->speed = 9600);
/*
* Open a new IrLAP layer instance.
*/
si->irlap = irlap_open(dev, &si->qos, "omap_sir");
err = -ENOMEM;
if (!si->irlap)
goto err_irlap;
/* Now enable the interrupt and start the queue */
si->open = 1;
/* Start RX DMA */
omap1610_irda_start_rx_dma(si);
enable_irq(dev->irq);
netif_start_queue(dev);
__ECHO_OUT;
return 0;
err_irlap:
si->open = 0;
omap1610_irda_shutdown(si);
err_startup:
err_irq:
free_irq(dev->irq, dev);
return err;
}
static int pxa250_irda_start(struct net_device *dev)
{
struct pxa250_irda *si = dev->priv;
int err;
unsigned int flags;
MOD_INC_USE_COUNT;
__ECHO_IN;
si->speed = 9600;
local_irq_save(flags);
err = request_irq(si->fir_irq, pxa250_irda_fir_irq, 0, dev->name, dev);
if (err)
goto err_fir_irq;
err = request_irq(dev->irq, pxa250_irda_irq, 0, dev->name, dev);
if (err)
goto err_irq;
/*
* The interrupt must remain disabled for now.
*/
disable_irq(dev->irq);
disable_irq(si->fir_irq);
local_irq_restore(flags);
/* Allocate DMA channel for receiver (not used) */
err = pxa_request_dma("IrDA receive", DMA_PRIO_LOW, pxa250_irda_rxdma_irq, dev);
if (err < 0 )
goto err_rx_dma;
si->rxdma_ch=err;
DRCMRRXICDR = DRCMR_MAPVLD | si->rxdma_ch;
/* Allocate DMA channel for transmit */
err = pxa_request_dma("IrDA transmit", DMA_PRIO_LOW, pxa250_irda_txdma_irq , dev);
if (err < 0 )
goto err_tx_dma;
si->txdma_ch=err;
/*
* Make sure that ICP will be able
* to assert the transmit dma request bit
* through the peripherals request bus (PREQ)
*/
DRCMRTXICDR = DRCMR_MAPVLD | si->txdma_ch;
DBG("rx(not used) channel=%d tx channel=%d\n",si->rxdma_ch,si->txdma_ch);
/* allocate consistent buffers for dma access
* buffers have to be aligned and situated in dma capable memory region;
*/
si->rxbuf_dma_virt = consistent_alloc(GFP_KERNEL | GFP_DMA ,HPSIR_MAX_RXLEN , &si->rxbuf_dma);
if (! si->rxbuf_dma_virt )
goto err_rxbuf_dma;
si->txbuf_dma_virt = consistent_alloc(GFP_KERNEL | GFP_DMA, HPSIR_MAX_TXLEN, &si->txbuf_dma);
if (! si->txbuf_dma_virt )
goto err_txbuf_dma;
/* Alocate skb for receiver */
err=pxa250_irda_rx_alloc(si);
if (err)
goto err_rx_alloc;
/*
* Setup the serial port for the specified config.
*/
err = pxa250_irda_startup(dev);
if (err)
goto err_startup;
pxa250_irda_set_speed(dev,si->speed = 9600);
/*
* Open a new IrLAP layer instance.
*/
si->irlap = irlap_open(dev, &si->qos, "pxa250");
err = -ENOMEM;
if (!si->irlap)
goto err_irlap;
/*
* Now enable the interrupt and start the queue
*/
si->open = 1;
enable_irq(dev->irq);
netif_start_queue(dev);
return 0;
err_irlap:
si->open = 0;
pxa250_sir_irda_shutdown(si);
err_startup:
dev_kfree_skb(si->rxskb);
err_rx_alloc:
consistent_free (si->txbuf_dma_virt,HPSIR_MAX_TXLEN,si->txbuf_dma);
err_txbuf_dma:
consistent_free (si->rxbuf_dma_virt,HPSIR_MAX_RXLEN,si->rxbuf_dma);
err_rxbuf_dma:
pxa_free_dma(si->txdma_ch);
err_tx_dma:
pxa_free_dma(si->rxdma_ch);
err_rx_dma:
free_irq(dev->irq, dev);
err_irq:
free_irq(si->fir_irq, dev);
err_fir_irq:
MOD_DEC_USE_COUNT;
return err;
}
/*
* Function kingsun_net_open (dev)
*
* Network device is taken up. Usually this is done by "ifconfig irda0 up"
*/
static int ks959_net_open(struct net_device *netdev)
{
struct ks959_cb *kingsun = netdev_priv(netdev);
int err = -ENOMEM;
char hwname[16];
/* At this point, urbs are NULL, and skb is NULL (see kingsun_probe) */
kingsun->receiving = 0;
/* Initialize for SIR to copy data directly into skb. */
kingsun->rx_unwrap_buff.in_frame = FALSE;
kingsun->rx_unwrap_buff.state = OUTSIDE_FRAME;
kingsun->rx_unwrap_buff.truesize = IRDA_SKB_MAX_MTU;
kingsun->rx_unwrap_buff.skb = dev_alloc_skb(IRDA_SKB_MAX_MTU);
if (!kingsun->rx_unwrap_buff.skb)
goto free_mem;
skb_reserve(kingsun->rx_unwrap_buff.skb, 1);
kingsun->rx_unwrap_buff.head = kingsun->rx_unwrap_buff.skb->data;
do_gettimeofday(&kingsun->rx_time);
kingsun->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
if (!kingsun->rx_urb)
goto free_mem;
kingsun->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
if (!kingsun->tx_urb)
goto free_mem;
kingsun->speed_urb = usb_alloc_urb(0, GFP_KERNEL);
if (!kingsun->speed_urb)
goto free_mem;
/* Initialize speed for dongle */
kingsun->new_speed = 9600;
err = ks959_change_speed(kingsun, 9600);
if (err < 0)
goto free_mem;
/*
* Now that everything should be initialized properly,
* Open new IrLAP layer instance to take care of us...
*/
sprintf(hwname, "usb#%d", kingsun->usbdev->devnum);
kingsun->irlap = irlap_open(netdev, &kingsun->qos, hwname);
if (!kingsun->irlap) {
err("ks959-sir: irlap_open failed");
goto free_mem;
}
/* Start reception. Setup request already pre-filled in ks959_probe */
usb_fill_control_urb(kingsun->rx_urb, kingsun->usbdev,
usb_rcvctrlpipe(kingsun->usbdev, 0),
(unsigned char *)kingsun->rx_setuprequest,
kingsun->rx_buf, KINGSUN_RCV_FIFO_SIZE,
ks959_rcv_irq, kingsun);
kingsun->rx_urb->status = 0;
err = usb_submit_urb(kingsun->rx_urb, GFP_KERNEL);
if (err) {
err("ks959-sir: first urb-submit failed: %d", err);
goto close_irlap;
}
netif_start_queue(netdev);
/* Situation at this point:
- all work buffers allocated
- urbs allocated and ready to fill
- max rx packet known (in max_rx)
- unwrap state machine initialized, in state outside of any frame
- receive request in progress
- IrLAP layer started, about to hand over packets to send
*/
return 0;
close_irlap:
irlap_close(kingsun->irlap);
free_mem:
usb_free_urb(kingsun->speed_urb);
kingsun->speed_urb = NULL;
usb_free_urb(kingsun->tx_urb);
kingsun->tx_urb = NULL;
usb_free_urb(kingsun->rx_urb);
kingsun->rx_urb = NULL;
if (kingsun->rx_unwrap_buff.skb) {
kfree_skb(kingsun->rx_unwrap_buff.skb);
kingsun->rx_unwrap_buff.skb = NULL;
kingsun->rx_unwrap_buff.head = NULL;
}
return err;
}
static int omap_irda_start(struct net_device *dev)
{
struct omap_irda *omap_ir = netdev_priv(dev);
int err;
omap_ir->speed = 9600;
err = request_irq(dev->irq, omap_irda_irq, 0, dev->name, dev);
if (err)
goto err_irq;
/*
* The interrupt must remain disabled for now.
*/
disable_irq(dev->irq);
/* Request DMA channels for IrDA hardware */
if (omap_request_dma(omap_ir->pdata->rx_channel, "IrDA Rx DMA",
(void *)omap_irda_rx_dma_callback,
dev, &(omap_ir->rx_dma_channel))) {
printk(KERN_ERR "Failed to request IrDA Rx DMA\n");
goto err_irq;
}
if (omap_request_dma(omap_ir->pdata->tx_channel, "IrDA Tx DMA",
(void *)omap_irda_tx_dma_callback,
dev, &(omap_ir->tx_dma_channel))) {
printk(KERN_ERR "Failed to request IrDA Tx DMA\n");
goto err_irq;
}
/* Allocate TX and RX buffers for DMA channels */
omap_ir->rx_buf_dma_virt =
dma_alloc_coherent(NULL, IRDA_SKB_MAX_MTU,
&(omap_ir->rx_buf_dma_phys),
GFP_KERNEL);
if (!omap_ir->rx_buf_dma_virt) {
printk(KERN_ERR "Unable to allocate memory for rx_buf_dma\n");
goto err_irq;
}
omap_ir->tx_buf_dma_virt =
dma_alloc_coherent(NULL, IRDA_SIR_MAX_FRAME,
&(omap_ir->tx_buf_dma_phys),
GFP_KERNEL);
if (!omap_ir->tx_buf_dma_virt) {
printk(KERN_ERR "Unable to allocate memory for tx_buf_dma\n");
goto err_mem1;
}
/*
* Setup the serial port for the specified config.
*/
if (omap_ir->pdata->select_irda)
omap_ir->pdata->select_irda(omap_ir->dev, IR_SEL);
err = omap_irda_startup(dev);
if (err)
goto err_startup;
omap_irda_set_speed(dev, omap_ir->speed = 9600);
/*
* Open a new IrLAP layer instance.
*/
omap_ir->irlap = irlap_open(dev, &omap_ir->qos, "omap_sir");
err = -ENOMEM;
if (!omap_ir->irlap)
goto err_irlap;
/* Now enable the interrupt and start the queue */
omap_ir->open = 1;
/* Start RX DMA */
omap_irda_start_rx_dma(omap_ir);
enable_irq(dev->irq);
netif_start_queue(dev);
return 0;
err_irlap:
omap_ir->open = 0;
omap_irda_shutdown(omap_ir);
err_startup:
dma_free_coherent(NULL, IRDA_SIR_MAX_FRAME,
omap_ir->tx_buf_dma_virt, omap_ir->tx_buf_dma_phys);
err_mem1:
dma_free_coherent(NULL, IRDA_SKB_MAX_MTU,
omap_ir->rx_buf_dma_virt, omap_ir->rx_buf_dma_phys);
err_irq:
free_irq(dev->irq, dev);
return err;
}
static int kingsun_net_open(struct net_device *netdev)
{
struct kingsun_cb *kingsun = netdev_priv(netdev);
int err = -ENOMEM;
char hwname[16];
kingsun->receiving = 0;
kingsun->rx_buff.in_frame = FALSE;
kingsun->rx_buff.state = OUTSIDE_FRAME;
kingsun->rx_buff.truesize = IRDA_SKB_MAX_MTU;
kingsun->rx_buff.skb = dev_alloc_skb(IRDA_SKB_MAX_MTU);
if (!kingsun->rx_buff.skb)
goto free_mem;
skb_reserve(kingsun->rx_buff.skb, 1);
kingsun->rx_buff.head = kingsun->rx_buff.skb->data;
do_gettimeofday(&kingsun->rx_time);
kingsun->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
if (!kingsun->rx_urb)
goto free_mem;
kingsun->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
if (!kingsun->tx_urb)
goto free_mem;
sprintf(hwname, "usb#%d", kingsun->usbdev->devnum);
kingsun->irlap = irlap_open(netdev, &kingsun->qos, hwname);
if (!kingsun->irlap) {
err("kingsun-sir: irlap_open failed");
goto free_mem;
}
usb_fill_int_urb(kingsun->rx_urb, kingsun->usbdev,
usb_rcvintpipe(kingsun->usbdev, kingsun->ep_in),
kingsun->in_buf, kingsun->max_rx,
kingsun_rcv_irq, kingsun, 1);
kingsun->rx_urb->status = 0;
err = usb_submit_urb(kingsun->rx_urb, GFP_KERNEL);
if (err) {
err("kingsun-sir: first urb-submit failed: %d", err);
goto close_irlap;
}
netif_start_queue(netdev);
return 0;
close_irlap:
irlap_close(kingsun->irlap);
free_mem:
if (kingsun->tx_urb) {
usb_free_urb(kingsun->tx_urb);
kingsun->tx_urb = NULL;
}
if (kingsun->rx_urb) {
usb_free_urb(kingsun->rx_urb);
kingsun->rx_urb = NULL;
}
if (kingsun->rx_buff.skb) {
kfree_skb(kingsun->rx_buff.skb);
kingsun->rx_buff.skb = NULL;
kingsun->rx_buff.head = NULL;
}
return err;
}
