int __devinit usb6fire_comm_init(struct sfire_chip *chip)
{
struct comm_runtime *rt = kzalloc(sizeof(struct comm_runtime),
GFP_KERNEL);
struct urb *urb;
int ret;
if (!rt)
return -ENOMEM;
urb = &rt->receiver;
rt->serial = 1;
rt->chip = chip;
usb_init_urb(urb);
rt->init_urb = usb6fire_comm_init_urb;
rt->write8 = usb6fire_comm_write8;
rt->write16 = usb6fire_comm_write16;
/* submit an urb that receives communication data from device */
urb->transfer_buffer = rt->receiver_buffer;
urb->transfer_buffer_length = COMM_RECEIVER_BUFSIZE;
urb->pipe = usb_rcvintpipe(chip->dev, COMM_EP);
urb->dev = chip->dev;
urb->complete = usb6fire_comm_receiver_handler;
urb->context = rt;
urb->interval = 1;
ret = usb_submit_urb(urb, GFP_KERNEL);
if (ret < 0) {
kfree(rt);
snd_printk(KERN_ERR PREFIX "cannot create comm data receiver.");
return ret;
}
chip->comm = rt;
return 0;
}
int usb_control_msg(struct usb_device *dev, u32 pipe,
u8 request, u8 requesttype, u16 value, u16 index,
void *data, u16 size, int timeout)
{
int rc;
u64 tout;
struct urb u;
struct vmm_completion uc;
struct usb_devrequest setup_packet;
/* Initialize setup packet */
setup_packet.requesttype = requesttype;
setup_packet.request = request;
setup_packet.value = vmm_cpu_to_le16(value);
setup_packet.index = vmm_cpu_to_le16(index);
setup_packet.length = vmm_cpu_to_le16(size);
DPRINTF("%s: request: 0x%X, requesttype: 0x%X, " \
"value 0x%X index 0x%X length 0x%X\n",
__func__, request, requesttype, value, index, size);
/* Initialize URB */
usb_init_urb(&u);
/* Initialize URB completion */
INIT_COMPLETION(&uc);
/* Fill URB */
usb_fill_control_urb(&u, dev, pipe,
(unsigned char *)&setup_packet, data, size,
urb_request_complete, &uc);
/* Submit URB */
rc = usb_hcd_submit_urb(&u);
if (rc) {
return rc;
}
/* Wait for completion */
if (timeout < 1) {
vmm_completion_wait(&uc);
rc = VMM_OK;
} else {
tout = timeout * 1000000ULL;
rc = vmm_completion_wait_timeout(&uc, &tout);
}
if (rc) {
return rc;
}
/* If URB failed then return status */
if (u.status < 0) {
return u.status;
}
return VMM_OK;
}
static struct _urb *_urb_alloc(int isoc, gfp_t gfp)
{
struct _urb *_urb = kmalloc(sizeof(struct _urb) +
sizeof(struct usb_iso_packet_descriptor) * isoc, gfp);
if (_urb) {
memset(_urb, 0, sizeof(*_urb));
usb_init_urb(&_urb->urb);
}
return _urb;
}
static void usb6fire_comm_init_urb(struct comm_runtime *rt, struct urb *urb,
u8 *buffer, void *context, void(*handler)(struct urb *urb))
{
usb_init_urb(urb);
urb->transfer_buffer = buffer;
urb->pipe = usb_sndintpipe(rt->chip->dev, COMM_EP);
urb->complete = handler;
urb->context = context;
urb->interval = 1;
urb->dev = rt->chip->dev;
}
/**
* usb_alloc_urb - creates a new urb for a USB driver to use
* @iso_packets: number of iso packets for this urb
* @mem_flags: the type of memory to allocate, see kmalloc() for a list of
* valid options for this.
*
* Creates an urb for the USB driver to use, initializes a few internal
* structures, increments the usage counter, and returns a pointer to it.
*
* If the driver want to use this urb for interrupt, control, or bulk
* endpoints, pass '0' as the number of iso packets.
*
* The driver must call usb_free_urb() when it is finished with the urb.
*
* Return: A pointer to the new urb, or %NULL if no memory is available.
*/
struct urb *usb_alloc_urb(int iso_packets, gfp_t mem_flags)
{
struct urb *urb;
urb = kmalloc(sizeof(struct urb) +
iso_packets * sizeof(struct usb_iso_packet_descriptor),
mem_flags);
if (!urb)
return NULL;
usb_init_urb(urb);
return urb;
}
/**
* usb_alloc_urb - creates a new urb for a USB driver to use
* @iso_packets: number of iso packets for this urb
* @mem_flags: the type of memory to allocate, see kmalloc() for a list of
* valid options for this.
*
* Creates an urb for the USB driver to use, initializes a few internal
* structures, incrementes the usage counter, and returns a pointer to it.
*
* If no memory is available, NULL is returned.
*
* If the driver want to use this urb for interrupt, control, or bulk
* endpoints, pass '0' as the number of iso packets.
*
* The driver must call usb_free_urb() when it is finished with the urb.
*/
struct urb *usb_alloc_urb(int iso_packets, gfp_t mem_flags)
{
struct urb *urb;
urb = kmalloc(sizeof(struct urb) +
iso_packets * sizeof(struct usb_iso_packet_descriptor),
mem_flags);
if (!urb) {
printk(KERN_ERR "alloc_urb: kmalloc failed\n");
return NULL;
}
usb_init_urb(urb);
return urb;
}
/**
* usb_alloc_urb - creates a new urb for a USB driver to use
* @iso_packets: number of iso packets for this urb
* @mem_flags: the type of memory to allocate, see kmalloc() for a list of
* valid options for this.
*
* Creates an urb for the USB driver to use, initializes a few internal
* structures, incrementes the usage counter, and returns a pointer to it.
*
* If no memory is available, NULL is returned.
*
* If the driver want to use this urb for interrupt, control, or bulk
* endpoints, pass '0' as the number of iso packets.
*
* The driver must call usb_free_urb() when it is finished with the urb.
*/
struct urb *usb_alloc_urb(int iso_packets, int mem_flags)
{
struct urb *urb;
urb = (struct urb *)kmalloc(sizeof(struct urb) +
iso_packets * sizeof(struct usb_iso_packet_descriptor),
mem_flags);
if (!urb) {
err("alloc_urb: kmalloc failed");
return NULL;
}
usb_init_urb(urb);
return urb;
}
int usb_bulk_msg(struct usb_device *dev, u32 pipe,
void *data, int len, int *actual_length, int timeout)
{
int rc;
u64 tout;
struct urb u;
struct vmm_completion uc;
/* Initialize URB */
usb_init_urb(&u);
/* Initialize URB completion */
INIT_COMPLETION(&uc);
/* Fill Bulk URB */
usb_fill_bulk_urb(&u, dev, pipe,
data, len,
urb_request_complete, &uc);
/* Submit URB */
rc = usb_hcd_submit_urb(&u);
if (rc) {
return rc;
}
/* Wait for completion */
if (timeout < 1) {
vmm_completion_wait(&uc);
rc = VMM_OK;
} else {
tout = timeout * 1000000ULL;
rc = vmm_completion_wait_timeout(&uc, &tout);
}
if (rc) {
return rc;
}
/* If URB failed then return status */
if (u.status < 0) {
return u.status;
}
/* Return actual transfer length */
if (actual_length) {
*actual_length = u.actual_length;
}
return VMM_OK;
}
static int alloc_stream_urbs(struct ua101 *ua, struct ua101_stream *stream,
void (*urb_complete)(struct urb *))
{
unsigned max_packet_size = stream->max_packet_bytes;
struct ua101_urb *urb;
unsigned int b, u = 0;
for (b = 0; b < ARRAY_SIZE(stream->buffers); ++b) {
unsigned int size = stream->buffers[b].size;
u8 *addr = stream->buffers[b].addr;
dma_addr_t dma = stream->buffers[b].dma;
while (size >= max_packet_size) {
if (u >= stream->queue_length)
goto bufsize_error;
urb = kmalloc(sizeof(*urb), GFP_KERNEL);
if (!urb)
return -ENOMEM;
usb_init_urb(&urb->urb);
urb->urb.dev = ua->dev;
urb->urb.pipe = stream->usb_pipe;
urb->urb.transfer_flags = URB_ISO_ASAP |
URB_NO_TRANSFER_DMA_MAP;
urb->urb.transfer_buffer = addr;
urb->urb.transfer_dma = dma;
urb->urb.transfer_buffer_length = max_packet_size;
urb->urb.number_of_packets = 1;
urb->urb.interval = 1;
urb->urb.context = ua;
urb->urb.complete = urb_complete;
urb->urb.iso_frame_desc[0].offset = 0;
urb->urb.iso_frame_desc[0].length = max_packet_size;
stream->urbs[u++] = urb;
size -= max_packet_size;
addr += max_packet_size;
dma += max_packet_size;
}
}
if (u == stream->queue_length)
return 0;
bufsize_error:
dev_err(&ua->dev->dev, "internal buffer size error\n");
return -ENXIO;
}
static int prism2_usb_probe(struct usb_interface *interface,
const struct usb_device_id *id)
{
struct usb_device *usb;
local_info_t *local = NULL;
struct net_device *dev = NULL;
static int cards_found /* = 0 */;
struct hostap_interface *iface;
struct hostap_usb_priv *hw_priv;
hw_priv = kzalloc(sizeof(*hw_priv), GFP_KERNEL);
if (hw_priv == NULL)
return -ENOMEM;
usb = interface_to_usbdev(interface);
hw_priv->endp_in = usb_rcvbulkpipe(usb, 1);
hw_priv->endp_out = usb_sndbulkpipe(usb, 2);
usb_init_urb(&hw_priv->tx_urb);
usb_init_urb(&hw_priv->rx_urb);
hw_priv->present = 1;
skb_queue_head_init(&hw_priv->tx_queue);
dev = prism2_init_local_data(&prism2_usb_funcs, cards_found,
&interface->dev);
if (dev == NULL)
goto fail;
iface = netdev_priv(dev);
local = iface->local;
local->hw_priv = hw_priv;
cards_found++;
hw_priv->usb = usb_get_dev(usb);
prism2_usb_cor_sreset(local);
usb_set_intfdata(interface, dev);
if (!local->pri_only && prism2_hw_config(dev, 1)) {
printk(KERN_DEBUG "%s: hardware initialization failed\n",
dev_info);
goto fail2;
}
printk(KERN_INFO "%s: Intersil Prism2/2.5/3 USB", dev->name);
return hostap_hw_ready(dev);
fail2:
usb_put_dev(hw_priv->usb);
fail:
hw_priv->present = 0;
prism2_free_local_data(dev);
usb_kill_urb(&hw_priv->rx_urb);
usb_kill_urb(&hw_priv->tx_urb);
// err_out_free:
kfree(hw_priv);
return -ENODEV;
}
static int __devinit init_card(struct snd_usb_caiaqdev *dev)
{
char *c;
struct usb_device *usb_dev = dev->chip.dev;
struct snd_card *card = dev->chip.card;
int err, len;
if (usb_set_interface(usb_dev, 0, 1) != 0) {
log("can't set alt interface.\n");
return -EIO;
}
usb_init_urb(&dev->ep1_in_urb);
usb_init_urb(&dev->midi_out_urb);
usb_fill_bulk_urb(&dev->ep1_in_urb, usb_dev,
usb_rcvbulkpipe(usb_dev, 0x1),
dev->ep1_in_buf, EP1_BUFSIZE,
usb_ep1_command_reply_dispatch, dev);
usb_fill_bulk_urb(&dev->midi_out_urb, usb_dev,
usb_sndbulkpipe(usb_dev, 0x1),
dev->midi_out_buf, EP1_BUFSIZE,
snd_usb_caiaq_midi_output_done, dev);
init_waitqueue_head(&dev->ep1_wait_queue);
init_waitqueue_head(&dev->prepare_wait_queue);
if (usb_submit_urb(&dev->ep1_in_urb, GFP_KERNEL) != 0)
return -EIO;
err = snd_usb_caiaq_send_command(dev, EP1_CMD_GET_DEVICE_INFO, NULL, 0);
if (err)
return err;
if (!wait_event_timeout(dev->ep1_wait_queue, dev->spec_received, HZ))
return -ENODEV;
usb_string(usb_dev, usb_dev->descriptor.iManufacturer,
dev->vendor_name, CAIAQ_USB_STR_LEN);
usb_string(usb_dev, usb_dev->descriptor.iProduct,
dev->product_name, CAIAQ_USB_STR_LEN);
usb_string(usb_dev, usb_dev->descriptor.iSerialNumber,
dev->serial, CAIAQ_USB_STR_LEN);
/* terminate serial string at first white space occurence */
c = strchr(dev->serial, ' ');
if (c)
*c = '\0';
strcpy(card->driver, MODNAME);
strcpy(card->shortname, dev->product_name);
len = snprintf(card->longname, sizeof(card->longname),
"%s %s (serial %s, ",
dev->vendor_name, dev->product_name, dev->serial);
if (len < sizeof(card->longname) - 2)
len += usb_make_path(usb_dev, card->longname + len,
sizeof(card->longname) - len);
card->longname[len++] = ')';
card->longname[len] = '\0';
setup_card(dev);
return 0;
}
static int init_card(struct snd_usb_caiaqdev *dev)
{
char *c, usbpath[32];
struct usb_device *usb_dev = dev->chip.dev;
struct snd_card *card = dev->chip.card;
int err, len;
if (usb_set_interface(usb_dev, 0, 1) != 0) {
log("can't set alt interface.\n");
return -EIO;
}
usb_init_urb(&dev->ep1_in_urb);
usb_init_urb(&dev->midi_out_urb);
usb_fill_bulk_urb(&dev->ep1_in_urb, usb_dev,
usb_rcvbulkpipe(usb_dev, 0x1),
dev->ep1_in_buf, EP1_BUFSIZE,
usb_ep1_command_reply_dispatch, dev);
usb_fill_bulk_urb(&dev->midi_out_urb, usb_dev,
usb_sndbulkpipe(usb_dev, 0x1),
dev->midi_out_buf, EP1_BUFSIZE,
snd_usb_caiaq_midi_output_done, dev);
init_waitqueue_head(&dev->ep1_wait_queue);
init_waitqueue_head(&dev->prepare_wait_queue);
if (usb_submit_urb(&dev->ep1_in_urb, GFP_KERNEL) != 0)
return -EIO;
err = snd_usb_caiaq_send_command(dev, EP1_CMD_GET_DEVICE_INFO, NULL, 0);
if (err)
return err;
if (!wait_event_timeout(dev->ep1_wait_queue, dev->spec_received, HZ))
return -ENODEV;
usb_string(usb_dev, usb_dev->descriptor.iManufacturer,
dev->vendor_name, CAIAQ_USB_STR_LEN);
usb_string(usb_dev, usb_dev->descriptor.iProduct,
dev->product_name, CAIAQ_USB_STR_LEN);
strlcpy(card->driver, MODNAME, sizeof(card->driver));
strlcpy(card->shortname, dev->product_name, sizeof(card->shortname));
strlcpy(card->mixername, dev->product_name, sizeof(card->mixername));
/* if the id was not passed as module option, fill it with a shortened
* version of the product string which does not contain any
* whitespaces */
if (*card->id == '\0') {
char id[sizeof(card->id)];
memset(id, 0, sizeof(id));
for (c = card->shortname, len = 0;
*c && len < sizeof(card->id); c++)
if (*c != ' ')
id[len++] = *c;
snd_card_set_id(card, id);
}
usb_make_path(usb_dev, usbpath, sizeof(usbpath));
snprintf(card->longname, sizeof(card->longname),
"%s %s (%s)",
dev->vendor_name, dev->product_name, usbpath);
setup_card(dev);
return 0;
}
/*
* Read an ack from the notification endpoint
*
* @i2400m:
* @_ack: pointer to where to store the read data
* @ack_size: how many bytes we should read
*
* Returns: < 0 errno code on error; otherwise, amount of received bytes.
*
* Submits a notification read, appends the read data to the given ack
* buffer and then repeats (until @ack_size bytes have been
* received).
*/
ssize_t i2400mu_bus_bm_wait_for_ack(struct i2400m *i2400m,
struct i2400m_bootrom_header *_ack,
size_t ack_size)
{
ssize_t result = -ENOMEM;
struct device *dev = i2400m_dev(i2400m);
struct i2400mu *i2400mu = container_of(i2400m, struct i2400mu, i2400m);
struct urb notif_urb;
void *ack = _ack;
size_t offset, len;
long val;
int do_autopm = 1;
DECLARE_COMPLETION_ONSTACK(notif_completion);
d_fnstart(8, dev, "(i2400m %p ack %p size %zu)\n",
i2400m, ack, ack_size);
BUG_ON(_ack == i2400m->bm_ack_buf);
result = usb_autopm_get_interface(i2400mu->usb_iface);
if (result < 0) {
dev_err(dev, "BM-ACK: can't get autopm: %d\n", (int) result);
do_autopm = 0;
}
usb_init_urb(¬if_urb); /* ready notifications */
usb_get_urb(¬if_urb);
offset = 0;
while (offset < ack_size) {
init_completion(¬if_completion);
result = i2400mu_notif_submit(i2400mu, ¬if_urb,
¬if_completion);
if (result < 0)
goto error_notif_urb_submit;
val = wait_for_completion_interruptible_timeout(
¬if_completion, HZ);
if (val == 0) {
result = -ETIMEDOUT;
usb_kill_urb(¬if_urb); /* Timedout */
goto error_notif_wait;
}
if (val == -ERESTARTSYS) {
result = -EINTR; /* Interrupted */
usb_kill_urb(¬if_urb);
goto error_notif_wait;
}
result = notif_urb.status; /* How was the ack? */
switch (result) {
case 0:
break;
case -EINVAL: /* while removing driver */
case -ENODEV: /* dev disconnect ... */
case -ENOENT: /* just ignore it */
case -ESHUTDOWN: /* and exit */
case -ECONNRESET:
result = -ESHUTDOWN;
goto error_dev_gone;
default: /* any other? */
usb_kill_urb(¬if_urb); /* Timedout */
if (edc_inc(&i2400mu->urb_edc,
EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME))
goto error_exceeded;
dev_err(dev, "BM-ACK: URB error %d, "
"retrying\n", notif_urb.status);
continue; /* retry */
}
if (notif_urb.actual_length == 0) {
d_printf(6, dev, "ZLP received, retrying\n");
continue;
}
/* Got data, append it to the buffer */
len = min(ack_size - offset, (size_t) notif_urb.actual_length);
memcpy(ack + offset, i2400m->bm_ack_buf, len);
offset += len;
}
result = offset;
error_notif_urb_submit:
error_notif_wait:
error_dev_gone:
out:
if (do_autopm)
usb_autopm_put_interface(i2400mu->usb_iface);
d_fnend(8, dev, "(i2400m %p ack %p size %zu) = %ld\n",
i2400m, ack, ack_size, (long) result);
return result;
error_exceeded:
dev_err(dev, "bm: maximum errors in notification URB exceeded; "
"resetting device\n");
usb_queue_reset_device(i2400mu->usb_iface);
goto out;
}
//****************************************************************************
// usb resource allocation
//
static int pcan_usb_allocate_resources(struct pcan_usb_interface *usb_if)
{
struct pcandev *dev;
USB_PORT *u;
int err = 0;
int c;
DPRINTK(KERN_DEBUG "%s: %s()\n", DEVICE_NAME, __FUNCTION__);
// make param URB
usb_init_urb(&usb_if->urb_cmd_sync);
usb_init_urb(&usb_if->urb_cmd_async);
// allocate write buffer
// Check revision according to device id.
switch (usb_if->usb_dev->descriptor.idProduct)
{
#ifdef HW_USB_PRO
case PCAN_USBPRO_PRODUCT_ID:
/* Rev 0x00 */
/* Copied from Win32 Driver:
pDeviceContext->IsDeviceHighSpeed ? 512 : 64 */
/* 512 bytes packet size leads to fragmentation issue while messages */
/* are 1024 bytes large */
if (usb_if->usb_dev->speed == USB_SPEED_HIGH)
{
usb_if->read_packet_size = 1024;
usb_if->dev[0].port.usb.write_packet_size =
usb_if->dev[1].port.usb.write_packet_size = 512;
}
else
{
usb_if->read_packet_size = 64;
usb_if->dev[0].port.usb.write_packet_size =
usb_if->dev[1].port.usb.write_packet_size = 64;
}
#ifdef PCAN_USBPRO_READ_BUFFER_SIZE
usb_if->read_buffer_size = PCAN_USBPRO_READ_BUFFER_SIZE;
#else
usb_if->read_buffer_size = usb_if->read_packet_size;
#endif
#ifdef PCAN_USBPRO_WRITE_BUFFER_SIZE
usb_if->dev[0].port.usb.write_buffer_size = PCAN_USBPRO_WRITE_BUFFER_SIZE;
usb_if->dev[1].port.usb.write_buffer_size = PCAN_USBPRO_WRITE_BUFFER_SIZE;
#else
usb_if->dev[0].port.usb.write_buffer_size = \
usb_if->dev[0].port.usb.write_packet_size;
usb_if->dev[1].port.usb.write_buffer_size = \
usb_if->dev[1].port.usb.write_packet_size;
#endif
break;
#endif
case PCAN_USB_PRODUCT_ID:
if (usb_if->ucRevision >= 7)
{
usb_if->read_buffer_size = PCAN_USB_READ_BUFFER_SIZE;
usb_if->dev[0].port.usb.write_buffer_size = PCAN_USB_WRITE_BUFFER_SIZE;
usb_if->read_packet_size = PCAN_USB_READ_PACKET_SIZE;
usb_if->dev[0].port.usb.write_packet_size = PCAN_USB_WRITE_PACKET_SIZE;
break;
}
default:
usb_if->read_buffer_size = PCAN_USB_READ_BUFFER_SIZE_OLD;
usb_if->dev[0].port.usb.write_buffer_size = \
PCAN_USB_WRITE_BUFFER_SIZE_OLD;
usb_if->read_packet_size = PCAN_USB_READ_PACKET_SIZE;
usb_if->dev[0].port.usb.write_packet_size = PCAN_USB_WRITE_PACKET_SIZE;
break;
}
dev = &usb_if->dev[0];
for (c=0; c < usb_if->dev_ctrl_count; c++, dev++)
{
u = &dev->port.usb;
u->write_buffer_addr = kmalloc(u->write_buffer_size, GFP_KERNEL);
if (!u->write_buffer_addr)
{
err = -ENOMEM;
goto fail;
}
DPRINTK(KERN_DEBUG "%s: %s() allocate %d bytes buffer for writing\n",
DEVICE_NAME, __FUNCTION__, u->write_buffer_size);
// make write urb
usb_init_urb(&u->write_data);
}
// allocate two read buffers for URB
usb_if->read_buffer_addr[0] = \
kmalloc(usb_if->read_buffer_size * 2, GFP_KERNEL);
if (!usb_if->read_buffer_addr[0])
{
err = -ENOMEM;
goto fail;
}
DPRINTK(KERN_DEBUG "%s: %s() allocate %d buffers of %d bytes for reading\n",
DEVICE_NAME, __FUNCTION__, 2, usb_if->read_buffer_size);
usb_if->read_buffer_addr[1] = usb_if->read_buffer_addr[0]
+ usb_if->read_buffer_size;
// make read urb
usb_init_urb(&usb_if->read_data);
fail:
return err;
}
