USB: gadget: f_rmnet_smd: Add support for new composition framework
Signed-off-by: Manu Gautam <mgautam@codeaurora.org>
diff --git a/drivers/usb/gadget/android.c b/drivers/usb/gadget/android.c
index 7133707..0c78dc3 100644
--- a/drivers/usb/gadget/android.c
+++ b/drivers/usb/gadget/android.c
@@ -47,6 +47,7 @@
#include "composite.c"
#include "f_diag.c"
+#include "f_rmnet_smd.c"
#include "f_mass_storage.c"
#include "u_serial.c"
#include "u_sdio.c"
@@ -194,6 +195,18 @@
/*-------------------------------------------------------------------------*/
/* Supported functions initialization */
+static int rmnet_smd_function_bind_config(struct android_usb_function *f,
+ struct usb_configuration *c)
+{
+ return rmnet_smd_bind_config(c);
+}
+
+static struct android_usb_function rmnet_smd_function = {
+ .name = "rmnet_smd",
+ .bind_config = rmnet_smd_function_bind_config,
+};
+
+
char diag_clients[32]; /* enabled DIAG clients - "diag[,diag_mdm]" */
static ssize_t clients_store(
struct device *device, struct device_attribute *attr,
@@ -786,6 +799,7 @@
static struct android_usb_function *supported_functions[] = {
+ &rmnet_smd_function,
&diag_function,
&serial_function,
&adb_function,
diff --git a/drivers/usb/gadget/f_rmnet_smd.c b/drivers/usb/gadget/f_rmnet_smd.c
index 00925f9..268c7b0 100644
--- a/drivers/usb/gadget/f_rmnet_smd.c
+++ b/drivers/usb/gadget/f_rmnet_smd.c
@@ -39,7 +39,6 @@
#include <linux/usb/cdc.h>
#include <linux/usb/composite.h>
#include <linux/usb/ch9.h>
-#include <linux/usb/android_composite.h>
#include "gadget_chips.h"
@@ -51,22 +50,22 @@
module_param(rmnet_data_ch, charp, S_IRUGO);
MODULE_PARM_DESC(rmnet_data_ch, "RmNet data SMD channel");
-#define ACM_CTRL_DTR (1 << 0)
+#define RMNET_SMD_ACM_CTRL_DTR (1 << 0)
-#define RMNET_NOTIFY_INTERVAL 5
-#define RMNET_MAX_NOTIFY_SIZE sizeof(struct usb_cdc_notification)
+#define RMNET_SMD_NOTIFY_INTERVAL 5
+#define RMNET_SMD_MAX_NOTIFY_SIZE sizeof(struct usb_cdc_notification)
-#define QMI_REQ_MAX 4
-#define QMI_REQ_SIZE 2048
-#define QMI_RESP_MAX 8
-#define QMI_RESP_SIZE 2048
+#define QMI_REQ_MAX 4
+#define QMI_REQ_SIZE 2048
+#define QMI_RESP_MAX 8
+#define QMI_RESP_SIZE 2048
-#define RX_REQ_MAX 8
-#define RX_REQ_SIZE 2048
-#define TX_REQ_MAX 8
-#define TX_REQ_SIZE 2048
+#define RMNET_RX_REQ_MAX 8
+#define RMNET_RX_REQ_SIZE 2048
+#define RMNET_TX_REQ_MAX 8
+#define RMNET_TX_REQ_SIZE 2048
-#define TXN_MAX 2048
+#define RMNET_TXN_MAX 2048
/* QMI requests & responses buffer*/
struct qmi_buf {
@@ -76,7 +75,7 @@
};
/* Control & data SMD channel private data */
-struct rmnet_smd_info {
+struct rmnet_smd_ch_info {
struct smd_channel *ch;
struct tasklet_struct tx_tlet;
struct tasklet_struct rx_tlet;
@@ -88,7 +87,7 @@
wait_queue_head_t wait;
};
-struct rmnet_dev {
+struct rmnet_smd_dev {
struct usb_function function;
struct usb_composite_dev *cdev;
@@ -112,8 +111,8 @@
atomic_t online;
atomic_t notify_count;
- struct rmnet_smd_info smd_ctl;
- struct rmnet_smd_info smd_data;
+ struct rmnet_smd_ch_info smd_ctl;
+ struct rmnet_smd_ch_info smd_data;
struct workqueue_struct *wq;
struct work_struct connect_work;
@@ -130,7 +129,7 @@
unsigned long cpkts_to_modem;
};
-static struct usb_interface_descriptor rmnet_interface_desc = {
+static struct usb_interface_descriptor rmnet_smd_interface_desc = {
.bLength = USB_DT_INTERFACE_SIZE,
.bDescriptorType = USB_DT_INTERFACE,
/* .bInterfaceNumber = DYNAMIC */
@@ -142,16 +141,17 @@
};
/* Full speed support */
-static struct usb_endpoint_descriptor rmnet_fs_notify_desc = {
+static struct usb_endpoint_descriptor rmnet_smd_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_MAX_NOTIFY_SIZE),
- .bInterval = 1 << RMNET_NOTIFY_INTERVAL,
+ .wMaxPacketSize = __constant_cpu_to_le16(
+ RMNET_SMD_MAX_NOTIFY_SIZE),
+ .bInterval = 1 << RMNET_SMD_NOTIFY_INTERVAL,
};
-static struct usb_endpoint_descriptor rmnet_fs_in_desc = {
+static struct usb_endpoint_descriptor rmnet_smd_fs_in_desc = {
.bLength = USB_DT_ENDPOINT_SIZE,
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = USB_DIR_IN,
@@ -159,7 +159,7 @@
.wMaxPacketSize = __constant_cpu_to_le16(64),
};
-static struct usb_endpoint_descriptor rmnet_fs_out_desc = {
+static struct usb_endpoint_descriptor rmnet_smd_fs_out_desc = {
.bLength = USB_DT_ENDPOINT_SIZE,
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = USB_DIR_OUT,
@@ -167,25 +167,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_smd_fs_function[] = {
+ (struct usb_descriptor_header *) &rmnet_smd_interface_desc,
+ (struct usb_descriptor_header *) &rmnet_smd_fs_notify_desc,
+ (struct usb_descriptor_header *) &rmnet_smd_fs_in_desc,
+ (struct usb_descriptor_header *) &rmnet_smd_fs_out_desc,
NULL,
};
/* High speed support */
-static struct usb_endpoint_descriptor rmnet_hs_notify_desc = {
+static struct usb_endpoint_descriptor rmnet_smd_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_MAX_NOTIFY_SIZE),
- .bInterval = RMNET_NOTIFY_INTERVAL + 4,
+ .wMaxPacketSize = __constant_cpu_to_le16(
+ RMNET_SMD_MAX_NOTIFY_SIZE),
+ .bInterval = RMNET_SMD_NOTIFY_INTERVAL + 4,
};
-static struct usb_endpoint_descriptor rmnet_hs_in_desc = {
+static struct usb_endpoint_descriptor rmnet_smd_hs_in_desc = {
.bLength = USB_DT_ENDPOINT_SIZE,
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = USB_DIR_IN,
@@ -193,7 +194,7 @@
.wMaxPacketSize = __constant_cpu_to_le16(512),
};
-static struct usb_endpoint_descriptor rmnet_hs_out_desc = {
+static struct usb_endpoint_descriptor rmnet_smd_hs_out_desc = {
.bLength = USB_DT_ENDPOINT_SIZE,
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = USB_DIR_OUT,
@@ -201,33 +202,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_smd_hs_function[] = {
+ (struct usb_descriptor_header *) &rmnet_smd_interface_desc,
+ (struct usb_descriptor_header *) &rmnet_smd_hs_notify_desc,
+ (struct usb_descriptor_header *) &rmnet_smd_hs_in_desc,
+ (struct usb_descriptor_header *) &rmnet_smd_hs_out_desc,
NULL,
};
/* String descriptors */
-static struct usb_string rmnet_string_defs[] = {
+static struct usb_string rmnet_smd_string_defs[] = {
[0].s = "QMI RmNet",
{ } /* end of list */
};
-static struct usb_gadget_strings rmnet_string_table = {
+static struct usb_gadget_strings rmnet_smd_string_table = {
.language = 0x0409, /* en-us */
- .strings = rmnet_string_defs,
+ .strings = rmnet_smd_string_defs,
};
-static struct usb_gadget_strings *rmnet_strings[] = {
- &rmnet_string_table,
+static struct usb_gadget_strings *rmnet_smd_strings[] = {
+ &rmnet_smd_string_table,
NULL,
};
static struct qmi_buf *
-rmnet_alloc_qmi(unsigned len, gfp_t kmalloc_flags)
+rmnet_smd_alloc_qmi(unsigned len, gfp_t kmalloc_flags)
{
struct qmi_buf *qmi;
@@ -243,7 +244,7 @@
return qmi ? qmi : ERR_PTR(-ENOMEM);
}
-static void rmnet_free_qmi(struct qmi_buf *qmi)
+static void rmnet_smd_free_qmi(struct qmi_buf *qmi)
{
kfree(qmi->buf);
kfree(qmi);
@@ -253,7 +254,7 @@
* usb_request or a 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_smd_alloc_req(struct usb_ep *ep, unsigned len, gfp_t kmalloc_flags)
{
struct usb_request *req;
@@ -274,15 +275,16 @@
/*
* Free a usb_request and its buffer.
*/
-static void rmnet_free_req(struct usb_ep *ep, struct usb_request *req)
+static void rmnet_smd_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_smd_notify_complete(struct usb_ep *ep,
+ struct usb_request *req)
{
- struct rmnet_dev *dev = req->context;
+ struct rmnet_smd_dev *dev = req->context;
struct usb_composite_dev *cdev = dev->cdev;
int status = req->status;
@@ -315,7 +317,7 @@
}
}
-static void qmi_response_available(struct rmnet_dev *dev)
+static void qmi_smd_response_available(struct rmnet_smd_dev *dev)
{
struct usb_composite_dev *cdev = dev->cdev;
struct usb_request *req = dev->notify_req;
@@ -343,11 +345,12 @@
/* TODO
* handle modem restart events
*/
-static void rmnet_smd_notify(void *priv, unsigned event)
+static void rmnet_smd_event_notify(void *priv, unsigned event)
{
- struct rmnet_smd_info *smd_info = priv;
+ struct rmnet_smd_ch_info *smd_info = priv;
int len = atomic_read(&smd_info->rx_pkt);
- struct rmnet_dev *dev = (struct rmnet_dev *) smd_info->tx_tlet.data;
+ struct rmnet_smd_dev *dev =
+ (struct rmnet_smd_dev *) smd_info->tx_tlet.data;
switch (event) {
case SMD_EVENT_DATA: {
@@ -380,7 +383,7 @@
static void rmnet_control_tx_tlet(unsigned long arg)
{
- struct rmnet_dev *dev = (struct rmnet_dev *) arg;
+ struct rmnet_smd_dev *dev = (struct rmnet_smd_dev *) arg;
struct usb_composite_dev *cdev = dev->cdev;
struct qmi_buf *qmi_resp;
int sz;
@@ -411,14 +414,14 @@
list_add_tail(&qmi_resp->list, &dev->qmi_resp_q);
spin_unlock_irqrestore(&dev->lock, flags);
- qmi_response_available(dev);
+ qmi_smd_response_available(dev);
}
}
static void rmnet_control_rx_tlet(unsigned long arg)
{
- struct rmnet_dev *dev = (struct rmnet_dev *) arg;
+ struct rmnet_smd_dev *dev = (struct rmnet_smd_dev *) arg;
struct usb_composite_dev *cdev = dev->cdev;
struct qmi_buf *qmi_req;
int ret;
@@ -454,9 +457,9 @@
spin_unlock_irqrestore(&dev->lock, flags);
}
-static void rmnet_command_complete(struct usb_ep *ep, struct usb_request *req)
+static void rmnet_smd_command_complete(struct usb_ep *ep, struct usb_request *req)
{
- struct rmnet_dev *dev = req->context;
+ struct rmnet_smd_dev *dev = req->context;
struct usb_composite_dev *cdev = dev->cdev;
struct qmi_buf *qmi_req;
int ret;
@@ -502,7 +505,7 @@
}
static void rmnet_txcommand_complete(struct usb_ep *ep, struct usb_request *req)
{
- struct rmnet_dev *dev = req->context;
+ struct rmnet_smd_dev *dev = req->context;
spin_lock(&dev->lock);
dev->cpkts_to_host++;
@@ -510,9 +513,9 @@
}
static int
-rmnet_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
+rmnet_smd_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
{
- struct rmnet_dev *dev = container_of(f, struct rmnet_dev, function);
+ struct rmnet_smd_dev *dev = container_of(f, struct rmnet_smd_dev, function);
struct usb_composite_dev *cdev = f->config->cdev;
struct usb_request *req = cdev->req;
int ret = -EOPNOTSUPP;
@@ -532,7 +535,7 @@
if (w_length > req->length)
goto invalid;
ret = w_length;
- req->complete = rmnet_command_complete;
+ req->complete = rmnet_smd_command_complete;
req->context = dev;
break;
@@ -581,7 +584,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_SMD_ACM_CTRL_DTR)
ret = smd_tiocmset(dev->smd_ctl.ch, TIOCM_DTR, 0);
else
ret = smd_tiocmset(dev->smd_ctl.ch, 0, TIOCM_DTR);
@@ -610,7 +613,7 @@
return ret;
}
-static void rmnet_start_rx(struct rmnet_dev *dev)
+static void rmnet_smd_start_rx(struct rmnet_smd_dev *dev)
{
struct usb_composite_dev *cdev = dev->cdev;
int status;
@@ -638,7 +641,7 @@
static void rmnet_data_tx_tlet(unsigned long arg)
{
- struct rmnet_dev *dev = (struct rmnet_dev *) arg;
+ struct rmnet_smd_dev *dev = (struct rmnet_smd_dev *) arg;
struct usb_composite_dev *cdev = dev->cdev;
struct usb_request *req;
int status;
@@ -681,7 +684,7 @@
static void rmnet_data_rx_tlet(unsigned long arg)
{
- struct rmnet_dev *dev = (struct rmnet_dev *) arg;
+ struct rmnet_smd_dev *dev = (struct rmnet_smd_dev *) arg;
struct usb_composite_dev *cdev = dev->cdev;
struct usb_request *req;
int ret;
@@ -715,7 +718,7 @@
spin_unlock_irqrestore(&dev->lock, flags);
/* We have free rx data requests. */
- rmnet_start_rx(dev);
+ rmnet_smd_start_rx(dev);
}
/* If SMD has enough room to accommodate a data rx packet,
@@ -723,9 +726,9 @@
* We will not write into SMD directly untill rx_queue is
* empty to strictly follow the ordering requests.
*/
-static void rmnet_complete_epout(struct usb_ep *ep, struct usb_request *req)
+static void rmnet_smd_complete_epout(struct usb_ep *ep, struct usb_request *req)
{
- struct rmnet_dev *dev = req->context;
+ struct rmnet_smd_dev *dev = req->context;
struct usb_composite_dev *cdev = dev->cdev;
int status = req->status;
int ret;
@@ -769,7 +772,7 @@
dev->dpkts_to_modem++;
list_add_tail(&req->list, &dev->rx_idle);
spin_unlock(&dev->lock);
- rmnet_start_rx(dev);
+ rmnet_smd_start_rx(dev);
return;
}
queue_req:
@@ -777,9 +780,9 @@
spin_unlock(&dev->lock);
}
-static void rmnet_complete_epin(struct usb_ep *ep, struct usb_request *req)
+static void rmnet_smd_complete_epin(struct usb_ep *ep, struct usb_request *req)
{
- struct rmnet_dev *dev = req->context;
+ struct rmnet_smd_dev *dev = req->context;
struct usb_composite_dev *cdev = dev->cdev;
int status = req->status;
int schedule = 0;
@@ -809,12 +812,12 @@
}
-static void rmnet_disconnect_work(struct work_struct *w)
+static void rmnet_smd_disconnect_work(struct work_struct *w)
{
struct qmi_buf *qmi;
struct usb_request *req;
struct list_head *act, *tmp;
- struct rmnet_dev *dev = container_of(w, struct rmnet_dev,
+ struct rmnet_smd_dev *dev = container_of(w, struct rmnet_smd_dev,
disconnect_work);
tasklet_kill(&dev->smd_ctl.rx_tlet);
@@ -853,9 +856,10 @@
/* SMD close may sleep
* schedule a work to close smd channels
*/
-static void rmnet_disable(struct usb_function *f)
+static void rmnet_smd_disable(struct usb_function *f)
{
- struct rmnet_dev *dev = container_of(f, struct rmnet_dev, function);
+ struct rmnet_smd_dev *dev = container_of(f, struct rmnet_smd_dev,
+ function);
if (!atomic_read(&dev->online))
return;
@@ -874,15 +878,16 @@
queue_work(dev->wq, &dev->disconnect_work);
}
-static void rmnet_connect_work(struct work_struct *w)
+static void rmnet_smd_connect_work(struct work_struct *w)
{
- struct rmnet_dev *dev = container_of(w, struct rmnet_dev, connect_work);
+ struct rmnet_smd_dev *dev = container_of(w, struct rmnet_smd_dev,
+ connect_work);
struct usb_composite_dev *cdev = dev->cdev;
int ret = 0;
/* Control channel for QMI messages */
ret = smd_open(rmnet_ctl_ch, &dev->smd_ctl.ch,
- &dev->smd_ctl, rmnet_smd_notify);
+ &dev->smd_ctl, rmnet_smd_event_notify);
if (ret) {
ERROR(cdev, "Unable to open control smd channel\n");
return;
@@ -892,7 +897,7 @@
/* Data channel for network packets */
ret = smd_open(rmnet_data_ch, &dev->smd_data.ch,
- &dev->smd_data, rmnet_smd_notify);
+ &dev->smd_data, rmnet_smd_event_notify);
if (ret) {
ERROR(cdev, "Unable to open data smd channel\n");
smd_close(dev->smd_ctl.ch);
@@ -903,31 +908,32 @@
atomic_set(&dev->online, 1);
/* Queue Rx data requests */
- rmnet_start_rx(dev);
+ rmnet_smd_start_rx(dev);
}
/* SMD open may sleep.
* Schedule a work to open smd channels and enable
* endpoints if smd channels are opened successfully.
*/
-static int rmnet_set_alt(struct usb_function *f,
+static int rmnet_smd_set_alt(struct usb_function *f,
unsigned intf, unsigned alt)
{
- struct rmnet_dev *dev = container_of(f, struct rmnet_dev, function);
+ struct rmnet_smd_dev *dev = container_of(f, struct rmnet_smd_dev,
+ function);
struct usb_composite_dev *cdev = dev->cdev;
int ret = 0;
ret = usb_ep_enable(dev->epin, ep_choose(cdev->gadget,
- &rmnet_hs_in_desc,
- &rmnet_fs_in_desc));
+ &rmnet_smd_hs_in_desc,
+ &rmnet_smd_fs_in_desc));
if (ret) {
ERROR(cdev, "can't enable %s, result %d\n",
dev->epin->name, ret);
return ret;
}
ret = usb_ep_enable(dev->epout, ep_choose(cdev->gadget,
- &rmnet_hs_out_desc,
- &rmnet_fs_out_desc));
+ &rmnet_smd_hs_out_desc,
+ &rmnet_smd_fs_out_desc));
if (ret) {
ERROR(cdev, "can't enable %s, result %d\n",
dev->epout->name, ret);
@@ -936,8 +942,8 @@
}
ret = usb_ep_enable(dev->epnotify, ep_choose(cdev->gadget,
- &rmnet_hs_notify_desc,
- &rmnet_fs_notify_desc));
+ &rmnet_smd_hs_notify_desc,
+ &rmnet_smd_fs_notify_desc));
if (ret) {
ERROR(cdev, "can't enable %s, result %d\n",
dev->epnotify->name, ret);
@@ -950,7 +956,7 @@
return 0;
}
-static void rmnet_free_buf(struct rmnet_dev *dev)
+static void rmnet_smd_free_buf(struct rmnet_smd_dev *dev)
{
struct qmi_buf *qmi;
struct usb_request *req;
@@ -969,36 +975,37 @@
list_for_each_safe(act, tmp, &dev->tx_idle) {
req = list_entry(act, struct usb_request, list);
list_del(&req->list);
- rmnet_free_req(dev->epout, req);
+ rmnet_smd_free_req(dev->epout, req);
}
/* free all usb requests in rx pool */
list_for_each_safe(act, tmp, &dev->rx_idle) {
req = list_entry(act, struct usb_request, list);
list_del(&req->list);
- rmnet_free_req(dev->epin, req);
+ rmnet_smd_free_req(dev->epin, req);
}
/* free all buffers in qmi request pool */
list_for_each_safe(act, tmp, &dev->qmi_req_pool) {
qmi = list_entry(act, struct qmi_buf, list);
list_del(&qmi->list);
- rmnet_free_qmi(qmi);
+ rmnet_smd_free_qmi(qmi);
}
/* free all buffers in qmi request pool */
list_for_each_safe(act, tmp, &dev->qmi_resp_pool) {
qmi = list_entry(act, struct qmi_buf, list);
list_del(&qmi->list);
- rmnet_free_qmi(qmi);
+ rmnet_smd_free_qmi(qmi);
}
- rmnet_free_req(dev->epnotify, dev->notify_req);
+ rmnet_smd_free_req(dev->epnotify, dev->notify_req);
}
-static int rmnet_bind(struct usb_configuration *c, struct usb_function *f)
+static int rmnet_smd_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_smd_dev *dev = container_of(f, struct rmnet_smd_dev,
+ function);
int i, id, ret;
struct qmi_buf *qmi;
struct usb_request *req;
@@ -1011,21 +1018,21 @@
if (id < 0)
return id;
dev->ifc_id = id;
- rmnet_interface_desc.bInterfaceNumber = id;
+ rmnet_smd_interface_desc.bInterfaceNumber = id;
- ep = usb_ep_autoconfig(cdev->gadget, &rmnet_fs_in_desc);
+ ep = usb_ep_autoconfig(cdev->gadget, &rmnet_smd_fs_in_desc);
if (!ep)
return -ENODEV;
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_smd_fs_out_desc);
if (!ep)
return -ENODEV;
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_smd_fs_notify_desc);
if (!ep)
return -ENODEV;
ep->driver_data = cdev; /* clain endpoint */
@@ -1036,28 +1043,28 @@
* 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_smd_hs_in_desc.bEndpointAddress =
+ rmnet_smd_fs_in_desc.bEndpointAddress;
+ rmnet_smd_hs_out_desc.bEndpointAddress =
+ rmnet_smd_fs_out_desc.bEndpointAddress;
+ rmnet_smd_hs_notify_desc.bEndpointAddress =
+ rmnet_smd_fs_notify_desc.bEndpointAddress;
}
/* allocate notification */
- dev->notify_req = rmnet_alloc_req(dev->epnotify, RMNET_MAX_NOTIFY_SIZE,
- GFP_KERNEL);
+ dev->notify_req = rmnet_smd_alloc_req(dev->epnotify,
+ RMNET_SMD_MAX_NOTIFY_SIZE, GFP_KERNEL);
if (IS_ERR(dev->notify_req))
return PTR_ERR(dev->notify_req);
- dev->notify_req->complete = rmnet_notify_complete;
+ dev->notify_req->complete = rmnet_smd_notify_complete;
dev->notify_req->context = dev;
- dev->notify_req->length = RMNET_MAX_NOTIFY_SIZE;
+ dev->notify_req->length = RMNET_SMD_MAX_NOTIFY_SIZE;
/* Allocate the qmi request and response buffers */
for (i = 0; i < QMI_REQ_MAX; i++) {
- qmi = rmnet_alloc_qmi(QMI_REQ_SIZE, GFP_KERNEL);
+ qmi = rmnet_smd_alloc_qmi(QMI_REQ_SIZE, GFP_KERNEL);
if (IS_ERR(qmi)) {
ret = PTR_ERR(qmi);
goto free_buf;
@@ -1066,7 +1073,7 @@
}
for (i = 0; i < QMI_RESP_MAX; i++) {
- qmi = rmnet_alloc_qmi(QMI_RESP_SIZE, GFP_KERNEL);
+ qmi = rmnet_smd_alloc_qmi(QMI_RESP_SIZE, GFP_KERNEL);
if (IS_ERR(qmi)) {
ret = PTR_ERR(qmi);
goto free_buf;
@@ -1075,44 +1082,45 @@
}
/* Allocate bulk in/out requests for data transfer */
- for (i = 0; i < RX_REQ_MAX; i++) {
- req = rmnet_alloc_req(dev->epout, RX_REQ_SIZE, GFP_KERNEL);
+ for (i = 0; i < RMNET_RX_REQ_MAX; i++) {
+ req = rmnet_smd_alloc_req(dev->epout, RMNET_RX_REQ_SIZE,
+ GFP_KERNEL);
if (IS_ERR(req)) {
ret = PTR_ERR(req);
goto free_buf;
}
- req->length = TXN_MAX;
+ req->length = RMNET_TXN_MAX;
req->context = dev;
- req->complete = rmnet_complete_epout;
+ req->complete = rmnet_smd_complete_epout;
list_add_tail(&req->list, &dev->rx_idle);
}
- for (i = 0; i < TX_REQ_MAX; i++) {
- req = rmnet_alloc_req(dev->epin, TX_REQ_SIZE, GFP_KERNEL);
+ for (i = 0; i < RMNET_TX_REQ_MAX; i++) {
+ req = rmnet_smd_alloc_req(dev->epin, RMNET_TX_REQ_SIZE, GFP_KERNEL);
if (IS_ERR(req)) {
ret = PTR_ERR(req);
goto free_buf;
}
req->context = dev;
- req->complete = rmnet_complete_epin;
+ req->complete = rmnet_smd_complete_epin;
list_add_tail(&req->list, &dev->tx_idle);
}
return 0;
free_buf:
- rmnet_free_buf(dev);
+ rmnet_smd_free_buf(dev);
dev->epout = dev->epin = dev->epnotify = NULL; /* release endpoints */
return ret;
}
#if defined(CONFIG_DEBUG_FS)
-static ssize_t debug_read_stats(struct file *file, char __user *ubuf,
+static ssize_t rmnet_smd_debug_read_stats(struct file *file, char __user *ubuf,
size_t count, loff_t *ppos)
{
- struct rmnet_dev *dev = file->private_data;
- struct rmnet_smd_info smd_ctl_info = dev->smd_ctl;
- struct rmnet_smd_info smd_data_info = dev->smd_data;
+ struct rmnet_smd_dev *dev = file->private_data;
+ struct rmnet_smd_ch_info smd_ctl_info = dev->smd_ctl;
+ struct rmnet_smd_ch_info smd_data_info = dev->smd_data;
char *buf;
unsigned long flags;
int ret;
@@ -1166,10 +1174,10 @@
return ret;
}
-static ssize_t debug_reset_stats(struct file *file, const char __user *buf,
+static ssize_t rmnet_smd_debug_reset_stats(struct file *file, const char __user *buf,
size_t count, loff_t *ppos)
{
- struct rmnet_dev *dev = file->private_data;
+ struct rmnet_smd_dev *dev = file->private_data;
unsigned long flags;
spin_lock_irqsave(&dev->lock, flags);
@@ -1189,48 +1197,49 @@
return count;
}
-static int debug_open(struct inode *inode, struct file *file)
+static int rmnet_smd_debug_open(struct inode *inode, struct file *file)
{
file->private_data = inode->i_private;
return 0;
}
-const struct file_operations rmnet_debug_stats_ops = {
- .open = debug_open,
- .read = debug_read_stats,
- .write = debug_reset_stats,
+const struct file_operations rmnet_smd_debug_stats_ops = {
+ .open = rmnet_smd_debug_open,
+ .read = rmnet_smd_debug_read_stats,
+ .write = rmnet_smd_debug_reset_stats,
};
-struct dentry *dent;
-struct dentry *dent_status;
+struct dentry *dent_smd;
+struct dentry *dent_smd_status;
-static void usb_debugfs_init(struct rmnet_dev *dev)
+static void rmnet_smd_debugfs_init(struct rmnet_smd_dev *dev)
{
- dent = debugfs_create_dir("usb_rmnet", 0);
- if (IS_ERR(dent))
+ dent_smd = debugfs_create_dir("usb_rmnet", 0);
+ if (IS_ERR(dent_smd))
return;
- dent_status = debugfs_create_file("status", 0444, dent, dev,
- &rmnet_debug_stats_ops);
+ dent_smd_status = debugfs_create_file("status", 0444, dent_smd, dev,
+ &rmnet_smd_debug_stats_ops);
- if (!dent_status) {
- debugfs_remove(dent);
- dent = NULL;
+ if (!dent_smd_status) {
+ debugfs_remove(dent_smd);
+ dent_smd = NULL;
return;
}
return;
}
#else
-static void usb_debugfs_init(struct rmnet_dev *dev) {}
+static void rmnet_smd_debugfs_init(struct rmnet_smd_dev *dev) {}
#endif
static void
-rmnet_unbind(struct usb_configuration *c, struct usb_function *f)
+rmnet_smd_unbind(struct usb_configuration *c, struct usb_function *f)
{
- struct rmnet_dev *dev = container_of(f, struct rmnet_dev, function);
+ struct rmnet_smd_dev *dev = container_of(f, struct rmnet_smd_dev,
+ function);
tasklet_kill(&dev->smd_ctl.rx_tlet);
tasklet_kill(&dev->smd_ctl.tx_tlet);
@@ -1238,18 +1247,18 @@
tasklet_kill(&dev->smd_data.tx_tlet);
flush_workqueue(dev->wq);
- rmnet_free_buf(dev);
+ rmnet_smd_free_buf(dev);
dev->epout = dev->epin = dev->epnotify = NULL; /* release endpoints */
destroy_workqueue(dev->wq);
- debugfs_remove_recursive(dent);
+ debugfs_remove_recursive(dent_smd);
kfree(dev);
}
-int rmnet_function_add(struct usb_configuration *c)
+int rmnet_smd_bind_config(struct usb_configuration *c)
{
- struct rmnet_dev *dev;
+ struct rmnet_smd_dev *dev;
int ret;
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
@@ -1268,8 +1277,8 @@
atomic_set(&dev->smd_ctl.rx_pkt, 0);
atomic_set(&dev->smd_data.rx_pkt, 0);
- INIT_WORK(&dev->connect_work, rmnet_connect_work);
- INIT_WORK(&dev->disconnect_work, rmnet_disconnect_work);
+ INIT_WORK(&dev->connect_work, rmnet_smd_connect_work);
+ INIT_WORK(&dev->disconnect_work, rmnet_smd_disconnect_work);
tasklet_init(&dev->smd_ctl.rx_tlet, rmnet_control_rx_tlet,
(unsigned long) dev);
@@ -1292,20 +1301,20 @@
INIT_LIST_HEAD(&dev->tx_idle);
dev->function.name = "rmnet";
- 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.strings = rmnet_smd_strings;
+ dev->function.descriptors = rmnet_smd_fs_function;
+ dev->function.hs_descriptors = rmnet_smd_hs_function;
+ dev->function.bind = rmnet_smd_bind;
+ dev->function.unbind = rmnet_smd_unbind;
+ dev->function.setup = rmnet_smd_setup;
+ dev->function.set_alt = rmnet_smd_set_alt;
+ dev->function.disable = rmnet_smd_disable;
ret = usb_add_function(c, &dev->function);
if (ret)
goto free_wq;
- usb_debugfs_init(dev);
+ rmnet_smd_debugfs_init(dev);
return 0;
@@ -1316,18 +1325,3 @@
return ret;
}
-
-#ifdef CONFIG_USB_ANDROID_RMNET
-static struct android_usb_function rmnet_function = {
- .name = "rmnet",
- .bind_config = rmnet_function_add,
-};
-
-static int __init init(void)
-{
- android_register_function(&rmnet_function);
- return 0;
-}
-module_init(init);
-
-#endif /* CONFIG_USB_ANDROID_RMNET */