/* * 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; }