diff options
Diffstat (limited to 'drivers/net')
| -rw-r--r-- | drivers/net/ethernet/msm/msm_rmnet_bam.c | 4 | ||||
| -rw-r--r-- | drivers/net/usb/rmnet_usb.h | 72 | ||||
| -rw-r--r-- | drivers/net/usb/rmnet_usb_ctrl.c | 479 | ||||
| -rw-r--r-- | drivers/net/usb/rmnet_usb_data.c | 356 | ||||
| -rw-r--r-- | drivers/net/usb/usbnet.c | 12 | ||||
| -rw-r--r-- | drivers/net/wireless/cnss/cnss.c | 52 | ||||
| -rw-r--r-- | drivers/net/wireless/wcnss/wcnss_wlan.c | 4 |
7 files changed, 402 insertions, 577 deletions
diff --git a/drivers/net/ethernet/msm/msm_rmnet_bam.c b/drivers/net/ethernet/msm/msm_rmnet_bam.c index 9f062580308..7ec317a0d3e 100644 --- a/drivers/net/ethernet/msm/msm_rmnet_bam.c +++ b/drivers/net/ethernet/msm/msm_rmnet_bam.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -341,6 +341,8 @@ static int _rmnet_xmit(struct sk_buff *skb, struct net_device *dev) if (bam_ret != 0 && bam_ret != -EAGAIN && bam_ret != -EFAULT) { pr_err("[%s] %s: write returned error %d", dev->name, __func__, bam_ret); + if (RMNET_IS_MODE_QOS(opmode)) + skb_pull(skb, sizeof(struct QMI_QOS_HDR_S)); return -EPERM; } diff --git a/drivers/net/usb/rmnet_usb.h b/drivers/net/usb/rmnet_usb.h index 2e7db04351f..ccf59012440 100644 --- a/drivers/net/usb/rmnet_usb.h +++ b/drivers/net/usb/rmnet_usb.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -53,18 +53,16 @@ struct mux_hdr { __u16 pkt_len_w_padding; } __packed; -struct rmnet_ctrl_dev { +struct rmnet_ctrl_udev { - /*for debugging purpose*/ - char name[CTRL_DEV_MAX_LEN]; - - struct cdev cdev; - struct device *devicep; - unsigned ch_id; - - /*to identify the usb device*/ - unsigned id; + /* + * In case of non-mux ctrl channel there is a one to one mapping + * between rmnet_ctrl_dev and rmnet_ctrl_udev. Save the claimed + * device id. + */ + unsigned int ctrldev_id; + unsigned int rdev_num; struct usb_interface *intf; unsigned int int_pipe; struct urb *rcvurb; @@ -75,15 +73,38 @@ struct rmnet_ctrl_dev { void *intbuf; struct usb_ctrlrequest *in_ctlreq; + struct workqueue_struct *wq; + struct work_struct get_encap_work; + + unsigned long status; + + /*counters*/ + unsigned int snd_encap_cmd_cnt; + unsigned int get_encap_resp_cnt; + unsigned int resp_avail_cnt; + unsigned int get_encap_failure_cnt; + unsigned int set_ctrl_line_state_cnt; + unsigned int tx_ctrl_err_cnt; + unsigned int zlp_cnt; + unsigned int invalid_mux_id_cnt; +}; + +struct rmnet_ctrl_dev { + + /*for debugging purpose*/ + char name[CTRL_DEV_MAX_LEN]; + + struct cdev cdev; + struct device *devicep; + unsigned ch_id; + + struct rmnet_ctrl_udev *cudev; + spinlock_t rx_lock; struct mutex dev_lock; struct list_head rx_list; wait_queue_head_t read_wait_queue; wait_queue_head_t open_wait_queue; - - struct workqueue_struct *wq; - struct work_struct get_encap_work; - unsigned long status; bool claimed; @@ -94,27 +115,20 @@ struct rmnet_ctrl_dev { unsigned int cbits_tolocal; /*output control lines (DTR, RTS)*/ unsigned int cbits_tomdm; - - /*counters*/ - unsigned int snd_encap_cmd_cnt; - unsigned int get_encap_resp_cnt; - unsigned int resp_avail_cnt; - unsigned int get_encap_failure_cnt; - unsigned int set_ctrl_line_state_cnt; - unsigned int tx_ctrl_err_cnt; - unsigned int zlp_cnt; }; extern struct workqueue_struct *usbnet_wq; -extern int rmnet_usb_ctrl_start_rx(struct rmnet_ctrl_dev *); -extern int rmnet_usb_ctrl_suspend(struct rmnet_ctrl_dev *dev); -extern int rmnet_usb_ctrl_init(int num_devs, int insts_per_dev); -extern void rmnet_usb_ctrl_exit(int num_devs, int insts_per_dev); +extern int rmnet_usb_ctrl_start_rx(struct rmnet_ctrl_udev *); +extern int rmnet_usb_ctrl_suspend(struct rmnet_ctrl_udev *dev); +extern int rmnet_usb_ctrl_init(int num_devs, int insts_per_dev, + unsigned long mux_info); +extern void rmnet_usb_ctrl_exit(int num_devs, int insts_per_dev, + unsigned long mux_info); extern int rmnet_usb_ctrl_probe(struct usb_interface *intf, struct usb_host_endpoint *int_in, unsigned long rmnet_devnum, unsigned long *data); -extern void rmnet_usb_ctrl_disconnect(struct rmnet_ctrl_dev *); +extern void rmnet_usb_ctrl_disconnect(struct rmnet_ctrl_udev *); #endif /* __RMNET_USB_H*/ diff --git a/drivers/net/usb/rmnet_usb_ctrl.c b/drivers/net/usb/rmnet_usb_ctrl.c index 21325a24fc1..946031dadd1 100644 --- a/drivers/net/usb/rmnet_usb_ctrl.c +++ b/drivers/net/usb/rmnet_usb_ctrl.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 and @@ -38,10 +38,6 @@ module_param_array(rmnet_dev_names, charp, NULL, S_IRUGO | S_IWUSR); #define ACM_CTRL_RI BIT(2) #define ACM_CTRL_CD BIT(3) -/* polling interval for Interrupt ep */ -#define HS_INTERVAL 7 -#define FS_LS_INTERVAL 3 - /*echo modem_wait > /sys/class/hsicctl/hsicctlx/modem_wait*/ static ssize_t modem_wait_store(struct device *d, struct device_attribute *attr, const char *buf, size_t n) @@ -172,8 +168,8 @@ static void rmnet_usb_ctrl_mux(unsigned int id, struct ctrl_pkt *cpkt) static void get_encap_work(struct work_struct *w) { struct usb_device *udev; - struct rmnet_ctrl_dev *dev = - container_of(w, struct rmnet_ctrl_dev, get_encap_work); + struct rmnet_ctrl_udev *dev = + container_of(w, struct rmnet_ctrl_udev, get_encap_work); int status; if (!test_bit(RMNET_CTRL_DEV_READY, &dev->status)) @@ -202,8 +198,7 @@ static void get_encap_work(struct work_struct *w) usb_unanchor_urb(dev->rcvurb); usb_autopm_put_interface(dev->intf); if (status != -ENODEV) - dev_err(dev->devicep, - "%s: Error submitting Read URB %d\n", + pr_err("%s: Error submitting Read URB %d\n", __func__, status); goto resubmit_int_urb; } @@ -218,8 +213,7 @@ resubmit_int_urb: if (status) { usb_unanchor_urb(dev->inturb); if (status != -ENODEV) - dev_err(dev->devicep, - "%s: Error re-submitting Int URB %d\n", + pr_err("%s: Error re-submitting Int URB %d\n", __func__, status); } } @@ -230,7 +224,12 @@ static void notification_available_cb(struct urb *urb) int status; struct usb_cdc_notification *ctrl; struct usb_device *udev; - struct rmnet_ctrl_dev *dev = urb->context; + struct rmnet_ctrl_udev *dev = urb->context; + struct rmnet_ctrl_dev *cdev; + + /*usb device disconnect*/ + if (urb->dev->state == USB_STATE_NOTATTACHED) + return; udev = interface_to_usbdev(dev->intf); @@ -268,13 +267,14 @@ static void notification_available_cb(struct urb *urb) switch (ctrl->bNotificationType) { case USB_CDC_NOTIFY_RESPONSE_AVAILABLE: dev->resp_avail_cnt++; - /* If MUX is not enabled, wakeup up the open process * upon first notify response available. */ if (!test_bit(RMNET_CTRL_DEV_READY, &dev->status)) { set_bit(RMNET_CTRL_DEV_READY, &dev->status); - wake_up(&dev->open_wait_queue); + + cdev = &ctrl_devs[dev->rdev_num][dev->ctrldev_id]; + wake_up(&cdev->open_wait_queue); } usb_mark_last_busy(udev); @@ -282,7 +282,7 @@ static void notification_available_cb(struct urb *urb) return; default: - dev_err(dev->devicep, + dev_err(&dev->intf->dev, "%s:Command not implemented\n", __func__); } @@ -292,8 +292,7 @@ resubmit_int_urb: if (status) { usb_unanchor_urb(urb); if (status != -ENODEV) - dev_err(dev->devicep, - "%s: Error re-submitting Int URB %d\n", + pr_err("%s: Error re-submitting Int URB %d\n", __func__, status); } @@ -304,11 +303,17 @@ static void resp_avail_cb(struct urb *urb) { struct usb_device *udev; struct ctrl_pkt_list_elem *list_elem = NULL; - struct rmnet_ctrl_dev *rx_dev, *dev = urb->context; + struct rmnet_ctrl_udev *dev = urb->context; + struct rmnet_ctrl_dev *rx_dev; void *cpkt; - int ch_id, status = 0; + int status = 0; + int ch_id = -EINVAL; size_t cpkt_size = 0; + /*usb device disconnect*/ + if (urb->dev->state == USB_STATE_NOTATTACHED) + return; + udev = interface_to_usbdev(dev->intf); usb_autopm_put_interface_async(dev->intf); @@ -334,26 +339,24 @@ static void resp_avail_cb(struct urb *urb) goto resubmit_int_urb; } - dev_dbg(dev->devicep, "Read %d bytes for %s\n", - urb->actual_length, dev->name); - cpkt = urb->transfer_buffer; cpkt_size = urb->actual_length; if (!cpkt_size) { dev->zlp_cnt++; - dev_dbg(dev->devicep, "%s: zero length pkt received\n", + dev_dbg(&dev->intf->dev, "%s: zero length pkt received\n", __func__); goto resubmit_int_urb; } list_elem = kmalloc(sizeof(struct ctrl_pkt_list_elem), GFP_ATOMIC); if (!list_elem) { - dev_err(dev->devicep, "%s: list_elem alloc failed\n", __func__); + dev_err(&dev->intf->dev, "%s: list_elem alloc failed\n", + __func__); return; } list_elem->cpkt.data = kmalloc(cpkt_size, GFP_ATOMIC); if (!list_elem->cpkt.data) { - dev_err(dev->devicep, "%s: list_elem->data alloc failed\n", + dev_err(&dev->intf->dev, "%s: list_elem->data alloc failed\n", __func__); kfree(list_elem); return; @@ -361,20 +364,23 @@ static void resp_avail_cb(struct urb *urb) memcpy(list_elem->cpkt.data, cpkt, cpkt_size); list_elem->cpkt.data_size = cpkt_size; - rx_dev = dev; + ch_id = dev->ctrldev_id; if (test_bit(RMNET_CTRL_DEV_MUX_EN, &dev->status)) { ch_id = rmnet_usb_ctrl_dmux(list_elem); if (ch_id < 0) { + dev->invalid_mux_id_cnt++; kfree(list_elem->cpkt.data); kfree(list_elem); goto resubmit_int_urb; } - - rx_dev = &ctrl_devs[dev->id][ch_id]; } - rx_dev->get_encap_resp_cnt++; + rx_dev = &ctrl_devs[dev->rdev_num][ch_id]; + + dev->get_encap_resp_cnt++; + dev_dbg(&dev->intf->dev, "Read %d bytes for %s\n", + urb->actual_length, rx_dev->name); spin_lock(&rx_dev->rx_lock); list_add_tail(&list_elem->list, &rx_dev->rx_list); @@ -391,14 +397,13 @@ resubmit_int_urb: if (status) { usb_unanchor_urb(dev->inturb); if (status != -ENODEV) - dev_err(dev->devicep, - "%s: Error re-submitting Int URB %d\n", + pr_err("%s: Error re-submitting Int URB %d\n", __func__, status); } } } -int rmnet_usb_ctrl_start_rx(struct rmnet_ctrl_dev *dev) +int rmnet_usb_ctrl_start_rx(struct rmnet_ctrl_udev *dev) { int retval = 0; @@ -407,14 +412,13 @@ int rmnet_usb_ctrl_start_rx(struct rmnet_ctrl_dev *dev) if (retval < 0) { usb_unanchor_urb(dev->inturb); if (retval != -ENODEV) - dev_err(dev->devicep, - "%s Intr submit %d\n", __func__, retval); + pr_err("%s Intr submit %d\n", __func__, retval); } return retval; } -static int rmnet_usb_ctrl_alloc_rx(struct rmnet_ctrl_dev *dev) +static int rmnet_usb_ctrl_alloc_rx(struct rmnet_ctrl_udev *dev) { dev->rcvurb = usb_alloc_urb(0, GFP_KERNEL); if (!dev->rcvurb) { @@ -444,118 +448,43 @@ nomem: return -ENOMEM; } -static int rmnet_usb_ctrl_write_cmd(struct rmnet_ctrl_dev *dev) +static int rmnet_usb_ctrl_write_cmd(struct rmnet_ctrl_udev *dev, u8 req, + u16 val, void *data, u16 size) { struct usb_device *udev; + int ret; if (!test_bit(RMNET_CTRL_DEV_READY, &dev->status)) - return -ENODEV; + return -ENETRESET; + + ret = usb_autopm_get_interface(dev->intf); + if (ret < 0) { + pr_debug("%s: Unable to resume interface: %d\n", + __func__, ret); + return ret; + } udev = interface_to_usbdev(dev->intf); - dev->set_ctrl_line_state_cnt++; - return usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), - USB_CDC_REQ_SET_CONTROL_LINE_STATE, + ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), + req, (USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE), - dev->cbits_tomdm, + val, dev->intf->cur_altsetting->desc.bInterfaceNumber, - NULL, 0, USB_CTRL_SET_TIMEOUT); -} - -static void ctrl_write_callback(struct urb *urb) -{ - struct ctrl_pkt *cpkt = urb->context; - struct rmnet_ctrl_dev *dev = cpkt->ctxt; - - if (urb->status) { + data, size, USB_CTRL_SET_TIMEOUT); + if (ret < 0) dev->tx_ctrl_err_cnt++; - pr_debug_ratelimited("Write status/size %d/%d\n", - urb->status, urb->actual_length); - } - - kfree(urb->setup_packet); - kfree(urb->transfer_buffer); - usb_free_urb(urb); - kfree(cpkt); - usb_autopm_put_interface_async(dev->intf); -} - -static int rmnet_usb_ctrl_write(struct rmnet_ctrl_dev *dev, - struct ctrl_pkt *cpkt, size_t size) -{ - int result; - struct urb *sndurb; - struct usb_ctrlrequest *out_ctlreq; - struct usb_device *udev; - - if (!test_bit(RMNET_CTRL_DEV_READY, &dev->status)) - return -ENETRESET; - - udev = interface_to_usbdev(dev->intf); - - sndurb = usb_alloc_urb(0, GFP_KERNEL); - if (!sndurb) { - dev_err(dev->devicep, "Error allocating read urb\n"); - return -ENOMEM; - } - - out_ctlreq = kmalloc(sizeof(*out_ctlreq), GFP_KERNEL); - if (!out_ctlreq) { - usb_free_urb(sndurb); - dev_err(dev->devicep, "Error allocating setup packet buffer\n"); - return -ENOMEM; - } - /* CDC Send Encapsulated Request packet */ - out_ctlreq->bRequestType = (USB_DIR_OUT | USB_TYPE_CLASS | - USB_RECIP_INTERFACE); - out_ctlreq->bRequest = USB_CDC_SEND_ENCAPSULATED_COMMAND; - out_ctlreq->wValue = 0; - out_ctlreq->wIndex = dev->intf->cur_altsetting->desc.bInterfaceNumber; - out_ctlreq->wLength = cpu_to_le16(cpkt->data_size); - - usb_fill_control_urb(sndurb, udev, - usb_sndctrlpipe(udev, 0), - (unsigned char *)out_ctlreq, (void *)cpkt->data, - cpkt->data_size, ctrl_write_callback, cpkt); - - result = usb_autopm_get_interface(dev->intf); - if (result < 0) { - dev_dbg(dev->devicep, "%s: Unable to resume interface: %d\n", - __func__, result); - - /* - * Revisit: if (result == -EPERM) - * rmnet_usb_suspend(dev->intf, PMSG_SUSPEND); - */ - - usb_free_urb(sndurb); - kfree(out_ctlreq); - return result; - } - - usb_anchor_urb(sndurb, &dev->tx_submitted); - dev->snd_encap_cmd_cnt++; - result = usb_submit_urb(sndurb, GFP_KERNEL); - if (result < 0) { - if (result != -ENODEV) - dev_err(dev->devicep, - "%s: Submit URB error %d\n", - __func__, result); - dev->snd_encap_cmd_cnt--; - usb_autopm_put_interface(dev->intf); - usb_unanchor_urb(sndurb); - usb_free_urb(sndurb); - kfree(out_ctlreq); - return result; - } + usb_autopm_put_interface(dev->intf); - return size; + return ret; } static int rmnet_ctl_open(struct inode *inode, struct file *file) { - int retval = 0; - struct rmnet_ctrl_dev *dev = + struct ctrl_pkt_list_elem *list_elem = NULL; + unsigned long flag; + int retval = 0; + struct rmnet_ctrl_dev *dev = container_of(inode->i_cdev, struct rmnet_ctrl_dev, cdev); if (!dev) @@ -565,10 +494,11 @@ static int rmnet_ctl_open(struct inode *inode, struct file *file) goto already_opened; if (dev->mdm_wait_timeout && - !test_bit(RMNET_CTRL_DEV_READY, &dev->status)) { + !test_bit(RMNET_CTRL_DEV_READY, &dev->cudev->status)) { retval = wait_event_interruptible_timeout( dev->open_wait_queue, - test_bit(RMNET_CTRL_DEV_READY, &dev->status), + test_bit(RMNET_CTRL_DEV_READY, + &dev->cudev->status), msecs_to_jiffies(dev->mdm_wait_timeout * 1000)); if (retval == 0) { dev_err(dev->devicep, "%s: Timeout opening %s\n", @@ -581,12 +511,25 @@ static int rmnet_ctl_open(struct inode *inode, struct file *file) } } - if (!test_bit(RMNET_CTRL_DEV_READY, &dev->status)) { + if (!test_bit(RMNET_CTRL_DEV_READY, &dev->cudev->status)) { dev_dbg(dev->devicep, "%s: Connection timedout opening %s\n", __func__, dev->name); return -ETIMEDOUT; } + /* clear stale data if device close called but channel was ready */ + spin_lock_irqsave(&dev->rx_lock, flag); + while (!list_empty(&dev->rx_list)) { + list_elem = list_first_entry( + &dev->rx_list, + struct ctrl_pkt_list_elem, + list); + list_del(&list_elem->list); + kfree(list_elem->cpkt.data); + kfree(list_elem); + } + spin_unlock_irqrestore(&dev->rx_lock, flag); + set_bit(RMNET_CTRL_DEV_OPEN, &dev->status); file->private_data = dev; @@ -602,7 +545,6 @@ static int rmnet_ctl_release(struct inode *inode, struct file *file) struct ctrl_pkt_list_elem *list_elem = NULL; struct rmnet_ctrl_dev *dev; unsigned long flag; - int time; dev = file->private_data; if (!dev) @@ -624,11 +566,6 @@ static int rmnet_ctl_release(struct inode *inode, struct file *file) clear_bit(RMNET_CTRL_DEV_OPEN, &dev->status); - time = usb_wait_anchor_empty_timeout(&dev->tx_submitted, - UNLINK_TIMEOUT_MS); - if (!time) - usb_kill_anchored_urbs(&dev->tx_submitted); - file->private_data = NULL; return 0; @@ -644,7 +581,7 @@ static unsigned int rmnet_ctl_poll(struct file *file, poll_table *wait) return POLLERR; poll_wait(file, &dev->read_wait_queue, wait); - if (!test_bit(RMNET_CTRL_DEV_READY, &dev->status)) { + if (!test_bit(RMNET_CTRL_DEV_READY, &dev->cudev->status)) { dev_dbg(dev->devicep, "%s: Device not connected\n", __func__); return POLLERR; @@ -673,7 +610,7 @@ static ssize_t rmnet_ctl_read(struct file *file, char __user *buf, size_t count, DBG("%s: Read from %s\n", __func__, dev->name); ctrl_read: - if (!test_bit(RMNET_CTRL_DEV_READY, &dev->status)) { + if (!test_bit(RMNET_CTRL_DEV_READY, &dev->cudev->status)) { dev_dbg(dev->devicep, "%s: Device not connected\n", __func__); return -ENETRESET; @@ -684,7 +621,8 @@ ctrl_read: retval = wait_event_interruptible(dev->read_wait_queue, !list_empty(&dev->rx_list) || - !test_bit(RMNET_CTRL_DEV_READY, &dev->status)); + !test_bit(RMNET_CTRL_DEV_READY, + &dev->cudev->status)); if (retval < 0) return retval; @@ -740,7 +678,7 @@ static ssize_t rmnet_ctl_write(struct file *file, const char __user * buf, if (size <= 0) return -EINVAL; - if (!test_bit(RMNET_CTRL_DEV_READY, &dev->status)) + if (!test_bit(RMNET_CTRL_DEV_READY, &dev->cudev->status)) return -ENETRESET; DBG("%s: Writing %i bytes on %s\n", __func__, size, dev->name); @@ -779,9 +717,14 @@ static ssize_t rmnet_ctl_write(struct file *file, const char __user * buf, } DUMP_BUFFER("Write: ", size, buf); - status = rmnet_usb_ctrl_write(dev, cpkt, size); - if (status == size) - return size; + status = rmnet_usb_ctrl_write_cmd(dev->cudev, + USB_CDC_SEND_ENCAPSULATED_COMMAND, 0, cpkt->data, + cpkt->data_size); + if (status > 0) + dev->cudev->snd_encap_cmd_cnt++; + + kfree(cpkt->data); + kfree(cpkt); return status; } @@ -810,16 +753,11 @@ static int rmnet_ctrl_tiocmset(struct rmnet_ctrl_dev *dev, unsigned int set, mutex_unlock(&dev->dev_lock); - retval = usb_autopm_get_interface(dev->intf); - if (retval < 0) { - dev_dbg(dev->devicep, "%s: Unable to resume interface: %d\n", - __func__, retval); - return retval; - } - - retval = rmnet_usb_ctrl_write_cmd(dev); + retval = rmnet_usb_ctrl_write_cmd(dev->cudev, + USB_CDC_REQ_SET_CONTROL_LINE_STATE, 0, NULL, 0); + if (!retval) + dev->cudev->set_ctrl_line_state_cnt++; - usb_autopm_put_interface(dev->intf); return retval; } @@ -884,6 +822,7 @@ int rmnet_usb_ctrl_probe(struct usb_interface *intf, unsigned long rmnet_devnum, unsigned long *data) { + struct rmnet_ctrl_udev *cudev; struct rmnet_ctrl_dev *dev = NULL; u16 wMaxPacketSize; struct usb_endpoint_descriptor *ep; @@ -904,91 +843,99 @@ int rmnet_usb_ctrl_probe(struct usb_interface *intf, return -ENODEV; } - dev->int_pipe = usb_rcvintpipe(udev, - int_in->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); - - dev->intf = intf; + cudev = dev->cudev; - dev->id = rmnet_devnum; + cudev->int_pipe = usb_rcvintpipe(udev, + int_in->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); - dev->snd_encap_cmd_cnt = 0; - dev->get_encap_resp_cnt = 0; - dev->resp_avail_cnt = 0; - dev->tx_ctrl_err_cnt = 0; - dev->set_ctrl_line_state_cnt = 0; + cudev->intf = intf; - dev->inturb = usb_alloc_urb(0, GFP_KERNEL); - if (!dev->inturb) { - dev_err(dev->devicep, "Error allocating int urb\n"); + cudev->inturb = usb_alloc_urb(0, GFP_KERNEL); + if (!cudev->inturb) { + dev_err(&intf->dev, "Error allocating int urb\n"); + kfree(cudev); return -ENOMEM; } /*use max pkt size from ep desc*/ - ep = &dev->intf->cur_altsetting->endpoint[0].desc; + ep = &cudev->intf->cur_altsetting->endpoint[0].desc; wMaxPacketSize = le16_to_cpu(ep->wMaxPacketSize); - dev->intbuf = kmalloc(wMaxPacketSize, GFP_KERNEL); - if (!dev->intbuf) { - usb_free_urb(dev->inturb); - dev_err(dev->devicep, "Error allocating int buffer\n"); + cudev->intbuf = kmalloc(wMaxPacketSize, GFP_KERNEL); + if (!cudev->intbuf) { + usb_free_urb(cudev->inturb); + kfree(cudev); + dev_err(&intf->dev, "Error allocating int buffer\n"); return -ENOMEM; } - dev->in_ctlreq->bRequestType = + cudev->in_ctlreq->bRequestType = (USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE); - dev->in_ctlreq->bRequest = USB_CDC_GET_ENCAPSULATED_RESPONSE; - dev->in_ctlreq->wValue = 0; - dev->in_ctlreq->wIndex = - dev->intf->cur_altsetting->desc.bInterfaceNumber; - dev->in_ctlreq->wLength = cpu_to_le16(DEFAULT_READ_URB_LENGTH); + cudev->in_ctlreq->bRequest = USB_CDC_GET_ENCAPSULATED_RESPONSE; + cudev->in_ctlreq->wValue = 0; + cudev->in_ctlreq->wIndex = + cudev->intf->cur_altsetting->desc.bInterfaceNumber; + cudev->in_ctlreq->wLength = cpu_to_le16(DEFAULT_READ_URB_LENGTH); - interval = max((int)int_in->desc.bInterval, - (udev->speed == USB_SPEED_HIGH) ? HS_INTERVAL - : FS_LS_INTERVAL); + interval = int_in->desc.bInterval; - usb_fill_int_urb(dev->inturb, udev, - dev->int_pipe, - dev->intbuf, wMaxPacketSize, - notification_available_cb, dev, interval); + usb_fill_int_urb(cudev->inturb, udev, + cudev->int_pipe, + cudev->intbuf, wMaxPacketSize, + notification_available_cb, cudev, interval); usb_mark_last_busy(udev); - ret = rmnet_usb_ctrl_start_rx(dev); + ret = rmnet_usb_ctrl_start_rx(cudev); if (ret) { - usb_free_urb(dev->inturb); - kfree(dev->intbuf); + usb_free_urb(cudev->inturb); + kfree(cudev->intbuf); + kfree(cudev); return ret; } - dev->claimed = true; - - /*mux info is passed to data parameter*/ - if (*data) - set_bit(RMNET_CTRL_DEV_MUX_EN, &dev->status); + *data = (unsigned long)cudev; - *data = (unsigned long)dev; /* If MUX is enabled, wakeup the open process here */ - if (test_bit(RMNET_CTRL_DEV_MUX_EN, &dev->status)) { - set_bit(RMNET_CTRL_DEV_READY, &dev->status); - wake_up(&dev->open_wait_queue); + if (test_bit(RMNET_CTRL_DEV_MUX_EN, &cudev->status)) { + set_bit(RMNET_CTRL_DEV_READY, &cudev->status); + for (n = 0; n < insts_per_dev; n++) { + dev = &ctrl_devs[rmnet_devnum][n]; + wake_up(&dev->open_wait_queue); + } + } else { + cudev->ctrldev_id = n; + dev->claimed = true; } return 0; } -void rmnet_usb_ctrl_disconnect(struct rmnet_ctrl_dev *dev) +void rmnet_usb_ctrl_disconnect(struct rmnet_ctrl_udev *dev) { - dev->claimed = false; + struct rmnet_ctrl_dev *cdev; + int n; clear_bit(RMNET_CTRL_DEV_READY, &dev->status); - mutex_lock(&dev->dev_lock); - /*TBD: for now just update CD status*/ - dev->cbits_tolocal = ~ACM_CTRL_CD; - dev->cbits_tomdm = ~ACM_CTRL_DTR; - mutex_unlock(&dev->dev_lock); - - wake_up(&dev->read_wait_queue); + if (test_bit(RMNET_CTRL_DEV_MUX_EN, &dev->status)) { + for (n = 0; n < insts_per_dev; n++) { + cdev = &ctrl_devs[dev->rdev_num][n]; + wake_up(&cdev->read_wait_queue); + mutex_lock(&cdev->dev_lock); + cdev->cbits_tolocal = ~ACM_CTRL_CD; + cdev->cbits_tomdm = ~ACM_CTRL_DTR; + mutex_unlock(&cdev->dev_lock); + } + } else { + cdev = &ctrl_devs[dev->rdev_num][dev->ctrldev_id]; + cdev->claimed = false; + wake_up(&cdev->read_wait_queue); + mutex_lock(&cdev->dev_lock); + cdev->cbits_tolocal = ~ACM_CTRL_CD; + cdev->cbits_tomdm = ~ACM_CTRL_DTR; + mutex_unlock(&cdev->dev_lock); + } cancel_work_sync(&dev->get_encap_work); @@ -1007,7 +954,8 @@ void rmnet_usb_ctrl_disconnect(struct rmnet_ctrl_dev *dev) static ssize_t rmnet_usb_ctrl_read_stats(struct file *file, char __user *ubuf, size_t count, loff_t *ppos) { - struct rmnet_ctrl_dev *dev; + struct rmnet_ctrl_udev *dev; + struct rmnet_ctrl_dev *cdev; char *buf; int ret; int i, n; @@ -1019,7 +967,8 @@ static ssize_t rmnet_usb_ctrl_read_stats(struct file *file, char __user *ubuf, for (i = 0; i < num_devs; i++) { for (n = 0; n < insts_per_dev; n++) { - dev = &ctrl_devs[i][n]; + cdev = &ctrl_devs[i][n]; + dev = cdev->cudev; temp += scnprintf(buf + temp, DEBUG_BUF_SIZE - temp, "\n#ctrl_dev: %p Name: %s#\n" "snd encap cmd cnt %u\n" @@ -1032,20 +981,22 @@ static ssize_t rmnet_usb_ctrl_read_stats(struct file *file, char __user *ubuf, "mdm_wait_timeout: %u\n" "zlp_cnt: %u\n" "get_encap_failure_cnt %u\n" + "invalid mux id cnt %u\n" "RMNET_CTRL_DEV_MUX_EN: %d\n" "RMNET_CTRL_DEV_OPEN: %d\n" "RMNET_CTRL_DEV_READY: %d\n", - dev, dev->name, + cdev, cdev->name, dev->snd_encap_cmd_cnt, dev->resp_avail_cnt, dev->get_encap_resp_cnt, dev->set_ctrl_line_state_cnt, dev->tx_ctrl_err_cnt, - dev->cbits_tolocal, - dev->cbits_tomdm, - dev->mdm_wait_timeout, + cdev->cbits_tolocal, + cdev->cbits_tomdm, + cdev->mdm_wait_timeout, dev->zlp_cnt, dev->get_encap_failure_cnt, + dev->invalid_mux_id_cnt, test_bit(RMNET_CTRL_DEV_MUX_EN, &dev->status), test_bit(RMNET_CTRL_DEV_OPEN, @@ -1063,12 +1014,14 @@ static ssize_t rmnet_usb_ctrl_read_stats(struct file *file, char __user *ubuf, static ssize_t rmnet_usb_ctrl_reset_stats(struct file *file, const char __user * buf, size_t count, loff_t *ppos) { - struct rmnet_ctrl_dev *dev; + struct rmnet_ctrl_udev *dev; + struct rmnet_ctrl_dev *cdev; int i, n; for (i = 0; i < num_devs; i++) { for (n = 0; n < insts_per_dev; n++) { - dev = &ctrl_devs[i][n]; + cdev = &ctrl_devs[i][n]; + dev = cdev->cudev; dev->snd_encap_cmd_cnt = 0; dev->resp_avail_cnt = 0; @@ -1076,6 +1029,7 @@ static ssize_t rmnet_usb_ctrl_reset_stats(struct file *file, const char __user * dev->set_ctrl_line_state_cnt = 0; dev->tx_ctrl_err_cnt = 0; dev->zlp_cnt = 0; + dev->invalid_mux_id_cnt = 0; } } return count; @@ -1111,11 +1065,14 @@ static void rmnet_usb_ctrl_debugfs_init(void) { } static void rmnet_usb_ctrl_debugfs_exit(void) { } #endif -int rmnet_usb_ctrl_init(int no_rmnet_devs, int no_rmnet_insts_per_dev) +int rmnet_usb_ctrl_init(int no_rmnet_devs, int no_rmnet_insts_per_dev, + unsigned long mux_info) { struct rmnet_ctrl_dev *dev; + struct rmnet_ctrl_udev *cudev; int i, n; int status; + int cmux_enabled; num_devs = no_rmnet_devs; insts_per_dev = no_rmnet_insts_per_dev; @@ -1153,13 +1110,6 @@ int rmnet_usb_ctrl_init(int no_rmnet_devs, int no_rmnet_insts_per_dev) snprintf(dev->name, CTRL_DEV_MAX_LEN, "%s%d", rmnet_dev_names[i], n); - dev->wq = create_singlethread_workqueue(dev->name); - if (!dev->wq) { - pr_err("unable to allocate workqueue"); - kfree(dev); - return -ENOMEM; - } - dev->ch_id = n; mutex_init(&dev->dev_lock); @@ -1167,9 +1117,6 @@ int rmnet_usb_ctrl_init(int no_rmnet_devs, int no_rmnet_insts_per_dev) init_waitqueue_head(&dev->read_wait_queue); init_waitqueue_head(&dev->open_wait_queue); INIT_LIST_HEAD(&dev->rx_list); - init_usb_anchor(&dev->tx_submitted); - init_usb_anchor(&dev->rx_submitted); - INIT_WORK(&dev->get_encap_work, get_encap_work); cdev_init(&dev->cdev, &ctrldev_fops); dev->cdev.owner = THIS_MODULE; @@ -1178,7 +1125,6 @@ int rmnet_usb_ctrl_init(int no_rmnet_devs, int no_rmnet_insts_per_dev) if (status) { pr_err("%s: cdev_add() ret %i\n", __func__, status); - destroy_workqueue(dev->wq); kfree(dev); return status; } @@ -1191,7 +1137,6 @@ int rmnet_usb_ctrl_init(int no_rmnet_devs, int no_rmnet_insts_per_dev) pr_err("%s: device_create() returned %ld\n", __func__, PTR_ERR(dev->devicep)); cdev_del(&dev->cdev); - destroy_workqueue(dev->wq); kfree(dev); return PTR_ERR(dev->devicep); } @@ -1203,23 +1148,65 @@ int rmnet_usb_ctrl_init(int no_rmnet_devs, int no_rmnet_insts_per_dev) device_destroy(dev->devicep->class, dev->devicep->devt); cdev_del(&dev->cdev); - destroy_workqueue(dev->wq); kfree(dev); return status; } dev_set_drvdata(dev->devicep, dev); - status = rmnet_usb_ctrl_alloc_rx(dev); + cmux_enabled = test_bit(i, &mux_info); + if (n && cmux_enabled) { + dev->cudev = cudev; + set_bit(RMNET_CTRL_DEV_MUX_EN, &dev->status); + continue; + } + cudev = kzalloc(sizeof(*cudev), GFP_KERNEL); + if (!cudev) { + pr_err("Error allocating rmnet usb ctrl dev\n"); + device_remove_file(dev->devicep, + &dev_attr_modem_wait); + device_destroy(dev->devicep->class, + dev->devicep->devt); + cdev_del(&dev->cdev); + kfree(dev); + return -ENOMEM; + } + + cudev->rdev_num = i; + cudev->wq = create_singlethread_workqueue(dev->name); + if (!cudev->wq) { + pr_err("unable to allocate workqueue"); + kfree(cudev); + device_remove_file(dev->devicep, + &dev_attr_modem_wait); + device_destroy(dev->devicep->class, + dev->devicep->devt); + cdev_del(&dev->cdev); + kfree(dev); + return -ENOMEM; + } + + init_usb_anchor(&cudev->tx_submitted); + init_usb_anchor(&cudev->rx_submitted); + INIT_WORK(&cudev->get_encap_work, get_encap_work); + + status = rmnet_usb_ctrl_alloc_rx(cudev); if (status) { + destroy_workqueue(cudev->wq); + kfree(cudev); device_remove_file(dev->devicep, &dev_attr_modem_wait); device_destroy(dev->devicep->class, dev->devicep->devt); cdev_del(&dev->cdev); - destroy_workqueue(dev->wq); kfree(dev); return status; } + + dev->cudev = cudev; + if (cmux_enabled) { + set_bit(RMNET_CTRL_DEV_MUX_EN, &dev->status); + set_bit(RMNET_CTRL_DEV_MUX_EN, &cudev->status); + } } } @@ -1230,25 +1217,35 @@ int rmnet_usb_ctrl_init(int no_rmnet_devs, int no_rmnet_insts_per_dev) static void free_rmnet_ctrl_dev(struct rmnet_ctrl_dev *dev) { - kfree(dev->in_ctlreq); - kfree(dev->rcvbuf); - kfree(dev->intbuf); - usb_free_urb(dev->rcvurb); - usb_free_urb(dev->inturb); device_remove_file(dev->devicep, &dev_attr_modem_wait); cdev_del(&dev->cdev); - destroy_workqueue(dev->wq); device_destroy(dev->devicep->class, dev->devicep->devt); } -void rmnet_usb_ctrl_exit(int no_rmnet_devs, int no_rmnet_insts_per_dev) +static void free_rmnet_ctrl_udev(struct rmnet_ctrl_udev *cudev) +{ + kfree(cudev->in_ctlreq); + kfree(cudev->rcvbuf); + kfree(cudev->intbuf); + usb_free_urb(cudev->rcvurb); + usb_free_urb(cudev->inturb); + destroy_workqueue(cudev->wq); + kfree(cudev); +} + +void rmnet_usb_ctrl_exit(int no_rmnet_devs, int no_rmnet_insts_per_dev, + unsigned long mux_info) { int i, n; for (i = 0; i < no_rmnet_devs; i++) { - for (n = 0; n < no_rmnet_insts_per_dev; n++) + for (n = 0; n < no_rmnet_insts_per_dev; n++) { free_rmnet_ctrl_dev(&ctrl_devs[i][n]); + if (n && test_bit(i, &mux_info)) + continue; + free_rmnet_ctrl_udev((&ctrl_devs[i][n])->cudev); + } kfree(ctrl_devs[i]); diff --git a/drivers/net/usb/rmnet_usb_data.c b/drivers/net/usb/rmnet_usb_data.c index e2514537163..7a17525560b 100644 --- a/drivers/net/usb/rmnet_usb_data.c +++ b/drivers/net/usb/rmnet_usb_data.c @@ -24,13 +24,7 @@ #include "rmnet_usb.h" #define RMNET_DATA_LEN 2000 -#define RMNET_HEADROOM_W_MUX (sizeof(struct mux_hdr) + \ - sizeof(struct QMI_QOS_HDR_S)) #define RMNET_HEADROOM sizeof(struct QMI_QOS_HDR_S) -#define RMNET_TAILROOM MAX_PAD_BYTES(4); - -static unsigned int override_data_muxing = 1; -module_param(override_data_muxing, uint, S_IRUGO | S_IWUSR); static unsigned int no_rmnet_devs = 1; module_param(no_rmnet_devs, uint, S_IRUGO | S_IWUSR); @@ -46,9 +40,6 @@ module_param(no_rmnet_insts_per_dev, uint, S_IRUGO | S_IWUSR); static unsigned long mux_enabled; module_param(mux_enabled, ulong, S_IRUGO | S_IWUSR); -static unsigned int no_fwd_rmnet_links; -module_param(no_fwd_rmnet_links, uint, S_IRUGO | S_IWUSR); - struct usbnet *unet_list[TOTAL_RMNET_DEV_COUNT]; /* net device name prefixes, indexed by driver_info->data */ @@ -57,11 +48,6 @@ static const char * const rmnet_names[] = { "rmnet2_usb%d", }; -/* net device reverse link name prefixes, indexed by driver_info->data */ -static const char * const rev_rmnet_names[] = { - "rev_rmnet_usb%d", - "rev_rmnet2_usb%d", -}; static int data_msg_dbg_mask; enum { @@ -145,93 +131,40 @@ static struct kernel_param_ops rmnet_init_ops = { module_param_cb(rmnet_data_init, &rmnet_init_ops, &rmnet_data_init, S_IRUGO | S_IWUSR); -static void rmnet_usb_setup(struct net_device *, int mux_enabled); +static void rmnet_usb_setup(struct net_device *); static int rmnet_ioctl(struct net_device *, struct ifreq *, int); static int rmnet_usb_suspend(struct usb_interface *iface, pm_message_t message) { struct usbnet *unet = usb_get_intfdata(iface); - struct rmnet_ctrl_dev *dev; - int i, n, rdev_cnt, unet_id; - int retval = 0; - - rdev_cnt = unet->data[4] ? no_rmnet_insts_per_dev : 1; - - for (n = 0; n < rdev_cnt; n++) { - unet_id = n + unet->driver_info->data * no_rmnet_insts_per_dev; - unet = - unet->data[4] ? unet_list[unet_id] : usb_get_intfdata(iface); - - dev = (struct rmnet_ctrl_dev *)unet->data[1]; - spin_lock_irq(&unet->txq.lock); - if (work_busy(&dev->get_encap_work) || unet->txq.qlen) { - spin_unlock_irq(&unet->txq.lock); - retval = -EBUSY; - goto abort_suspend; - } + struct rmnet_ctrl_udev *dev; - set_bit(EVENT_DEV_ASLEEP, &unet->flags); - spin_unlock_irq(&unet->txq.lock); + dev = (struct rmnet_ctrl_udev *)unet->data[1]; + if (work_busy(&dev->get_encap_work)) + return -EBUSY; - usb_kill_anchored_urbs(&dev->rx_submitted); - if (work_busy(&dev->get_encap_work)) { - spin_lock_irq(&unet->txq.lock); - clear_bit(EVENT_DEV_ASLEEP, &unet->flags); - spin_unlock_irq(&unet->txq.lock); - retval = -EBUSY; - goto abort_suspend; - } - } + usb_kill_anchored_urbs(&dev->rx_submitted); + if (work_busy(&dev->get_encap_work)) + return -EBUSY; - for (n = 0; n < rdev_cnt; n++) { - unet_id = n + unet->driver_info->data * no_rmnet_insts_per_dev; - unet = - unet->data[4] ? unet_list[unet_id] : usb_get_intfdata(iface); - - dev = (struct rmnet_ctrl_dev *)unet->data[1]; - netif_device_detach(unet->net); - usbnet_terminate_urbs(unet); - netif_device_attach(unet->net); + if (usbnet_suspend(iface, message)) { + rmnet_usb_ctrl_start_rx(dev); + return -EBUSY; } return 0; - -abort_suspend: - for (i = 0; i < n; i++) { - unet_id = i + unet->driver_info->data * no_rmnet_insts_per_dev; - unet = - unet->data[4] ? unet_list[unet_id] : usb_get_intfdata(iface); - - dev = (struct rmnet_ctrl_dev *)unet->data[1]; - rmnet_usb_ctrl_start_rx(dev); - spin_lock_irq(&unet->txq.lock); - clear_bit(EVENT_DEV_ASLEEP, &unet->flags); - spin_unlock_irq(&unet->txq.lock); - } - return retval; } static int rmnet_usb_resume(struct usb_interface *iface) { struct usbnet *unet = usb_get_intfdata(iface); - struct rmnet_ctrl_dev *dev; - int n, rdev_cnt, unet_id; - - rdev_cnt = unet->data[4] ? no_rmnet_insts_per_dev : 1; + struct rmnet_ctrl_udev *dev; - for (n = 0; n < rdev_cnt; n++) { - unet_id = n + unet->driver_info->data * no_rmnet_insts_per_dev; - unet = - unet->data[4] ? unet_list[unet_id] : usb_get_intfdata(iface); + dev = (struct rmnet_ctrl_udev *)unet->data[1]; - dev = (struct rmnet_ctrl_dev *)unet->data[1]; - rmnet_usb_ctrl_start_rx(dev); - usb_set_intfdata(iface, unet); - unet->suspend_count = 1; - usbnet_resume(iface); - } + usbnet_resume(iface); - return 0; + return rmnet_usb_ctrl_start_rx(dev); } static int rmnet_usb_bind(struct usbnet *usbnet, struct usb_interface *iface) @@ -244,9 +177,6 @@ static int rmnet_usb_bind(struct usbnet *usbnet, struct usb_interface *iface) int status = 0; int i; int numends; - bool mux; - - mux = test_bit(info->data, &mux_enabled); numends = iface->cur_altsetting->desc.bNumEndpoints; for (i = 0; i < numends; i++) { @@ -276,87 +206,13 @@ static int rmnet_usb_bind(struct usbnet *usbnet, struct usb_interface *iface) bulk_out->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK); usbnet->status = int_in; - /*change name of net device to rmnet_usbx here*/ - if (mux && (info->in > no_fwd_rmnet_links)) - strlcpy(usbnet->net->name, rev_rmnet_names[info->data], - IFNAMSIZ); - else - strlcpy(usbnet->net->name, rmnet_names[info->data], - IFNAMSIZ); - - if (mux) - usbnet->rx_urb_size = usbnet->hard_mtu + sizeof(struct mux_hdr) - + MAX_PAD_BYTES(4); + strlcpy(usbnet->net->name, rmnet_names[info->data], + IFNAMSIZ); + out: return status; } -static int rmnet_usb_data_dmux(struct sk_buff *skb, struct urb *rx_urb) -{ - struct mux_hdr *hdr; - size_t pad_len; - size_t total_len; - unsigned int mux_id; - - hdr = (struct mux_hdr *)skb->data; - mux_id = hdr->mux_id; - if (!mux_id || mux_id > no_rmnet_insts_per_dev) { - pr_err_ratelimited("%s: Invalid data channel id %u.\n", - __func__, mux_id); - return -EINVAL; - } - - pad_len = hdr->padding_info >> MUX_PAD_SHIFT; - if (pad_len > MAX_PAD_BYTES(4)) { - pr_err_ratelimited("%s: Invalid pad len %d\n", - __func__, pad_len); - return -EINVAL; - } - - total_len = le16_to_cpu(hdr->pkt_len_w_padding); - if (!total_len || !(total_len - pad_len)) { - pr_err_ratelimited("%s: Invalid pkt length %d\n", __func__, - total_len); - return -EINVAL; - } - - skb->data = (unsigned char *)(hdr + 1); - skb_reset_tail_pointer(skb); - rx_urb->actual_length = total_len - pad_len; - - return mux_id - 1; -} - -static struct sk_buff *rmnet_usb_data_mux(struct sk_buff *skb, unsigned int id) -{ - struct mux_hdr *hdr; - size_t len; - struct sk_buff *new_skb; - - if ((skb->len & 0x3) && (skb_tailroom(skb) < (4 - (skb->len & 0x3)))) { - new_skb = skb_copy_expand(skb, skb_headroom(skb), - 4 - (skb->len & 0x3), GFP_ATOMIC); - dev_kfree_skb_any(skb); - if (new_skb == NULL) { - pr_err("%s: cannot allocate skb\n", __func__); - return NULL; - } - skb = new_skb; - } - - hdr = (struct mux_hdr *)skb_push(skb, sizeof(struct mux_hdr)); - hdr->mux_id = id + 1; - len = skb->len - sizeof(struct mux_hdr); - - /*add padding if len is not 4 byte aligned*/ - skb_put(skb, ALIGN(len, 4) - len); - - hdr->pkt_len_w_padding = cpu_to_le16(skb->len - sizeof(struct mux_hdr)); - hdr->padding_info = (ALIGN(len, 4) - len) << MUX_PAD_SHIFT; - - return skb; -} - static struct sk_buff *rmnet_usb_tx_fixup(struct usbnet *dev, struct sk_buff *skb, gfp_t flags) { @@ -370,9 +226,6 @@ static struct sk_buff *rmnet_usb_tx_fixup(struct usbnet *dev, qmih->flow_id = skb->mark; } - if (!override_data_muxing && dev->data[4]) - rmnet_usb_data_mux(skb, dev->data[3]); - if (skb) DBG1("[%s] Tx packet #%lu len=%d mark=0x%x\n", dev->net->name, dev->net->stats.tx_packets, @@ -403,32 +256,6 @@ static __be16 rmnet_ip_type_trans(struct sk_buff *skb) return protocol; } -static void rmnet_usb_rx_complete(struct urb *rx_urb) -{ - struct sk_buff *skb = (struct sk_buff *) rx_urb->context; - struct skb_data *entry = (struct skb_data *) skb->cb; - struct usbnet *dev = entry->dev; - unsigned int unet_offset; - unsigned int unet_id; - int mux_id; - - unet_offset = dev->driver_info->data * no_rmnet_insts_per_dev; - - if (!override_data_muxing && !rx_urb->status && dev->data[4]) { - mux_id = rmnet_usb_data_dmux(skb, rx_urb); - if (mux_id < 0) { - /*resubmit urb and free skb in rx_complete*/ - rx_urb->status = -EINVAL; - } else { - /*map urb to actual network iface based on mux id*/ - unet_id = unet_offset + mux_id; - skb->dev = unet_list[unet_id]->net; - } - } - - rx_complete(rx_urb); -} - static int rmnet_usb_rx_fixup(struct usbnet *dev, struct sk_buff *skb) { if (test_bit(RMNET_MODE_LLP_IP, &dev->data[0])) @@ -642,7 +469,7 @@ static int rmnet_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) return rc; } -static void rmnet_usb_setup(struct net_device *dev, int mux_enabled) +static void rmnet_usb_setup(struct net_device *dev) { /* Using Ethernet mode by default */ dev->netdev_ops = &rmnet_usb_ops_ether; @@ -650,14 +477,8 @@ static void rmnet_usb_setup(struct net_device *dev, int mux_enabled) /* set this after calling ether_setup */ dev->mtu = RMNET_DATA_LEN; - if (mux_enabled) { - dev->needed_headroom = RMNET_HEADROOM_W_MUX; - - /*max pad bytes for 4 byte alignment*/ - dev->needed_tailroom = RMNET_TAILROOM; - } else { - dev->needed_headroom = RMNET_HEADROOM; - } + /* for QOS header */ + dev->needed_headroom = RMNET_HEADROOM; random_ether_addr(dev->dev_addr); dev->watchdog_timeo = 1000; /* 10 seconds? */ @@ -755,75 +576,51 @@ static int rmnet_usb_probe(struct usb_interface *iface, struct driver_info *info = (struct driver_info *)prod->driver_info; struct usb_device *udev; int status = 0; - unsigned int i, unet_id, rdev_cnt, n = 0; - bool mux; - struct rmnet_ctrl_dev *dev; udev = interface_to_usbdev(iface); if (iface->num_altsetting != 1) { dev_err(&iface->dev, "%s invalid num_altsetting %u\n", __func__, iface->num_altsetting); - status = -EINVAL; - goto out; + return -EINVAL; } - mux = test_bit(info->data, &mux_enabled); - rdev_cnt = mux ? no_rmnet_insts_per_dev : 1; - info->in = 0; - - for (n = 0; n < rdev_cnt; n++) { - - /* Use this filed to increment device count this will be - * used by bind to determin the forward link and reverse - * link network interface names. - */ - info->in++; - status = usbnet_probe(iface, prod); - if (status < 0) { - dev_err(&iface->dev, "usbnet_probe failed %d\n", - status); - goto out; - } - - unet_id = n + info->data * no_rmnet_insts_per_dev; - - unet_list[unet_id] = unet = usb_get_intfdata(iface); - - /*store mux id for later access*/ - unet->data[3] = n; - - /*save mux info for control and usbnet devices*/ - unet->data[1] = unet->data[4] = mux; + status = usbnet_probe(iface, prod); + if (status < 0) { + dev_err(&iface->dev, "usbnet_probe failed %d\n", + status); + return status; + } - /*set rmnet operation mode to eth by default*/ - set_bit(RMNET_MODE_LLP_ETH, &unet->data[0]); + unet = usb_get_intfdata(iface); - /*update net device*/ - rmnet_usb_setup(unet->net, mux); + /*set rmnet operation mode to eth by default*/ + set_bit(RMNET_MODE_LLP_ETH, &unet->data[0]); - /*create /sys/class/net/rmnet_usbx/dbg_mask*/ - status = device_create_file(&unet->net->dev, - &dev_attr_dbg_mask); - if (status) { - usbnet_disconnect(iface); - goto out; - } + /*update net device*/ + rmnet_usb_setup(unet->net); - status = rmnet_usb_ctrl_probe(iface, unet->status, info->data, - &unet->data[1]); - if (status) { - device_remove_file(&unet->net->dev, &dev_attr_dbg_mask); - usbnet_disconnect(iface); - goto out; - } + /*create /sys/class/net/rmnet_usbx/dbg_mask*/ + status = device_create_file(&unet->net->dev, + &dev_attr_dbg_mask); + if (status) { + usbnet_disconnect(iface); + return status; + } - status = rmnet_usb_data_debugfs_init(unet); - if (status) - dev_dbg(&iface->dev, - "mode debugfs file is not available\n"); + status = rmnet_usb_ctrl_probe(iface, unet->status, info->data, + &unet->data[1]); + if (status) { + device_remove_file(&unet->net->dev, &dev_attr_dbg_mask); + usbnet_disconnect(iface); + return status; } + status = rmnet_usb_data_debugfs_init(unet); + if (status) + dev_dbg(&iface->dev, + "mode debugfs file is not available\n"); + usb_enable_autosuspend(udev); if (udev->parent && !udev->parent->parent) { @@ -833,51 +630,23 @@ static int rmnet_usb_probe(struct usb_interface *iface, } return 0; - -out: - for (i = 0; i < n; i++) { - /* This cleanup happens only for MUX case */ - unet_id = i + info->data * no_rmnet_insts_per_dev; - unet = unet_list[unet_id]; - dev = (struct rmnet_ctrl_dev *)unet->data[1]; - - rmnet_usb_data_debugfs_cleanup(unet); - rmnet_usb_ctrl_disconnect(dev); - device_remove_file(&unet->net->dev, &dev_attr_dbg_mask); - usb_set_intfdata(iface, unet_list[unet_id]); - usbnet_disconnect(iface); - unet_list[unet_id] = NULL; - } - - return status; } static void rmnet_usb_disconnect(struct usb_interface *intf) { struct usbnet *unet = usb_get_intfdata(intf); - struct rmnet_ctrl_dev *dev; - unsigned int n, rdev_cnt, unet_id; - struct driver_info *info = unet->driver_info; - bool mux = unet->data[4]; - - rdev_cnt = mux ? no_rmnet_insts_per_dev : 1; + struct rmnet_ctrl_udev *dev; device_set_wakeup_enable(&unet->udev->dev, 0); - for (n = 0; n < rdev_cnt; n++) { - unet_id = n + info->data * no_rmnet_insts_per_dev; - unet = mux ? unet_list[unet_id] : usb_get_intfdata(intf); - device_remove_file(&unet->net->dev, &dev_attr_dbg_mask); + device_remove_file(&unet->net->dev, &dev_attr_dbg_mask); - dev = (struct rmnet_ctrl_dev *)unet->data[1]; - rmnet_usb_ctrl_disconnect(dev); - unet->data[0] = 0; - unet->data[1] = 0; - rmnet_usb_data_debugfs_cleanup(unet); - usb_set_intfdata(intf, unet); - usbnet_disconnect(intf); - unet_list[unet_id] = NULL; - } + dev = (struct rmnet_ctrl_udev *)unet->data[1]; + rmnet_usb_ctrl_disconnect(dev); + unet->data[0] = 0; + unet->data[1] = 0; + rmnet_usb_data_debugfs_cleanup(unet); + usbnet_disconnect(intf); } static struct driver_info rmnet_info = { @@ -886,7 +655,6 @@ static struct driver_info rmnet_info = { .bind = rmnet_usb_bind, .tx_fixup = rmnet_usb_tx_fixup, .rx_fixup = rmnet_usb_rx_fixup, - .rx_complete = rmnet_usb_rx_complete, .manage_power = rmnet_usb_manage_power, .data = 0, }; @@ -897,7 +665,6 @@ static struct driver_info rmnet_usb_info = { .bind = rmnet_usb_bind, .tx_fixup = rmnet_usb_tx_fixup, .rx_fixup = rmnet_usb_rx_fixup, - .rx_complete = rmnet_usb_rx_complete, .manage_power = rmnet_usb_manage_power, .data = 1, }; @@ -984,7 +751,8 @@ static int rmnet_data_start(void) } /* initialize ctrl devices */ - retval = rmnet_usb_ctrl_init(no_rmnet_devs, no_rmnet_insts_per_dev); + retval = rmnet_usb_ctrl_init(no_rmnet_devs, no_rmnet_insts_per_dev, + mux_enabled); if (retval) { pr_err("rmnet_usb_cmux_init failed: %d", retval); return retval; @@ -1002,7 +770,7 @@ static int rmnet_data_start(void) static void __exit rmnet_usb_exit(void) { usb_deregister(&rmnet_usb); - rmnet_usb_ctrl_exit(no_rmnet_devs, no_rmnet_insts_per_dev); + rmnet_usb_ctrl_exit(no_rmnet_devs, no_rmnet_insts_per_dev, mux_enabled); } module_exit(rmnet_usb_exit); diff --git a/drivers/net/usb/usbnet.c b/drivers/net/usb/usbnet.c index 207a1259009..15ce89b77e7 100644 --- a/drivers/net/usb/usbnet.c +++ b/drivers/net/usb/usbnet.c @@ -440,11 +440,12 @@ EXPORT_SYMBOL_GPL(usbnet_defer_kevent); /*-------------------------------------------------------------------------*/ +static void rx_complete(struct urb *urb); + static int rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags) { struct sk_buff *skb; struct skb_data *entry; - usb_complete_t complete_fn; int retval = 0; unsigned long lockflags; size_t size = dev->rx_urb_size; @@ -468,13 +469,8 @@ static int rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags) entry->dev = dev; entry->length = 0; - if (dev->driver_info->rx_complete) - complete_fn = dev->driver_info->rx_complete; - else - complete_fn = rx_complete; - usb_fill_bulk_urb (urb, dev->udev, dev->in, - skb->data, size, complete_fn, skb); + skb->data, size, rx_complete, skb); spin_lock_irqsave (&dev->rxq.lock, lockflags); @@ -548,7 +544,7 @@ done: /*-------------------------------------------------------------------------*/ -void rx_complete(struct urb *urb) +static void rx_complete(struct urb *urb) { struct sk_buff *skb = (struct sk_buff *) urb->context; struct skb_data *entry = (struct skb_data *) skb->cb; diff --git a/drivers/net/wireless/cnss/cnss.c b/drivers/net/wireless/cnss/cnss.c index f1e41dc41c4..eb30cdd634f 100644 --- a/drivers/net/wireless/cnss/cnss.c +++ b/drivers/net/wireless/cnss/cnss.c @@ -23,10 +23,12 @@ #include <linux/of_gpio.h> #include <linux/pm.h> #include <linux/pm_wakeup.h> +#include <linux/sched.h> +#include <linux/pm_qos.h> +#include <soc/qcom/subsystem_restart.h> +#include <soc/qcom/ramdump.h> #include <mach/gpiomux.h> #include <mach/msm_pcie.h> -#include <mach/subsystem_restart.h> -#include <mach/ramdump.h> #include <net/cnss.h> #define subsys_to_drv(d) container_of(d, struct cnss_data, subsys_desc) @@ -57,6 +59,7 @@ struct cnss_wlan_gpio_info { u32 num; bool state; bool init; + bool prop; }; struct cnss_wlan_vreg_info { @@ -83,6 +86,7 @@ static struct cnss_data { struct pci_saved_state *saved_state; u16 revision_id; struct cnss_fw_files fw_files; + struct pm_qos_request qos_request; } *penv; static int cnss_wlan_vreg_set(struct cnss_wlan_vreg_info *vreg_info, bool state) @@ -140,6 +144,9 @@ err_gpio_req: static void cnss_wlan_gpio_set(struct cnss_wlan_gpio_info *info, bool state) { + if (!info->prop) + return; + if (info->state == state) { pr_debug("Already %s gpio is %s\n", info->name, state ? "high" : "low"); @@ -178,6 +185,12 @@ static int cnss_wlan_get_resources(struct platform_device *pdev) } vreg_info->state = VREG_ON; + if (!of_find_property((&pdev->dev)->of_node, gpio_info->name, NULL)) { + gpio_info->prop = false; + goto end; + } + + gpio_info->prop = true; ret = of_get_named_gpio((&pdev->dev)->of_node, gpio_info->name, 0); @@ -200,6 +213,7 @@ static int cnss_wlan_get_resources(struct platform_device *pdev) goto err_gpio_init; } +end: return ret; err_gpio_init: @@ -223,6 +237,7 @@ static void cnss_wlan_release_resources(void) gpio_free(gpio_info->num); regulator_put(vreg_info->wlan_reg); gpio_info->state = WLAN_EN_LOW; + gpio_info->prop = false; vreg_info->state = VREG_OFF; } @@ -586,6 +601,20 @@ void cnss_pm_wake_lock_destroy(struct wakeup_source *ws) } EXPORT_SYMBOL(cnss_pm_wake_lock_destroy); +void cnss_flush_work(void *work) +{ + struct work_struct *cnss_work = work; + cancel_work_sync(cnss_work); +} +EXPORT_SYMBOL(cnss_flush_work); + +void cnss_flush_delayed_work(void *dwork) +{ + struct delayed_work *cnss_dwork = dwork; + cancel_delayed_work_sync(cnss_dwork); +} +EXPORT_SYMBOL(cnss_flush_delayed_work); + int cnss_get_ramdump_mem(unsigned long *address, unsigned long *size) { struct resource *res; @@ -614,6 +643,12 @@ void cnss_device_crashed(void) } EXPORT_SYMBOL(cnss_device_crashed); +int cnss_set_cpus_allowed_ptr(struct task_struct *task, ulong cpu) +{ + return set_cpus_allowed_ptr(task, cpumask_of(cpu)); +} +EXPORT_SYMBOL(cnss_set_cpus_allowed_ptr); + static int cnss_shutdown(const struct subsys_desc *subsys, bool force_stop) { struct cnss_wlan_driver *wdrv; @@ -800,6 +835,7 @@ static int cnss_probe(struct platform_device *pdev) penv->gpio_info.num = 0; penv->gpio_info.state = WLAN_EN_LOW; penv->gpio_info.init = WLAN_EN_HIGH; + penv->gpio_info.prop = false; penv->vreg_info.wlan_reg = NULL; penv->vreg_info.state = VREG_OFF; @@ -873,6 +909,18 @@ static void __exit cnss_exit(void) platform_driver_unregister(&cnss_driver); } +void cnss_request_pm_qos(u32 qos_val) +{ + pm_qos_add_request(&penv->qos_request, PM_QOS_CPU_DMA_LATENCY, qos_val); +} +EXPORT_SYMBOL(cnss_request_pm_qos); + +void cnss_remove_pm_qos(void) +{ + pm_qos_remove_request(&penv->qos_request); +} +EXPORT_SYMBOL(cnss_remove_pm_qos); + module_init(cnss_initialize); module_exit(cnss_exit); diff --git a/drivers/net/wireless/wcnss/wcnss_wlan.c b/drivers/net/wireless/wcnss/wcnss_wlan.c index 71a1e61a9bc..919b0dddede 100644 --- a/drivers/net/wireless/wcnss/wcnss_wlan.c +++ b/drivers/net/wireless/wcnss/wcnss_wlan.c @@ -35,11 +35,11 @@ #include <linux/rwsem.h> #include <linux/mfd/pm8xxx/misc.h> #include <linux/qpnp/qpnp-adc.h> +#include <soc/qcom/subsystem_restart.h> +#include <soc/qcom/subsystem_notif.h> #include <mach/msm_smd.h> #include <mach/msm_iomap.h> -#include <mach/subsystem_restart.h> -#include <mach/subsystem_notif.h> #ifdef CONFIG_WCNSS_MEM_PRE_ALLOC #include "wcnss_prealloc.h" |