usb: rmnet_sdio/rmnet_smd_sdio: Add support for new composition framework
Also rename various function/variable names and defines to fix
redeclaration errors.
Signed-off-by: Manu Gautam <mgautam@codeaurora.org>
diff --git a/drivers/usb/gadget/android.c b/drivers/usb/gadget/android.c
index 827c041..20b73a1 100644
--- a/drivers/usb/gadget/android.c
+++ b/drivers/usb/gadget/android.c
@@ -48,6 +48,8 @@
#include "f_diag.c"
#include "f_rmnet_smd.c"
+#include "f_rmnet_sdio.c"
+#include "f_rmnet_smd_sdio.c"
#include "f_rmnet.c"
#include "f_mass_storage.c"
#include "u_serial.c"
@@ -197,6 +199,7 @@
/*-------------------------------------------------------------------------*/
/* Supported functions initialization */
+/* RMNET_SMD */
static int rmnet_smd_function_bind_config(struct android_usb_function *f,
struct usb_configuration *c)
{
@@ -208,6 +211,48 @@
.bind_config = rmnet_smd_function_bind_config,
};
+/* RMNET_SDIO */
+static int rmnet_sdio_function_bind_config(struct android_usb_function *f,
+ struct usb_configuration *c)
+{
+ return rmnet_sdio_function_add(c);
+}
+
+static struct android_usb_function rmnet_sdio_function = {
+ .name = "rmnet_sdio",
+ .bind_config = rmnet_sdio_function_bind_config,
+};
+
+/* RMNET_SMD_SDIO */
+static int rmnet_smd_sdio_function_init(struct android_usb_function *f,
+ struct usb_composite_dev *cdev)
+{
+ return rmnet_smd_sdio_init();
+}
+
+static void rmnet_smd_sdio_function_cleanup(struct android_usb_function *f)
+{
+ rmnet_smd_sdio_cleanup();
+}
+
+static int rmnet_smd_sdio_bind_config(struct android_usb_function *f,
+ struct usb_configuration *c)
+{
+ return rmnet_smd_sdio_function_add(c);
+}
+
+static struct device_attribute *rmnet_smd_sdio_attributes[] = {
+ &dev_attr_transport, NULL };
+
+static struct android_usb_function rmnet_smd_sdio_function = {
+ .name = "rmnet_smd_sdio",
+ .init = rmnet_smd_sdio_function_init,
+ .cleanup = rmnet_smd_sdio_function_cleanup,
+ .bind_config = rmnet_smd_sdio_bind_config,
+ .attributes = rmnet_smd_sdio_attributes,
+};
+
+/* RMNET - used with BAM */
#define MAX_RMNET_INSTANCES 1
static int rmnet_instances;
static int rmnet_function_init(struct android_usb_function *f,
@@ -269,7 +314,7 @@
.attributes = rmnet_function_attributes,
};
-
+/* DIAG */
static char diag_clients[32]; /*enabled DIAG clients- "diag[,diag_mdm]" */
static ssize_t clients_store(
struct device *device, struct device_attribute *attr,
@@ -332,6 +377,7 @@
.attributes = diag_function_attributes,
};
+/* SERIAL */
static char serial_transports[32]; /*enabled FSERIAL ports - "tty[,sdio]"*/
static ssize_t serial_transports_store(
struct device *device, struct device_attribute *attr,
@@ -405,6 +451,7 @@
};
+/* ADB */
static int adb_function_init(struct android_usb_function *f, struct usb_composite_dev *cdev)
{
return adb_setup();
@@ -867,6 +914,8 @@
static struct android_usb_function *supported_functions[] = {
&rmnet_smd_function,
+ &rmnet_sdio_function,
+ &rmnet_smd_sdio_function,
&rmnet_function,
&diag_function,
&serial_function,
diff --git a/drivers/usb/gadget/f_rmnet_sdio.c b/drivers/usb/gadget/f_rmnet_sdio.c
index b6a351a..61a67bb 100644
--- a/drivers/usb/gadget/f_rmnet_sdio.c
+++ b/drivers/usb/gadget/f_rmnet_sdio.c
@@ -34,43 +34,50 @@
#include <linux/usb/cdc.h>
#include <linux/usb/composite.h>
#include <linux/usb/ch9.h>
-#include <linux/usb/android_composite.h>
#include <linux/termios.h>
#include <linux/debugfs.h>
#include <mach/sdio_cmux.h>
#include <mach/sdio_dmux.h>
+#ifdef CONFIG_RMNET_SDIO_CTL_CHANNEL
static uint32_t rmnet_sdio_ctl_ch = CONFIG_RMNET_SDIO_CTL_CHANNEL;
+#else
+static uint32_t rmnet_sdio_ctl_ch;
+#endif
module_param(rmnet_sdio_ctl_ch, uint, S_IRUGO);
MODULE_PARM_DESC(rmnet_sdio_ctl_ch, "RmNet control SDIO channel ID");
+#ifdef CONFIG_RMNET_SDIO_DATA_CHANNEL
static uint32_t rmnet_sdio_data_ch = CONFIG_RMNET_SDIO_DATA_CHANNEL;
+#else
+static uint32_t rmnet_sdio_data_ch;
+#endif
module_param(rmnet_sdio_data_ch, uint, S_IRUGO);
MODULE_PARM_DESC(rmnet_sdio_data_ch, "RmNet data SDIO channel ID");
-#define ACM_CTRL_DTR (1 << 0)
+#define ACM_CTRL_DTR (1 << 0)
-#define SDIO_MUX_HDR 8
-#define RMNET_SDIO_NOTIFY_INTERVAL 5
+#define SDIO_MUX_HDR 8
+#define RMNET_SDIO_NOTIFY_INTERVAL 5
#define RMNET_SDIO_MAX_NFY_SZE sizeof(struct usb_cdc_notification)
-#define RMNET_SDIO_RX_REQ_MAX 16
-#define RMNET_SDIO_RX_REQ_SIZE 2048
-#define RMNET_SDIO_TX_REQ_MAX 200
+#define RMNET_SDIO_RX_REQ_MAX 16
+#define RMNET_SDIO_RX_REQ_SIZE 2048
+#define RMNET_SDIO_TX_REQ_MAX 200
#define TX_PKT_DROP_THRESHOLD 1000
#define RX_PKT_FLOW_CTRL_EN_THRESHOLD 1000
#define RX_PKT_FLOW_CTRL_DISABLE 500
-unsigned int tx_pkt_drop_thld = TX_PKT_DROP_THRESHOLD;
-module_param(tx_pkt_drop_thld, uint, S_IRUGO | S_IWUSR);
+unsigned int sdio_tx_pkt_drop_thld = TX_PKT_DROP_THRESHOLD;
+module_param(sdio_tx_pkt_drop_thld, uint, S_IRUGO | S_IWUSR);
-unsigned int rx_fctrl_en_thld = RX_PKT_FLOW_CTRL_EN_THRESHOLD;
-module_param(rx_fctrl_en_thld, uint, S_IRUGO | S_IWUSR);
+unsigned int sdio_rx_fctrl_en_thld = RX_PKT_FLOW_CTRL_EN_THRESHOLD;
+module_param(sdio_rx_fctrl_en_thld, uint, S_IRUGO | S_IWUSR);
-unsigned int rx_fctrl_dis_thld = RX_PKT_FLOW_CTRL_DISABLE;
-module_param(rx_fctrl_dis_thld, uint, S_IRUGO | S_IWUSR);
+unsigned int sdio_rx_fctrl_dis_thld = RX_PKT_FLOW_CTRL_DISABLE;
+module_param(sdio_rx_fctrl_dis_thld, uint, S_IRUGO | S_IWUSR);
/* QMI requests & responses buffer*/
struct rmnet_sdio_qmi_buf {
@@ -79,7 +86,7 @@
struct list_head list;
};
-struct rmnet_dev {
+struct rmnet_sdio_dev {
struct usb_function function;
struct usb_composite_dev *cdev;
@@ -114,7 +121,7 @@
struct delayed_work sdio_open_work;
struct work_struct sdio_close_work;
-#define CH_OPEN 1
+#define RMNET_SDIO_CH_OPEN 1
unsigned long data_ch_status;
unsigned long ctrl_ch_status;
@@ -123,6 +130,7 @@
struct work_struct set_modem_ctl_bits_work;
/* pkt logging dpkt - data pkt; cpkt - control pkt*/
+ struct dentry *dent;
unsigned long dpkt_tolaptop;
unsigned long dpkt_tomodem;
unsigned long tx_drp_cnt;
@@ -130,7 +138,7 @@
unsigned long cpkt_tomodem;
};
-static struct usb_interface_descriptor rmnet_interface_desc = {
+static struct usb_interface_descriptor rmnet_sdio_interface_desc = {
.bLength = USB_DT_INTERFACE_SIZE,
.bDescriptorType = USB_DT_INTERFACE,
/* .bInterfaceNumber = DYNAMIC */
@@ -142,7 +150,7 @@
};
/* Full speed support */
-static struct usb_endpoint_descriptor rmnet_fs_notify_desc = {
+static struct usb_endpoint_descriptor rmnet_sdio_fs_notify_desc = {
.bLength = USB_DT_ENDPOINT_SIZE,
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = USB_DIR_IN,
@@ -151,7 +159,7 @@
.bInterval = 1 << RMNET_SDIO_NOTIFY_INTERVAL,
};
-static struct usb_endpoint_descriptor rmnet_fs_in_desc = {
+static struct usb_endpoint_descriptor rmnet_sdio_fs_in_desc = {
.bLength = USB_DT_ENDPOINT_SIZE,
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = USB_DIR_IN,
@@ -159,7 +167,7 @@
.wMaxPacketSize = __constant_cpu_to_le16(64),
};
-static struct usb_endpoint_descriptor rmnet_fs_out_desc = {
+static struct usb_endpoint_descriptor rmnet_sdio_fs_out_desc = {
.bLength = USB_DT_ENDPOINT_SIZE,
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = USB_DIR_OUT,
@@ -167,16 +175,16 @@
.wMaxPacketSize = __constant_cpu_to_le16(64),
};
-static struct usb_descriptor_header *rmnet_fs_function[] = {
- (struct usb_descriptor_header *) &rmnet_interface_desc,
- (struct usb_descriptor_header *) &rmnet_fs_notify_desc,
- (struct usb_descriptor_header *) &rmnet_fs_in_desc,
- (struct usb_descriptor_header *) &rmnet_fs_out_desc,
+static struct usb_descriptor_header *rmnet_sdio_fs_function[] = {
+ (struct usb_descriptor_header *) &rmnet_sdio_interface_desc,
+ (struct usb_descriptor_header *) &rmnet_sdio_fs_notify_desc,
+ (struct usb_descriptor_header *) &rmnet_sdio_fs_in_desc,
+ (struct usb_descriptor_header *) &rmnet_sdio_fs_out_desc,
NULL,
};
/* High speed support */
-static struct usb_endpoint_descriptor rmnet_hs_notify_desc = {
+static struct usb_endpoint_descriptor rmnet_sdio_hs_notify_desc = {
.bLength = USB_DT_ENDPOINT_SIZE,
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = USB_DIR_IN,
@@ -185,7 +193,7 @@
.bInterval = RMNET_SDIO_NOTIFY_INTERVAL + 4,
};
-static struct usb_endpoint_descriptor rmnet_hs_in_desc = {
+static struct usb_endpoint_descriptor rmnet_sdio_hs_in_desc = {
.bLength = USB_DT_ENDPOINT_SIZE,
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = USB_DIR_IN,
@@ -193,7 +201,7 @@
.wMaxPacketSize = __constant_cpu_to_le16(512),
};
-static struct usb_endpoint_descriptor rmnet_hs_out_desc = {
+static struct usb_endpoint_descriptor rmnet_sdio_hs_out_desc = {
.bLength = USB_DT_ENDPOINT_SIZE,
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = USB_DIR_OUT,
@@ -201,33 +209,33 @@
.wMaxPacketSize = __constant_cpu_to_le16(512),
};
-static struct usb_descriptor_header *rmnet_hs_function[] = {
- (struct usb_descriptor_header *) &rmnet_interface_desc,
- (struct usb_descriptor_header *) &rmnet_hs_notify_desc,
- (struct usb_descriptor_header *) &rmnet_hs_in_desc,
- (struct usb_descriptor_header *) &rmnet_hs_out_desc,
+static struct usb_descriptor_header *rmnet_sdio_hs_function[] = {
+ (struct usb_descriptor_header *) &rmnet_sdio_interface_desc,
+ (struct usb_descriptor_header *) &rmnet_sdio_hs_notify_desc,
+ (struct usb_descriptor_header *) &rmnet_sdio_hs_in_desc,
+ (struct usb_descriptor_header *) &rmnet_sdio_hs_out_desc,
NULL,
};
/* String descriptors */
-static struct usb_string rmnet_string_defs[] = {
+static struct usb_string rmnet_sdio_string_defs[] = {
[0].s = "QMI RmNet",
{ } /* end of list */
};
-static struct usb_gadget_strings rmnet_string_table = {
+static struct usb_gadget_strings rmnet_sdio_string_table = {
.language = 0x0409, /* en-us */
- .strings = rmnet_string_defs,
+ .strings = rmnet_sdio_string_defs,
};
-static struct usb_gadget_strings *rmnet_strings[] = {
- &rmnet_string_table,
+static struct usb_gadget_strings *rmnet_sdio_strings[] = {
+ &rmnet_sdio_string_table,
NULL,
};
static struct rmnet_sdio_qmi_buf *
-rmnet_alloc_qmi(unsigned len, gfp_t kmalloc_flags)
+rmnet_sdio_alloc_qmi(unsigned len, gfp_t kmalloc_flags)
{
struct rmnet_sdio_qmi_buf *qmi;
@@ -244,7 +252,7 @@
return qmi ? qmi : ERR_PTR(-ENOMEM);
}
-static void rmnet_free_qmi(struct rmnet_sdio_qmi_buf *qmi)
+static void rmnet_sdio_free_qmi(struct rmnet_sdio_qmi_buf *qmi)
{
kfree(qmi->buf);
kfree(qmi);
@@ -254,7 +262,7 @@
* usb_request or a pointer with an error code if there is an error.
*/
static struct usb_request *
-rmnet_alloc_req(struct usb_ep *ep, unsigned len, gfp_t kmalloc_flags)
+rmnet_sdio_alloc_req(struct usb_ep *ep, unsigned len, gfp_t kmalloc_flags)
{
struct usb_request *req;
@@ -275,15 +283,16 @@
/*
* Free a usb_request and its buffer.
*/
-static void rmnet_free_req(struct usb_ep *ep, struct usb_request *req)
+static void rmnet_sdio_free_req(struct usb_ep *ep, struct usb_request *req)
{
kfree(req->buf);
usb_ep_free_request(ep, req);
}
-static void rmnet_notify_complete(struct usb_ep *ep, struct usb_request *req)
+static void rmnet_sdio_notify_complete(struct usb_ep *ep,
+ struct usb_request *req)
{
- struct rmnet_dev *dev = req->context;
+ struct rmnet_sdio_dev *dev = req->context;
struct usb_composite_dev *cdev = dev->cdev;
int status = req->status;
@@ -298,7 +307,7 @@
/* FALLTHROUGH */
case 0:
- if (!test_bit(CH_OPEN, &dev->ctrl_ch_status))
+ if (!test_bit(RMNET_SDIO_CH_OPEN, &dev->ctrl_ch_status))
return;
/* handle multiple pending QMI_RESPONSE_AVAILABLE
@@ -316,7 +325,7 @@
}
}
-static void rmnet_qmi_response_available(struct rmnet_dev *dev)
+static void rmnet_sdio_qmi_resp_available(struct rmnet_sdio_dev *dev)
{
struct usb_composite_dev *cdev = dev->cdev;
struct usb_cdc_notification *event;
@@ -352,32 +361,32 @@
}
}
-#define MAX_CTRL_PKT_SIZE 4096
-static void rmnet_ctl_receive_cb(void *data, int size, void *priv)
+#define SDIO_MAX_CTRL_PKT_SIZE 4096
+static void rmnet_sdio_ctl_receive_cb(void *data, int size, void *priv)
{
- struct rmnet_dev *dev = priv;
+ struct rmnet_sdio_dev *dev = priv;
struct usb_composite_dev *cdev = dev->cdev;
struct rmnet_sdio_qmi_buf *qmi_resp;
unsigned long flags;
if (!data) {
pr_info("%s: cmux_ch close event\n", __func__);
- if (test_bit(CH_OPEN, &dev->ctrl_ch_status) &&
- test_bit(CH_OPEN, &dev->data_ch_status)) {
- clear_bit(CH_OPEN, &dev->ctrl_ch_status);
- clear_bit(CH_OPEN, &dev->data_ch_status);
+ if (test_bit(RMNET_SDIO_CH_OPEN, &dev->ctrl_ch_status) &&
+ test_bit(RMNET_SDIO_CH_OPEN, &dev->data_ch_status)) {
+ clear_bit(RMNET_SDIO_CH_OPEN, &dev->ctrl_ch_status);
+ clear_bit(RMNET_SDIO_CH_OPEN, &dev->data_ch_status);
queue_work(dev->wq, &dev->sdio_close_work);
}
return;
}
- if (!size || !test_bit(CH_OPEN, &dev->ctrl_ch_status))
+ if (!size || !test_bit(RMNET_SDIO_CH_OPEN, &dev->ctrl_ch_status))
return;
- if (size > MAX_CTRL_PKT_SIZE) {
+ if (size > SDIO_MAX_CTRL_PKT_SIZE) {
ERROR(cdev, "ctrl pkt size:%d exceeds max pkt size:%d\n",
- size, MAX_CTRL_PKT_SIZE);
+ size, SDIO_MAX_CTRL_PKT_SIZE);
return;
}
@@ -386,7 +395,7 @@
return;
}
- qmi_resp = rmnet_alloc_qmi(size, GFP_KERNEL);
+ qmi_resp = rmnet_sdio_alloc_qmi(size, GFP_KERNEL);
if (IS_ERR(qmi_resp)) {
DBG(cdev, "unable to allocate memory for QMI resp\n");
return;
@@ -398,28 +407,29 @@
dev->qresp_q_len++;
spin_unlock_irqrestore(&dev->lock, flags);
- rmnet_qmi_response_available(dev);
+ rmnet_sdio_qmi_resp_available(dev);
}
-static void rmnet_ctl_write_done(void *data, int size, void *priv)
+static void rmnet_sdio_ctl_write_done(void *data, int size, void *priv)
{
- struct rmnet_dev *dev = priv;
+ struct rmnet_sdio_dev *dev = priv;
struct usb_composite_dev *cdev = dev->cdev;
VDBG(cdev, "rmnet control write done = %d bytes\n", size);
}
-static void rmnet_sts_callback(int id, void *priv)
+static void rmnet_sdio_sts_callback(int id, void *priv)
{
- struct rmnet_dev *dev = priv;
+ struct rmnet_sdio_dev *dev = priv;
struct usb_composite_dev *cdev = dev->cdev;
- DBG(cdev, "rmnet_sts_callback: id: %d\n", id);
+ DBG(cdev, "rmnet_sdio_sts_callback: id: %d\n", id);
}
-static void rmnet_control_rx_work(struct work_struct *w)
+static void rmnet_sdio_control_rx_work(struct work_struct *w)
{
- struct rmnet_dev *dev = container_of(w, struct rmnet_dev, ctl_rx_work);
+ struct rmnet_sdio_dev *dev = container_of(w, struct rmnet_sdio_dev,
+ ctl_rx_work);
struct usb_composite_dev *cdev = dev->cdev;
struct rmnet_sdio_qmi_buf *qmi_req;
unsigned long flags;
@@ -449,15 +459,16 @@
* cmux_write API copies the buffer and gives it to sdio_al.
* Hence freeing the memory before write is completed.
*/
- rmnet_free_qmi(qmi_req);
+ rmnet_sdio_free_qmi(qmi_req);
}
unlock:
spin_unlock_irqrestore(&dev->lock, flags);
}
-static void rmnet_response_complete(struct usb_ep *ep, struct usb_request *req)
+static void rmnet_sdio_response_complete(struct usb_ep *ep,
+ struct usb_request *req)
{
- struct rmnet_dev *dev = req->context;
+ struct rmnet_sdio_dev *dev = req->context;
struct usb_composite_dev *cdev = dev->cdev;
switch (req->status) {
@@ -472,9 +483,10 @@
}
}
-static void rmnet_command_complete(struct usb_ep *ep, struct usb_request *req)
+static void rmnet_sdio_command_complete(struct usb_ep *ep,
+ struct usb_request *req)
{
- struct rmnet_dev *dev = req->context;
+ struct rmnet_sdio_dev *dev = req->context;
struct usb_composite_dev *cdev = dev->cdev;
struct rmnet_sdio_qmi_buf *qmi_req;
int len = req->actual;
@@ -485,10 +497,10 @@
}
/* discard the packet if sdio is not available */
- if (!test_bit(CH_OPEN, &dev->ctrl_ch_status))
+ if (!test_bit(RMNET_SDIO_CH_OPEN, &dev->ctrl_ch_status))
return;
- qmi_req = rmnet_alloc_qmi(len, GFP_ATOMIC);
+ qmi_req = rmnet_sdio_alloc_qmi(len, GFP_ATOMIC);
if (IS_ERR(qmi_req)) {
ERROR(cdev, "unable to allocate memory for QMI req\n");
return;
@@ -503,9 +515,10 @@
}
static int
-rmnet_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
+rmnet_sdio_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
{
- struct rmnet_dev *dev = container_of(f, struct rmnet_dev, function);
+ struct rmnet_sdio_dev *dev = container_of(f, struct rmnet_sdio_dev,
+ function);
struct usb_composite_dev *cdev = f->config->cdev;
struct usb_request *req = cdev->req;
int ret = -EOPNOTSUPP;
@@ -524,7 +537,7 @@
if (w_length > req->length)
goto invalid;
ret = w_length;
- req->complete = rmnet_command_complete;
+ req->complete = rmnet_sdio_command_complete;
req->context = dev;
break;
@@ -557,8 +570,8 @@
memcpy(req->buf, resp->buf, len);
ret = len;
req->context = dev;
- req->complete = rmnet_response_complete;
- rmnet_free_qmi(resp);
+ req->complete = rmnet_sdio_response_complete;
+ rmnet_sdio_free_qmi(resp);
/* check if its the right place to add */
dev->cpkt_tolaptop++;
@@ -608,7 +621,8 @@
}
static int
-rmnet_rx_submit(struct rmnet_dev *dev, struct usb_request *req, gfp_t gfp_flags)
+rmnet_sdio_rx_submit(struct rmnet_sdio_dev *dev, struct usb_request *req,
+ gfp_t gfp_flags)
{
struct sk_buff *skb;
int retval;
@@ -629,7 +643,7 @@
return retval;
}
-static void rmnet_start_rx(struct rmnet_dev *dev)
+static void rmnet_sdio_start_rx(struct rmnet_sdio_dev *dev)
{
struct usb_composite_dev *cdev = dev->cdev;
int status;
@@ -648,7 +662,7 @@
dev->rx_idle_len--;
spin_unlock_irqrestore(&dev->lock, flags);
- status = rmnet_rx_submit(dev, req, GFP_ATOMIC);
+ status = rmnet_sdio_rx_submit(dev, req, GFP_ATOMIC);
spin_lock_irqsave(&dev->lock, flags);
if (status) {
@@ -661,7 +675,7 @@
spin_unlock_irqrestore(&dev->lock, flags);
}
-static void usb_rmnet_sdio_start_tx(struct rmnet_dev *dev)
+static void rmnet_sdio_start_tx(struct rmnet_sdio_dev *dev)
{
unsigned long flags;
int status;
@@ -672,7 +686,7 @@
if (!atomic_read(&dev->online))
return;
- if (!test_bit(CH_OPEN, &dev->data_ch_status))
+ if (!test_bit(RMNET_SDIO_CH_OPEN, &dev->data_ch_status))
return;
spin_lock_irqsave(&dev->lock, flags);
@@ -703,7 +717,7 @@
__skb_queue_head(&dev->tx_skb_queue, skb);
} else {
req->buf = 0;
- rmnet_free_req(dev->epin, req);
+ rmnet_sdio_free_req(dev->epin, req);
dev_kfree_skb_any(skb);
}
break;
@@ -713,18 +727,18 @@
spin_unlock_irqrestore(&dev->lock, flags);
}
-static void rmnet_data_receive_cb(void *priv, struct sk_buff *skb)
+static void rmnet_sdio_data_receive_cb(void *priv, struct sk_buff *skb)
{
- struct rmnet_dev *dev = priv;
+ struct rmnet_sdio_dev *dev = priv;
unsigned long flags;
/* SDIO mux sends NULL SKB when link state changes */
if (!skb) {
pr_info("%s: dmux_ch close event\n", __func__);
- if (test_bit(CH_OPEN, &dev->ctrl_ch_status) &&
- test_bit(CH_OPEN, &dev->data_ch_status)) {
- clear_bit(CH_OPEN, &dev->ctrl_ch_status);
- clear_bit(CH_OPEN, &dev->data_ch_status);
+ if (test_bit(RMNET_SDIO_CH_OPEN, &dev->ctrl_ch_status) &&
+ test_bit(RMNET_SDIO_CH_OPEN, &dev->data_ch_status)) {
+ clear_bit(RMNET_SDIO_CH_OPEN, &dev->ctrl_ch_status);
+ clear_bit(RMNET_SDIO_CH_OPEN, &dev->data_ch_status);
queue_work(dev->wq, &dev->sdio_close_work);
}
return;
@@ -737,7 +751,7 @@
spin_lock_irqsave(&dev->lock, flags);
- if (dev->tx_skb_queue.qlen > tx_pkt_drop_thld) {
+ if (dev->tx_skb_queue.qlen > sdio_tx_pkt_drop_thld) {
if (printk_ratelimit())
pr_err("%s: tx pkt dropped: tx_drop_cnt:%lu\n",
__func__, dev->tx_drp_cnt);
@@ -750,12 +764,12 @@
__skb_queue_tail(&dev->tx_skb_queue, skb);
spin_unlock_irqrestore(&dev->lock, flags);
- usb_rmnet_sdio_start_tx(dev);
+ rmnet_sdio_start_tx(dev);
}
-static void rmnet_data_write_done(void *priv, struct sk_buff *skb)
+static void rmnet_sdio_data_write_done(void *priv, struct sk_buff *skb)
{
- struct rmnet_dev *dev = priv;
+ struct rmnet_sdio_dev *dev = priv;
/* SDIO mux sends NULL SKB when link state changes */
if (!skb) {
@@ -771,25 +785,26 @@
spin_lock(&dev->lock);
dev->dpkts_pending_atdmux--;
- if (!test_bit(CH_OPEN, &dev->data_ch_status) ||
- dev->dpkts_pending_atdmux >= rx_fctrl_dis_thld) {
+ if (!test_bit(RMNET_SDIO_CH_OPEN, &dev->data_ch_status) ||
+ dev->dpkts_pending_atdmux >= sdio_rx_fctrl_dis_thld) {
spin_unlock(&dev->lock);
return;
}
spin_unlock(&dev->lock);
- rmnet_start_rx(dev);
+ rmnet_sdio_start_rx(dev);
}
-static void rmnet_data_rx_work(struct work_struct *w)
+static void rmnet_sdio_data_rx_work(struct work_struct *w)
{
- struct rmnet_dev *dev = container_of(w, struct rmnet_dev, data_rx_work);
+ struct rmnet_sdio_dev *dev = container_of(w, struct rmnet_sdio_dev,
+ data_rx_work);
struct usb_composite_dev *cdev = dev->cdev;
struct sk_buff *skb;
int ret;
unsigned long flags;
- if (!test_bit(CH_OPEN, &dev->data_ch_status)) {
+ if (!test_bit(RMNET_SDIO_CH_OPEN, &dev->data_ch_status)) {
pr_info("%s: sdio data ch not open\n", __func__);
return;
}
@@ -811,9 +826,10 @@
spin_unlock_irqrestore(&dev->lock, flags);
}
-static void rmnet_complete_epout(struct usb_ep *ep, struct usb_request *req)
+static void rmnet_sdio_complete_epout(struct usb_ep *ep,
+ struct usb_request *req)
{
- struct rmnet_dev *dev = ep->driver_data;
+ struct rmnet_sdio_dev *dev = ep->driver_data;
struct usb_composite_dev *cdev = dev->cdev;
struct sk_buff *skb = req->context;
int status = req->status;
@@ -830,7 +846,7 @@
/* connection gone */
dev_kfree_skb_any(skb);
req->buf = 0;
- rmnet_free_req(ep, req);
+ rmnet_sdio_free_req(ep, req);
return;
default:
/* unexpected failure */
@@ -841,11 +857,11 @@
break;
}
- if (!test_bit(CH_OPEN, &dev->data_ch_status)) {
+ if (!test_bit(RMNET_SDIO_CH_OPEN, &dev->data_ch_status)) {
pr_info("%s: sdio data ch not open\n", __func__);
dev_kfree_skb_any(skb);
req->buf = 0;
- rmnet_free_req(ep, req);
+ rmnet_sdio_free_req(ep, req);
return;
}
@@ -855,7 +871,7 @@
queue_work(dev->wq, &dev->data_rx_work);
}
- if (dev->dpkts_pending_atdmux >= rx_fctrl_en_thld) {
+ if (dev->dpkts_pending_atdmux >= sdio_rx_fctrl_en_thld) {
list_add_tail(&req->list, &dev->rx_idle);
dev->rx_idle_len++;
spin_unlock(&dev->lock);
@@ -863,7 +879,7 @@
}
spin_unlock(&dev->lock);
- status = rmnet_rx_submit(dev, req, GFP_ATOMIC);
+ status = rmnet_sdio_rx_submit(dev, req, GFP_ATOMIC);
if (status) {
ERROR(cdev, "rmnet data rx enqueue err %d\n", status);
list_add_tail(&req->list, &dev->rx_idle);
@@ -871,9 +887,9 @@
}
}
-static void rmnet_complete_epin(struct usb_ep *ep, struct usb_request *req)
+static void rmnet_sdio_complete_epin(struct usb_ep *ep, struct usb_request *req)
{
- struct rmnet_dev *dev = ep->driver_data;
+ struct rmnet_sdio_dev *dev = ep->driver_data;
struct sk_buff *skb = req->context;
struct usb_composite_dev *cdev = dev->cdev;
int status = req->status;
@@ -896,10 +912,10 @@
spin_unlock(&dev->lock);
dev_kfree_skb_any(skb);
- usb_rmnet_sdio_start_tx(dev);
+ rmnet_sdio_start_tx(dev);
}
-static void rmnet_free_buf(struct rmnet_dev *dev)
+static void rmnet_sdio_free_buf(struct rmnet_sdio_dev *dev)
{
struct rmnet_sdio_qmi_buf *qmi;
struct usb_request *req;
@@ -923,7 +939,7 @@
list_del(&req->list);
dev->tx_idle_len--;
req->buf = NULL;
- rmnet_free_req(dev->epout, req);
+ rmnet_sdio_free_req(dev->epout, req);
}
/* free all usb requests in rx pool */
@@ -932,7 +948,7 @@
list_del(&req->list);
dev->rx_idle_len--;
req->buf = NULL;
- rmnet_free_req(dev->epin, req);
+ rmnet_sdio_free_req(dev->epin, req);
}
/* free all buffers in qmi request pool */
@@ -940,7 +956,7 @@
qmi = list_entry(act, struct rmnet_sdio_qmi_buf, list);
list_del(&qmi->list);
dev->qreq_q_len--;
- rmnet_free_qmi(qmi);
+ rmnet_sdio_free_qmi(qmi);
}
/* free all buffers in qmi request pool */
@@ -948,7 +964,7 @@
qmi = list_entry(act, struct rmnet_sdio_qmi_buf, list);
list_del(&qmi->list);
dev->qresp_q_len--;
- rmnet_free_qmi(qmi);
+ rmnet_sdio_free_qmi(qmi);
}
while ((skb = __skb_dequeue(&dev->tx_skb_queue)))
@@ -957,18 +973,18 @@
while ((skb = __skb_dequeue(&dev->rx_skb_queue)))
dev_kfree_skb_any(skb);
- rmnet_free_req(dev->epnotify, dev->notify_req);
+ rmnet_sdio_free_req(dev->epnotify, dev->notify_req);
spin_unlock_irqrestore(&dev->lock, flags);
}
-static void rmnet_set_modem_ctl_bits_work(struct work_struct *w)
+static void rmnet_sdio_set_modem_cbits_w(struct work_struct *w)
{
- struct rmnet_dev *dev;
+ struct rmnet_sdio_dev *dev;
- dev = container_of(w, struct rmnet_dev, set_modem_ctl_bits_work);
+ dev = container_of(w, struct rmnet_sdio_dev, set_modem_ctl_bits_work);
- if (!test_bit(CH_OPEN, &dev->ctrl_ch_status))
+ if (!test_bit(RMNET_SDIO_CH_OPEN, &dev->ctrl_ch_status))
return;
pr_debug("%s: cbits_to_modem:%d\n",
@@ -979,13 +995,14 @@
~dev->cbits_to_modem);
}
-static void rmnet_disconnect_work(struct work_struct *w)
+static void rmnet_sdio_disconnect_work(struct work_struct *w)
{
/* REVISIT: Push all the data to sdio if anythign is pending */
}
-static void rmnet_suspend(struct usb_function *f)
+static void rmnet_sdio_suspend(struct usb_function *f)
{
- struct rmnet_dev *dev = container_of(f, struct rmnet_dev, function);
+ struct rmnet_sdio_dev *dev = container_of(f, struct rmnet_sdio_dev,
+ function);
if (!atomic_read(&dev->online))
return;
@@ -997,9 +1014,10 @@
dev->cbits_to_modem &= ~TIOCM_DTR;
queue_work(dev->wq, &dev->set_modem_ctl_bits_work);
}
-static void rmnet_disable(struct usb_function *f)
+static void rmnet_sdio_disable(struct usb_function *f)
{
- struct rmnet_dev *dev = container_of(f, struct rmnet_dev, function);
+ struct rmnet_sdio_dev *dev = container_of(f, struct rmnet_sdio_dev,
+ function);
if (!atomic_read(&dev->online))
return;
@@ -1010,7 +1028,7 @@
atomic_set(&dev->online, 0);
atomic_set(&dev->notify_count, 0);
- rmnet_free_buf(dev);
+ rmnet_sdio_free_buf(dev);
/* cleanup work */
queue_work(dev->wq, &dev->disconnect_work);
@@ -1020,7 +1038,7 @@
static void rmnet_close_sdio_work(struct work_struct *w)
{
- struct rmnet_dev *dev;
+ struct rmnet_sdio_dev *dev;
unsigned long flags;
struct usb_cdc_notification *event;
int status;
@@ -1030,7 +1048,7 @@
pr_debug("%s:\n", __func__);
- dev = container_of(w, struct rmnet_dev, sdio_close_work);
+ dev = container_of(w, struct rmnet_sdio_dev, sdio_close_work);
if (!atomic_read(&dev->online))
return;
@@ -1073,7 +1091,7 @@
list_del(&req->list);
dev->tx_idle_len--;
req->buf = NULL;
- rmnet_free_req(dev->epout, req);
+ rmnet_sdio_free_req(dev->epout, req);
}
/* free all usb requests in rx pool */
@@ -1082,7 +1100,7 @@
list_del(&req->list);
dev->rx_idle_len--;
req->buf = NULL;
- rmnet_free_req(dev->epin, req);
+ rmnet_sdio_free_req(dev->epin, req);
}
/* free all buffers in qmi request pool */
@@ -1091,7 +1109,7 @@
struct rmnet_sdio_qmi_buf, list);
list_del(&qmi->list);
dev->qreq_q_len--;
- rmnet_free_qmi(qmi);
+ rmnet_sdio_free_qmi(qmi);
}
/* free all buffers in qmi response pool */
@@ -1100,7 +1118,7 @@
struct rmnet_sdio_qmi_buf, list);
list_del(&qmi->list);
dev->qresp_q_len--;
- rmnet_free_qmi(qmi);
+ rmnet_sdio_free_qmi(qmi);
}
atomic_set(&dev->notify_count, 0);
@@ -1115,7 +1133,7 @@
spin_unlock_irqrestore(&dev->lock, flags);
}
-static int rmnet_start_io(struct rmnet_dev *dev)
+static int rmnet_sdio_start_io(struct rmnet_sdio_dev *dev)
{
struct usb_request *req;
int ret, i;
@@ -1127,79 +1145,82 @@
return 0;
}
- if (!test_bit(CH_OPEN, &dev->data_ch_status) ||
- !test_bit(CH_OPEN, &dev->ctrl_ch_status)) {
+ if (!test_bit(RMNET_SDIO_CH_OPEN, &dev->data_ch_status) ||
+ !test_bit(RMNET_SDIO_CH_OPEN, &dev->ctrl_ch_status)) {
spin_unlock_irqrestore(&dev->lock, flags);
return 0;
}
for (i = 0; i < RMNET_SDIO_RX_REQ_MAX; i++) {
- req = rmnet_alloc_req(dev->epout, 0, GFP_ATOMIC);
+ req = rmnet_sdio_alloc_req(dev->epout, 0, GFP_ATOMIC);
if (IS_ERR(req)) {
ret = PTR_ERR(req);
spin_unlock_irqrestore(&dev->lock, flags);
goto free_buf;
}
- req->complete = rmnet_complete_epout;
+ req->complete = rmnet_sdio_complete_epout;
list_add_tail(&req->list, &dev->rx_idle);
dev->rx_idle_len++;
}
for (i = 0; i < RMNET_SDIO_TX_REQ_MAX; i++) {
- req = rmnet_alloc_req(dev->epin, 0, GFP_ATOMIC);
+ req = rmnet_sdio_alloc_req(dev->epin, 0, GFP_ATOMIC);
if (IS_ERR(req)) {
ret = PTR_ERR(req);
spin_unlock_irqrestore(&dev->lock, flags);
goto free_buf;
}
- req->complete = rmnet_complete_epin;
+ req->complete = rmnet_sdio_complete_epin;
list_add_tail(&req->list, &dev->tx_idle);
dev->tx_idle_len++;
}
spin_unlock_irqrestore(&dev->lock, flags);
/* Queue Rx data requests */
- rmnet_start_rx(dev);
+ rmnet_sdio_start_rx(dev);
return 0;
free_buf:
- rmnet_free_buf(dev);
+ rmnet_sdio_free_buf(dev);
dev->epout = dev->epin = dev->epnotify = NULL; /* release endpoints */
return ret;
}
-#define SDIO_OPEN_RETRY_DELAY msecs_to_jiffies(2000)
-#define SDIO_OPEN_MAX_RETRY 90
+#define RMNET_SDIO_OPEN_RETRY_DELAY msecs_to_jiffies(2000)
+#define SDIO_SDIO_OPEN_MAX_RETRY 90
static void rmnet_open_sdio_work(struct work_struct *w)
{
- struct rmnet_dev *dev =
- container_of(w, struct rmnet_dev, sdio_open_work.work);
+ struct rmnet_sdio_dev *dev =
+ container_of(w, struct rmnet_sdio_dev,
+ sdio_open_work.work);
struct usb_composite_dev *cdev = dev->cdev;
int ret;
static int retry_cnt;
- if (!test_bit(CH_OPEN, &dev->ctrl_ch_status)) {
+ if (!test_bit(RMNET_SDIO_CH_OPEN, &dev->ctrl_ch_status)) {
/* Control channel for QMI messages */
- ret = sdio_cmux_open(rmnet_sdio_ctl_ch, rmnet_ctl_receive_cb,
- rmnet_ctl_write_done, rmnet_sts_callback, dev);
+ ret = sdio_cmux_open(rmnet_sdio_ctl_ch,
+ rmnet_sdio_ctl_receive_cb,
+ rmnet_sdio_ctl_write_done,
+ rmnet_sdio_sts_callback, dev);
if (!ret)
- set_bit(CH_OPEN, &dev->ctrl_ch_status);
+ set_bit(RMNET_SDIO_CH_OPEN, &dev->ctrl_ch_status);
}
- if (!test_bit(CH_OPEN, &dev->data_ch_status)) {
+ if (!test_bit(RMNET_SDIO_CH_OPEN, &dev->data_ch_status)) {
/* Data channel for network packets */
ret = msm_sdio_dmux_open(rmnet_sdio_data_ch, dev,
- rmnet_data_receive_cb,
- rmnet_data_write_done);
+ rmnet_sdio_data_receive_cb,
+ rmnet_sdio_data_write_done);
if (!ret)
- set_bit(CH_OPEN, &dev->data_ch_status);
+ set_bit(RMNET_SDIO_CH_OPEN, &dev->data_ch_status);
}
- if (test_bit(CH_OPEN, &dev->data_ch_status) &&
- test_bit(CH_OPEN, &dev->ctrl_ch_status)) {
+ if (test_bit(RMNET_SDIO_CH_OPEN, &dev->data_ch_status) &&
+ test_bit(RMNET_SDIO_CH_OPEN, &dev->ctrl_ch_status)) {
- rmnet_start_io(dev);
+ rmnet_sdio_start_io(dev);
/* if usb cable is connected, update DTR status to modem */
if (atomic_read(&dev->online))
@@ -1215,40 +1236,41 @@
pr_debug("%s: usb rmnet sdio open retry_cnt:%d\n",
__func__, retry_cnt);
- if (retry_cnt > SDIO_OPEN_MAX_RETRY) {
- if (!test_bit(CH_OPEN, &dev->ctrl_ch_status))
+ if (retry_cnt > SDIO_SDIO_OPEN_MAX_RETRY) {
+ if (!test_bit(RMNET_SDIO_CH_OPEN, &dev->ctrl_ch_status))
ERROR(cdev, "Unable to open control SDIO channel\n");
- if (!test_bit(CH_OPEN, &dev->data_ch_status))
+ if (!test_bit(RMNET_SDIO_CH_OPEN, &dev->data_ch_status))
ERROR(cdev, "Unable to open DATA SDIO channel\n");
} else {
queue_delayed_work(dev->wq, &dev->sdio_open_work,
- SDIO_OPEN_RETRY_DELAY);
+ RMNET_SDIO_OPEN_RETRY_DELAY);
}
}
-static int rmnet_set_alt(struct usb_function *f,
+static int rmnet_sdio_set_alt(struct usb_function *f,
unsigned intf, unsigned alt)
{
- struct rmnet_dev *dev = container_of(f, struct rmnet_dev, function);
+ struct rmnet_sdio_dev *dev = container_of(f, struct rmnet_sdio_dev,
+ function);
struct usb_composite_dev *cdev = dev->cdev;
int ret = 0;
dev->epin->driver_data = dev;
usb_ep_enable(dev->epin, ep_choose(cdev->gadget,
- &rmnet_hs_in_desc,
- &rmnet_fs_in_desc));
+ &rmnet_sdio_hs_in_desc,
+ &rmnet_sdio_fs_in_desc));
dev->epout->driver_data = dev;
usb_ep_enable(dev->epout, ep_choose(cdev->gadget,
- &rmnet_hs_out_desc,
- &rmnet_fs_out_desc));
+ &rmnet_sdio_hs_out_desc,
+ &rmnet_sdio_fs_out_desc));
usb_ep_enable(dev->epnotify, ep_choose(cdev->gadget,
- &rmnet_hs_notify_desc,
- &rmnet_fs_notify_desc));
+ &rmnet_sdio_hs_notify_desc,
+ &rmnet_sdio_fs_notify_desc));
/* allocate notification */
- dev->notify_req = rmnet_alloc_req(dev->epnotify,
+ dev->notify_req = rmnet_sdio_alloc_req(dev->epnotify,
RMNET_SDIO_MAX_NFY_SZE, GFP_ATOMIC);
if (IS_ERR(dev->notify_req)) {
@@ -1257,22 +1279,23 @@
__func__);
return ret;
}
- dev->notify_req->complete = rmnet_notify_complete;
+ dev->notify_req->complete = rmnet_sdio_notify_complete;
dev->notify_req->context = dev;
dev->notify_req->length = RMNET_SDIO_MAX_NFY_SZE;
atomic_set(&dev->online, 1);
- ret = rmnet_start_io(dev);
+ ret = rmnet_sdio_start_io(dev);
return ret;
}
-static int rmnet_bind(struct usb_configuration *c, struct usb_function *f)
+static int rmnet_sdio_bind(struct usb_configuration *c, struct usb_function *f)
{
struct usb_composite_dev *cdev = c->cdev;
- struct rmnet_dev *dev = container_of(f, struct rmnet_dev, function);
+ struct rmnet_sdio_dev *dev = container_of(f, struct rmnet_sdio_dev,
+ function);
int id;
struct usb_ep *ep;
@@ -1283,21 +1306,21 @@
if (id < 0)
return id;
dev->ifc_id = id;
- rmnet_interface_desc.bInterfaceNumber = id;
+ rmnet_sdio_interface_desc.bInterfaceNumber = id;
- ep = usb_ep_autoconfig(cdev->gadget, &rmnet_fs_in_desc);
+ ep = usb_ep_autoconfig(cdev->gadget, &rmnet_sdio_fs_in_desc);
if (!ep)
goto out;
ep->driver_data = cdev; /* claim endpoint */
dev->epin = ep;
- ep = usb_ep_autoconfig(cdev->gadget, &rmnet_fs_out_desc);
+ ep = usb_ep_autoconfig(cdev->gadget, &rmnet_sdio_fs_out_desc);
if (!ep)
goto out;
ep->driver_data = cdev; /* claim endpoint */
dev->epout = ep;
- ep = usb_ep_autoconfig(cdev->gadget, &rmnet_fs_notify_desc);
+ ep = usb_ep_autoconfig(cdev->gadget, &rmnet_sdio_fs_notify_desc);
if (!ep)
goto out;
ep->driver_data = cdev; /* claim endpoint */
@@ -1308,12 +1331,12 @@
* both speeds
*/
if (gadget_is_dualspeed(c->cdev->gadget)) {
- rmnet_hs_in_desc.bEndpointAddress =
- rmnet_fs_in_desc.bEndpointAddress;
- rmnet_hs_out_desc.bEndpointAddress =
- rmnet_fs_out_desc.bEndpointAddress;
- rmnet_hs_notify_desc.bEndpointAddress =
- rmnet_fs_notify_desc.bEndpointAddress;
+ rmnet_sdio_hs_in_desc.bEndpointAddress =
+ rmnet_sdio_fs_in_desc.bEndpointAddress;
+ rmnet_sdio_hs_out_desc.bEndpointAddress =
+ rmnet_sdio_fs_out_desc.bEndpointAddress;
+ rmnet_sdio_hs_notify_desc.bEndpointAddress =
+ rmnet_sdio_fs_notify_desc.bEndpointAddress;
}
queue_delayed_work(dev->wq, &dev->sdio_open_work, 0);
@@ -1332,29 +1355,33 @@
}
static void
-rmnet_unbind(struct usb_configuration *c, struct usb_function *f)
+rmnet_sdio_unbind(struct usb_configuration *c, struct usb_function *f)
{
- struct rmnet_dev *dev = container_of(f, struct rmnet_dev, function);
+ struct rmnet_sdio_dev *dev = container_of(f, struct rmnet_sdio_dev,
+ function);
- destroy_workqueue(dev->wq);
+ destroy_workqueue(dev->wq);
- rmnet_free_buf(dev);
- dev->epout = dev->epin = dev->epnotify = NULL; /* release endpoints */
+ rmnet_sdio_free_buf(dev);
+ dev->epout = dev->epin = dev->epnotify = NULL; /* release endpoints */
msm_sdio_dmux_close(rmnet_sdio_data_ch);
sdio_cmux_close(rmnet_sdio_ctl_ch);
- clear_bit(CH_OPEN, &dev->data_ch_status);
- clear_bit(CH_OPEN, &dev->ctrl_ch_status);
- kfree(dev);
+ clear_bit(RMNET_SDIO_CH_OPEN, &dev->data_ch_status);
+ clear_bit(RMNET_SDIO_CH_OPEN, &dev->ctrl_ch_status);
+
+ debugfs_remove_recursive(dev->dent);
+
+ kfree(dev);
}
#if defined(CONFIG_DEBUG_FS)
-static ssize_t debug_read_stats(struct file *file, char __user *ubuf,
+static ssize_t rmnet_sdio_read_stats(struct file *file, char __user *ubuf,
size_t count, loff_t *ppos)
{
- struct rmnet_dev *dev = file->private_data;
+ struct rmnet_sdio_dev *dev = file->private_data;
char *buf;
unsigned long flags;
int ret;
@@ -1395,10 +1422,10 @@
return ret;
}
-static ssize_t debug_reset_stats(struct file *file, const char __user *buf,
+static ssize_t rmnet_sdio_reset_stats(struct file *file, const char __user *buf,
size_t count, loff_t *ppos)
{
- struct rmnet_dev *dev = file->private_data;
+ struct rmnet_sdio_dev *dev = file->private_data;
dev->dpkt_tolaptop = 0;
dev->dpkt_tomodem = 0;
@@ -1414,31 +1441,30 @@
return count;
}
-static int debug_open(struct inode *inode, struct file *file)
+static int debug_rmnet_sdio_open(struct inode *inode, struct file *file)
{
file->private_data = inode->i_private;
return 0;
}
-const struct file_operations debug_stats_ops = {
- .open = debug_open,
- .read = debug_read_stats,
- .write = debug_reset_stats,
+const struct file_operations debug_rmnet_sdio_stats_ops = {
+ .open = debug_rmnet_sdio_open,
+ .read = rmnet_sdio_read_stats,
+ .write = rmnet_sdio_reset_stats,
};
-static void usb_debugfs_init(struct rmnet_dev *dev)
+static void rmnet_sdio_debugfs_init(struct rmnet_sdio_dev *dev)
{
- struct dentry *dent;
-
- dent = debugfs_create_dir("usb_rmnet", 0);
- if (IS_ERR(dent))
+ dev->dent = debugfs_create_dir("usb_rmnet", 0);
+ if (IS_ERR(dev->dent))
return;
- debugfs_create_file("status", 0444, dent, dev, &debug_stats_ops);
+ debugfs_create_file("status", 0444, dev->dent, dev,
+ &debug_rmnet_sdio_stats_ops);
}
#else
-static void usb_debugfs_init(struct rmnet_dev *dev)
+static void rmnet_sdio_debugfs_init(struct rmnet_sdio_dev *dev)
{
return;
}
@@ -1446,7 +1472,7 @@
int rmnet_sdio_function_add(struct usb_configuration *c)
{
- struct rmnet_dev *dev;
+ struct rmnet_sdio_dev *dev;
int ret;
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
@@ -1463,11 +1489,11 @@
atomic_set(&dev->notify_count, 0);
atomic_set(&dev->online, 0);
- INIT_WORK(&dev->disconnect_work, rmnet_disconnect_work);
- INIT_WORK(&dev->set_modem_ctl_bits_work, rmnet_set_modem_ctl_bits_work);
+ INIT_WORK(&dev->disconnect_work, rmnet_sdio_disconnect_work);
+ INIT_WORK(&dev->set_modem_ctl_bits_work, rmnet_sdio_set_modem_cbits_w);
- INIT_WORK(&dev->ctl_rx_work, rmnet_control_rx_work);
- INIT_WORK(&dev->data_rx_work, rmnet_data_rx_work);
+ INIT_WORK(&dev->ctl_rx_work, rmnet_sdio_control_rx_work);
+ INIT_WORK(&dev->data_rx_work, rmnet_sdio_data_rx_work);
INIT_DELAYED_WORK(&dev->sdio_open_work, rmnet_open_sdio_work);
INIT_WORK(&dev->sdio_close_work, rmnet_close_sdio_work);
@@ -1481,21 +1507,21 @@
skb_queue_head_init(&dev->rx_skb_queue);
dev->function.name = "rmnet_sdio";
- dev->function.strings = rmnet_strings;
- dev->function.descriptors = rmnet_fs_function;
- dev->function.hs_descriptors = rmnet_hs_function;
- dev->function.bind = rmnet_bind;
- dev->function.unbind = rmnet_unbind;
- dev->function.setup = rmnet_setup;
- dev->function.set_alt = rmnet_set_alt;
- dev->function.disable = rmnet_disable;
- dev->function.suspend = rmnet_suspend;
+ dev->function.strings = rmnet_sdio_strings;
+ dev->function.descriptors = rmnet_sdio_fs_function;
+ dev->function.hs_descriptors = rmnet_sdio_hs_function;
+ dev->function.bind = rmnet_sdio_bind;
+ dev->function.unbind = rmnet_sdio_unbind;
+ dev->function.setup = rmnet_sdio_setup;
+ dev->function.set_alt = rmnet_sdio_set_alt;
+ dev->function.disable = rmnet_sdio_disable;
+ dev->function.suspend = rmnet_sdio_suspend;
ret = usb_add_function(c, &dev->function);
if (ret)
goto free_wq;
- usb_debugfs_init(dev);
+ rmnet_sdio_debugfs_init(dev);
return 0;
@@ -1506,18 +1532,3 @@
return ret;
}
-
-#ifdef CONFIG_USB_ANDROID_RMNET_SDIO
-static struct android_usb_function rmnet_function = {
- .name = "rmnet_sdio",
- .bind_config = rmnet_sdio_function_add,
-};
-
-static int __init rmnet_init(void)
-{
- android_register_function(&rmnet_function);
- return 0;
-}
-module_init(rmnet_init);
-
-#endif /* CONFIG_USB_ANDROID_RMNET_SDIO */
diff --git a/drivers/usb/gadget/f_rmnet_smd_sdio.c b/drivers/usb/gadget/f_rmnet_smd_sdio.c
index e99716b..b9120ca 100644
--- a/drivers/usb/gadget/f_rmnet_smd_sdio.c
+++ b/drivers/usb/gadget/f_rmnet_smd_sdio.c
@@ -26,6 +26,7 @@
#include <linux/workqueue.h>
#include <linux/netdevice.h>
#include <linux/interrupt.h>
+#include <linux/ratelimit.h>
#include <linux/fs.h>
#include <linux/miscdevice.h>
@@ -35,7 +36,6 @@
#include <linux/usb/cdc.h>
#include <linux/usb/composite.h>
#include <linux/usb/ch9.h>
-#include <linux/usb/android_composite.h>
#include <linux/termios.h>
#include <linux/debugfs.h>
@@ -43,62 +43,74 @@
#include <mach/sdio_cmux.h>
#include <mach/sdio_dmux.h>
-static uint32_t rmnet_sdio_ctl_ch = CONFIG_RMNET_SMD_SDIO_CTL_CHANNEL;
-module_param(rmnet_sdio_ctl_ch, uint, S_IRUGO);
-MODULE_PARM_DESC(rmnet_sdio_ctl_ch, "RmNet control SDIO channel ID");
+#ifdef CONFIG_RMNET_SMD_SDIO_CTL_CHANNEL
+static uint32_t rmnet_mux_sdio_ctl_ch = CONFIG_RMNET_SMD_SDIO_CTL_CHANNEL;
+#else
+static uint32_t rmnet_mux_sdio_ctl_ch;
+#endif
+module_param(rmnet_mux_sdio_ctl_ch, uint, S_IRUGO);
+MODULE_PARM_DESC(rmnet_mux_sdio_ctl_ch, "RmNetMUX control SDIO channel ID");
-static uint32_t rmnet_sdio_data_ch = CONFIG_RMNET_SMD_SDIO_DATA_CHANNEL;
-module_param(rmnet_sdio_data_ch, uint, S_IRUGO);
-MODULE_PARM_DESC(rmnet_sdio_data_ch, "RmNet data SDIO channel ID");
+#ifdef CONFIG_RMNET_SMD_SDIO_DATA_CHANNEL
+static uint32_t rmnet_mux_sdio_data_ch = CONFIG_RMNET_SMD_SDIO_DATA_CHANNEL;
+#else
+static uint32_t rmnet_mux_sdio_data_ch;
+#endif
+module_param(rmnet_mux_sdio_data_ch, uint, S_IRUGO);
+MODULE_PARM_DESC(rmnet_mux_sdio_data_ch, "RmNetMUX data SDIO channel ID");
-static char *rmnet_smd_data_ch = CONFIG_RMNET_SDIO_SMD_DATA_CHANNEL;
-module_param(rmnet_smd_data_ch, charp, S_IRUGO);
-MODULE_PARM_DESC(rmnet_smd_data_ch, "RmNet data SMD channel");
+#ifdef CONFIG_RMNET_SDIO_SMD_DATA_CHANNEL
+static char *rmnet_mux_smd_data_ch = CONFIG_RMNET_SDIO_SMD_DATA_CHANNEL;
+#else
+static char *rmnet_mux_smd_data_ch;
+#endif
+module_param(rmnet_mux_smd_data_ch, charp, S_IRUGO);
+MODULE_PARM_DESC(rmnet_mux_smd_data_ch, "RmNetMUX data SMD channel");
-#define ACM_CTRL_DTR (1 << 0)
+#define RMNET_MUX_ACM_CTRL_DTR (1 << 0)
-#define SDIO_MUX_HDR 8
-#define RMNET_SDIO_NOTIFY_INTERVAL 5
-#define RMNET_SDIO_MAX_NFY_SZE sizeof(struct usb_cdc_notification)
+#define RMNET_MUX_SDIO_HDR 8
+#define RMNET_MUX_SDIO_NOTIFY_INTERVAL 5
+#define RMNET_MUX_SDIO_MAX_NFY_SZE sizeof(struct usb_cdc_notification)
-#define RMNET_SDIO_RX_REQ_MAX 16
-#define RMNET_SDIO_RX_REQ_SIZE 2048
-#define RMNET_SDIO_TX_REQ_MAX 100
+#define RMNET_MUX_SDIO_RX_REQ_MAX 16
+#define RMNET_MUX_SDIO_RX_REQ_SIZE 2048
+#define RMNET_MUX_SDIO_TX_REQ_MAX 100
-#define RMNET_SDIO_TX_PKT_DROP_THRESHOLD 1000
-#define RMNET_SDIO_RX_PKT_FLOW_CTRL_EN_THRESHOLD 1000
-#define RMNET_SDIO_RX_PKT_FLOW_CTRL_DISABLE 500
+#define RMNET_MUX_SDIO_TX_LIMIT 1000
+#define RMNET_MUX_SDIO_RX_ENABLE_LIMIT 1000
+#define RMNET_MUX_SDIO_RX_DISABLE_LIMIT 500
-static uint32_t sdio_tx_pkt_drop_thld = RMNET_SDIO_TX_PKT_DROP_THRESHOLD;
-module_param(sdio_tx_pkt_drop_thld, uint, S_IRUGO | S_IWUSR);
+static uint32_t mux_sdio_tx_pkt_drop_thld = RMNET_MUX_SDIO_TX_LIMIT;
+module_param(mux_sdio_tx_pkt_drop_thld, uint, S_IRUGO | S_IWUSR);
-static uint32_t sdio_rx_fctrl_en_thld =
- RMNET_SDIO_RX_PKT_FLOW_CTRL_EN_THRESHOLD;
-module_param(sdio_rx_fctrl_en_thld, uint, S_IRUGO | S_IWUSR);
+static uint32_t mux_sdio_rx_fctrl_en_thld =
+ RMNET_MUX_SDIO_RX_ENABLE_LIMIT;
+module_param(mux_sdio_rx_fctrl_en_thld, uint, S_IRUGO | S_IWUSR);
-static uint32_t sdio_rx_fctrl_dis_thld = RMNET_SDIO_RX_PKT_FLOW_CTRL_DISABLE;
-module_param(sdio_rx_fctrl_dis_thld, uint, S_IRUGO | S_IWUSR);
+static uint32_t mux_sdio_rx_fctrl_dis_thld = RMNET_MUX_SDIO_RX_DISABLE_LIMIT;
+module_param(mux_sdio_rx_fctrl_dis_thld, uint, S_IRUGO | S_IWUSR);
-#define RMNET_SMD_RX_REQ_MAX 8
-#define RMNET_SMD_RX_REQ_SIZE 2048
-#define RMNET_SMD_TX_REQ_MAX 8
-#define RMNET_SMD_TX_REQ_SIZE 2048
-#define RMNET_SMD_TXN_MAX 2048
+#define RMNET_MUX_SMD_RX_REQ_MAX 8
+#define RMNET_MUX_SMD_RX_REQ_SIZE 2048
+#define RMNET_MUX_SMD_TX_REQ_MAX 8
+#define RMNET_MUX_SMD_TX_REQ_SIZE 2048
+#define RMNET_MUX_SMD_TXN_MAX 2048
-struct rmnet_ctrl_pkt {
+struct rmnet_mux_ctrl_pkt {
void *buf;
int len;
struct list_head list;
};
-enum usb_rmnet_xport_type {
- USB_RMNET_XPORT_UNDEFINED,
- USB_RMNET_XPORT_SDIO,
- USB_RMNET_XPORT_SMD,
+enum usb_rmnet_mux_xport_type {
+ USB_RMNET_MUX_XPORT_UNDEFINED,
+ USB_RMNET_MUX_XPORT_SDIO,
+ USB_RMNET_MUX_XPORT_SMD,
};
-struct rmnet_ctrl_dev {
+struct rmnet_mux_ctrl_dev {
struct list_head tx_q;
wait_queue_head_t tx_wait_q;
unsigned long tx_len;
@@ -111,7 +123,7 @@
unsigned opened;
};
-struct rmnet_sdio_dev {
+struct rmnet_mux_sdio_dev {
/* Tx/Rx lists */
struct list_head tx_idle;
struct sk_buff_head tx_skb_queue;
@@ -129,11 +141,11 @@
};
/* Data SMD channel */
-struct rmnet_smd_info {
+struct rmnet_mux_smd_info {
struct smd_channel *ch;
struct tasklet_struct tx_tlet;
struct tasklet_struct rx_tlet;
-#define CH_OPENED 0
+#define RMNET_MUX_CH_OPENED 0
unsigned long flags;
/* pending rx packet length */
atomic_t rx_pkt;
@@ -141,16 +153,16 @@
wait_queue_head_t wait;
};
-struct rmnet_smd_dev {
+struct rmnet_mux_smd_dev {
/* Tx/Rx lists */
struct list_head tx_idle;
struct list_head rx_idle;
struct list_head rx_queue;
- struct rmnet_smd_info smd_data;
+ struct rmnet_mux_smd_info smd_data;
};
-struct rmnet_dev {
+struct rmnet_mux_dev {
struct usb_function function;
struct usb_composite_dev *cdev;
@@ -159,12 +171,12 @@
struct usb_ep *epnotify;
struct usb_request *notify_req;
- struct rmnet_smd_dev smd_dev;
- struct rmnet_sdio_dev sdio_dev;
- struct rmnet_ctrl_dev ctrl_dev;
+ struct rmnet_mux_smd_dev smd_dev;
+ struct rmnet_mux_sdio_dev sdio_dev;
+ struct rmnet_mux_ctrl_dev ctrl_dev;
u8 ifc_id;
- enum usb_rmnet_xport_type xport;
+ enum usb_rmnet_mux_xport_type xport;
spinlock_t lock;
atomic_t online;
atomic_t notify_count;
@@ -181,9 +193,9 @@
unsigned long cpkts_drp_cnt;
};
-static struct rmnet_dev *_dev;
+static struct rmnet_mux_dev *rmux_dev;
-static struct usb_interface_descriptor rmnet_interface_desc = {
+static struct usb_interface_descriptor rmnet_mux_interface_desc = {
.bLength = USB_DT_INTERFACE_SIZE,
.bDescriptorType = USB_DT_INTERFACE,
.bNumEndpoints = 3,
@@ -193,16 +205,17 @@
};
/* Full speed support */
-static struct usb_endpoint_descriptor rmnet_fs_notify_desc = {
+static struct usb_endpoint_descriptor rmnet_mux_fs_notify_desc = {
.bLength = USB_DT_ENDPOINT_SIZE,
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = USB_DIR_IN,
.bmAttributes = USB_ENDPOINT_XFER_INT,
- .wMaxPacketSize = __constant_cpu_to_le16(RMNET_SDIO_MAX_NFY_SZE),
- .bInterval = 1 << RMNET_SDIO_NOTIFY_INTERVAL,
+ .wMaxPacketSize = __constant_cpu_to_le16(
+ RMNET_MUX_SDIO_MAX_NFY_SZE),
+ .bInterval = 1 << RMNET_MUX_SDIO_NOTIFY_INTERVAL,
};
-static struct usb_endpoint_descriptor rmnet_fs_in_desc = {
+static struct usb_endpoint_descriptor rmnet_mux_fs_in_desc = {
.bLength = USB_DT_ENDPOINT_SIZE,
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = USB_DIR_IN,
@@ -210,7 +223,7 @@
.wMaxPacketSize = __constant_cpu_to_le16(64),
};
-static struct usb_endpoint_descriptor rmnet_fs_out_desc = {
+static struct usb_endpoint_descriptor rmnet_mux_fs_out_desc = {
.bLength = USB_DT_ENDPOINT_SIZE,
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = USB_DIR_OUT,
@@ -218,25 +231,26 @@
.wMaxPacketSize = __constant_cpu_to_le16(64),
};
-static struct usb_descriptor_header *rmnet_fs_function[] = {
- (struct usb_descriptor_header *) &rmnet_interface_desc,
- (struct usb_descriptor_header *) &rmnet_fs_notify_desc,
- (struct usb_descriptor_header *) &rmnet_fs_in_desc,
- (struct usb_descriptor_header *) &rmnet_fs_out_desc,
+static struct usb_descriptor_header *rmnet_mux_fs_function[] = {
+ (struct usb_descriptor_header *) &rmnet_mux_interface_desc,
+ (struct usb_descriptor_header *) &rmnet_mux_fs_notify_desc,
+ (struct usb_descriptor_header *) &rmnet_mux_fs_in_desc,
+ (struct usb_descriptor_header *) &rmnet_mux_fs_out_desc,
NULL,
};
/* High speed support */
-static struct usb_endpoint_descriptor rmnet_hs_notify_desc = {
+static struct usb_endpoint_descriptor rmnet_mux_hs_notify_desc = {
.bLength = USB_DT_ENDPOINT_SIZE,
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = USB_DIR_IN,
.bmAttributes = USB_ENDPOINT_XFER_INT,
- .wMaxPacketSize = __constant_cpu_to_le16(RMNET_SDIO_MAX_NFY_SZE),
- .bInterval = RMNET_SDIO_NOTIFY_INTERVAL + 4,
+ .wMaxPacketSize = __constant_cpu_to_le16(
+ RMNET_MUX_SDIO_MAX_NFY_SZE),
+ .bInterval = RMNET_MUX_SDIO_NOTIFY_INTERVAL + 4,
};
-static struct usb_endpoint_descriptor rmnet_hs_in_desc = {
+static struct usb_endpoint_descriptor rmnet_mux_hs_in_desc = {
.bLength = USB_DT_ENDPOINT_SIZE,
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = USB_DIR_IN,
@@ -244,7 +258,7 @@
.wMaxPacketSize = __constant_cpu_to_le16(512),
};
-static struct usb_endpoint_descriptor rmnet_hs_out_desc = {
+static struct usb_endpoint_descriptor rmnet_mux_hs_out_desc = {
.bLength = USB_DT_ENDPOINT_SIZE,
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = USB_DIR_OUT,
@@ -252,48 +266,49 @@
.wMaxPacketSize = __constant_cpu_to_le16(512),
};
-static struct usb_descriptor_header *rmnet_hs_function[] = {
- (struct usb_descriptor_header *) &rmnet_interface_desc,
- (struct usb_descriptor_header *) &rmnet_hs_notify_desc,
- (struct usb_descriptor_header *) &rmnet_hs_in_desc,
- (struct usb_descriptor_header *) &rmnet_hs_out_desc,
+static struct usb_descriptor_header *rmnet_mux_hs_function[] = {
+ (struct usb_descriptor_header *) &rmnet_mux_interface_desc,
+ (struct usb_descriptor_header *) &rmnet_mux_hs_notify_desc,
+ (struct usb_descriptor_header *) &rmnet_mux_hs_in_desc,
+ (struct usb_descriptor_header *) &rmnet_mux_hs_out_desc,
NULL,
};
/* String descriptors */
-static struct usb_string rmnet_string_defs[] = {
+static struct usb_string rmnet_mux_string_defs[] = {
[0].s = "RmNet",
{ } /* end of list */
};
-static struct usb_gadget_strings rmnet_string_table = {
+static struct usb_gadget_strings rmnet_mux_string_table = {
.language = 0x0409, /* en-us */
- .strings = rmnet_string_defs,
+ .strings = rmnet_mux_string_defs,
};
-static struct usb_gadget_strings *rmnet_strings[] = {
- &rmnet_string_table,
+static struct usb_gadget_strings *rmnet_mux_strings[] = {
+ &rmnet_mux_string_table,
NULL,
};
-static char *xport_to_str(enum usb_rmnet_xport_type t)
+static char *xport_to_str(enum usb_rmnet_mux_xport_type t)
{
switch (t) {
- case USB_RMNET_XPORT_SDIO:
+ case USB_RMNET_MUX_XPORT_SDIO:
return "SDIO";
- case USB_RMNET_XPORT_SMD:
+ case USB_RMNET_MUX_XPORT_SMD:
return "SMD";
default:
return "UNDEFINED";
}
}
-static struct rmnet_ctrl_pkt *rmnet_alloc_ctrl_pkt(unsigned len, gfp_t flags)
+static struct rmnet_mux_ctrl_pkt *rmnet_mux_alloc_ctrl_pkt(unsigned len,
+ gfp_t flags)
{
- struct rmnet_ctrl_pkt *cpkt;
+ struct rmnet_mux_ctrl_pkt *cpkt;
- cpkt = kzalloc(sizeof(struct rmnet_ctrl_pkt), flags);
+ cpkt = kzalloc(sizeof(struct rmnet_mux_ctrl_pkt), flags);
if (!cpkt)
return 0;
@@ -309,7 +324,7 @@
}
-static void rmnet_free_ctrl_pkt(struct rmnet_ctrl_pkt *cpkt)
+static void rmnet_mux_free_ctrl_pkt(struct rmnet_mux_ctrl_pkt *cpkt)
{
kfree(cpkt->buf);
kfree(cpkt);
@@ -320,7 +335,7 @@
* usb_request or a pointer with an error code if there is an error.
*/
static struct usb_request *
-rmnet_alloc_req(struct usb_ep *ep, unsigned len, gfp_t kmalloc_flags)
+rmnet_mux_alloc_req(struct usb_ep *ep, unsigned len, gfp_t kmalloc_flags)
{
struct usb_request *req;
@@ -341,25 +356,26 @@
/*
* Free a usb_request and its buffer.
*/
-static void rmnet_free_req(struct usb_ep *ep, struct usb_request *req)
+static void rmnet_mux_free_req(struct usb_ep *ep, struct usb_request *req)
{
kfree(req->buf);
usb_ep_free_request(ep, req);
}
-static int rmnet_sdio_rx_submit(struct rmnet_dev *dev, struct usb_request *req,
- gfp_t gfp_flags)
+static int rmnet_mux_sdio_rx_submit(struct rmnet_mux_dev *dev,
+ struct usb_request *req, gfp_t gfp_flags)
{
struct sk_buff *skb;
int retval;
- skb = alloc_skb(RMNET_SDIO_RX_REQ_SIZE + SDIO_MUX_HDR, gfp_flags);
+ skb = alloc_skb(RMNET_MUX_SDIO_RX_REQ_SIZE + RMNET_MUX_SDIO_HDR,
+ gfp_flags);
if (skb == NULL)
return -ENOMEM;
- skb_reserve(skb, SDIO_MUX_HDR);
+ skb_reserve(skb, RMNET_MUX_SDIO_HDR);
req->buf = skb->data;
- req->length = RMNET_SDIO_RX_REQ_SIZE;
+ req->length = RMNET_MUX_SDIO_RX_REQ_SIZE;
req->context = skb;
retval = usb_ep_queue(dev->epout, req, gfp_flags);
@@ -369,9 +385,9 @@
return retval;
}
-static void rmnet_sdio_start_rx(struct rmnet_dev *dev)
+static void rmnet_mux_sdio_start_rx(struct rmnet_mux_dev *dev)
{
- struct rmnet_sdio_dev *sdio_dev = &dev->sdio_dev;
+ struct rmnet_mux_sdio_dev *sdio_dev = &dev->sdio_dev;
struct usb_composite_dev *cdev = dev->cdev;
int status;
struct usb_request *req;
@@ -390,11 +406,12 @@
list_del(&req->list);
spin_unlock_irqrestore(&dev->lock, flags);
- status = rmnet_sdio_rx_submit(dev, req, GFP_KERNEL);
+ status = rmnet_mux_sdio_rx_submit(dev, req, GFP_KERNEL);
spin_lock_irqsave(&dev->lock, flags);
if (status) {
- ERROR(cdev, "rmnet data rx enqueue err %d\n", status);
+ ERROR(cdev, "rmnet_mux data rx enqueue err %d\n",
+ status);
list_add_tail(&req->list, &sdio_dev->rx_idle);
break;
}
@@ -402,13 +419,13 @@
spin_unlock_irqrestore(&dev->lock, flags);
}
-static void rmnet_sdio_start_tx(struct rmnet_dev *dev)
+static void rmnet_mux_sdio_start_tx(struct rmnet_mux_dev *dev)
{
unsigned long flags;
int status;
struct sk_buff *skb;
struct usb_request *req;
- struct rmnet_sdio_dev *sdio_dev = &dev->sdio_dev;
+ struct rmnet_mux_sdio_dev *sdio_dev = &dev->sdio_dev;
struct usb_composite_dev *cdev = dev->cdev;
@@ -442,7 +459,7 @@
__skb_queue_head(&sdio_dev->tx_skb_queue, skb);
} else {
req->buf = 0;
- rmnet_free_req(dev->epin, req);
+ rmnet_mux_free_req(dev->epin, req);
dev_kfree_skb_any(skb);
}
break;
@@ -452,10 +469,10 @@
spin_unlock_irqrestore(&dev->lock, flags);
}
-static void rmnet_sdio_data_receive_cb(void *priv, struct sk_buff *skb)
+static void rmnet_mux_sdio_data_receive_cb(void *priv, struct sk_buff *skb)
{
- struct rmnet_dev *dev = priv;
- struct rmnet_sdio_dev *sdio_dev = &dev->sdio_dev;
+ struct rmnet_mux_dev *dev = priv;
+ struct rmnet_mux_sdio_dev *sdio_dev = &dev->sdio_dev;
unsigned long flags;
if (!skb)
@@ -465,7 +482,7 @@
return;
}
spin_lock_irqsave(&dev->lock, flags);
- if (sdio_dev->tx_skb_queue.qlen > sdio_tx_pkt_drop_thld) {
+ if (sdio_dev->tx_skb_queue.qlen > mux_sdio_tx_pkt_drop_thld) {
pr_err_ratelimited("%s: tx pkt dropped: tx_drop_cnt:%lu\n",
__func__, dev->tx_drp_cnt);
dev->tx_drp_cnt++;
@@ -475,13 +492,13 @@
}
__skb_queue_tail(&sdio_dev->tx_skb_queue, skb);
spin_unlock_irqrestore(&dev->lock, flags);
- rmnet_sdio_start_tx(dev);
+ rmnet_mux_sdio_start_tx(dev);
}
-static void rmnet_sdio_data_write_done(void *priv, struct sk_buff *skb)
+static void rmnet_mux_sdio_data_write_done(void *priv, struct sk_buff *skb)
{
- struct rmnet_dev *dev = priv;
- struct rmnet_sdio_dev *sdio_dev = &dev->sdio_dev;
+ struct rmnet_mux_dev *dev = priv;
+ struct rmnet_mux_sdio_dev *sdio_dev = &dev->sdio_dev;
if (!skb)
return;
@@ -493,20 +510,20 @@
spin_lock(&dev->lock);
sdio_dev->dpkts_pending_atdmux--;
- if (sdio_dev->dpkts_pending_atdmux >= sdio_rx_fctrl_dis_thld) {
+ if (sdio_dev->dpkts_pending_atdmux >= mux_sdio_rx_fctrl_dis_thld) {
spin_unlock(&dev->lock);
return;
}
spin_unlock(&dev->lock);
- rmnet_sdio_start_rx(dev);
+ rmnet_mux_sdio_start_rx(dev);
}
-static void rmnet_sdio_data_rx_work(struct work_struct *w)
+static void rmnet_mux_sdio_data_rx_work(struct work_struct *w)
{
- struct rmnet_dev *dev = container_of(w, struct rmnet_dev,
+ struct rmnet_mux_dev *dev = container_of(w, struct rmnet_mux_dev,
sdio_dev.data_rx_work);
- struct rmnet_sdio_dev *sdio_dev = &dev->sdio_dev;
+ struct rmnet_mux_sdio_dev *sdio_dev = &dev->sdio_dev;
struct usb_composite_dev *cdev = dev->cdev;
struct sk_buff *skb;
@@ -516,10 +533,10 @@
spin_lock_irqsave(&dev->lock, flags);
while ((skb = __skb_dequeue(&sdio_dev->rx_skb_queue))) {
spin_unlock_irqrestore(&dev->lock, flags);
- ret = msm_sdio_dmux_write(rmnet_sdio_data_ch, skb);
+ ret = msm_sdio_dmux_write(rmnet_mux_sdio_data_ch, skb);
spin_lock_irqsave(&dev->lock, flags);
if (ret < 0) {
- ERROR(cdev, "rmnet SDIO data write failed\n");
+ ERROR(cdev, "rmnet_mux SDIO data write failed\n");
dev_kfree_skb_any(skb);
} else {
dev->dpkts_tomdm++;
@@ -530,19 +547,19 @@
}
static void
-rmnet_sdio_complete_epout(struct usb_ep *ep, struct usb_request *req)
+rmnet_mux_sdio_complete_epout(struct usb_ep *ep, struct usb_request *req)
{
- struct rmnet_dev *dev = ep->driver_data;
- struct rmnet_sdio_dev *sdio_dev = &dev->sdio_dev;
+ struct rmnet_mux_dev *dev = ep->driver_data;
+ struct rmnet_mux_sdio_dev *sdio_dev = &dev->sdio_dev;
struct usb_composite_dev *cdev = dev->cdev;
struct sk_buff *skb = req->context;
int status = req->status;
int queue = 0;
- if (dev->xport == USB_RMNET_XPORT_UNDEFINED) {
+ if (dev->xport == USB_RMNET_MUX_XPORT_UNDEFINED) {
dev_kfree_skb_any(skb);
req->buf = 0;
- rmnet_free_req(ep, req);
+ rmnet_mux_free_req(ep, req);
return;
}
@@ -557,11 +574,11 @@
/* connection gone */
dev_kfree_skb_any(skb);
req->buf = 0;
- rmnet_free_req(ep, req);
+ rmnet_mux_free_req(ep, req);
return;
default:
/* unexpected failure */
- ERROR(cdev, "RMNET %s response error %d, %d/%d\n",
+ ERROR(cdev, "RMNET_MUX %s response error %d, %d/%d\n",
ep->name, status,
req->actual, req->length);
dev_kfree_skb_any(skb);
@@ -574,33 +591,33 @@
queue_work(dev->wq, &sdio_dev->data_rx_work);
}
- if (sdio_dev->dpkts_pending_atdmux >= sdio_rx_fctrl_en_thld) {
+ if (sdio_dev->dpkts_pending_atdmux >= mux_sdio_rx_fctrl_en_thld) {
list_add_tail(&req->list, &sdio_dev->rx_idle);
spin_unlock(&dev->lock);
return;
}
spin_unlock(&dev->lock);
- status = rmnet_sdio_rx_submit(dev, req, GFP_ATOMIC);
+ status = rmnet_mux_sdio_rx_submit(dev, req, GFP_ATOMIC);
if (status) {
- ERROR(cdev, "rmnet data rx enqueue err %d\n", status);
+ ERROR(cdev, "rmnet_mux data rx enqueue err %d\n", status);
list_add_tail(&req->list, &sdio_dev->rx_idle);
}
}
static void
-rmnet_sdio_complete_epin(struct usb_ep *ep, struct usb_request *req)
+rmnet_mux_sdio_complete_epin(struct usb_ep *ep, struct usb_request *req)
{
- struct rmnet_dev *dev = ep->driver_data;
- struct rmnet_sdio_dev *sdio_dev = &dev->sdio_dev;
+ struct rmnet_mux_dev *dev = ep->driver_data;
+ struct rmnet_mux_sdio_dev *sdio_dev = &dev->sdio_dev;
struct sk_buff *skb = req->context;
struct usb_composite_dev *cdev = dev->cdev;
int status = req->status;
- if (dev->xport == USB_RMNET_XPORT_UNDEFINED) {
+ if (dev->xport == USB_RMNET_MUX_XPORT_UNDEFINED) {
dev_kfree_skb_any(skb);
req->buf = 0;
- rmnet_free_req(ep, req);
+ rmnet_mux_free_req(ep, req);
return;
}
@@ -612,7 +629,7 @@
/* connection gone */
break;
default:
- ERROR(cdev, "rmnet data tx ep error %d\n", status);
+ ERROR(cdev, "rmnet_mux data tx ep error %d\n", status);
break;
}
@@ -621,12 +638,12 @@
spin_unlock(&dev->lock);
dev_kfree_skb_any(skb);
- rmnet_sdio_start_tx(dev);
+ rmnet_mux_sdio_start_tx(dev);
}
-static int rmnet_sdio_enable(struct rmnet_dev *dev)
+static int rmnet_mux_sdio_enable(struct rmnet_mux_dev *dev)
{
- struct rmnet_sdio_dev *sdio_dev = &dev->sdio_dev;
+ struct rmnet_mux_sdio_dev *sdio_dev = &dev->sdio_dev;
int i;
struct usb_request *req;
@@ -634,29 +651,29 @@
* If the memory allocation fails, all the allocated
* requests will be freed upon cable disconnect.
*/
- for (i = 0; i < RMNET_SDIO_RX_REQ_MAX; i++) {
- req = rmnet_alloc_req(dev->epout, 0, GFP_KERNEL);
+ for (i = 0; i < RMNET_MUX_SDIO_RX_REQ_MAX; i++) {
+ req = rmnet_mux_alloc_req(dev->epout, 0, GFP_KERNEL);
if (IS_ERR(req))
return PTR_ERR(req);
- req->complete = rmnet_sdio_complete_epout;
+ req->complete = rmnet_mux_sdio_complete_epout;
list_add_tail(&req->list, &sdio_dev->rx_idle);
}
- for (i = 0; i < RMNET_SDIO_TX_REQ_MAX; i++) {
- req = rmnet_alloc_req(dev->epin, 0, GFP_KERNEL);
+ for (i = 0; i < RMNET_MUX_SDIO_TX_REQ_MAX; i++) {
+ req = rmnet_mux_alloc_req(dev->epin, 0, GFP_KERNEL);
if (IS_ERR(req))
return PTR_ERR(req);
- req->complete = rmnet_sdio_complete_epin;
+ req->complete = rmnet_mux_sdio_complete_epin;
list_add_tail(&req->list, &sdio_dev->tx_idle);
}
- rmnet_sdio_start_rx(dev);
+ rmnet_mux_sdio_start_rx(dev);
return 0;
}
-static void rmnet_smd_start_rx(struct rmnet_dev *dev)
+static void rmnet_mux_smd_start_rx(struct rmnet_mux_dev *dev)
{
struct usb_composite_dev *cdev = dev->cdev;
- struct rmnet_smd_dev *smd_dev = &dev->smd_dev;
+ struct rmnet_mux_smd_dev *smd_dev = &dev->smd_dev;
int status;
struct usb_request *req;
struct list_head *pool = &smd_dev->rx_idle;
@@ -680,10 +697,10 @@
spin_unlock_irqrestore(&dev->lock, flags);
}
-static void rmnet_smd_data_tx_tlet(unsigned long arg)
+static void rmnet_mux_smd_data_tx_tlet(unsigned long arg)
{
- struct rmnet_dev *dev = (struct rmnet_dev *) arg;
- struct rmnet_smd_dev *smd_dev = &dev->smd_dev;
+ struct rmnet_mux_dev *dev = (struct rmnet_mux_dev *) arg;
+ struct rmnet_mux_smd_dev *smd_dev = &dev->smd_dev;
struct usb_composite_dev *cdev = dev->cdev;
struct usb_request *req;
int status;
@@ -702,7 +719,7 @@
spin_lock_irqsave(&dev->lock, flags);
if (list_empty(&smd_dev->tx_idle)) {
spin_unlock_irqrestore(&dev->lock, flags);
- DBG(cdev, "rmnet data Tx buffers full\n");
+ DBG(cdev, "rmnet_mux data Tx buffers full\n");
break;
}
req = list_first_entry(&smd_dev->tx_idle,
@@ -724,10 +741,10 @@
}
-static void rmnet_smd_data_rx_tlet(unsigned long arg)
+static void rmnet_mux_smd_data_rx_tlet(unsigned long arg)
{
- struct rmnet_dev *dev = (struct rmnet_dev *) arg;
- struct rmnet_smd_dev *smd_dev = &dev->smd_dev;
+ struct rmnet_mux_dev *dev = (struct rmnet_mux_dev *) arg;
+ struct rmnet_mux_smd_dev *smd_dev = &dev->smd_dev;
struct usb_composite_dev *cdev = dev->cdev;
struct usb_request *req;
int ret;
@@ -745,7 +762,7 @@
struct usb_request, list);
if (smd_write_avail(smd_dev->smd_data.ch) < req->actual) {
atomic_set(&smd_dev->smd_data.rx_pkt, req->actual);
- DBG(cdev, "rmnet SMD data channel full\n");
+ DBG(cdev, "rmnet_mux SMD data channel full\n");
break;
}
@@ -754,7 +771,7 @@
ret = smd_write(smd_dev->smd_data.ch, req->buf, req->actual);
spin_lock_irqsave(&dev->lock, flags);
if (ret != req->actual) {
- ERROR(cdev, "rmnet SMD data write failed\n");
+ ERROR(cdev, "rmnet_mux SMD data write failed\n");
break;
}
dev->dpkts_tomsm++;
@@ -763,7 +780,7 @@
spin_unlock_irqrestore(&dev->lock, flags);
/* We have free rx data requests. */
- rmnet_smd_start_rx(dev);
+ rmnet_mux_smd_start_rx(dev);
}
/* If SMD has enough room to accommodate a data rx packet,
@@ -772,16 +789,16 @@
* empty to strictly follow the ordering requests.
*/
static void
-rmnet_smd_complete_epout(struct usb_ep *ep, struct usb_request *req)
+rmnet_mux_smd_complete_epout(struct usb_ep *ep, struct usb_request *req)
{
- struct rmnet_dev *dev = req->context;
- struct rmnet_smd_dev *smd_dev = &dev->smd_dev;
+ struct rmnet_mux_dev *dev = req->context;
+ struct rmnet_mux_smd_dev *smd_dev = &dev->smd_dev;
struct usb_composite_dev *cdev = dev->cdev;
int status = req->status;
int ret;
- if (dev->xport == USB_RMNET_XPORT_UNDEFINED) {
- rmnet_free_req(ep, req);
+ if (dev->xport == USB_RMNET_MUX_XPORT_UNDEFINED) {
+ rmnet_mux_free_req(ep, req);
return;
}
@@ -798,7 +815,7 @@
return;
default:
/* unexpected failure */
- ERROR(cdev, "RMNET %s response error %d, %d/%d\n",
+ ERROR(cdev, "RMNET_MUX %s response error %d, %d/%d\n",
ep->name, status,
req->actual, req->length);
spin_lock(&dev->lock);
@@ -817,13 +834,13 @@
ret = smd_write(smd_dev->smd_data.ch, req->buf, req->actual);
/* This should never happen */
if (ret != req->actual)
- ERROR(cdev, "rmnet data smd write failed\n");
+ ERROR(cdev, "rmnet_mux data smd write failed\n");
/* Restart Rx */
dev->dpkts_tomsm++;
spin_lock(&dev->lock);
list_add_tail(&req->list, &smd_dev->rx_idle);
spin_unlock(&dev->lock);
- rmnet_smd_start_rx(dev);
+ rmnet_mux_smd_start_rx(dev);
return;
}
queue_req:
@@ -831,16 +848,17 @@
spin_unlock(&dev->lock);
}
-static void rmnet_smd_complete_epin(struct usb_ep *ep, struct usb_request *req)
+static void rmnet_mux_smd_complete_epin(struct usb_ep *ep,
+ struct usb_request *req)
{
- struct rmnet_dev *dev = req->context;
- struct rmnet_smd_dev *smd_dev = &dev->smd_dev;
+ struct rmnet_mux_dev *dev = req->context;
+ struct rmnet_mux_smd_dev *smd_dev = &dev->smd_dev;
struct usb_composite_dev *cdev = dev->cdev;
int status = req->status;
int schedule = 0;
- if (dev->xport == USB_RMNET_XPORT_UNDEFINED) {
- rmnet_free_req(ep, req);
+ if (dev->xport == USB_RMNET_MUX_XPORT_UNDEFINED) {
+ rmnet_mux_free_req(ep, req);
return;
}
@@ -853,7 +871,7 @@
spin_unlock(&dev->lock);
break;
default:
- ERROR(cdev, "rmnet data tx ep error %d\n", status);
+ ERROR(cdev, "rmnet_mux data tx ep error %d\n", status);
/* FALLTHROUGH */
case 0:
spin_lock(&dev->lock);
@@ -870,10 +888,10 @@
}
-static void rmnet_smd_notify(void *priv, unsigned event)
+static void rmnet_mux_smd_notify(void *priv, unsigned event)
{
- struct rmnet_dev *dev = priv;
- struct rmnet_smd_info *smd_info = &dev->smd_dev.smd_data;
+ struct rmnet_mux_dev *dev = priv;
+ struct rmnet_mux_smd_info *smd_info = &dev->smd_dev.smd_data;
int len = atomic_read(&smd_info->rx_pkt);
switch (event) {
@@ -893,36 +911,36 @@
* are opened. wake up worker thread to continue
* connection processing
*/
- set_bit(CH_OPENED, &smd_info->flags);
+ set_bit(RMNET_MUX_CH_OPENED, &smd_info->flags);
wake_up(&smd_info->wait);
break;
case SMD_EVENT_CLOSE:
/* We will never come here.
* reset flags after closing smd channel
* */
- clear_bit(CH_OPENED, &smd_info->flags);
+ clear_bit(RMNET_MUX_CH_OPENED, &smd_info->flags);
break;
}
}
-static int rmnet_smd_enable(struct rmnet_dev *dev)
+static int rmnet_mux_smd_enable(struct rmnet_mux_dev *dev)
{
struct usb_composite_dev *cdev = dev->cdev;
- struct rmnet_smd_dev *smd_dev = &dev->smd_dev;
+ struct rmnet_mux_smd_dev *smd_dev = &dev->smd_dev;
int i, ret;
struct usb_request *req;
- if (test_bit(CH_OPENED, &smd_dev->smd_data.flags))
+ if (test_bit(RMNET_MUX_CH_OPENED, &smd_dev->smd_data.flags))
goto smd_alloc_req;
- ret = smd_open(rmnet_smd_data_ch, &smd_dev->smd_data.ch,
- dev, rmnet_smd_notify);
+ ret = smd_open(rmnet_mux_smd_data_ch, &smd_dev->smd_data.ch,
+ dev, rmnet_mux_smd_notify);
if (ret) {
ERROR(cdev, "Unable to open data smd channel\n");
return ret;
}
- wait_event(smd_dev->smd_data.wait, test_bit(CH_OPENED,
+ wait_event(smd_dev->smd_data.wait, test_bit(RMNET_MUX_CH_OPENED,
&smd_dev->smd_data.flags));
/* Allocate bulk in/out requests for data transfer.
@@ -930,34 +948,35 @@
* requests will be freed upon cable disconnect.
*/
smd_alloc_req:
- for (i = 0; i < RMNET_SMD_RX_REQ_MAX; i++) {
- req = rmnet_alloc_req(dev->epout, RMNET_SMD_RX_REQ_SIZE,
+ for (i = 0; i < RMNET_MUX_SMD_RX_REQ_MAX; i++) {
+ req = rmnet_mux_alloc_req(dev->epout, RMNET_MUX_SMD_RX_REQ_SIZE,
GFP_KERNEL);
if (IS_ERR(req))
return PTR_ERR(req);
- req->length = RMNET_SMD_TXN_MAX;
+ req->length = RMNET_MUX_SMD_TXN_MAX;
req->context = dev;
- req->complete = rmnet_smd_complete_epout;
+ req->complete = rmnet_mux_smd_complete_epout;
list_add_tail(&req->list, &smd_dev->rx_idle);
}
- for (i = 0; i < RMNET_SMD_TX_REQ_MAX; i++) {
- req = rmnet_alloc_req(dev->epin, RMNET_SMD_TX_REQ_SIZE,
+ for (i = 0; i < RMNET_MUX_SMD_TX_REQ_MAX; i++) {
+ req = rmnet_mux_alloc_req(dev->epin, RMNET_MUX_SMD_TX_REQ_SIZE,
GFP_KERNEL);
if (IS_ERR(req))
return PTR_ERR(req);
req->context = dev;
- req->complete = rmnet_smd_complete_epin;
+ req->complete = rmnet_mux_smd_complete_epin;
list_add_tail(&req->list, &smd_dev->tx_idle);
}
- rmnet_smd_start_rx(dev);
+ rmnet_mux_smd_start_rx(dev);
return 0;
}
-static void rmnet_notify_complete(struct usb_ep *ep, struct usb_request *req)
+static void rmnet_mux_notify_complete(struct usb_ep *ep,
+ struct usb_request *req)
{
- struct rmnet_dev *dev = req->context;
+ struct rmnet_mux_dev *dev = req->context;
struct usb_composite_dev *cdev = dev->cdev;
int status = req->status;
@@ -968,7 +987,7 @@
atomic_set(&dev->notify_count, 0);
break;
default:
- ERROR(cdev, "rmnet notifyep error %d\n", status);
+ ERROR(cdev, "rmnet_mux notifyep error %d\n", status);
/* FALLTHROUGH */
case 0:
@@ -984,7 +1003,7 @@
}
}
-static void ctrl_response_available(struct rmnet_dev *dev)
+static void ctrl_response_available(struct rmnet_mux_dev *dev)
{
struct usb_composite_dev *cdev = dev->cdev;
struct usb_request *req = dev->notify_req;
@@ -1005,15 +1024,16 @@
status = usb_ep_queue(dev->epnotify, dev->notify_req, GFP_ATOMIC);
if (status < 0) {
atomic_dec(&dev->notify_count);
- ERROR(cdev, "rmnet notify ep enqueue error %d\n", status);
+ ERROR(cdev, "rmnet_mux notify ep enqueue error %d\n", status);
}
}
#define MAX_CTRL_PKT_SIZE 4096
-static void rmnet_response_complete(struct usb_ep *ep, struct usb_request *req)
+static void rmnet_mux_response_complete(struct usb_ep *ep,
+ struct usb_request *req)
{
- struct rmnet_dev *dev = req->context;
+ struct rmnet_mux_dev *dev = req->context;
struct usb_composite_dev *cdev = dev->cdev;
switch (req->status) {
@@ -1022,26 +1042,27 @@
case 0:
return;
default:
- INFO(cdev, "rmnet %s response error %d, %d/%d\n",
+ INFO(cdev, "rmnet_mux %s response error %d, %d/%d\n",
ep->name, req->status,
req->actual, req->length);
}
}
-static void rmnet_command_complete(struct usb_ep *ep, struct usb_request *req)
+static void rmnet_mux_command_complete(struct usb_ep *ep,
+ struct usb_request *req)
{
- struct rmnet_dev *dev = req->context;
+ struct rmnet_mux_dev *dev = req->context;
struct usb_composite_dev *cdev = dev->cdev;
- struct rmnet_ctrl_dev *ctrl_dev = &dev->ctrl_dev;
- struct rmnet_ctrl_pkt *cpkt;
+ struct rmnet_mux_ctrl_dev *ctrl_dev = &dev->ctrl_dev;
+ struct rmnet_mux_ctrl_pkt *cpkt;
int len = req->actual;
if (req->status < 0) {
- ERROR(cdev, "rmnet command error %d\n", req->status);
+ ERROR(cdev, "rmnet_mux command error %d\n", req->status);
return;
}
- cpkt = rmnet_alloc_ctrl_pkt(len, GFP_ATOMIC);
+ cpkt = rmnet_mux_alloc_ctrl_pkt(len, GFP_ATOMIC);
if (!cpkt) {
ERROR(cdev, "unable to allocate memory for ctrl req\n");
return;
@@ -1069,17 +1090,18 @@
}
static int
-rmnet_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
+rmnet_mux_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
{
- struct rmnet_dev *dev = container_of(f, struct rmnet_dev, function);
- struct rmnet_ctrl_dev *ctrl_dev = &dev->ctrl_dev;
+ struct rmnet_mux_dev *dev = container_of(f, struct rmnet_mux_dev,
+ function);
+ struct rmnet_mux_ctrl_dev *ctrl_dev = &dev->ctrl_dev;
struct usb_composite_dev *cdev = f->config->cdev;
struct usb_request *req = cdev->req;
int ret = -EOPNOTSUPP;
u16 w_index = le16_to_cpu(ctrl->wIndex);
u16 w_value = le16_to_cpu(ctrl->wValue);
u16 w_length = le16_to_cpu(ctrl->wLength);
- struct rmnet_ctrl_pkt *cpkt;
+ struct rmnet_mux_ctrl_pkt *cpkt;
if (!atomic_read(&dev->online))
return -ENOTCONN;
@@ -1091,7 +1113,7 @@
if (w_length > req->length)
goto invalid;
ret = w_length;
- req->complete = rmnet_command_complete;
+ req->complete = rmnet_mux_command_complete;
req->context = dev;
break;
@@ -1114,7 +1136,7 @@
}
cpkt = list_first_entry(&ctrl_dev->rx_q,
- struct rmnet_ctrl_pkt, list);
+ struct rmnet_mux_ctrl_pkt, list);
list_del(&cpkt->list);
ctrl_dev->rx_len--;
spin_unlock(&dev->lock);
@@ -1122,9 +1144,9 @@
len = min_t(unsigned, w_length, cpkt->len);
memcpy(req->buf, cpkt->buf, len);
ret = len;
- req->complete = rmnet_response_complete;
+ req->complete = rmnet_mux_response_complete;
req->context = dev;
- rmnet_free_ctrl_pkt(cpkt);
+ rmnet_mux_free_ctrl_pkt(cpkt);
dev->cpkts_tolaptop++;
}
@@ -1140,7 +1162,7 @@
* enabled from device manager (or during enumeration), the
* request will be sent with DTR being '1'.
*/
- if (w_value & ACM_CTRL_DTR)
+ if (w_value & RMNET_MUX_ACM_CTRL_DTR)
ctrl_dev->cbits_to_modem |= TIOCM_DTR;
else
ctrl_dev->cbits_to_modem &= ~TIOCM_DTR;
@@ -1158,25 +1180,25 @@
/* respond with data transfer or status phase? */
if (ret >= 0) {
- VDBG(cdev, "rmnet req%02x.%02x v%04x i%04x l%d\n",
+ VDBG(cdev, "rmnet_mux req%02x.%02x v%04x i%04x l%d\n",
ctrl->bRequestType, ctrl->bRequest,
w_value, w_index, w_length);
req->zero = (ret < w_length);
req->length = ret;
ret = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
if (ret < 0)
- ERROR(cdev, "rmnet ep0 enqueue err %d\n", ret);
+ ERROR(cdev, "rmnet_mux ep0 enqueue err %d\n", ret);
}
return ret;
}
-static void rmnet_free_buf(struct rmnet_dev *dev)
+static void rmnet_mux_free_buf(struct rmnet_mux_dev *dev)
{
- struct rmnet_sdio_dev *sdio_dev = &dev->sdio_dev;
- struct rmnet_ctrl_dev *ctrl_dev = &dev->ctrl_dev;
- struct rmnet_smd_dev *smd_dev = &dev->smd_dev;
- struct rmnet_ctrl_pkt *cpkt;
+ struct rmnet_mux_sdio_dev *sdio_dev = &dev->sdio_dev;
+ struct rmnet_mux_ctrl_dev *ctrl_dev = &dev->ctrl_dev;
+ struct rmnet_mux_smd_dev *smd_dev = &dev->smd_dev;
+ struct rmnet_mux_ctrl_pkt *cpkt;
struct usb_request *req;
struct list_head *pool;
struct sk_buff *skb;
@@ -1189,7 +1211,7 @@
req = list_first_entry(pool, struct usb_request, list);
list_del(&req->list);
req->buf = NULL;
- rmnet_free_req(dev->epout, req);
+ rmnet_mux_free_req(dev->epout, req);
}
pool = &sdio_dev->rx_idle;
@@ -1198,7 +1220,7 @@
req = list_first_entry(pool, struct usb_request, list);
list_del(&req->list);
req->buf = NULL;
- rmnet_free_req(dev->epin, req);
+ rmnet_mux_free_req(dev->epin, req);
}
while ((skb = __skb_dequeue(&sdio_dev->tx_skb_queue)))
@@ -1212,7 +1234,7 @@
while (!list_empty(pool)) {
req = list_first_entry(pool, struct usb_request, list);
list_del(&req->list);
- rmnet_free_req(dev->epout, req);
+ rmnet_mux_free_req(dev->epout, req);
}
pool = &smd_dev->rx_idle;
@@ -1220,7 +1242,7 @@
while (!list_empty(pool)) {
req = list_first_entry(pool, struct usb_request, list);
list_del(&req->list);
- rmnet_free_req(dev->epin, req);
+ rmnet_mux_free_req(dev->epin, req);
}
/* free all usb requests in SMD rx queue */
@@ -1228,50 +1250,51 @@
while (!list_empty(pool)) {
req = list_first_entry(pool, struct usb_request, list);
list_del(&req->list);
- rmnet_free_req(dev->epin, req);
+ rmnet_mux_free_req(dev->epin, req);
}
pool = &ctrl_dev->tx_q;
while (!list_empty(pool)) {
- cpkt = list_first_entry(pool, struct rmnet_ctrl_pkt, list);
+ cpkt = list_first_entry(pool, struct rmnet_mux_ctrl_pkt, list);
list_del(&cpkt->list);
- rmnet_free_ctrl_pkt(cpkt);
+ rmnet_mux_free_ctrl_pkt(cpkt);
ctrl_dev->tx_len--;
}
pool = &ctrl_dev->rx_q;
while (!list_empty(pool)) {
- cpkt = list_first_entry(pool, struct rmnet_ctrl_pkt, list);
+ cpkt = list_first_entry(pool, struct rmnet_mux_ctrl_pkt, list);
list_del(&cpkt->list);
- rmnet_free_ctrl_pkt(cpkt);
+ rmnet_mux_free_ctrl_pkt(cpkt);
ctrl_dev->rx_len--;
}
spin_unlock_irqrestore(&dev->lock, flags);
}
-static void rmnet_disconnect_work(struct work_struct *w)
+static void rmnet_mux_disconnect_work(struct work_struct *w)
{
- struct rmnet_dev *dev = container_of(w, struct rmnet_dev,
+ struct rmnet_mux_dev *dev = container_of(w, struct rmnet_mux_dev,
disconnect_work);
- struct rmnet_smd_dev *smd_dev = &dev->smd_dev;
- struct rmnet_ctrl_dev *ctrl_dev = &dev->ctrl_dev;
+ struct rmnet_mux_smd_dev *smd_dev = &dev->smd_dev;
+ struct rmnet_mux_ctrl_dev *ctrl_dev = &dev->ctrl_dev;
- if (dev->xport == USB_RMNET_XPORT_SMD) {
+ if (dev->xport == USB_RMNET_MUX_XPORT_SMD) {
tasklet_kill(&smd_dev->smd_data.rx_tlet);
tasklet_kill(&smd_dev->smd_data.tx_tlet);
}
- rmnet_free_buf(dev);
+ rmnet_mux_free_buf(dev);
dev->xport = 0;
/* wakeup read thread */
wake_up(&ctrl_dev->tx_wait_q);
}
-static void rmnet_suspend(struct usb_function *f)
+static void rmnet_mux_suspend(struct usb_function *f)
{
- struct rmnet_dev *dev = container_of(f, struct rmnet_dev, function);
- struct rmnet_ctrl_dev *ctrl_dev = &dev->ctrl_dev;
+ struct rmnet_mux_dev *dev = container_of(f, struct rmnet_mux_dev,
+ function);
+ struct rmnet_mux_ctrl_dev *ctrl_dev = &dev->ctrl_dev;
if (!atomic_read(&dev->online))
return;
@@ -1283,10 +1306,11 @@
ctrl_dev->cbits_to_modem &= ~TIOCM_DTR;
}
-static void rmnet_disable(struct usb_function *f)
+static void rmnet_mux_disable(struct usb_function *f)
{
- struct rmnet_dev *dev = container_of(f, struct rmnet_dev, function);
- struct rmnet_ctrl_dev *ctrl_dev = &dev->ctrl_dev;
+ struct rmnet_mux_dev *dev = container_of(f, struct rmnet_mux_dev,
+ function);
+ struct rmnet_mux_ctrl_dev *ctrl_dev = &dev->ctrl_dev;
if (!atomic_read(&dev->online))
return;
@@ -1295,7 +1319,7 @@
usb_ep_fifo_flush(dev->epnotify);
usb_ep_disable(dev->epnotify);
- rmnet_free_req(dev->epnotify, dev->notify_req);
+ rmnet_mux_free_req(dev->epnotify, dev->notify_req);
usb_ep_fifo_flush(dev->epout);
usb_ep_disable(dev->epout);
@@ -1310,19 +1334,19 @@
#define SDIO_OPEN_RETRY_DELAY msecs_to_jiffies(2000)
#define SDIO_OPEN_MAX_RETRY 90
-static void rmnet_open_sdio_work(struct work_struct *w)
+static void rmnet_mux_open_sdio_work(struct work_struct *w)
{
- struct rmnet_dev *dev =
- container_of(w, struct rmnet_dev, sdio_dev.open_work.work);
- struct rmnet_sdio_dev *sdio_dev = &dev->sdio_dev;
+ struct rmnet_mux_dev *dev =
+ container_of(w, struct rmnet_mux_dev, sdio_dev.open_work.work);
+ struct rmnet_mux_sdio_dev *sdio_dev = &dev->sdio_dev;
struct usb_composite_dev *cdev = dev->cdev;
int ret;
static int retry_cnt;
/* Data channel for network packets */
- ret = msm_sdio_dmux_open(rmnet_sdio_data_ch, dev,
- rmnet_sdio_data_receive_cb,
- rmnet_sdio_data_write_done);
+ ret = msm_sdio_dmux_open(rmnet_mux_sdio_data_ch, dev,
+ rmnet_mux_sdio_data_receive_cb,
+ rmnet_mux_sdio_data_write_done);
if (ret) {
if (retry_cnt > SDIO_OPEN_MAX_RETRY) {
ERROR(cdev, "Unable to open SDIO DATA channel\n");
@@ -1336,41 +1360,42 @@
atomic_set(&sdio_dev->sdio_open, 1);
- pr_info("%s: usb rmnet sdio channels are open retry_cnt:%d\n",
+ pr_info("%s: usb rmnet_mux sdio channels are open retry_cnt:%d\n",
__func__, retry_cnt);
retry_cnt = 0;
return;
}
-static int rmnet_set_alt(struct usb_function *f,
+static int rmnet_mux_set_alt(struct usb_function *f,
unsigned intf, unsigned alt)
{
- struct rmnet_dev *dev = container_of(f, struct rmnet_dev, function);
- struct rmnet_sdio_dev *sdio_dev = &dev->sdio_dev;
+ struct rmnet_mux_dev *dev = container_of(f, struct rmnet_mux_dev,
+ function);
+ struct rmnet_mux_sdio_dev *sdio_dev = &dev->sdio_dev;
struct usb_composite_dev *cdev = dev->cdev;
/* allocate notification */
- dev->notify_req = rmnet_alloc_req(dev->epnotify,
- RMNET_SDIO_MAX_NFY_SZE, GFP_ATOMIC);
+ dev->notify_req = rmnet_mux_alloc_req(dev->epnotify,
+ RMNET_MUX_SDIO_MAX_NFY_SZE, GFP_ATOMIC);
if (IS_ERR(dev->notify_req))
return PTR_ERR(dev->notify_req);
- dev->notify_req->complete = rmnet_notify_complete;
+ dev->notify_req->complete = rmnet_mux_notify_complete;
dev->notify_req->context = dev;
- dev->notify_req->length = RMNET_SDIO_MAX_NFY_SZE;
+ dev->notify_req->length = RMNET_MUX_SDIO_MAX_NFY_SZE;
usb_ep_enable(dev->epnotify, ep_choose(cdev->gadget,
- &rmnet_hs_notify_desc,
- &rmnet_fs_notify_desc));
+ &rmnet_mux_hs_notify_desc,
+ &rmnet_mux_fs_notify_desc));
dev->epin->driver_data = dev;
usb_ep_enable(dev->epin, ep_choose(cdev->gadget,
- &rmnet_hs_in_desc,
- &rmnet_fs_in_desc));
+ &rmnet_mux_hs_in_desc,
+ &rmnet_mux_fs_in_desc));
dev->epout->driver_data = dev;
usb_ep_enable(dev->epout, ep_choose(cdev->gadget,
- &rmnet_hs_out_desc,
- &rmnet_fs_out_desc));
+ &rmnet_mux_hs_out_desc,
+ &rmnet_mux_fs_out_desc));
dev->dpkts_tolaptop = 0;
dev->cpkts_tolaptop = 0;
@@ -1390,12 +1415,13 @@
const char *buf, size_t size)
{
struct usb_function *f = dev_get_drvdata(device);
- struct rmnet_dev *dev = container_of(f, struct rmnet_dev, function);
+ struct rmnet_mux_dev *dev = container_of(f, struct rmnet_mux_dev,
+ function);
int value;
- enum usb_rmnet_xport_type given_xport;
- enum usb_rmnet_xport_type t;
- struct rmnet_smd_dev *smd_dev = &dev->smd_dev;
- struct rmnet_sdio_dev *sdio_dev = &dev->sdio_dev;
+ enum usb_rmnet_mux_xport_type given_xport;
+ enum usb_rmnet_mux_xport_type t;
+ struct rmnet_mux_smd_dev *smd_dev = &dev->smd_dev;
+ struct rmnet_mux_sdio_dev *sdio_dev = &dev->sdio_dev;
struct list_head *pool;
struct sk_buff_head *skb_pool;
struct sk_buff *skb;
@@ -1409,9 +1435,9 @@
sscanf(buf, "%d", &value);
if (value)
- given_xport = USB_RMNET_XPORT_SDIO;
+ given_xport = USB_RMNET_MUX_XPORT_SDIO;
else
- given_xport = USB_RMNET_XPORT_SMD;
+ given_xport = USB_RMNET_MUX_XPORT_SMD;
if (given_xport == dev->xport) {
pr_err("%s: given_xport:%s cur_xport:%s doing nothing\n",
@@ -1420,19 +1446,19 @@
return 0;
}
- pr_debug("usb_rmnet: TransportRequested: %s\n",
+ pr_debug("usb_rmnet_mux: TransportRequested: %s\n",
xport_to_str(given_xport));
/* prevent any other pkts to/from usb */
t = dev->xport;
- dev->xport = USB_RMNET_XPORT_UNDEFINED;
- if (t != USB_RMNET_XPORT_UNDEFINED) {
+ dev->xport = USB_RMNET_MUX_XPORT_UNDEFINED;
+ if (t != USB_RMNET_MUX_XPORT_UNDEFINED) {
usb_ep_fifo_flush(dev->epin);
usb_ep_fifo_flush(dev->epout);
}
switch (t) {
- case USB_RMNET_XPORT_SDIO:
+ case USB_RMNET_MUX_XPORT_SDIO:
spin_lock_irqsave(&dev->lock, flags);
/* tx_idle */
@@ -1443,7 +1469,7 @@
req = list_first_entry(pool, struct usb_request, list);
list_del(&req->list);
req->buf = NULL;
- rmnet_free_req(dev->epout, req);
+ rmnet_mux_free_req(dev->epout, req);
}
/* rx_idle */
@@ -1453,7 +1479,7 @@
req = list_first_entry(pool, struct usb_request, list);
list_del(&req->list);
req->buf = NULL;
- rmnet_free_req(dev->epin, req);
+ rmnet_mux_free_req(dev->epin, req);
}
/* tx_skb_queue */
@@ -1467,7 +1493,7 @@
spin_unlock_irqrestore(&dev->lock, flags);
break;
- case USB_RMNET_XPORT_SMD:
+ case USB_RMNET_MUX_XPORT_SMD:
/* close smd xport */
tasklet_kill(&smd_dev->smd_data.rx_tlet);
tasklet_kill(&smd_dev->smd_data.tx_tlet);
@@ -1478,7 +1504,7 @@
while (!list_empty(pool)) {
req = list_first_entry(pool, struct usb_request, list);
list_del(&req->list);
- rmnet_free_req(dev->epout, req);
+ rmnet_mux_free_req(dev->epout, req);
}
pool = &smd_dev->rx_idle;
@@ -1486,7 +1512,7 @@
while (!list_empty(pool)) {
req = list_first_entry(pool, struct usb_request, list);
list_del(&req->list);
- rmnet_free_req(dev->epin, req);
+ rmnet_mux_free_req(dev->epin, req);
}
/* free all usb requests in SMD rx queue */
@@ -1494,7 +1520,7 @@
while (!list_empty(pool)) {
req = list_first_entry(pool, struct usb_request, list);
list_del(&req->list);
- rmnet_free_req(dev->epin, req);
+ rmnet_mux_free_req(dev->epin, req);
}
spin_unlock_irqrestore(&dev->lock, flags);
@@ -1506,11 +1532,11 @@
dev->xport = given_xport;
switch (dev->xport) {
- case USB_RMNET_XPORT_SDIO:
- rmnet_sdio_enable(dev);
+ case USB_RMNET_MUX_XPORT_SDIO:
+ rmnet_mux_sdio_enable(dev);
break;
- case USB_RMNET_XPORT_SMD:
- rmnet_smd_enable(dev);
+ case USB_RMNET_MUX_XPORT_SMD:
+ rmnet_mux_smd_enable(dev);
break;
default:
/* we should never come here */
@@ -1521,12 +1547,13 @@
}
static DEVICE_ATTR(transport, S_IRUGO | S_IWUSR, NULL, transport_store);
-static int rmnet_bind(struct usb_configuration *c, struct usb_function *f)
+static int rmnet_mux_bind(struct usb_configuration *c, struct usb_function *f)
{
struct usb_composite_dev *cdev = c->cdev;
- struct rmnet_dev *dev = container_of(f, struct rmnet_dev, function);
- struct rmnet_sdio_dev *sdio_dev = &dev->sdio_dev;
- int id, ret;
+ struct rmnet_mux_dev *dev = container_of(f, struct rmnet_mux_dev,
+ function);
+ struct rmnet_mux_sdio_dev *sdio_dev = &dev->sdio_dev;
+ int id;
struct usb_ep *ep;
dev->cdev = cdev;
@@ -1536,21 +1563,21 @@
if (id < 0)
return id;
dev->ifc_id = id;
- rmnet_interface_desc.bInterfaceNumber = id;
+ rmnet_mux_interface_desc.bInterfaceNumber = id;
- ep = usb_ep_autoconfig(cdev->gadget, &rmnet_fs_in_desc);
+ ep = usb_ep_autoconfig(cdev->gadget, &rmnet_mux_fs_in_desc);
if (!ep)
goto out;
ep->driver_data = cdev; /* claim endpoint */
dev->epin = ep;
- ep = usb_ep_autoconfig(cdev->gadget, &rmnet_fs_out_desc);
+ ep = usb_ep_autoconfig(cdev->gadget, &rmnet_mux_fs_out_desc);
if (!ep)
goto out;
ep->driver_data = cdev; /* claim endpoint */
dev->epout = ep;
- ep = usb_ep_autoconfig(cdev->gadget, &rmnet_fs_notify_desc);
+ ep = usb_ep_autoconfig(cdev->gadget, &rmnet_mux_fs_notify_desc);
if (!ep)
goto out;
ep->driver_data = cdev; /* claim endpoint */
@@ -1561,18 +1588,14 @@
* both speeds
*/
if (gadget_is_dualspeed(c->cdev->gadget)) {
- rmnet_hs_in_desc.bEndpointAddress =
- rmnet_fs_in_desc.bEndpointAddress;
- rmnet_hs_out_desc.bEndpointAddress =
- rmnet_fs_out_desc.bEndpointAddress;
- rmnet_hs_notify_desc.bEndpointAddress =
- rmnet_fs_notify_desc.bEndpointAddress;
+ rmnet_mux_hs_in_desc.bEndpointAddress =
+ rmnet_mux_fs_in_desc.bEndpointAddress;
+ rmnet_mux_hs_out_desc.bEndpointAddress =
+ rmnet_mux_fs_out_desc.bEndpointAddress;
+ rmnet_mux_hs_notify_desc.bEndpointAddress =
+ rmnet_mux_fs_notify_desc.bEndpointAddress;
}
- ret = device_create_file(f->dev, &dev_attr_transport);
- if (ret)
- goto out;
-
queue_delayed_work(dev->wq, &sdio_dev->open_work, 0);
return 0;
@@ -1588,15 +1611,15 @@
return -ENODEV;
}
-static void rmnet_smd_init(struct rmnet_smd_dev *smd_dev)
+static void rmnet_mux_smd_init(struct rmnet_mux_smd_dev *smd_dev)
{
- struct rmnet_dev *dev = container_of(smd_dev,
- struct rmnet_dev, smd_dev);
+ struct rmnet_mux_dev *dev = container_of(smd_dev,
+ struct rmnet_mux_dev, smd_dev);
atomic_set(&smd_dev->smd_data.rx_pkt, 0);
- tasklet_init(&smd_dev->smd_data.rx_tlet, rmnet_smd_data_rx_tlet,
+ tasklet_init(&smd_dev->smd_data.rx_tlet, rmnet_mux_smd_data_rx_tlet,
(unsigned long) dev);
- tasklet_init(&smd_dev->smd_data.tx_tlet, rmnet_smd_data_tx_tlet,
+ tasklet_init(&smd_dev->smd_data.tx_tlet, rmnet_mux_smd_data_tx_tlet,
(unsigned long) dev);
init_waitqueue_head(&smd_dev->smd_data.wait);
@@ -1606,11 +1629,11 @@
INIT_LIST_HEAD(&smd_dev->tx_idle);
}
-static void rmnet_sdio_init(struct rmnet_sdio_dev *sdio_dev)
+static void rmnet_mux_sdio_init(struct rmnet_mux_sdio_dev *sdio_dev)
{
- INIT_WORK(&sdio_dev->data_rx_work, rmnet_sdio_data_rx_work);
+ INIT_WORK(&sdio_dev->data_rx_work, rmnet_mux_sdio_data_rx_work);
- INIT_DELAYED_WORK(&sdio_dev->open_work, rmnet_open_sdio_work);
+ INIT_DELAYED_WORK(&sdio_dev->open_work, rmnet_mux_open_sdio_work);
INIT_LIST_HEAD(&sdio_dev->rx_idle);
INIT_LIST_HEAD(&sdio_dev->tx_idle);
@@ -1619,24 +1642,23 @@
}
static void
-rmnet_unbind(struct usb_configuration *c, struct usb_function *f)
+rmnet_mux_unbind(struct usb_configuration *c, struct usb_function *f)
{
- struct rmnet_dev *dev = container_of(f, struct rmnet_dev, function);
- struct rmnet_smd_dev *smd_dev = &dev->smd_dev;
+ struct rmnet_mux_dev *dev = container_of(f, struct rmnet_mux_dev,
+ function);
+ struct rmnet_mux_smd_dev *smd_dev = &dev->smd_dev;
- smd_close(smd_dev->smd_data.ch);
smd_dev->smd_data.flags = 0;
-
}
#if defined(CONFIG_DEBUG_FS)
#define DEBUG_BUF_SIZE 1024
-static ssize_t debug_read_stats(struct file *file, char __user *ubuf,
+static ssize_t rmnet_mux_read_stats(struct file *file, char __user *ubuf,
size_t count, loff_t *ppos)
{
- struct rmnet_dev *dev = file->private_data;
- struct rmnet_sdio_dev *sdio_dev = &dev->sdio_dev;
- struct rmnet_ctrl_dev *ctrl_dev = &dev->ctrl_dev;
+ struct rmnet_mux_dev *dev = file->private_data;
+ struct rmnet_mux_sdio_dev *sdio_dev = &dev->sdio_dev;
+ struct rmnet_mux_ctrl_dev *ctrl_dev = &dev->ctrl_dev;
char *debug_buf;
unsigned long flags;
int ret;
@@ -1681,11 +1703,11 @@
return ret;
}
-static ssize_t debug_reset_stats(struct file *file, const char __user *buf,
+static ssize_t rmnet_mux_reset_stats(struct file *file, const char __user *buf,
size_t count, loff_t *ppos)
{
- struct rmnet_dev *dev = file->private_data;
- struct rmnet_sdio_dev *sdio_dev = &dev->sdio_dev;
+ struct rmnet_mux_dev *dev = file->private_data;
+ struct rmnet_mux_sdio_dev *sdio_dev = &dev->sdio_dev;
dev->dpkts_tolaptop = 0;
dev->cpkts_tolaptop = 0;
@@ -1698,38 +1720,39 @@
return count;
}
-static int debug_open(struct inode *inode, struct file *file)
+static int dbg_rmnet_mux_open(struct inode *inode, struct file *file)
{
file->private_data = inode->i_private;
return 0;
}
-const struct file_operations rmnet_svlte_debug_stats_ops = {
- .open = debug_open,
- .read = debug_read_stats,
- .write = debug_reset_stats,
+const struct file_operations rmnet_mux_svlte_debug_stats_ops = {
+ .open = dbg_rmnet_mux_open,
+ .read = rmnet_mux_read_stats,
+ .write = rmnet_mux_reset_stats,
};
-static void usb_debugfs_init(struct rmnet_dev *dev)
-{
- struct dentry *dent;
+struct dentry *dent_rmnet_mux;
- dent = debugfs_create_dir("usb_rmnet", 0);
- if (IS_ERR(dent))
+static void rmnet_mux_debugfs_init(struct rmnet_mux_dev *dev)
+{
+
+ dent_rmnet_mux = debugfs_create_dir("usb_rmnet_mux", 0);
+ if (IS_ERR(dent_rmnet_mux))
return;
- debugfs_create_file("status", 0444, dent, dev,
- &rmnet_svlte_debug_stats_ops);
+ debugfs_create_file("status", 0444, dent_rmnet_mux, dev,
+ &rmnet_mux_svlte_debug_stats_ops);
}
#else
-static void usb_debugfs_init(struct rmnet_dev *dev) {}
+static void rmnet_mux_debugfs_init(struct rmnet_mux_dev *dev) {}
#endif
-int usb_rmnet_ctrl_open(struct inode *inode, struct file *fp)
+int usb_rmnet_mux_ctrl_open(struct inode *inode, struct file *fp)
{
- struct rmnet_dev *dev = _dev;
- struct rmnet_ctrl_dev *ctrl_dev = &dev->ctrl_dev;
+ struct rmnet_mux_dev *dev = rmux_dev;
+ struct rmnet_mux_ctrl_dev *ctrl_dev = &dev->ctrl_dev;
unsigned long flags;
spin_lock_irqsave(&dev->lock, flags);
@@ -1747,10 +1770,10 @@
}
-int usb_rmnet_ctrl_release(struct inode *inode, struct file *fp)
+int usb_rmnet_mux_ctrl_release(struct inode *inode, struct file *fp)
{
- struct rmnet_dev *dev = fp->private_data;
- struct rmnet_ctrl_dev *ctrl_dev = &dev->ctrl_dev;
+ struct rmnet_mux_dev *dev = fp->private_data;
+ struct rmnet_mux_ctrl_dev *ctrl_dev = &dev->ctrl_dev;
unsigned long flags;
spin_lock_irqsave(&dev->lock, flags);
@@ -1761,14 +1784,14 @@
return 0;
}
-ssize_t usb_rmnet_ctrl_read(struct file *fp,
+ssize_t usb_rmnet_mux_ctrl_read(struct file *fp,
char __user *buf,
size_t count,
loff_t *ppos)
{
- struct rmnet_dev *dev = fp->private_data;
- struct rmnet_ctrl_dev *ctrl_dev = &dev->ctrl_dev;
- struct rmnet_ctrl_pkt *cpkt;
+ struct rmnet_mux_dev *dev = fp->private_data;
+ struct rmnet_mux_ctrl_dev *ctrl_dev = &dev->ctrl_dev;
+ struct rmnet_mux_ctrl_pkt *cpkt;
unsigned long flags;
int ret = 0;
@@ -1791,7 +1814,8 @@
goto ctrl_read;
}
- cpkt = list_first_entry(&ctrl_dev->tx_q, struct rmnet_ctrl_pkt, list);
+ cpkt = list_first_entry(&ctrl_dev->tx_q, struct rmnet_mux_ctrl_pkt,
+ list);
if (cpkt->len > count) {
spin_unlock_irqrestore(&dev->lock, flags);
pr_err("%s: cpkt size:%d > buf size:%d\n",
@@ -1807,7 +1831,7 @@
ret = copy_to_user(buf, cpkt->buf, count);
dev->cpkts_tomdm++;
- rmnet_free_ctrl_pkt(cpkt);
+ rmnet_mux_free_ctrl_pkt(cpkt);
if (ret)
return ret;
@@ -1815,14 +1839,14 @@
return count;
}
-ssize_t usb_rmnet_ctrl_write(struct file *fp,
+ssize_t usb_rmnet_mux_ctrl_write(struct file *fp,
const char __user *buf,
size_t count,
loff_t *ppos)
{
- struct rmnet_dev *dev = fp->private_data;
- struct rmnet_ctrl_dev *ctrl_dev = &dev->ctrl_dev;
- struct rmnet_ctrl_pkt *cpkt;
+ struct rmnet_mux_dev *dev = fp->private_data;
+ struct rmnet_mux_ctrl_dev *ctrl_dev = &dev->ctrl_dev;
+ struct rmnet_mux_ctrl_pkt *cpkt;
unsigned long flags;
int ret = 0;
@@ -1842,9 +1866,9 @@
return -ENOMEM;
}
- cpkt = rmnet_alloc_ctrl_pkt(count, GFP_KERNEL);
+ cpkt = rmnet_mux_alloc_ctrl_pkt(count, GFP_KERNEL);
if (!cpkt) {
- pr_err("%s: cannot allocate rmnet ctrl pkt\n", __func__);
+ pr_err("%s: cannot allocate rmnet_mux ctrl pkt\n", __func__);
return -ENOMEM;
}
@@ -1852,7 +1876,7 @@
if (ret) {
pr_err("%s: copy_from_user failed err:%d\n",
__func__, ret);
- rmnet_free_ctrl_pkt(cpkt);
+ rmnet_mux_free_ctrl_pkt(cpkt);
return ret;
}
@@ -1867,16 +1891,16 @@
}
-#define RMNET_CTRL_GET_DTR _IOR(0xFE, 0, int)
+#define RMNET_MUX_CTRL_GET_DTR _IOR(0xFE, 0, int)
static long
-usb_rmnet_ctrl_ioctl(struct file *fp, unsigned c, unsigned long value)
+usb_rmnet_mux_ctrl_ioctl(struct file *fp, unsigned c, unsigned long value)
{
- struct rmnet_dev *dev = fp->private_data;
- struct rmnet_ctrl_dev *ctrl_dev = &dev->ctrl_dev;
+ struct rmnet_mux_dev *dev = fp->private_data;
+ struct rmnet_mux_ctrl_dev *ctrl_dev = &dev->ctrl_dev;
unsigned long *temp = (unsigned long *)value;
int ret = 0;
- if (c != RMNET_CTRL_GET_DTR)
+ if (c != RMNET_MUX_CTRL_GET_DTR)
return -ENODEV;
ret = copy_to_user(temp,
@@ -1888,31 +1912,31 @@
return 0;
}
-static const struct file_operations rmnet_ctrl_fops = {
+static const struct file_operations rmnet_mux_ctrl_fops = {
.owner = THIS_MODULE,
- .open = usb_rmnet_ctrl_open,
- .release = usb_rmnet_ctrl_release,
- .read = usb_rmnet_ctrl_read,
- .write = usb_rmnet_ctrl_write,
- .unlocked_ioctl = usb_rmnet_ctrl_ioctl,
+ .open = usb_rmnet_mux_ctrl_open,
+ .release = usb_rmnet_mux_ctrl_release,
+ .read = usb_rmnet_mux_ctrl_read,
+ .write = usb_rmnet_mux_ctrl_write,
+ .unlocked_ioctl = usb_rmnet_mux_ctrl_ioctl,
};
-static struct miscdevice rmnet_ctrl_dev = {
+static struct miscdevice rmnet_mux_ctrl_dev = {
.minor = MISC_DYNAMIC_MINOR,
- .name = "rmnet_ctrl",
- .fops = &rmnet_ctrl_fops,
+ .name = "rmnet_mux_ctrl",
+ .fops = &rmnet_mux_ctrl_fops,
};
-static int rmnet_ctrl_device_init(struct rmnet_dev *dev)
+static int rmnet_mux_ctrl_device_init(struct rmnet_mux_dev *dev)
{
int ret;
- struct rmnet_ctrl_dev *ctrl_dev = &dev->ctrl_dev;
+ struct rmnet_mux_ctrl_dev *ctrl_dev = &dev->ctrl_dev;
INIT_LIST_HEAD(&ctrl_dev->tx_q);
INIT_LIST_HEAD(&ctrl_dev->rx_q);
init_waitqueue_head(&ctrl_dev->tx_wait_q);
- ret = misc_register(&rmnet_ctrl_dev);
+ ret = misc_register(&rmnet_mux_ctrl_dev);
if (ret) {
pr_err("%s: failed to register misc device\n", __func__);
return ret;
@@ -1921,18 +1945,41 @@
return 0;
}
-static int rmnet_function_add(struct usb_configuration *c)
+static int rmnet_smd_sdio_function_add(struct usb_configuration *c)
{
- struct rmnet_dev *dev;
+ struct rmnet_mux_dev *dev = rmux_dev;
+
+ if (!dev)
+ return -ENODEV;
+
+ pr_debug("rmnet_smd_sdio_function_add\n");
+
+ dev->function.name = "rmnet_smd_sdio";
+ dev->function.strings = rmnet_mux_strings;
+ dev->function.descriptors = rmnet_mux_fs_function;
+ dev->function.hs_descriptors = rmnet_mux_hs_function;
+ dev->function.bind = rmnet_mux_bind;
+ dev->function.unbind = rmnet_mux_unbind;
+ dev->function.setup = rmnet_mux_setup;
+ dev->function.set_alt = rmnet_mux_set_alt;
+ dev->function.disable = rmnet_mux_disable;
+ dev->function.suspend = rmnet_mux_suspend;
+
+ return usb_add_function(c, &dev->function);
+}
+
+static int rmnet_smd_sdio_init(void)
+{
+ struct rmnet_mux_dev *dev;
int ret;
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
if (!dev)
return -ENOMEM;
- _dev = dev;
+ rmux_dev = dev;
- dev->wq = create_singlethread_workqueue("k_rmnet_work");
+ dev->wq = create_singlethread_workqueue("k_rmnet_mux_work");
if (!dev->wq) {
ret = -ENOMEM;
goto free_dev;
@@ -1941,33 +1988,18 @@
spin_lock_init(&dev->lock);
atomic_set(&dev->notify_count, 0);
atomic_set(&dev->online, 0);
- INIT_WORK(&dev->disconnect_work, rmnet_disconnect_work);
- rmnet_smd_init(&dev->smd_dev);
- rmnet_sdio_init(&dev->sdio_dev);
+ INIT_WORK(&dev->disconnect_work, rmnet_mux_disconnect_work);
+ rmnet_mux_smd_init(&dev->smd_dev);
+ rmnet_mux_sdio_init(&dev->sdio_dev);
- ret = rmnet_ctrl_device_init(dev);
+ ret = rmnet_mux_ctrl_device_init(dev);
if (ret) {
- pr_debug("%s: rmnet_ctrl_device_init failed, err:%d\n",
+ pr_debug("%s: rmnet_mux_ctrl_device_init failed, err:%d\n",
__func__, ret);
goto free_wq;
}
- dev->function.name = "rmnet_smd_sdio";
- dev->function.strings = rmnet_strings;
- dev->function.descriptors = rmnet_fs_function;
- dev->function.hs_descriptors = rmnet_hs_function;
- dev->function.bind = rmnet_bind;
- dev->function.unbind = rmnet_unbind;
- dev->function.setup = rmnet_setup;
- dev->function.set_alt = rmnet_set_alt;
- dev->function.disable = rmnet_disable;
- dev->function.suspend = rmnet_suspend;
-
- ret = usb_add_function(c, &dev->function);
- if (ret)
- goto free_wq;
-
- usb_debugfs_init(dev);
+ rmnet_mux_debugfs_init(dev);
return 0;
@@ -1979,17 +2011,14 @@
return ret;
}
-#ifdef CONFIG_USB_ANDROID_RMNET_SMD_SDIO
-static struct android_usb_function rmnet_function = {
- .name = "rmnet_smd_sdio",
- .bind_config = rmnet_function_add,
-};
-
-static int __init rmnet_init(void)
+static void rmnet_smd_sdio_cleanup(void)
{
- android_register_function(&rmnet_function);
- return 0;
-}
-module_init(rmnet_init);
+ struct rmnet_mux_dev *dev = rmux_dev;
+ struct rmnet_mux_smd_dev *smd_dev = &dev->smd_dev;
-#endif /* CONFIG_USB_ANDROID_RMNET_SDIO */
+ debugfs_remove_recursive(dent_rmnet_mux);
+ misc_deregister(&rmnet_mux_ctrl_dev);
+ smd_close(smd_dev->smd_data.ch);
+ destroy_workqueue(dev->wq);
+ kfree(dev);
+}