static int usblp_set_protocol(struct usblp *usblp, int protocol) { int r, alts; if (protocol < USBLP_FIRST_PROTOCOL || protocol > USBLP_LAST_PROTOCOL) return -EINVAL; alts = usblp->protocol[protocol].alt_setting; if (alts < 0) return -EINVAL; r = usb_set_interface(usblp->dev, usblp->ifnum, alts); if (r < 0) { err("can't set desired altsetting %d on interface %d", alts, usblp->ifnum); return r; } FILL_BULK_URB(&usblp->writeurb, usblp->dev, usb_sndbulkpipe(usblp->dev, usblp->protocol[protocol].epwrite->bEndpointAddress), usblp->buf, 0, usblp_bulk, usblp); usblp->bidir = (usblp->protocol[protocol].epread != 0); if (usblp->bidir) FILL_BULK_URB(&usblp->readurb, usblp->dev, usb_rcvbulkpipe(usblp->dev, usblp->protocol[protocol].epread->bEndpointAddress), usblp->buf + USBLP_BUF_SIZE, USBLP_BUF_SIZE, usblp_bulk, usblp); usblp->current_protocol = protocol; dbg("usblp%d set protocol %d", usblp->minor, protocol); return 0; }
static int rtl8150_start_xmit(struct sk_buff *skb, struct net_device *netdev) { rtl8150_t *dev; int count, res; netif_stop_queue(netdev); dev = netdev->priv; count = (skb->len < 60) ? 60 : skb->len; count = (count & 0x3f) ? count : count + 1; memcpy(dev->tx_buff, skb->data, skb->len); FILL_BULK_URB(dev->tx_urb, dev->udev, usb_sndbulkpipe(dev->udev, 2), dev->tx_buff, count, write_bulk_callback, dev); dev->tx_urb->transfer_buffer_length = count; if ((res = usb_submit_urb(dev->tx_urb))) { warn("failed tx_urb %d\n", res); dev->stats.tx_errors++; netif_start_queue(netdev); } else { dev->stats.tx_packets++; dev->stats.tx_bytes += skb->len; netdev->trans_start = jiffies; } dev_kfree_skb(skb); return 0; }
static int rtl8150_open(struct net_device *netdev) { rtl8150_t *dev; int res; dev = netdev->priv; if (dev == NULL) { return -ENODEV; } down(&dev->sem); set_registers(dev, IDR, 6, netdev->dev_addr); FILL_BULK_URB(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1), dev->rx_buff, RTL8150_MAX_MTU, read_bulk_callback, dev); if ((res = usb_submit_urb(dev->rx_urb))) warn("%s: rx_urb submit failed: %d", __FUNCTION__, res); FILL_INT_URB(dev->intr_urb, dev->udev, usb_rcvintpipe(dev->udev, 3), dev->intr_buff, sizeof(dev->intr_buff), intr_callback, dev, dev->intr_interval); if ((res = usb_submit_urb(dev->intr_urb))) warn("%s: intr_urb submit failed: %d", __FUNCTION__, res); netif_start_queue(netdev); enable_net_traffic(dev); up(&dev->sem); return res; }
//**************************************************************************** // start and stop functions for CAN data IN and OUT static int pcan_usb_start(struct pcandev *dev) { int err = 0; USB_PORT *u = &dev->port.usb; struct pcan_usb_interface *usb_if = u->usb_if; DPRINTK(KERN_DEBUG "%s: %s(CAN#%d), minor = %d.\n", DEVICE_NAME, __FUNCTION__, u->dev_ctrl_index, dev->nMinor); /* if not, wait for packet on the interface */ if (!atomic_read(&usb_if->read_data.use_count)) { FILL_BULK_URB(&usb_if->read_data, usb_if->usb_dev, usb_rcvbulkpipe(usb_if->usb_dev, usb_if->pipe_read.ucNumber), usb_if->read_buffer_addr[0], usb_if->read_buffer_size, pcan_usb_read_notify, usb_if); // submit urb if ((err = __usb_submit_urb(&usb_if->read_data))) printk(KERN_ERR "%s: %s() can't submit! (%d)\n", DEVICE_NAME, __FUNCTION__, err); else atomic_inc(&usb_if->active_urbs); } return err; }
inline static void mts_int_submit_urb (struct urb* transfer, int pipe, void* data, unsigned length, mts_usb_urb_callback callback ) /* Interrupt context! */ /* Holding transfer->context->lock! */ { int res; MTS_INT_INIT(); FILL_BULK_URB(transfer, context->instance->usb_dev, pipe, data, length, callback, context ); transfer->status = 0; res = usb_submit_urb( transfer ); if ( res ) { MTS_INT_ERROR( "could not submit URB! Error was %d\n",(int)res ); context->srb->result = DID_ERROR << 16; mts_transfer_cleanup(transfer); } return; }
static int CDCEther_start_xmit( struct sk_buff *skb, struct net_device *net ) { ether_dev_t *ether_dev = net->priv; int count; int res; // If we are told to transmit an ethernet frame that fits EXACTLY // into an integer number of USB packets, we force it to send one // more byte so the device will get a runt USB packet signalling the // end of the ethernet frame if ( (skb->len) ^ (ether_dev->data_ep_out_size) ) { // It was not an exact multiple // no need to add anything extra count = skb->len; } else { // Add one to make it NOT an exact multiple count = skb->len + 1; } // Tell the kernel, "No more frames 'til we are done // with this one.' netif_stop_queue( net ); // Copy it from kernel memory to OUR memory memcpy(ether_dev->tx_buff, skb->data, skb->len); // Fill in the URB for shipping it out. FILL_BULK_URB( ðer_dev->tx_urb, ether_dev->usb, usb_sndbulkpipe(ether_dev->usb, ether_dev->data_ep_out), ether_dev->tx_buff, ether_dev->wMaxSegmentSize, write_bulk_callback, ether_dev ); // Tell the URB how much it will be transporting today ether_dev->tx_urb.transfer_buffer_length = count; // Send the URB on its merry way. if ((res = usb_submit_urb(ðer_dev->tx_urb))) { // Hmm... It didn't go. Tell someone... warn("failed tx_urb %d", res); // update some stats... ether_dev->stats.tx_errors++; // and tell the kernel to give us another. // Maybe we'll get it right next time. netif_start_queue( net ); } else { // Okay, it went out. // Update statistics ether_dev->stats.tx_packets++; ether_dev->stats.tx_bytes += skb->len; // And tell the kernel when the last transmit occurred. net->trans_start = jiffies; } // We are done with the kernel's memory dev_kfree_skb(skb); // We are done here. return 0; }
static int ir_open (struct usb_serial_port *port, struct file *filp) { struct usb_serial *serial = port->serial; char *buffer; int result = 0; if (port_paranoia_check (port, __FUNCTION__)) return -ENODEV; dbg(__FUNCTION__ " - port %d", port->number); down (&port->sem); ++port->open_count; MOD_INC_USE_COUNT; if (!port->active) { port->active = 1; if (buffer_size) { /* override the default buffer sizes */ buffer = kmalloc (buffer_size, GFP_KERNEL); if (!buffer) { err (__FUNCTION__ " - out of memory."); return -ENOMEM; } kfree (port->read_urb->transfer_buffer); port->read_urb->transfer_buffer = buffer; port->read_urb->transfer_buffer_length = buffer_size; buffer = kmalloc (buffer_size, GFP_KERNEL); if (!buffer) { err (__FUNCTION__ " - out of memory."); return -ENOMEM; } kfree (port->write_urb->transfer_buffer); port->write_urb->transfer_buffer = buffer; port->write_urb->transfer_buffer_length = buffer_size; port->bulk_out_size = buffer_size; } /* Start reading from the device */ FILL_BULK_URB(port->read_urb, serial->dev, usb_rcvbulkpipe(serial->dev, port->bulk_in_endpointAddress), port->read_urb->transfer_buffer, port->read_urb->transfer_buffer_length, ir_read_bulk_callback, port); result = usb_submit_urb(port->read_urb); if (result) err(__FUNCTION__ " - failed submitting read urb, error %d", result); } up (&port->sem); return result; }
static int generic_write (struct usb_serial_port *port, int from_user, const unsigned char *buf, int count) { struct usb_serial *serial = port->serial; int result; dbg(__FUNCTION__ " - port %d", port->number); if (count == 0) { dbg(__FUNCTION__ " - write request of 0 bytes"); return (0); } /* only do something if we have a bulk out endpoint */ if (serial->num_bulk_out) { if (port->write_urb->status == -EINPROGRESS) { dbg (__FUNCTION__ " - already writing"); return (0); } count = (count > port->bulk_out_size) ? port->bulk_out_size : count; if (from_user) { if (copy_from_user(port->write_urb->transfer_buffer, buf, count)) return -EFAULT; } else { memcpy (port->write_urb->transfer_buffer, buf, count); } usb_serial_debug_data (__FILE__, __FUNCTION__, count, port->write_urb->transfer_buffer); /* set up our urb */ FILL_BULK_URB(port->write_urb, serial->dev, usb_sndbulkpipe(serial->dev, port->bulk_out_endpointAddress), port->write_urb->transfer_buffer, count, ((serial->type->write_bulk_callback) ? serial->type->write_bulk_callback : generic_write_bulk_callback), port); /* send the data out the bulk port */ result = usb_submit_urb(port->write_urb); if (result) err(__FUNCTION__ " - failed submitting write urb, error %d", result); else result = count; return result; } /* no bulk out, so return 0 bytes written */ return (0); }
static int mts_scsi_queuecommand( Scsi_Cmnd *srb, mts_scsi_cmnd_callback callback ) { struct mts_desc* desc = (struct mts_desc*)(srb->host->hostdata[0]); int err = 0; int res; MTS_DEBUG_GOT_HERE(); mts_show_command(srb); mts_debug_dump(desc); if ( srb->device->lun || srb->device->id || srb->device->channel ) { MTS_DEBUG("Command to LUN=%d ID=%d CHANNEL=%d from SCSI layer\n",(int)srb->device->lun,(int)srb->device->id, (int)srb->device->channel ); MTS_DEBUG("this device doesn't exist\n"); srb->result = DID_BAD_TARGET << 16; if(callback) callback(srb); goto out; } FILL_BULK_URB(&desc->urb, desc->usb_dev, usb_sndbulkpipe(desc->usb_dev,desc->ep_out), srb->cmnd, srb->cmd_len, mts_command_done, &desc->context ); mts_build_transfer_context( srb, desc ); desc->context.final_callback = callback; res=usb_submit_urb(&desc->urb); if(res){ MTS_ERROR("error %d submitting URB\n",(int)res); srb->result = DID_ERROR << 16; if(callback) callback(srb); } out: return err; }
static void read_bulk_callback(struct urb *urb) { rtl8150_t *dev; int pkt_len, res; struct sk_buff *skb; struct net_device *netdev; u16 rx_stat; dev = urb->context; if (!dev) { warn("!dev"); return; } netdev = dev->netdev; if (!netif_device_present(netdev)) { warn("netdev is not present"); return; } switch (urb->status) { case 0: break; case -ENOENT: return; case -ETIMEDOUT: warn("need a device reset?.."); goto goon; default: warn("Rx status %d", urb->status); goto goon; } pkt_len = urb->actual_length - 4; rx_stat = le16_to_cpu(*(u16 *) (dev->rx_buff + pkt_len)); if (!(skb = dev_alloc_skb(pkt_len + 2))) goto goon; skb->dev = netdev; skb_reserve(skb, 2); eth_copy_and_sum(skb, dev->rx_buff, pkt_len, 0); skb_put(skb, pkt_len); skb->protocol = eth_type_trans(skb, netdev); netif_rx(skb); dev->stats.rx_packets++; dev->stats.rx_bytes += pkt_len; goon: FILL_BULK_URB(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1), dev->rx_buff, RTL8150_MAX_MTU, read_bulk_callback, dev); if ((res = usb_submit_urb(dev->rx_urb))) warn("%s: Rx urb submission failed %d", netdev->name, res); }
static void generic_read_bulk_callback (struct urb *urb) { struct usb_serial_port *port = (struct usb_serial_port *)urb->context; struct usb_serial *serial = get_usb_serial (port, __FUNCTION__); struct tty_struct *tty; unsigned char *data = urb->transfer_buffer; int i; int result; dbg(__FUNCTION__ " - port %d", port->number); if (!serial) { dbg(__FUNCTION__ " - bad serial pointer, exiting"); return; } if (urb->status) { dbg(__FUNCTION__ " - nonzero read bulk status received: %d", urb->status); return; } usb_serial_debug_data (__FILE__, __FUNCTION__, urb->actual_length, data); tty = port->tty; if (urb->actual_length) { for (i = 0; i < urb->actual_length ; ++i) { /* if we insert more than TTY_FLIPBUF_SIZE characters, we drop them. */ if(tty->flip.count >= TTY_FLIPBUF_SIZE) { tty_flip_buffer_push(tty); } /* this doesn't actually push the data through unless tty->low_latency is set */ tty_insert_flip_char(tty, data[i], 0); } tty_flip_buffer_push(tty); } /* Continue trying to always read */ FILL_BULK_URB(port->read_urb, serial->dev, usb_rcvbulkpipe(serial->dev, port->bulk_in_endpointAddress), port->read_urb->transfer_buffer, port->read_urb->transfer_buffer_length, ((serial->type->read_bulk_callback) ? serial->type->read_bulk_callback : generic_read_bulk_callback), port); result = usb_submit_urb(port->read_urb); if (result) err(__FUNCTION__ " - failed resubmitting read urb, error %d", result); }
void RTusb_fill_bulk_urb (struct urb *pUrb, struct usb_device *pUsb_Dev, unsigned int bulkpipe, void *pTransferBuf, int BufSize, usb_complete_t Complete, void *pContext) { #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0) usb_fill_bulk_urb(pUrb, pUsb_Dev, bulkpipe, pTransferBuf, BufSize, Complete, pContext); #else FILL_BULK_URB(pUrb, pUsb_Dev, bulkpipe, pTransferBuf, BufSize, Complete, pContext); #endif }
/* * This is our function to emulate usb_bulk_msg() but give us enough * access to make aborts/resets work */ static int usb_stor_bulk_msg(UMAS_DATA_T *umas, void *data, int pipe, uint32_t len, uint32_t *act_len) { URB_T *urb = umas->current_urb; volatile int t0; int status; /* fill the URB */ FILL_BULK_URB(urb, umas->pusb_dev, pipe, data, len, usb_stor_blocking_completion, NULL); urb->actual_length = 0; urb->error_count = 0; urb->transfer_flags = USB_ASYNC_UNLINK; _UmasUrbComplete = 0; /* submit the URB */ status = USBH_SubmitUrb(urb); if(status) return status; #if 1 for(t0 = 0; t0 < 0x1000000; t0++) { if(is_urb_completed()) break; } if(t0 >= 0x8000000) #else t0 = umas_get_ticks(); while(umas_get_ticks() - t0 < 500) { if(is_urb_completed()) break; } if(umas_get_ticks() - t0 >= 500) #endif { UMAS_DEBUG("usb_stor_bulk_msg time-out failed!\n"); return USB_ERR_TIMEOUT; } /* return the actual length of the data transferred */ *act_len = urb->actual_length; return urb->status; }
/***************************************************************************** * generic devices specific driver functions *****************************************************************************/ static int generic_open (struct usb_serial_port *port, struct file *filp) { struct usb_serial *serial = port->serial; int result = 0; if (port_paranoia_check (port, __FUNCTION__)) return -ENODEV; /* only increment our usage count, if this device is _really_ a generic device */ if_generic_do(MOD_INC_USE_COUNT); dbg(__FUNCTION__ " - port %d", port->number); down (&port->sem); ++port->open_count; if (!port->active) { port->active = 1; /* force low_latency on so that our tty_push actually forces the data through, otherwise it is scheduled, and with high data rates (like with OHCI) data can get lost. */ port->tty->low_latency = 1; /* if we have a bulk interrupt, start reading from it */ if (serial->num_bulk_in) { /* Start reading from the device */ FILL_BULK_URB(port->read_urb, serial->dev, usb_rcvbulkpipe(serial->dev, port->bulk_in_endpointAddress), port->read_urb->transfer_buffer, port->read_urb->transfer_buffer_length, ((serial->type->read_bulk_callback) ? serial->type->read_bulk_callback : generic_read_bulk_callback), port); result = usb_submit_urb(port->read_urb); if (result) err(__FUNCTION__ " - failed resubmitting read urb, error %d", result); } } up (&port->sem); return result; }
static int rtl8150_open(struct net_device *netdev) { rtl8150_t *dev; int res; dev = netdev->priv; if (dev == NULL) { return -ENODEV; } down(&dev->sem); set_registers(dev, IDR, 6, netdev->dev_addr); FILL_BULK_URB(dev->rx_urb, dev->udev, usb_rcvbulkpipe(dev->udev, 1), dev->rx_buff, RTL8150_MAX_MTU, read_bulk_callback, dev); if ((res = usb_submit_urb(dev->rx_urb))) warn("%s: rx_urb submit failed: %d", __FUNCTION__, res); FILL_INT_URB(dev->intr_urb, dev->udev, usb_rcvintpipe(dev->udev, 3), dev->intr_buff, sizeof(dev->intr_buff), intr_callback, dev, dev->intr_interval); if ((res = usb_submit_urb(dev->intr_urb))) warn("%s: intr_urb submit failed: %d", __FUNCTION__, res); netif_start_queue(netdev); enable_net_traffic(dev); up(&dev->sem); #ifdef CONFIG_RTL865XB_3G { if (0!=reCore_registerWANDevice(netdev)) printk("XXX Can't register wan device\n"); if(0!=devglue_regExtDevice(netdev->name, 8, CONFIG_RTL865XB_3G_PORT, &myLinkID2)) printk("XXX Can't register a link ID for device %s on extPort 0x%x!!!\n", netdev->name,CONFIG_RTL865XB_3G_PORT ); else printk("Device %s on vlan ID %d using Link ID %d. Loopback/Ext port is %d\n", netdev->name, 8, myLinkID2, CONFIG_RTL865XB_3G_PORT); } #endif return res; }
/* This is our function to emulate usb_bulk_msg() but give us enough * access to make aborts/resets work */ int usb_stor_bulk_msg(struct us_data *us, void *data, int pipe, unsigned int len, unsigned int *act_len) { struct completion urb_done; int status; /* set up data structures for the wakeup system */ init_completion(&urb_done); /* lock the URB */ down(&(us->current_urb_sem)); /* fill the URB */ FILL_BULK_URB(us->current_urb, us->pusb_dev, pipe, data, len, usb_stor_blocking_completion, &urb_done); us->current_urb->actual_length = 0; us->current_urb->error_count = 0; us->current_urb->transfer_flags = USB_ASYNC_UNLINK; /* submit the URB */ status = usb_submit_urb(us->current_urb); if (status) { /* something went wrong */ up(&(us->current_urb_sem)); return status; } /* wait for the completion of the URB */ up(&(us->current_urb_sem)); wait_for_completion(&urb_done); down(&(us->current_urb_sem)); /* return the actual length of the data transferred */ *act_len = us->current_urb->actual_length; /* release the lock and return status */ up(&(us->current_urb_sem)); return us->current_urb->status; }
static int hci_usb_write_msg(struct hci_usb *husb, struct sk_buff *skb) { struct urb *urb = husb->write_urb; int pipe, status; DBG("%s len %d", husb->hdev.name, skb->len); pipe = usb_sndbulkpipe(husb->udev, husb->bulk_out_ep_addr); FILL_BULK_URB(urb, husb->udev, pipe, skb->data, skb->len, hci_usb_bulk_write, skb); urb->transfer_flags |= USB_QUEUE_BULK; if ((status = usb_submit_urb(urb))) { DBG("%s write URB submit failed %d", husb->hdev.name, status); return status; } return 0; }
static void ir_read_bulk_callback (struct urb *urb) { struct usb_serial_port *port = (struct usb_serial_port *)urb->context; struct usb_serial *serial = get_usb_serial (port, __FUNCTION__); struct tty_struct *tty; unsigned char *data = urb->transfer_buffer; int result; if (port_paranoia_check (port, __FUNCTION__)) return; dbg(__FUNCTION__ " - port %d", port->number); if (!serial) { dbg(__FUNCTION__ " - bad serial pointer, exiting"); return; } if (urb->status) { dbg(__FUNCTION__ " - nonzero read bulk status received: %d", urb->status); return; } usb_serial_debug_data (__FILE__, __FUNCTION__, urb->actual_length, data); /* Bypass flip-buffers, and feed the ldisc directly due to our * potentally large buffer size. Since we used to set low_latency, * this is exactly what the tty layer did anyway :) */ tty = port->tty; tty->ldisc.receive_buf(tty, data+1, NULL, urb->actual_length-1); /* Continue trying to always read */ FILL_BULK_URB(port->read_urb, serial->dev, usb_rcvbulkpipe(serial->dev, port->bulk_in_endpointAddress), port->read_urb->transfer_buffer, port->read_urb->transfer_buffer_length, ir_read_bulk_callback, port); result = usb_submit_urb(port->read_urb); if (result) err(__FUNCTION__ " - failed resubmitting read urb, error %d", result); return; }
inline static void mts_int_submit_urb (struct urb* transfer, int pipe, void* data, unsigned length, mts_usb_urb_callback callback ) /* Interrupt context! */ /* Holding transfer->context->lock! */ { int res; struct mts_transfer_context* context; MTS_INT_INIT(); FILL_BULK_URB(transfer, context->instance->usb_dev, pipe, data, length, callback, context ); /* transfer->transfer_flags = USB_DISABLE_SPD;*/ transfer->transfer_flags = USB_ASYNC_UNLINK; transfer->status = 0; transfer->timeout = 100; res = usb_submit_urb( transfer ); if ( res ) { MTS_INT_ERROR( "could not submit URB! Error was %d\n",(int)res ); context->srb->result = DID_ERROR << 16; context->state = mts_con_error; mts_transfer_cleanup(transfer); } return; }
static int CDCEther_open(struct net_device *net) { ether_dev_t *ether_dev = (ether_dev_t *)net->priv; int res; // We are finally getting used! MOD_INC_USE_COUNT; // Turn on the USB and let the packets flow!!! if ( (res = enable_net_traffic( ether_dev )) ) { err( __FUNCTION__ "can't enable_net_traffic() - %d", res ); MOD_DEC_USE_COUNT; return -EIO; } // Prep a receive URB FILL_BULK_URB( ðer_dev->rx_urb, ether_dev->usb, usb_rcvbulkpipe(ether_dev->usb, ether_dev->data_ep_in), ether_dev->rx_buff, ether_dev->wMaxSegmentSize, read_bulk_callback, ether_dev ); // Put it out there so the device can send us stuff if ( (res = usb_submit_urb(ðer_dev->rx_urb)) ) { // Hmm... Okay... warn( __FUNCTION__ " failed rx_urb %d", res ); } // Tell the kernel we are ready to start receiving from it netif_start_queue( net ); // We are up and running. ether_dev->flags |= CDC_ETHER_RUNNING; // Let's get ready to move frames!!! return 0; }
/****************************************************************************** * Empeg specific driver functions ******************************************************************************/ static int empeg_open (struct usb_serial_port *port, struct file *filp) { struct usb_serial *serial = port->serial; int result = 0;; if (port_paranoia_check (port, __FUNCTION__)) return -ENODEV; dbg("%s - port %d", __FUNCTION__, port->number); /* Force default termio settings */ empeg_set_termios (port, NULL) ; bytes_in = 0; bytes_out = 0; /* Start reading from the device */ FILL_BULK_URB( port->read_urb, serial->dev, usb_rcvbulkpipe(serial->dev, port->bulk_in_endpointAddress), port->read_urb->transfer_buffer, port->read_urb->transfer_buffer_length, empeg_read_bulk_callback, port); port->read_urb->transfer_flags |= USB_QUEUE_BULK; result = usb_submit_urb(port->read_urb); if (result) err("%s - failed submitting read urb, error %d", __FUNCTION__, result); return result; }
static void *usblp_probe(struct usb_device *dev, unsigned int ifnum) { struct usb_interface_descriptor *interface; struct usb_endpoint_descriptor *epread, *epwrite; struct usblp *usblp; int minor, i, alts = -1, bidir = 0; int length, err; char *buf; for (i = 0; i < dev->actconfig->interface[ifnum].num_altsetting; i++) { interface = &dev->actconfig->interface[ifnum].altsetting[i]; if (interface->bInterfaceClass != 7 || interface->bInterfaceSubClass != 1 || interface->bInterfaceProtocol < 1 || interface->bInterfaceProtocol > 3 || (interface->bInterfaceProtocol > 1 && interface->bNumEndpoints < 2)) continue; if (alts == -1) alts = i; if (!bidir && interface->bInterfaceProtocol > 1) { bidir = 1; alts = i; } } if (alts == -1) return NULL; interface = &dev->actconfig->interface[ifnum].altsetting[alts]; if (usb_set_interface(dev, ifnum, alts)) err("can't set desired altsetting %d on interface %d", alts, ifnum); epwrite = interface->endpoint + 0; epread = bidir ? interface->endpoint + 1 : NULL; if ((epwrite->bEndpointAddress & 0x80) == 0x80) { if (interface->bNumEndpoints == 1) return NULL; epwrite = interface->endpoint + 1; epread = bidir ? interface->endpoint + 0 : NULL; } if ((epwrite->bEndpointAddress & 0x80) == 0x80) return NULL; if (bidir && (epread->bEndpointAddress & 0x80) != 0x80) return NULL; for (minor = 0; minor < USBLP_MINORS && usblp_table[minor]; minor++); if (usblp_table[minor]) { err("no more free usblp devices"); return NULL; } if (!(usblp = kmalloc(sizeof(struct usblp), GFP_KERNEL))) { err("out of memory"); return NULL; } memset(usblp, 0, sizeof(struct usblp)); usblp->dev = dev; usblp->ifnum = ifnum; usblp->minor = minor; usblp->bidir = bidir; init_waitqueue_head(&usblp->wait); if (!(buf = kmalloc(USBLP_BUF_SIZE * (bidir ? 2 : 1), GFP_KERNEL))) { err("out of memory"); kfree(usblp); return NULL; } if (!(usblp->device_id_string = kmalloc(DEVICE_ID_SIZE, GFP_KERNEL))) { err("out of memory"); kfree(usblp); kfree(buf); return NULL; } FILL_BULK_URB(&usblp->writeurb, dev, usb_sndbulkpipe(dev, epwrite->bEndpointAddress), buf, 0, usblp_bulk, usblp); if (bidir) FILL_BULK_URB(&usblp->readurb, dev, usb_rcvbulkpipe(dev, epread->bEndpointAddress), buf + USBLP_BUF_SIZE, USBLP_BUF_SIZE, usblp_bulk, usblp); /* Get the device_id string if possible. FIXME: Could make this kmalloc(length). */ err = usblp_get_id(usblp, 0, usblp->device_id_string, DEVICE_ID_SIZE - 1); if (err >= 0) { length = (usblp->device_id_string[0] << 8) + usblp->device_id_string[1]; /* big-endian */ if (length < DEVICE_ID_SIZE) usblp->device_id_string[length] = '\0'; else usblp->device_id_string[DEVICE_ID_SIZE - 1] = '\0'; dbg ("usblp%d Device ID string [%d]=%s", minor, length, &usblp->device_id_string[2]); } else { err ("usblp%d: error = %d reading IEEE-1284 Device ID string", minor, err); usblp->device_id_string[0] = usblp->device_id_string[1] = '\0'; } #ifdef DEBUG usblp_check_status(usblp); #endif info("usblp%d: USB %sdirectional printer dev %d if %d alt %d", minor, bidir ? "Bi" : "Uni", dev->devnum, ifnum, alts); return usblp_table[minor] = usblp; }
static void * usb_hpna_probe( struct usb_device *dev, unsigned int ifnum ) { // struct net_device *net_dev; struct device *net_dev; usb_hpna_t *hpna = &usb_dev_hpna; #ifdef PEGASUS_PRINT_PRODUCT_NAME int dev_index; #endif spinlock_t xxx = { }; #ifdef PEGASUS_PRINT_PRODUCT_NAME /* XXX */ if ( (dev_index = match_product(dev->descriptor.idVendor, dev->descriptor.idProduct)) == -1 ) { return NULL; } printk("USB Ethernet(Pegasus) %s found\n", product_list[dev_index].name); #else if ( dev->descriptor.idVendor != ADMTEK_VENDOR_ID || dev->descriptor.idProduct != ADMTEK_HPNA_PEGASUS ) { return NULL; } printk("USB HPNA Pegasus found\n"); #endif if ( usb_set_configuration(dev, dev->config[0].bConfigurationValue)) { err("usb_set_configuration() failed"); return NULL; } hpna->usb_dev = dev; hpna->rx_pipe = usb_rcvbulkpipe(hpna->usb_dev, 1); hpna->tx_pipe = usb_sndbulkpipe(hpna->usb_dev, 2); hpna->intr_pipe = usb_rcvintpipe(hpna->usb_dev, 0); if ( reset_mac(dev) ) { err("can't reset MAC"); } hpna->present = 1; if(!(hpna->rx_buff=kmalloc(MAX_MTU, GFP_KERNEL))) { err("not enough mem for out buff"); return NULL; } if(!(hpna->tx_buff=kmalloc(MAX_MTU, GFP_KERNEL))) { kfree_s(hpna->rx_buff, MAX_MTU); err("not enough mem for out buff"); return NULL; } net_dev = init_etherdev( 0, 0 ); hpna->net_dev = net_dev; net_dev->priv = hpna; net_dev->open = hpna_open; net_dev->stop = hpna_close; // net_dev->watchdog_timeo = TX_TIMEOUT; // net_dev->tx_timeout = tx_timeout; net_dev->do_ioctl = hpna_ioctl; net_dev->hard_start_xmit = hpna_start_xmit; net_dev->set_multicast_list = set_rx_mode; net_dev->get_stats = hpna_netdev_stats; net_dev->mtu = HPNA_MTU; #if 1 { /* * to support dhcp client daemon(dhcpcd), it needs to get HW address * in probe routine. */ struct usb_device *usb_dev = hpna->usb_dev; __u8 node_id[6]; if ( get_node_id(usb_dev, node_id) ) { printk("USB Pegasus can't get HW address in probe routine.\n"); printk("But Pegasus will re-try in open routine.\n"); goto next; } hpna_set_registers(usb_dev, 0x10, 6, node_id); memcpy(net_dev->dev_addr, node_id, 6); } next: #endif hpna->hpna_lock = xxx; //SPIN_LOCK_UNLOCKED; FILL_BULK_URB( &hpna->rx_urb, hpna->usb_dev, hpna->rx_pipe, hpna->rx_buff, MAX_MTU, hpna_read_irq, net_dev ); FILL_BULK_URB( &hpna->tx_urb, hpna->usb_dev, hpna->tx_pipe, hpna->tx_buff, MAX_MTU, hpna_write_irq, net_dev ); FILL_INT_URB( &hpna->intr_urb, hpna->usb_dev, hpna->intr_pipe, hpna->intr_buff, 8, hpna_irq, net_dev, 250 ); /* list_add( &hpna->list, &hpna_list );*/ return net_dev; }
static int visor_write (struct usb_serial_port *port, int from_user, const unsigned char *buf, int count) { struct usb_serial *serial = port->serial; struct urb *urb; const unsigned char *current_position = buf; unsigned long flags; int status; int i; int bytes_sent = 0; int transfer_size; dbg("%s - port %d", __FUNCTION__, port->number); while (count > 0) { /* try to find a free urb in our list of them */ urb = NULL; spin_lock_irqsave (&write_urb_pool_lock, flags); for (i = 0; i < NUM_URBS; ++i) { if (write_urb_pool[i]->status != -EINPROGRESS) { urb = write_urb_pool[i]; break; } } spin_unlock_irqrestore (&write_urb_pool_lock, flags); if (urb == NULL) { dbg("%s - no more free urbs", __FUNCTION__); goto exit; } if (urb->transfer_buffer == NULL) { urb->transfer_buffer = kmalloc (URB_TRANSFER_BUFFER_SIZE, GFP_KERNEL); if (urb->transfer_buffer == NULL) { err("%s no more kernel memory...", __FUNCTION__); goto exit; } } transfer_size = min (count, URB_TRANSFER_BUFFER_SIZE); if (from_user) { if (copy_from_user (urb->transfer_buffer, current_position, transfer_size)) { bytes_sent = -EFAULT; break; } } else { memcpy (urb->transfer_buffer, current_position, transfer_size); } usb_serial_debug_data (__FILE__, __FUNCTION__, transfer_size, urb->transfer_buffer); /* build up our urb */ FILL_BULK_URB (urb, serial->dev, usb_sndbulkpipe(serial->dev, port->bulk_out_endpointAddress), urb->transfer_buffer, transfer_size, visor_write_bulk_callback, port); urb->transfer_flags |= USB_QUEUE_BULK; /* send it down the pipe */ status = usb_submit_urb(urb); if (status) { err("%s - usb_submit_urb(write bulk) failed with status = %d", __FUNCTION__, status); bytes_sent = status; break; } current_position += transfer_size; bytes_sent += transfer_size; count -= transfer_size; bytes_out += transfer_size; } exit: return bytes_sent; }
static void read_bulk_callback( struct urb *urb ) { ether_dev_t *ether_dev = urb->context; struct net_device *net; int count = urb->actual_length, res; struct sk_buff *skb; // Sanity check if ( !ether_dev || !(ether_dev->flags & CDC_ETHER_RUNNING) ) { dbg("BULK IN callback but driver is not active!"); return; } net = ether_dev->net; if ( !netif_device_present(net) ) { // Somebody killed our network interface... return; } if ( ether_dev->flags & CDC_ETHER_RX_BUSY ) { // Are we already trying to receive a frame??? ether_dev->stats.rx_errors++; dbg("ether_dev Rx busy"); return; } // We are busy, leave us alone! ether_dev->flags |= CDC_ETHER_RX_BUSY; switch ( urb->status ) { case USB_ST_NOERROR: break; case USB_ST_NORESPONSE: dbg( "no repsonse in BULK IN" ); ether_dev->flags &= ~CDC_ETHER_RX_BUSY; break; default: dbg( "%s: RX status %d", net->name, urb->status ); goto goon; } // Check to make sure we got some data... if ( !count ) { // We got no data!!! goto goon; } // Tell the kernel we want some memory if ( !(skb = dev_alloc_skb(count)) ) { // We got no receive buffer. goto goon; } // Here's where it came from skb->dev = net; // Now we copy it over eth_copy_and_sum(skb, ether_dev->rx_buff, count, 0); // Not sure skb_put(skb, count); // Not sure here either skb->protocol = eth_type_trans(skb, net); // Ship it off to the kernel netif_rx(skb); // update out statistics ether_dev->stats.rx_packets++; ether_dev->stats.rx_bytes += count; goon: // Prep the USB to wait for another frame FILL_BULK_URB( ðer_dev->rx_urb, ether_dev->usb, usb_rcvbulkpipe(ether_dev->usb, ether_dev->data_ep_in), ether_dev->rx_buff, ether_dev->wMaxSegmentSize, read_bulk_callback, ether_dev ); // Give this to the USB subsystem so it can tell us // when more data arrives. if ( (res = usb_submit_urb(ðer_dev->rx_urb)) ) { warn( __FUNCTION__ " failed submint rx_urb %d", res); } // We are no longer busy, show us the frames!!! ether_dev->flags &= ~CDC_ETHER_RX_BUSY; }
/** * skel_write */ static ssize_t skel_write (struct file *file, const char *buffer, size_t count, loff_t *ppos) { struct usb_skel *dev; ssize_t bytes_written = 0; int retval = 0; dev = (struct usb_skel *)file->private_data; dbg(__FUNCTION__ " - minor %d, count = %d", dev->minor, count); /* lock this object */ down (&dev->sem); /* verify that the device wasn't unplugged */ if (dev->udev == NULL) { retval = -ENODEV; goto exit; } /* verify that we actually have some data to write */ if (count == 0) { dbg(__FUNCTION__ " - write request of 0 bytes"); goto exit; } /* see if we are already in the middle of a write */ if (dev->write_urb->status == -EINPROGRESS) { dbg (__FUNCTION__ " - already writing"); goto exit; } /* we can only write as much as 1 urb will hold */ bytes_written = (count > dev->bulk_out_size) ? dev->bulk_out_size : count; /* copy the data from userspace into our urb */ if (copy_from_user(dev->write_urb->transfer_buffer, buffer, bytes_written)) { retval = -EFAULT; goto exit; } usb_skel_debug_data (__FUNCTION__, bytes_written, dev->write_urb->transfer_buffer); /* set up our urb */ FILL_BULK_URB(dev->write_urb, dev->udev, usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr), dev->write_urb->transfer_buffer, bytes_written, skel_write_bulk_callback, dev); /* send the data out the bulk port */ retval = usb_submit_urb(dev->write_urb); if (retval) { err(__FUNCTION__ " - failed submitting write urb, error %d", retval); } else { retval = bytes_written; } exit: /* unlock the device */ up (&dev->sem); return retval; }
static void * hci_usb_probe(struct usb_device *udev, unsigned int ifnum, const struct usb_device_id *id) { struct usb_endpoint_descriptor *bulk_out_ep, *intr_in_ep, *bulk_in_ep; struct usb_interface_descriptor *uif; struct usb_endpoint_descriptor *ep; struct hci_usb *husb; struct hci_dev *hdev; int i, size, pipe; __u8 * buf; DBG("udev %p ifnum %d", udev, ifnum); /* Check device signature */ if ((udev->descriptor.bDeviceClass != HCI_DEV_CLASS) || (udev->descriptor.bDeviceSubClass != HCI_DEV_SUBCLASS)|| (udev->descriptor.bDeviceProtocol != HCI_DEV_PROTOCOL) ) return NULL; MOD_INC_USE_COUNT; uif = &udev->actconfig->interface[ifnum].altsetting[0]; if (uif->bNumEndpoints != 3) { DBG("Wrong number of endpoints %d", uif->bNumEndpoints); MOD_DEC_USE_COUNT; return NULL; } bulk_out_ep = intr_in_ep = bulk_in_ep = NULL; /* Find endpoints that we need */ for ( i = 0; i < uif->bNumEndpoints; ++i) { ep = &uif->endpoint[i]; switch (ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) { case USB_ENDPOINT_XFER_BULK: if (ep->bEndpointAddress & USB_DIR_IN) bulk_in_ep = ep; else bulk_out_ep = ep; break; case USB_ENDPOINT_XFER_INT: intr_in_ep = ep; break; }; } if (!bulk_in_ep || !bulk_out_ep || !intr_in_ep) { DBG("Endpoints not found: %p %p %p", bulk_in_ep, bulk_out_ep, intr_in_ep); MOD_DEC_USE_COUNT; return NULL; } if (!(husb = kmalloc(sizeof(struct hci_usb), GFP_KERNEL))) { ERR("Can't allocate: control structure"); MOD_DEC_USE_COUNT; return NULL; } memset(husb, 0, sizeof(struct hci_usb)); husb->udev = udev; husb->bulk_out_ep_addr = bulk_out_ep->bEndpointAddress; if (!(husb->ctrl_urb = usb_alloc_urb(0))) { ERR("Can't allocate: control URB"); goto probe_error; } if (!(husb->write_urb = usb_alloc_urb(0))) { ERR("Can't allocate: write URB"); goto probe_error; } if (!(husb->read_urb = usb_alloc_urb(0))) { ERR("Can't allocate: read URB"); goto probe_error; } ep = bulk_in_ep; pipe = usb_rcvbulkpipe(udev, ep->bEndpointAddress); size = HCI_MAX_FRAME_SIZE; if (!(buf = kmalloc(size, GFP_KERNEL))) { ERR("Can't allocate: read buffer"); goto probe_error; } FILL_BULK_URB(husb->read_urb, udev, pipe, buf, size, hci_usb_bulk_read, husb); husb->read_urb->transfer_flags |= USB_QUEUE_BULK; ep = intr_in_ep; pipe = usb_rcvintpipe(udev, ep->bEndpointAddress); size = usb_maxpacket(udev, pipe, usb_pipeout(pipe)); if (!(husb->intr_urb = usb_alloc_urb(0))) { ERR("Can't allocate: interrupt URB"); goto probe_error; } if (!(buf = kmalloc(size, GFP_KERNEL))) { ERR("Can't allocate: interrupt buffer"); goto probe_error; } FILL_INT_URB(husb->intr_urb, udev, pipe, buf, size, hci_usb_intr, husb, ep->bInterval); skb_queue_head_init(&husb->tx_ctrl_q); skb_queue_head_init(&husb->tx_write_q); /* Initialize and register HCI device */ hdev = &husb->hdev; hdev->type = HCI_USB; hdev->driver_data = husb; hdev->open = hci_usb_open; hdev->close = hci_usb_close; hdev->flush = hci_usb_flush; hdev->send = hci_usb_send_frame; if (hci_register_dev(hdev) < 0) { ERR("Can't register HCI device %s", hdev->name); goto probe_error; } return husb; probe_error: hci_usb_free_bufs(husb); kfree(husb); MOD_DEC_USE_COUNT; return NULL; }
/* * Callback to search the Mustek MDC800 on the USB Bus */ static void* mdc800_usb_probe (struct usb_device *dev ,unsigned int ifnum, const struct usb_device_id *id) { int i,j; struct usb_interface_descriptor *intf_desc; int irq_interval=0; dbg ("(mdc800_usb_probe) called."); if (mdc800->dev != 0) { warn ("only one Mustek MDC800 is supported."); return 0; } if (dev->descriptor.bNumConfigurations != 1) { err ("probe fails -> wrong Number of Configuration"); return 0; } intf_desc=&dev->actconfig->interface[ifnum].altsetting[0]; if ( ( intf_desc->bInterfaceClass != 0xff ) || ( intf_desc->bInterfaceSubClass != 0 ) || ( intf_desc->bInterfaceProtocol != 0 ) || ( intf_desc->bNumEndpoints != 4) ) { err ("probe fails -> wrong Interface"); return 0; } /* Check the Endpoints */ for (i=0; i<4; i++) { mdc800->endpoint[i]=-1; for (j=0; j<4; j++) { if (mdc800_endpoint_equals (&intf_desc->endpoint [j],&mdc800_ed [i])) { mdc800->endpoint[i]=intf_desc->endpoint [j].bEndpointAddress ; if (i==1) { irq_interval=intf_desc->endpoint [j].bInterval; } continue; } } if (mdc800->endpoint[i] == -1) { err ("probe fails -> Wrong Endpoints."); return 0; } } usb_driver_claim_interface (&mdc800_usb_driver, &dev->actconfig->interface[ifnum], mdc800); if (usb_set_interface (dev, ifnum, 0) < 0) { err ("MDC800 Configuration fails."); return 0; } info ("Found Mustek MDC800 on USB."); down (&mdc800->io_lock); mdc800->dev=dev; mdc800->open=0; /* Setup URB Structs */ FILL_INT_URB ( mdc800->irq_urb, mdc800->dev, usb_rcvintpipe (mdc800->dev,mdc800->endpoint [1]), mdc800->irq_urb_buffer, 8, mdc800_usb_irq, mdc800, irq_interval ); FILL_BULK_URB ( mdc800->write_urb, mdc800->dev, usb_sndbulkpipe (mdc800->dev, mdc800->endpoint[0]), mdc800->write_urb_buffer, 8, mdc800_usb_write_notify, mdc800 ); FILL_BULK_URB ( mdc800->download_urb, mdc800->dev, usb_rcvbulkpipe (mdc800->dev, mdc800->endpoint [3]), mdc800->download_urb_buffer, 64, mdc800_usb_download_notify, mdc800 ); mdc800->state=READY; up (&mdc800->io_lock); return mdc800; }
/** * skel_probe * * Called by the usb core when a new device is connected that it thinks * this driver might be interested in. */ static void * skel_probe(struct usb_device *udev, unsigned int ifnum, const struct usb_device_id *id) { struct usb_skel *dev = NULL; struct usb_interface *interface; struct usb_interface_descriptor *iface_desc; struct usb_endpoint_descriptor *endpoint; int minor; int buffer_size; int i; char name[10]; /* See if the device offered us matches what we can accept */ if ((udev->descriptor.idVendor != USB_SKEL_VENDOR_ID) || (udev->descriptor.idProduct != USB_SKEL_PRODUCT_ID)) { return NULL; } /* select a "subminor" number (part of a minor number) */ down (&minor_table_mutex); for (minor = 0; minor < MAX_DEVICES; ++minor) { if (minor_table[minor] == NULL) break; } if (minor >= MAX_DEVICES) { info ("Too many devices plugged in, can not handle this device."); goto exit; } /* allocate memory for our device state and intialize it */ dev = kmalloc (sizeof(struct usb_skel), GFP_KERNEL); if (dev == NULL) { err ("Out of memory"); goto exit; } memset (dev, 0x00, sizeof (*dev)); minor_table[minor] = dev; interface = &udev->actconfig->interface[ifnum]; init_MUTEX (&dev->sem); dev->udev = udev; dev->interface = interface; dev->minor = minor; /* set up the endpoint information */ /* check out the endpoints */ iface_desc = &interface->altsetting[0]; for (i = 0; i < iface_desc->bNumEndpoints; ++i) { endpoint = &iface_desc->endpoint[i]; if ((endpoint->bEndpointAddress & 0x80) && ((endpoint->bmAttributes & 3) == 0x02)) { /* we found a bulk in endpoint */ buffer_size = endpoint->wMaxPacketSize; dev->bulk_in_size = buffer_size; dev->bulk_in_endpointAddr = endpoint->bEndpointAddress; dev->bulk_in_buffer = kmalloc (buffer_size, GFP_KERNEL); if (!dev->bulk_in_buffer) { err("Couldn't allocate bulk_in_buffer"); goto error; } } if (((endpoint->bEndpointAddress & 0x80) == 0x00) && ((endpoint->bmAttributes & 3) == 0x02)) { /* we found a bulk out endpoint */ dev->write_urb = usb_alloc_urb(0); if (!dev->write_urb) { err("No free urbs available"); goto error; } buffer_size = endpoint->wMaxPacketSize; dev->bulk_out_size = buffer_size; dev->bulk_out_endpointAddr = endpoint->bEndpointAddress; dev->bulk_out_buffer = kmalloc (buffer_size, GFP_KERNEL); if (!dev->bulk_out_buffer) { err("Couldn't allocate bulk_out_buffer"); goto error; } FILL_BULK_URB(dev->write_urb, udev, usb_sndbulkpipe(udev, endpoint->bEndpointAddress), dev->bulk_out_buffer, buffer_size, skel_write_bulk_callback, dev); } } /* initialize the devfs node for this device and register it */ sprintf(name, "skel%d", dev->minor); dev->devfs = devfs_register (usb_devfs_handle, name, DEVFS_FL_DEFAULT, USB_MAJOR, USB_SKEL_MINOR_BASE + dev->minor, S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH, &skel_fops, NULL); /* let the user know what node this device is now attached to */ info ("USB Skeleton device now attached to USBSkel%d", dev->minor); goto exit; error: skel_delete (dev); dev = NULL; exit: up (&minor_table_mutex); return dev; }
static void *usblp_probe(struct usb_device *dev, unsigned int ifnum, const struct usb_device_id *id) { struct usb_interface_descriptor *interface; struct usb_endpoint_descriptor *epread, *epwrite; struct usblp *usblp; int minor, i, bidir = 0, quirks; int alts = dev->actconfig->interface[ifnum].act_altsetting; int length, err; char *buf; char name[6]; /* If a bidirectional interface exists, use it. */ for (i = 0; i < dev->actconfig->interface[ifnum].num_altsetting; i++) { interface = &dev->actconfig->interface[ifnum].altsetting[i]; if (interface->bInterfaceClass != 7 || interface->bInterfaceSubClass != 1 || interface->bInterfaceProtocol < 1 || interface->bInterfaceProtocol > 3 || (interface->bInterfaceProtocol > 1 && interface->bNumEndpoints < 2)) continue; if (interface->bInterfaceProtocol > 1) { bidir = 1; alts = i; break; } } interface = &dev->actconfig->interface[ifnum].altsetting[alts]; if (usb_set_interface(dev, ifnum, alts)) err("can't set desired altsetting %d on interface %d", alts, ifnum); epwrite = interface->endpoint + 0; epread = bidir ? interface->endpoint + 1 : NULL; if ((epwrite->bEndpointAddress & 0x80) == 0x80) { if (interface->bNumEndpoints == 1) return NULL; epwrite = interface->endpoint + 1; epread = bidir ? interface->endpoint + 0 : NULL; } if ((epwrite->bEndpointAddress & 0x80) == 0x80) return NULL; if (bidir && (epread->bEndpointAddress & 0x80) != 0x80) return NULL; for (minor = 0; minor < USBLP_MINORS && usblp_table[minor]; minor++); if (usblp_table[minor]) { err("no more free usblp devices"); return NULL; } if (!(usblp = kmalloc(sizeof(struct usblp), GFP_KERNEL))) { err("out of memory"); return NULL; } memset(usblp, 0, sizeof(struct usblp)); init_MUTEX (&usblp->sem); /* lookup quirks for this printer */ quirks = usblp_quirks(dev->descriptor.idVendor, dev->descriptor.idProduct); if (bidir && (quirks & USBLP_QUIRK_BIDIR)) { bidir = 0; epread = NULL; info ("Disabling reads from problem bidirectional printer on usblp%d", minor); } usblp->dev = dev; usblp->ifnum = ifnum; usblp->minor = minor; usblp->bidir = bidir; usblp->quirks = quirks; init_waitqueue_head(&usblp->wait); if (!(buf = kmalloc(USBLP_BUF_SIZE * (bidir ? 2 : 1), GFP_KERNEL))) { err("out of memory"); kfree(usblp); return NULL; } if (!(usblp->device_id_string = kmalloc(DEVICE_ID_SIZE, GFP_KERNEL))) { err("out of memory"); kfree(usblp); kfree(buf); return NULL; } FILL_BULK_URB(&usblp->writeurb, dev, usb_sndbulkpipe(dev, epwrite->bEndpointAddress), buf, 0, usblp_bulk, usblp); if (bidir) FILL_BULK_URB(&usblp->readurb, dev, usb_rcvbulkpipe(dev, epread->bEndpointAddress), buf + USBLP_BUF_SIZE, USBLP_BUF_SIZE, usblp_bulk, usblp); /* Get the device_id string if possible. FIXME: Could make this kmalloc(length). */ err = usblp_get_id(usblp, 0, usblp->device_id_string, DEVICE_ID_SIZE - 1); if (err >= 0) { length = (usblp->device_id_string[0] << 8) + usblp->device_id_string[1]; /* big-endian */ if (length < DEVICE_ID_SIZE) usblp->device_id_string[length] = '\0'; else usblp->device_id_string[DEVICE_ID_SIZE - 1] = '\0'; dbg ("usblp%d Device ID string [%d]=%s", minor, length, &usblp->device_id_string[2]); } else { err ("usblp%d: error = %d reading IEEE-1284 Device ID string", minor, err); usblp->device_id_string[0] = usblp->device_id_string[1] = '\0'; } #ifdef DEBUG usblp_check_status(usblp, 0); #endif sprintf(name, "lp%d", minor); /* if we have devfs, create with perms=660 */ usblp->devfs = devfs_register(usb_devfs_handle, name, DEVFS_FL_DEFAULT, USB_MAJOR, USBLP_MINOR_BASE + minor, S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP, &usblp_fops, NULL); info("usblp%d: USB %sdirectional printer dev %d if %d alt %d", minor, bidir ? "Bi" : "Uni", dev->devnum, ifnum, alts); return usblp_table[minor] = usblp; }