/* * URB callback for the notification endpoint * * @urb: the urb received from the notification endpoint * * This function will just process the USB side of the transaction, * checking everything is fine, pass the processing to * i2400m_notification_grok() and resubmit the URB. */ static void i2400mu_notification_cb(struct urb *urb) { int ret; struct i2400mu *i2400mu = urb->context; struct device *dev = &i2400mu->usb_iface->dev; d_fnstart(4, dev, "(urb %p status %d actual_length %d)\n", urb, urb->status, urb->actual_length); ret = urb->status; switch (ret) { case 0: ret = i2400mu_notification_grok(i2400mu, urb->transfer_buffer, urb->actual_length); if (ret == -EIO && edc_inc(&i2400mu->urb_edc, EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) goto error_exceeded; if (ret == -ENOMEM) /* uff...power cycle? shutdown? */ goto error_exceeded; break; case -EINVAL: /* while removing driver */ case -ENODEV: /* dev disconnect ... */ case -ENOENT: /* ditto */ case -ESHUTDOWN: /* URB killed */ case -ECONNRESET: /* disconnection */ goto out; /* Notify around */ default: /* Some error? */ if (edc_inc(&i2400mu->urb_edc, EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) goto error_exceeded; dev_err(dev, "notification: URB error %d, retrying\n", urb->status); } usb_mark_last_busy(i2400mu->usb_dev); ret = usb_submit_urb(i2400mu->notif_urb, GFP_ATOMIC); switch (ret) { case 0: case -EINVAL: /* while removing driver */ case -ENODEV: /* dev disconnect ... */ case -ENOENT: /* ditto */ case -ESHUTDOWN: /* URB killed */ case -ECONNRESET: /* disconnection */ break; /* just ignore */ default: /* Some error? */ dev_err(dev, "notification: cannot submit URB: %d\n", ret); goto error_submit; } d_fnend(4, dev, "(urb %p status %d actual_length %d) = void\n", urb, urb->status, urb->actual_length); return; error_exceeded: dev_err(dev, "maximum errors in notification URB exceeded; " "resetting device\n"); error_submit: usb_queue_reset_device(i2400mu->usb_iface); out: d_fnend(4, dev, "(urb %p status %d actual_length %d) = void\n", urb, urb->status, urb->actual_length); }
/* * Get the next TX message in the TX FIFO and send it to the device * * Note that any iteration consumes a message to be sent, no matter if * it succeeds or fails (we have no real way to retry or complain). * * Return: 0 if ok, < 0 errno code on hard error. */ static int i2400mu_tx(struct i2400mu *i2400mu, struct i2400m_msg_hdr *tx_msg, size_t tx_msg_size) { int result = 0; struct i2400m *i2400m = &i2400mu->i2400m; struct device *dev = &i2400mu->usb_iface->dev; int usb_pipe, sent_size, do_autopm; struct usb_endpoint_descriptor *epd; d_fnstart(4, dev, "(i2400mu %p)\n", i2400mu); do_autopm = atomic_read(&i2400mu->do_autopm); result = do_autopm ? usb_autopm_get_interface(i2400mu->usb_iface) : 0; if (result < 0) { dev_err(dev, "TX: can't get autopm: %d\n", result); do_autopm = 0; } epd = usb_get_epd(i2400mu->usb_iface, I2400MU_EP_BULK_OUT); usb_pipe = usb_sndbulkpipe(i2400mu->usb_dev, epd->bEndpointAddress); retry: result = usb_bulk_msg(i2400mu->usb_dev, usb_pipe, tx_msg, tx_msg_size, &sent_size, HZ); usb_mark_last_busy(i2400mu->usb_dev); switch (result) { case 0: if (sent_size != tx_msg_size) { /* Too short? drop it */ dev_err(dev, "TX: short write (%d B vs %zu " "expected)\n", sent_size, tx_msg_size); result = -EIO; } break; case -EINVAL: /* while removing driver */ case -ENODEV: /* dev disconnect ... */ case -ENOENT: /* just ignore it */ case -ESHUTDOWN: /* and exit */ case -ECONNRESET: result = -ESHUTDOWN; break; default: /* Some error? */ if (edc_inc(&i2400mu->urb_edc, EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) { dev_err(dev, "TX: maximum errors in URB " "exceeded; resetting device\n"); usb_queue_reset_device(i2400mu->usb_iface); } else { dev_err(dev, "TX: cannot send URB; retrying. " "tx_msg @%zu %zu B [%d sent]: %d\n", (void *) tx_msg - i2400m->tx_buf, tx_msg_size, sent_size, result); goto retry; } } if (do_autopm) usb_autopm_put_interface(i2400mu->usb_iface); d_fnend(4, dev, "(i2400mu %p) = result\n", i2400mu); return result; }
/** * Callback for the notification endpoint * * This mostly controls the xon/xoff protocol. In case of hard error, * we stop the queue. If not, we always retry. */ static void i1480u_notif_cb(struct urb *urb, struct pt_regs *regs) { struct i1480u *i1480u = urb->context; struct usb_interface *usb_iface = i1480u->usb_iface; struct device *dev = &usb_iface->dev; int result; switch (urb->status) { case 0: /* Got valid data, do xon/xoff */ switch (i1480u->notif_buffer[0]) { case 'N': dev_err(dev, "XOFF STOPPING queue at %lu\n", jiffies); netif_stop_queue(i1480u->net_dev); break; case 'A': dev_err(dev, "XON STARTING queue at %lu\n", jiffies); netif_start_queue(i1480u->net_dev); break; default: dev_err(dev, "NEP: unknown data 0x%02hhx\n", i1480u->notif_buffer[0]); } break; case -ECONNRESET: /* Controlled situation ... */ case -ENOENT: /* we killed the URB... */ dev_err(dev, "NEP: URB reset/noent %d\n", urb->status); goto error; case -ESHUTDOWN: /* going away! */ dev_err(dev, "NEP: URB down %d\n", urb->status); goto error; default: /* Retry unless it gets ugly */ if (edc_inc(&i1480u->notif_edc, EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) { dev_err(dev, "NEP: URB max acceptable errors " "exceeded; resetting device\n"); goto error_reset; } dev_err(dev, "NEP: URB error %d\n", urb->status); break; } result = usb_submit_urb(urb, GFP_ATOMIC); if (result < 0) { dev_err(dev, "NEP: Can't resubmit URB: %d; resetting device\n", result); goto error_reset; } return; error_reset: wlp_reset_all(&i1480-wlp); error: netif_stop_queue(i1480u->net_dev); return; }
/* * Called when an RX URB has finished receiving or has found some kind * of error condition. * * LIMITATIONS: * * - We read USB-transfers, each transfer contains a SINGLE fragment * (can contain a complete packet, or a 1st, next, or last fragment * of a packet). * Looks like a transfer can contain more than one fragment (07/18/06) * * - Each transfer buffer is the size of the maximum packet size (minus * headroom), i1480u_MAX_PKT_SIZE - 2 * * - We always read the full USB-transfer, no partials. * * - Each transfer is read directly into a skb. This skb will be used to * send data to the upper layers if it is the first fragment or a complete * packet. In the other cases the data will be copied from the skb to * another skb that is being prepared for the upper layers from a prev * first fragment. * * It is simply too much of a pain. Gosh, there should be a unified * SG infrastructure for *everything* [so that I could declare a SG * buffer, pass it to USB for receiving, append some space to it if * I wish, receive more until I have the whole chunk, adapt * pointers on each fragment to remove hardware headers and then * attach that to an skbuff and netif_rx()]. */ void i1480u_rx_cb(struct urb *urb) { int result; int do_parse_buffer = 1; struct i1480u_rx_buf *rx_buf = urb->context; struct i1480u *i1480u = rx_buf->i1480u; struct device *dev = &i1480u->usb_iface->dev; unsigned long flags; u8 rx_buf_idx = rx_buf - i1480u->rx_buf; switch (urb->status) { case 0: break; case -ECONNRESET: /* Not an error, but a controlled situation; */ case -ENOENT: /* (we killed the URB)...so, no broadcast */ case -ESHUTDOWN: /* going away! */ dev_err(dev, "RX URB[%u]: goind down %d\n", rx_buf_idx, urb->status); goto error; default: dev_err(dev, "RX URB[%u]: unknown status %d\n", rx_buf_idx, urb->status); if (edc_inc(&i1480u->rx_errors, EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) { dev_err(dev, "RX: max acceptable errors exceeded," " resetting device.\n"); i1480u_rx_unlink_urbs(i1480u); wlp_reset_all(&i1480u->wlp); goto error; } do_parse_buffer = 0; break; } spin_lock_irqsave(&i1480u->lock, flags); /* chew the data fragments, extract network packets */ if (do_parse_buffer) { i1480u_rx_buffer(rx_buf); if (rx_buf->data) { rx_buf->urb->transfer_buffer = rx_buf->data->data; result = usb_submit_urb(rx_buf->urb, GFP_ATOMIC); if (result < 0) { dev_err(dev, "RX URB[%u]: cannot submit %d\n", rx_buf_idx, result); } } } spin_unlock_irqrestore(&i1480u->lock, flags); error: return; }
/* * Sends a barker buffer to the device * * This helper will allocate a kmalloced buffer and use it to transmit * (then free it). Reason for this is that other arches cannot use * stack/vmalloc/text areas for DMA transfers. * * Error recovery here is simpler: anything is considered a hard error * and will move the reset code to use a last-resort bus-based reset. */ static int __i2400mu_send_barker(struct i2400mu *i2400mu, const __le32 *barker, size_t barker_size, unsigned endpoint) { struct usb_endpoint_descriptor *epd = NULL; int pipe, actual_len, ret; struct device *dev = &i2400mu->usb_iface->dev; void *buffer; int do_autopm = 1; ret = usb_autopm_get_interface(i2400mu->usb_iface); if (ret < 0) { dev_err(dev, "RESET: can't get autopm: %d\n", ret); do_autopm = 0; } ret = -ENOMEM; buffer = kmalloc(barker_size, GFP_KERNEL); if (buffer == NULL) goto error_kzalloc; epd = usb_get_epd(i2400mu->usb_iface, endpoint); pipe = usb_sndbulkpipe(i2400mu->usb_dev, epd->bEndpointAddress); memcpy(buffer, barker, barker_size); retry: ret = usb_bulk_msg(i2400mu->usb_dev, pipe, buffer, barker_size, &actual_len, 200); switch (ret) { case 0: if (actual_len != barker_size) { /* Too short? drop it */ dev_err(dev, "E: %s: short write (%d B vs %zu " "expected)\n", __func__, actual_len, barker_size); ret = -EIO; } break; case -EPIPE: /* * Stall -- maybe the device is choking with our * requests. Clear it and give it some time. If they * happen to often, it might be another symptom, so we * reset. * * No error handling for usb_clear_halt(0; if it * works, the retry works; if it fails, this switch * does the error handling for us. */ if (edc_inc(&i2400mu->urb_edc, 10 * EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) { dev_err(dev, "E: %s: too many stalls in " "URB; resetting device\n", __func__); usb_queue_reset_device(i2400mu->usb_iface); /* fallthrough */ } else { usb_clear_halt(i2400mu->usb_dev, pipe); msleep(10); /* give the device some time */ goto retry; } case -EINVAL: /* while removing driver */ case -ENODEV: /* dev disconnect ... */ case -ENOENT: /* just ignore it */ case -ESHUTDOWN: /* and exit */ case -ECONNRESET: ret = -ESHUTDOWN; break; default: /* Some error? */ if (edc_inc(&i2400mu->urb_edc, EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) { dev_err(dev, "E: %s: maximum errors in URB " "exceeded; resetting device\n", __func__); usb_queue_reset_device(i2400mu->usb_iface); } else { dev_warn(dev, "W: %s: cannot send URB: %d\n", __func__, ret); goto retry; } } kfree(buffer); error_kzalloc: if (do_autopm) usb_autopm_put_interface(i2400mu->usb_iface); return ret; }
static int i2400mu_tx(struct i2400mu *i2400mu, struct i2400m_msg_hdr *tx_msg, size_t tx_msg_size) { int result = 0; struct i2400m *i2400m = &i2400mu->i2400m; struct device *dev = &i2400mu->usb_iface->dev; int usb_pipe, sent_size, do_autopm; struct usb_endpoint_descriptor *epd; d_fnstart(4, dev, "(i2400mu %p)\n", i2400mu); do_autopm = atomic_read(&i2400mu->do_autopm); result = do_autopm ? usb_autopm_get_interface(i2400mu->usb_iface) : 0; if (result < 0) { dev_err(dev, "TX: can't get autopm: %d\n", result); do_autopm = 0; } epd = usb_get_epd(i2400mu->usb_iface, i2400mu->endpoint_cfg.bulk_out); usb_pipe = usb_sndbulkpipe(i2400mu->usb_dev, epd->bEndpointAddress); retry: result = usb_bulk_msg(i2400mu->usb_dev, usb_pipe, tx_msg, tx_msg_size, &sent_size, 200); usb_mark_last_busy(i2400mu->usb_dev); switch (result) { case 0: if (sent_size != tx_msg_size) { /* */ dev_err(dev, "TX: short write (%d B vs %zu " "expected)\n", sent_size, tx_msg_size); result = -EIO; } break; case -EPIPE: /* */ if (edc_inc(&i2400mu->urb_edc, 10 * EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) { dev_err(dev, "BM-CMD: too many stalls in " "URB; resetting device\n"); usb_queue_reset_device(i2400mu->usb_iface); /* */ } else { usb_clear_halt(i2400mu->usb_dev, usb_pipe); msleep(10); /* */ goto retry; } case -EINVAL: /* */ case -ENODEV: /* */ case -ENOENT: /* */ case -ESHUTDOWN: /* */ case -ECONNRESET: result = -ESHUTDOWN; break; default: /* */ if (edc_inc(&i2400mu->urb_edc, EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) { dev_err(dev, "TX: maximum errors in URB " "exceeded; resetting device\n"); usb_queue_reset_device(i2400mu->usb_iface); } else { dev_err(dev, "TX: cannot send URB; retrying. " "tx_msg @%zu %zu B [%d sent]: %d\n", (void *) tx_msg - i2400m->tx_buf, tx_msg_size, sent_size, result); goto retry; } } if (do_autopm) usb_autopm_put_interface(i2400mu->usb_iface); d_fnend(4, dev, "(i2400mu %p) = result\n", i2400mu); return result; }
/* * Kernel thread for USB reception of data * * This thread waits for a kick; once kicked, it will allocate an skb * and receive a single message to it from USB (using * i2400mu_rx()). Once received, it is passed to the generic i2400m RX * code for processing. * * When done processing, it runs some dirty statistics to verify if * the last 100 messages received were smaller than half of the * current RX buffer size. In that case, the RX buffer size is * halved. This will helps lowering the pressure on the memory * allocator. * * Hard errors force the thread to exit. */ static int i2400mu_rxd(void *_i2400mu) { int result = 0; struct i2400mu *i2400mu = _i2400mu; struct i2400m *i2400m = &i2400mu->i2400m; struct device *dev = &i2400mu->usb_iface->dev; struct net_device *net_dev = i2400m->wimax_dev.net_dev; size_t pending; int rx_size; struct sk_buff *rx_skb; unsigned long flags; d_fnstart(4, dev, "(i2400mu %p)\n", i2400mu); spin_lock_irqsave(&i2400m->rx_lock, flags); BUG_ON(i2400mu->rx_kthread != NULL); i2400mu->rx_kthread = current; spin_unlock_irqrestore(&i2400m->rx_lock, flags); while (1) { d_printf(2, dev, "RX: waiting for messages\n"); pending = 0; wait_event_interruptible( i2400mu->rx_wq, (kthread_should_stop() /* check this first! */ || (pending = atomic_read(&i2400mu->rx_pending_count))) ); if (kthread_should_stop()) break; if (pending == 0) continue; rx_size = i2400mu->rx_size; d_printf(2, dev, "RX: reading up to %d bytes\n", rx_size); rx_skb = __netdev_alloc_skb(net_dev, rx_size, GFP_KERNEL); if (rx_skb == NULL) { dev_err(dev, "RX: can't allocate skb [%d bytes]\n", rx_size); msleep(50); /* give it some time? */ continue; } /* Receive the message with the payloads */ rx_skb = i2400mu_rx(i2400mu, rx_skb); result = PTR_ERR(rx_skb); if (IS_ERR(rx_skb)) goto out; atomic_dec(&i2400mu->rx_pending_count); if (rx_skb == NULL || rx_skb->len == 0) { /* some "ignorable" condition */ kfree_skb(rx_skb); continue; } /* Deliver the message to the generic i2400m code */ i2400mu->rx_size_cnt++; i2400mu->rx_size_acc += rx_skb->len; result = i2400m_rx(i2400m, rx_skb); if (result == -EIO && edc_inc(&i2400mu->urb_edc, EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) { goto error_reset; } /* Maybe adjust RX buffer size */ i2400mu_rx_size_maybe_shrink(i2400mu); } result = 0; out: spin_lock_irqsave(&i2400m->rx_lock, flags); i2400mu->rx_kthread = NULL; spin_unlock_irqrestore(&i2400m->rx_lock, flags); d_fnend(4, dev, "(i2400mu %p) = %d\n", i2400mu, result); return result; error_reset: dev_err(dev, "RX: maximum errors in received buffer exceeded; " "resetting device\n"); usb_queue_reset_device(i2400mu->usb_iface); goto out; }
/* * Receive a message with payloads from the USB bus into an skb * * @i2400mu: USB device descriptor * @rx_skb: skb where to place the received message * * Deals with all the USB-specifics of receiving, dynamically * increasing the buffer size if so needed. Returns the payload in the * skb, ready to process. On a zero-length packet, we retry. * * On soft USB errors, we retry (until they become too frequent and * then are promoted to hard); on hard USB errors, we reset the * device. On other errors (skb realloacation, we just drop it and * hope for the next invocation to solve it). * * Returns: pointer to the skb if ok, ERR_PTR on error. * NOTE: this function might realloc the skb (if it is too small), * so always update with the one returned. * ERR_PTR() is < 0 on error. * Will return NULL if it cannot reallocate -- this can be * considered a transient retryable error. */ static struct sk_buff *i2400mu_rx(struct i2400mu *i2400mu, struct sk_buff *rx_skb) { int result = 0; struct device *dev = &i2400mu->usb_iface->dev; int usb_pipe, read_size, rx_size, do_autopm; struct usb_endpoint_descriptor *epd; const size_t max_pkt_size = 512; d_fnstart(4, dev, "(i2400mu %p)\n", i2400mu); do_autopm = atomic_read(&i2400mu->do_autopm); result = do_autopm ? usb_autopm_get_interface(i2400mu->usb_iface) : 0; if (result < 0) { dev_err(dev, "RX: can't get autopm: %d\n", result); do_autopm = 0; } epd = usb_get_epd(i2400mu->usb_iface, i2400mu->endpoint_cfg.bulk_in); usb_pipe = usb_rcvbulkpipe(i2400mu->usb_dev, epd->bEndpointAddress); retry: rx_size = skb_end_pointer(rx_skb) - rx_skb->data - rx_skb->len; if (unlikely(rx_size % max_pkt_size == 0)) { rx_size -= 8; d_printf(1, dev, "RX: rx_size adapted to %d [-8]\n", rx_size); } result = usb_bulk_msg( i2400mu->usb_dev, usb_pipe, rx_skb->data + rx_skb->len, rx_size, &read_size, 200); usb_mark_last_busy(i2400mu->usb_dev); switch (result) { case 0: if (read_size == 0) goto retry; /* ZLP, just resubmit */ skb_put(rx_skb, read_size); break; case -EPIPE: /* * Stall -- maybe the device is choking with our * requests. Clear it and give it some time. If they * happen to often, it might be another symptom, so we * reset. * * No error handling for usb_clear_halt(0; if it * works, the retry works; if it fails, this switch * does the error handling for us. */ if (edc_inc(&i2400mu->urb_edc, 10 * EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) { dev_err(dev, "BM-CMD: too many stalls in " "URB; resetting device\n"); goto do_reset; } usb_clear_halt(i2400mu->usb_dev, usb_pipe); msleep(10); /* give the device some time */ goto retry; case -EINVAL: /* while removing driver */ case -ENODEV: /* dev disconnect ... */ case -ENOENT: /* just ignore it */ case -ESHUTDOWN: case -ECONNRESET: break; case -EOVERFLOW: { /* too small, reallocate */ struct sk_buff *new_skb; rx_size = i2400mu_rx_size_grow(i2400mu); if (rx_size <= (1 << 16)) /* cap it */ i2400mu->rx_size = rx_size; else if (printk_ratelimit()) { dev_err(dev, "BUG? rx_size up to %d\n", rx_size); result = -EINVAL; goto out; } skb_put(rx_skb, read_size); new_skb = skb_copy_expand(rx_skb, 0, rx_size - rx_skb->len, GFP_KERNEL); if (new_skb == NULL) { if (printk_ratelimit()) dev_err(dev, "RX: Can't reallocate skb to %d; " "RX dropped\n", rx_size); kfree_skb(rx_skb); rx_skb = NULL; goto out; /* drop it...*/ } kfree_skb(rx_skb); rx_skb = new_skb; i2400mu->rx_size_cnt = 0; i2400mu->rx_size_acc = i2400mu->rx_size; d_printf(1, dev, "RX: size changed to %d, received %d, " "copied %d, capacity %ld\n", rx_size, read_size, rx_skb->len, (long) (skb_end_pointer(new_skb) - new_skb->head)); goto retry; } /* In most cases, it happens due to the hardware scheduling a * read when there was no data - unfortunately, we have no way * to tell this timeout from a USB timeout. So we just ignore * it. */ case -ETIMEDOUT: dev_err(dev, "RX: timeout: %d\n", result); result = 0; break; default: /* Any error */ if (edc_inc(&i2400mu->urb_edc, EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) goto error_reset; dev_err(dev, "RX: error receiving URB: %d, retrying\n", result); goto retry; } out: if (do_autopm) usb_autopm_put_interface(i2400mu->usb_iface); d_fnend(4, dev, "(i2400mu %p) = %p\n", i2400mu, rx_skb); return rx_skb; error_reset: dev_err(dev, "RX: maximum errors in URB exceeded; " "resetting device\n"); do_reset: usb_queue_reset_device(i2400mu->usb_iface); rx_skb = ERR_PTR(result); goto out; }
/* * Get the next TX message in the TX FIFO and send it to the device * * Note that any iteration consumes a message to be sent, no matter if * it succeeds or fails (we have no real way to retry or complain). * * Return: 0 if ok, < 0 errno code on hard error. */ static int i2400mu_tx(struct i2400mu *i2400mu, struct i2400m_msg_hdr *tx_msg, size_t tx_msg_size) { int result = 0; struct i2400m *i2400m = &i2400mu->i2400m; struct device *dev = &i2400mu->usb_iface->dev; int usb_pipe, sent_size, do_autopm; struct usb_endpoint_descriptor *epd; d_fnstart(4, dev, "(i2400mu %p)\n", i2400mu); do_autopm = atomic_read(&i2400mu->do_autopm); result = do_autopm ? usb_autopm_get_interface(i2400mu->usb_iface) : 0; if (result < 0) { dev_err(dev, "TX: can't get autopm: %d\n", result); do_autopm = 0; } epd = usb_get_epd(i2400mu->usb_iface, i2400mu->endpoint_cfg.bulk_out); usb_pipe = usb_sndbulkpipe(i2400mu->usb_dev, epd->bEndpointAddress); retry: result = usb_bulk_msg(i2400mu->usb_dev, usb_pipe, tx_msg, tx_msg_size, &sent_size, 200); usb_mark_last_busy(i2400mu->usb_dev); switch (result) { case 0: if (sent_size != tx_msg_size) { /* Too short? drop it */ dev_err(dev, "TX: short write (%d B vs %zu " "expected)\n", sent_size, tx_msg_size); result = -EIO; } break; case -EPIPE: /* * Stall -- maybe the device is choking with our * requests. Clear it and give it some time. If they * happen to often, it might be another symptom, so we * reset. * * No error handling for usb_clear_halt(0; if it * works, the retry works; if it fails, this switch * does the error handling for us. */ if (edc_inc(&i2400mu->urb_edc, 10 * EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) { dev_err(dev, "BM-CMD: too many stalls in " "URB; resetting device\n"); usb_queue_reset_device(i2400mu->usb_iface); /* fallthrough */ } else { usb_clear_halt(i2400mu->usb_dev, usb_pipe); msleep(10); /* give the device some time */ goto retry; } case -EINVAL: /* while removing driver */ case -ENODEV: /* dev disconnect ... */ case -ENOENT: /* just ignore it */ case -ESHUTDOWN: /* and exit */ case -ECONNRESET: result = -ESHUTDOWN; break; default: /* Some error? */ if (edc_inc(&i2400mu->urb_edc, EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) { dev_err(dev, "TX: maximum errors in URB " "exceeded; resetting device\n"); usb_queue_reset_device(i2400mu->usb_iface); } else { dev_err(dev, "TX: cannot send URB; retrying. " "tx_msg @%zu %zu B [%d sent]: %d\n", (void *) tx_msg - i2400m->tx_buf, tx_msg_size, sent_size, result); goto retry; } } if (do_autopm) usb_autopm_put_interface(i2400mu->usb_iface); d_fnend(4, dev, "(i2400mu %p) = result\n", i2400mu); return result; }
/* * Synchronous write to the device * * Takes care of updating EDC counts and thus, handle device errors. */ static ssize_t i2400mu_tx_bulk_out(struct i2400mu *i2400mu, void *buf, size_t buf_size) { int result; struct device *dev = &i2400mu->usb_iface->dev; int len; struct usb_endpoint_descriptor *epd; int pipe, do_autopm = 1; result = usb_autopm_get_interface(i2400mu->usb_iface); if (result < 0) { dev_err(dev, "BM-CMD: can't get autopm: %d\n", result); do_autopm = 0; } epd = usb_get_epd(i2400mu->usb_iface, i2400mu->endpoint_cfg.bulk_out); pipe = usb_sndbulkpipe(i2400mu->usb_dev, epd->bEndpointAddress); retry: result = usb_bulk_msg(i2400mu->usb_dev, pipe, buf, buf_size, &len, 200); switch (result) { case 0: if (len != buf_size) { dev_err(dev, "BM-CMD: short write (%u B vs %zu " "expected)\n", len, buf_size); result = -EIO; break; } result = len; break; case -EPIPE: /* * Stall -- maybe the device is choking with our * requests. Clear it and give it some time. If they * happen to often, it might be another symptom, so we * reset. * * No error handling for usb_clear_halt(0; if it * works, the retry works; if it fails, this switch * does the error handling for us. */ if (edc_inc(&i2400mu->urb_edc, 10 * EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) { dev_err(dev, "BM-CMD: too many stalls in " "URB; resetting device\n"); usb_queue_reset_device(i2400mu->usb_iface); /* fallthrough */ } else { usb_clear_halt(i2400mu->usb_dev, pipe); msleep(10); /* give the device some time */ goto retry; } case -EINVAL: /* while removing driver */ case -ENODEV: /* dev disconnect ... */ case -ENOENT: /* just ignore it */ case -ESHUTDOWN: /* and exit */ case -ECONNRESET: result = -ESHUTDOWN; break; case -ETIMEDOUT: /* bah... */ break; default: /* any other? */ if (edc_inc(&i2400mu->urb_edc, EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) { dev_err(dev, "BM-CMD: maximum errors in " "URB exceeded; resetting device\n"); usb_queue_reset_device(i2400mu->usb_iface); result = -ENODEV; break; } dev_err(dev, "BM-CMD: URB error %d, retrying\n", result); goto retry; } if (do_autopm) usb_autopm_put_interface(i2400mu->usb_iface); return result; }
/* * 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; }
static int __i2400mu_send_barker(struct i2400mu *i2400mu, const __le32 *barker, size_t barker_size, unsigned endpoint) { struct usb_endpoint_descriptor *epd = NULL; int pipe, actual_len, ret; struct device *dev = &i2400mu->usb_iface->dev; void *buffer; int do_autopm = 1; ret = usb_autopm_get_interface(i2400mu->usb_iface); if (ret < 0) { dev_err(dev, "RESET: can't get autopm: %d\n", ret); do_autopm = 0; } ret = -ENOMEM; buffer = kmalloc(barker_size, GFP_KERNEL); if (buffer == NULL) goto error_kzalloc; epd = usb_get_epd(i2400mu->usb_iface, endpoint); pipe = usb_sndbulkpipe(i2400mu->usb_dev, epd->bEndpointAddress); memcpy(buffer, barker, barker_size); retry: ret = usb_bulk_msg(i2400mu->usb_dev, pipe, buffer, barker_size, &actual_len, 200); switch (ret) { case 0: if (actual_len != barker_size) { /* */ dev_err(dev, "E: %s: short write (%d B vs %zu " "expected)\n", __func__, actual_len, barker_size); ret = -EIO; } break; case -EPIPE: /* */ if (edc_inc(&i2400mu->urb_edc, 10 * EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) { dev_err(dev, "E: %s: too many stalls in " "URB; resetting device\n", __func__); usb_queue_reset_device(i2400mu->usb_iface); /* */ } else { usb_clear_halt(i2400mu->usb_dev, pipe); msleep(10); /* */ goto retry; } case -EINVAL: /* */ case -ENODEV: /* */ case -ENOENT: /* */ case -ESHUTDOWN: /* */ case -ECONNRESET: ret = -ESHUTDOWN; break; default: /* */ if (edc_inc(&i2400mu->urb_edc, EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) { dev_err(dev, "E: %s: maximum errors in URB " "exceeded; resetting device\n", __func__); usb_queue_reset_device(i2400mu->usb_iface); } else { dev_warn(dev, "W: %s: cannot send URB: %d\n", __func__, ret); goto retry; } } kfree(buffer); error_kzalloc: if (do_autopm) usb_autopm_put_interface(i2400mu->usb_iface); return ret; }
static struct sk_buff *i2400mu_rx(struct i2400mu *i2400mu, struct sk_buff *rx_skb) { int result = 0; struct device *dev = &i2400mu->usb_iface->dev; int usb_pipe, read_size, rx_size, do_autopm; struct usb_endpoint_descriptor *epd; const size_t max_pkt_size = 512; d_fnstart(4, dev, "(i2400mu %p)\n", i2400mu); do_autopm = atomic_read(&i2400mu->do_autopm); result = do_autopm ? usb_autopm_get_interface(i2400mu->usb_iface) : 0; if (result < 0) { dev_err(dev, "RX: can't get autopm: %d\n", result); do_autopm = 0; } epd = usb_get_epd(i2400mu->usb_iface, i2400mu->endpoint_cfg.bulk_in); usb_pipe = usb_rcvbulkpipe(i2400mu->usb_dev, epd->bEndpointAddress); retry: rx_size = skb_end_pointer(rx_skb) - rx_skb->data - rx_skb->len; if (unlikely(rx_size % max_pkt_size == 0)) { rx_size -= 8; d_printf(1, dev, "RX: rx_size adapted to %d [-8]\n", rx_size); } result = usb_bulk_msg( i2400mu->usb_dev, usb_pipe, rx_skb->data + rx_skb->len, rx_size, &read_size, 200); usb_mark_last_busy(i2400mu->usb_dev); switch (result) { case 0: if (read_size == 0) goto retry; /* */ skb_put(rx_skb, read_size); break; case -EPIPE: /* */ if (edc_inc(&i2400mu->urb_edc, 10 * EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) { dev_err(dev, "BM-CMD: too many stalls in " "URB; resetting device\n"); goto do_reset; } usb_clear_halt(i2400mu->usb_dev, usb_pipe); msleep(10); /* */ goto retry; case -EINVAL: /* */ case -ENODEV: /* */ case -ENOENT: /* */ case -ESHUTDOWN: case -ECONNRESET: break; case -EOVERFLOW: { /* */ struct sk_buff *new_skb; rx_size = i2400mu_rx_size_grow(i2400mu); if (rx_size <= (1 << 16)) /* */ i2400mu->rx_size = rx_size; else if (printk_ratelimit()) { dev_err(dev, "BUG? rx_size up to %d\n", rx_size); result = -EINVAL; goto out; } skb_put(rx_skb, read_size); new_skb = skb_copy_expand(rx_skb, 0, rx_size - rx_skb->len, GFP_KERNEL); if (new_skb == NULL) { if (printk_ratelimit()) dev_err(dev, "RX: Can't reallocate skb to %d; " "RX dropped\n", rx_size); kfree_skb(rx_skb); rx_skb = NULL; goto out; /* */ } kfree_skb(rx_skb); rx_skb = new_skb; i2400mu->rx_size_cnt = 0; i2400mu->rx_size_acc = i2400mu->rx_size; d_printf(1, dev, "RX: size changed to %d, received %d, " "copied %d, capacity %ld\n", rx_size, read_size, rx_skb->len, (long) (skb_end_pointer(new_skb) - new_skb->head)); goto retry; } /* */ case -ETIMEDOUT: dev_err(dev, "RX: timeout: %d\n", result); result = 0; break; default: /* */ if (edc_inc(&i2400mu->urb_edc, EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) goto error_reset; dev_err(dev, "RX: error receiving URB: %d, retrying\n", result); goto retry; } out: if (do_autopm) usb_autopm_put_interface(i2400mu->usb_iface); d_fnend(4, dev, "(i2400mu %p) = %p\n", i2400mu, rx_skb); return rx_skb; error_reset: dev_err(dev, "RX: maximum errors in URB exceeded; " "resetting device\n"); do_reset: usb_queue_reset_device(i2400mu->usb_iface); rx_skb = ERR_PTR(result); goto out; }