Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2e85bf7c authored by Mayank Rana's avatar Mayank Rana Committed by Matt Wagantall
Browse files

USB: QTI: Make changes to use QTI as transport with other USB functions 



Currently USB QTI driver is used with USB RMNET function driver. This
change adds required support which allows to use QTI driver for control
transport with other USB function driver.

CRs-Fixed: 701879
Change-Id: Ia2991e615b4ef9a543d991c36e4de1de3539d3b0
Signed-off-by: default avatarMayank Rana <mrana@codeaurora.org>
parent 5309199d

drivers/usb/gadget/android.c

+1 −1
Original line number Diff line number Diff line
@@ -46,7 +46,7 @@ 
#include "u_smd.c"

#include "u_bam.c"

#include "u_rmnet_ctrl_smd.c"

#include "u_rmnet_ctrl_qti.c"

#include "u_ctrl_qti.c"

#include "u_ctrl_hsic.c"

#include "u_data_hsic.c"

#include "f_ccid.c"

drivers/usb/gadget/function/f_rmnet.c

+2 −1
Original line number Diff line number Diff line
@@ -384,7 +384,8 @@ static int gport_rmnet_connect(struct f_rmnet *dev, unsigned intf) 
		}

		break;

	case USB_GADGET_XPORT_QTI:

		ret = gqti_ctrl_connect(&dev->port, port_num, intf, dxport);

		ret = gqti_ctrl_connect(&dev->port, port_num, intf, dxport,

							USB_GADGET_RMNET);

		if (ret) {

			pr_err("%s: gqti_ctrl_connect failed: err:%d\n",

					__func__, ret);

drivers/usb/gadget/function/u_bam.c

+1 −1
Original line number Diff line number Diff line
@@ -22,7 +22,7 @@ 
#include <linux/termios.h>



#include <linux/usb/msm_hsusb.h>

#include <linux/usb/rmnet_ctrl_qti.h>

#include <linux/usb/usb_ctrl_qti.h>

#include <linux/usb_bam.h>



#include "usb_gadget_xport.h"

drivers/usb/gadget/function/u_rmnet_ctrl_qti.c→drivers/usb/gadget/function/u_ctrl_qti.c

+144 −117
Original line number Diff line number Diff line
@@ -13,7 +13,7 @@ 


#include <linux/wait.h>

#include <linux/poll.h>

#include <linux/usb/rmnet_ctrl_qti.h>

#include <linux/usb/usb_ctrl_qti.h>





#include "u_rmnet.h"
@@ -21,10 +21,10 @@ 


#define RMNET_CTRL_QTI_NAME "rmnet_ctrl"



struct rmnet_ctrl_qti_port {

	struct grmnet	*port_usb;

struct qti_ctrl_port {

	void		*port_usb;

	char		name[sizeof(RMNET_CTRL_QTI_NAME) + 2];

	struct miscdevice rmnet_device;

	struct miscdevice ctrl_device;



	bool		is_open;

	int index;
@@ -46,10 +46,11 @@ struct rmnet_ctrl_qti_port { 
	struct list_head	cpkt_req_q;



	spinlock_t	lock;

	enum gadget_type	gtype;

};

static struct rmnet_ctrl_qti_port *ctrl_port[NR_QTI_PORTS];

static struct qti_ctrl_port *ctrl_port[NR_QTI_PORTS];



static inline int rmnet_ctrl_lock(atomic_t *excl)

static inline int qti_ctrl_lock(atomic_t *excl)

{

	if (atomic_inc_return(excl) == 1) {

		return 0;
@@ -59,12 +60,12 @@ static inline int rmnet_ctrl_lock(atomic_t *excl) 
	}

}



static inline void rmnet_ctrl_unlock(atomic_t *excl)

static inline void qti_ctrl_unlock(atomic_t *excl)

{

	atomic_dec(excl);

}



static void rmnet_ctrl_queue_notify(struct rmnet_ctrl_qti_port *port)

static void qti_ctrl_queue_notify(struct qti_ctrl_port *port)

{

	unsigned long		flags;

	struct rmnet_ctrl_pkt	*cpkt = NULL;
@@ -94,11 +95,10 @@ static void rmnet_ctrl_queue_notify(struct rmnet_ctrl_qti_port *port) 
	wake_up(&port->read_wq);

}



static int grmnet_ctrl_qti_send_cpkt_tomodem(u8 portno,

	void *buf, size_t len)

static int gqti_ctrl_send_cpkt_tomodem(u8 portno, void *buf, size_t len)

{

	unsigned long		flags;

	struct rmnet_ctrl_qti_port	*port;

	struct qti_ctrl_port	*port;

	struct rmnet_ctrl_pkt *cpkt;



	if (len > MAX_QTI_PKT_SIZE) {
@@ -148,7 +148,7 @@ static int grmnet_ctrl_qti_send_cpkt_tomodem(u8 portno, 
static void

gqti_ctrl_notify_modem(void *gptr, u8 portno, int val)

{

	struct rmnet_ctrl_qti_port *port;

	struct qti_ctrl_port *port;



	if (portno >= NR_QTI_PORTS) {

		pr_err("%s: Invalid QTI port %d\n", __func__, portno);
@@ -159,14 +159,15 @@ gqti_ctrl_notify_modem(void *gptr, u8 portno, int val) 
	atomic_set(&port->line_state, val);



	/* send 0 len pkt to qti to notify state change */

	rmnet_ctrl_queue_notify(port);

	qti_ctrl_queue_notify(port);

}



#define BAM_DMUX_CHANNEL_ID 8

int gqti_ctrl_connect(struct grmnet *gr, u8 port_num, unsigned intf,

			enum transport_type dxport)

int gqti_ctrl_connect(void *gr, u8 port_num, unsigned intf,

			enum transport_type dxport, enum gadget_type gtype)

{

	struct rmnet_ctrl_qti_port	*port;

	struct qti_ctrl_port	*port;

	struct grmnet *g_rmnet = NULL;

	unsigned long flags;



	pr_debug("%s: grmnet:%p\n", __func__, gr);
@@ -174,6 +175,13 @@ int gqti_ctrl_connect(struct grmnet *gr, u8 port_num, unsigned intf, 
		pr_err("%s: Invalid QTI port %d\n", __func__, port_num);

		return -ENODEV;

	}



	if (gtype != USB_GADGET_RMNET) {

		pr_err("%s(): unrecognized gadget type(%d).\n",

						__func__, gtype);

		return -EINVAL;

	}



	port = ctrl_port[port_num];



	if (!gr || !port) {
@@ -181,7 +189,9 @@ int gqti_ctrl_connect(struct grmnet *gr, u8 port_num, unsigned intf, 
		return -ENODEV;

	}





	spin_lock_irqsave(&port->lock, flags);

	port->gtype = gtype;

	port->port_usb = gr;

	if (dxport == USB_GADGET_XPORT_BAM) {

		/*
@@ -205,24 +215,28 @@ int gqti_ctrl_connect(struct grmnet *gr, u8 port_num, unsigned intf, 
		port->ep_type = DATA_EP_TYPE_HSUSB;

		port->intf = intf;

	}

	gr->send_encap_cmd = grmnet_ctrl_qti_send_cpkt_tomodem;

	gr->notify_modem = gqti_ctrl_notify_modem;



	g_rmnet = (struct grmnet *)gr;

	g_rmnet->send_encap_cmd = gqti_ctrl_send_cpkt_tomodem;

	g_rmnet->notify_modem = gqti_ctrl_notify_modem;



	spin_unlock_irqrestore(&port->lock, flags);



	atomic_set(&port->connected, 1);

	wake_up(&port->read_wq);



	if (port->port_usb && port->port_usb->connect)

		port->port_usb->connect(port->port_usb);

	if (g_rmnet && g_rmnet->connect)

		g_rmnet->connect(port->port_usb);



	return 0;

}



void gqti_ctrl_disconnect(struct grmnet *gr, u8 port_num)

void gqti_ctrl_disconnect(void *gr, u8 port_num)

{

	struct rmnet_ctrl_qti_port	*port;

	struct qti_ctrl_port	*port;

	unsigned long		flags;

	struct rmnet_ctrl_pkt	*cpkt;

	struct grmnet *g_rmnet = NULL;



	pr_debug("%s: grmnet:%p\n", __func__, gr);
@@ -238,15 +252,24 @@ void gqti_ctrl_disconnect(struct grmnet *gr, u8 port_num) 
		return;

	}



	if (port->port_usb && port->port_usb->disconnect)

		port->port_usb->disconnect(port->port_usb);

	if (port->gtype != USB_GADGET_RMNET) {

		pr_err("%s(): unrecognized gadget type(%d).\n",

					__func__, port->gtype);

		return;

	}



	g_rmnet = (struct grmnet *)gr;

	g_rmnet->disconnect(port->port_usb);



	atomic_set(&port->connected, 0);

	atomic_set(&port->line_state, 0);

	spin_lock_irqsave(&port->lock, flags);

	port->port_usb = 0;

	gr->send_encap_cmd = 0;

	gr->notify_modem = 0;

	port->port_usb = NULL;



	if (g_rmnet) {

		g_rmnet->send_encap_cmd = NULL;

		g_rmnet->notify_modem = NULL;

	}



	while (!list_empty(&port->cpkt_req_q)) {

		cpkt = list_first_entry(&port->cpkt_req_q,
@@ -259,13 +282,13 @@ void gqti_ctrl_disconnect(struct grmnet *gr, u8 port_num) 
	spin_unlock_irqrestore(&port->lock, flags);



	/* send 0 len pkt to qti to notify state change */

	rmnet_ctrl_queue_notify(port);

	qti_ctrl_queue_notify(port);

}



void gqti_ctrl_update_ipa_pipes(struct grmnet *gr, u8 port_num, u32 ipa_prod,

void gqti_ctrl_update_ipa_pipes(void *gr, u8 port_num, u32 ipa_prod,

							u32 ipa_cons)

{

	struct rmnet_ctrl_qti_port	*port;

	struct qti_ctrl_port	*port;



	if (port_num >= NR_QTI_PORTS) {

		pr_err("%s: Invalid QTI port %d\n", __func__, port_num);
@@ -280,17 +303,17 @@ void gqti_ctrl_update_ipa_pipes(struct grmnet *gr, u8 port_num, u32 ipa_prod, 
}





static int rmnet_ctrl_open(struct inode *ip, struct file *fp)

static int qti_ctrl_open(struct inode *ip, struct file *fp)

{

	unsigned long		flags;

	struct rmnet_ctrl_qti_port *port = container_of(fp->private_data,

						struct rmnet_ctrl_qti_port,

						rmnet_device);

	struct qti_ctrl_port *port = container_of(fp->private_data,

						struct qti_ctrl_port,

						ctrl_device);



	pr_debug("Open rmnet_ctrl_qti device file name=%s(index=%d)\n",

		port->name, port->index);



	if (rmnet_ctrl_lock(&port->open_excl)) {

	if (qti_ctrl_lock(&port->open_excl)) {

		pr_err("Already opened\n");

		return -EBUSY;

	}
@@ -302,12 +325,12 @@ static int rmnet_ctrl_open(struct inode *ip, struct file *fp) 
	return 0;

}



static int rmnet_ctrl_release(struct inode *ip, struct file *fp)

static int qti_ctrl_release(struct inode *ip, struct file *fp)

{

	unsigned long		flags;

	struct rmnet_ctrl_qti_port *port = container_of(fp->private_data,

						struct rmnet_ctrl_qti_port,

						rmnet_device);

	struct qti_ctrl_port *port = container_of(fp->private_data,

						struct qti_ctrl_port,

						ctrl_device);



	pr_debug("Close rmnet control file");
@@ -315,17 +338,17 @@ static int rmnet_ctrl_release(struct inode *ip, struct file *fp) 
	port->is_open = false;

	spin_unlock_irqrestore(&port->lock, flags);



	rmnet_ctrl_unlock(&port->open_excl);

	qti_ctrl_unlock(&port->open_excl);



	return 0;

}



static ssize_t

rmnet_ctrl_read(struct file *fp, char __user *buf, size_t count, loff_t *pos)

qti_ctrl_read(struct file *fp, char __user *buf, size_t count, loff_t *pos)

{

	struct rmnet_ctrl_qti_port *port = container_of(fp->private_data,

						struct rmnet_ctrl_qti_port,

						rmnet_device);

	struct qti_ctrl_port *port = container_of(fp->private_data,

						struct qti_ctrl_port,

						ctrl_device);

	struct rmnet_ctrl_pkt *cpkt = NULL;

	unsigned long flags;

	int ret = 0;
@@ -338,7 +361,7 @@ rmnet_ctrl_read(struct file *fp, char __user *buf, size_t count, loff_t *pos) 
		return -EINVAL;

	}



	if (rmnet_ctrl_lock(&port->read_excl)) {

	if (qti_ctrl_lock(&port->read_excl)) {

		pr_err("Previous reading is not finished yet\n");

		return -EBUSY;

	}
@@ -355,7 +378,7 @@ rmnet_ctrl_read(struct file *fp, char __user *buf, size_t count, loff_t *pos) 
					!list_empty(&port->cpkt_req_q));

		if (ret < 0) {

			pr_debug("Waiting failed\n");

			rmnet_ctrl_unlock(&port->read_excl);

			qti_ctrl_unlock(&port->read_excl);

			return -ERESTARTSYS;

		}

	} while (1);
@@ -368,7 +391,7 @@ rmnet_ctrl_read(struct file *fp, char __user *buf, size_t count, loff_t *pos) 
	if (cpkt->len > count) {

		pr_err("cpkt size too big:%d > buf size:%zu\n",

				cpkt->len, count);

		rmnet_ctrl_unlock(&port->read_excl);

		qti_ctrl_unlock(&port->read_excl);

		free_rmnet_ctrl_pkt(cpkt);

		return -ENOMEM;

	}
@@ -376,7 +399,7 @@ rmnet_ctrl_read(struct file *fp, char __user *buf, size_t count, loff_t *pos) 
	pr_debug("%s: cpkt size:%d\n", __func__, cpkt->len);





	rmnet_ctrl_unlock(&port->read_excl);

	qti_ctrl_unlock(&port->read_excl);



	ret = copy_to_user(buf, cpkt->buf, cpkt->len);

	if (ret) {
@@ -393,15 +416,16 @@ rmnet_ctrl_read(struct file *fp, char __user *buf, size_t count, loff_t *pos) 
}



static ssize_t

rmnet_ctrl_write(struct file *fp, const char __user *buf, size_t count,

qti_ctrl_write(struct file *fp, const char __user *buf, size_t count,

		   loff_t *pos)

{

	struct rmnet_ctrl_qti_port *port = container_of(fp->private_data,

						struct rmnet_ctrl_qti_port,

						rmnet_device);

	struct qti_ctrl_port *port = container_of(fp->private_data,

						struct qti_ctrl_port,

						ctrl_device);

	void *kbuf;

	unsigned long flags;

	int ret = 0;

	struct grmnet *g_rmnet = NULL;



	pr_debug("%s: Enter(%zu) port_index=%d", __func__, count, port->index);
@@ -416,100 +440,102 @@ rmnet_ctrl_write(struct file *fp, const char __user *buf, size_t count, 
		return -EINVAL;

	}



	if (rmnet_ctrl_lock(&port->write_excl)) {

	if (qti_ctrl_lock(&port->write_excl)) {

		pr_err("Previous writing not finished yet\n");

		return -EBUSY;

	}



	if (!atomic_read(&port->connected)) {

		pr_debug("USB cable not connected\n");

		rmnet_ctrl_unlock(&port->write_excl);

		qti_ctrl_unlock(&port->write_excl);

		return -EPIPE;

	}



	kbuf = kmalloc(count, GFP_KERNEL);

	if (!kbuf) {

		pr_err("failed to allocate ctrl pkt\n");

		rmnet_ctrl_unlock(&port->write_excl);

		qti_ctrl_unlock(&port->write_excl);

		return -ENOMEM;

	}

	ret = copy_from_user(kbuf, buf, count);

	if (ret) {

		pr_err("copy_from_user failed err:%d\n", ret);

		kfree(kbuf);

		rmnet_ctrl_unlock(&port->write_excl);

		qti_ctrl_unlock(&port->write_excl);

		return -EFAULT;

	}



	spin_lock_irqsave(&port->lock, flags);

	if (port->port_usb && port->port_usb->send_cpkt_response) {

		ret = port->port_usb->send_cpkt_response(port->port_usb,

							kbuf, count);

		if (ret) {

			pr_err("failed to send ctrl packet. error=%d\n", ret);

	if (port && port->port_usb) {

		if (port->gtype == USB_GADGET_RMNET) {

			g_rmnet = (struct grmnet *)port->port_usb;

		} else {

			spin_unlock_irqrestore(&port->lock, flags);

			kfree(kbuf);

			rmnet_ctrl_unlock(&port->write_excl);

			return ret;

			pr_err("%s(): unrecognized gadget type(%d).\n",

						__func__, port->gtype);

			return -EINVAL;

		}



		if (g_rmnet && g_rmnet->send_cpkt_response) {

			ret = g_rmnet->send_cpkt_response(port->port_usb,

							kbuf, count);

			if (ret)

				pr_err("%d failed to send ctrl packet.\n", ret);

		} else {

			pr_err("send_cpkt_response callback is NULL\n");

		spin_unlock_irqrestore(&port->lock, flags);

		kfree(kbuf);

		rmnet_ctrl_unlock(&port->write_excl);

		return -EINVAL;

			ret = -EINVAL;

		}

	}

	spin_unlock_irqrestore(&port->lock, flags);



	spin_unlock_irqrestore(&port->lock, flags);

	kfree(kbuf);

	rmnet_ctrl_unlock(&port->write_excl);

	qti_ctrl_unlock(&port->write_excl);



	pr_debug("%s: Exit(%zu)", __func__, count);



	return count;



	return (ret) ? ret : count;

}



static long rmnet_ctrl_ioctl(struct file *fp, unsigned cmd, unsigned long arg)

static long qti_ctrl_ioctl(struct file *fp, unsigned cmd, unsigned long arg)

{

	struct rmnet_ctrl_qti_port *port = container_of(fp->private_data,

						struct rmnet_ctrl_qti_port,

						rmnet_device);

	struct qti_ctrl_port *port = container_of(fp->private_data,

						struct qti_ctrl_port,

						ctrl_device);

	struct grmnet *gr = NULL;

	struct ep_info info;

	int val, ret = 0;



	pr_debug("%s: Received command %d", __func__, cmd);

	pr_debug("%s: Received command %d for gtype:%d\n",

				__func__, cmd, port->gtype);



	if (rmnet_ctrl_lock(&port->ioctl_excl))

	if (qti_ctrl_lock(&port->ioctl_excl))

		return -EBUSY;



	switch (cmd) {

	case FRMNET_CTRL_MODEM_OFFLINE:

	case QTI_CTRL_MODEM_OFFLINE:

		if (port && port->port_usb)

			gr = port->port_usb;



		if (gr && gr->disconnect)

			gr->disconnect(gr);

		break;

	case FRMNET_CTRL_MODEM_ONLINE:

	case QTI_CTRL_MODEM_ONLINE:

		if (port && port->port_usb)

			gr = port->port_usb;



		if (gr && gr->connect)

			gr->connect(gr);

		break;

	case FRMNET_CTRL_GET_LINE_STATE:

	case QTI_CTRL_GET_LINE_STATE:

		val = atomic_read(&port->line_state);

		ret = copy_to_user((void __user *)arg, &val, sizeof(val));

		if (ret) {

			pr_err("copying to user space failed");

			ret = -EFAULT;

		}

		pr_debug("%s: Sent line_state: %d", __func__,

				 atomic_read(&port->line_state));

		pr_debug("%s: Sent line_state: %d for gtype:%d\n", __func__,

				atomic_read(&port->line_state), port->gtype);

		break;

	case FRMNET_CTRL_EP_LOOKUP:

	case QTI_CTRL_EP_LOOKUP:

		val = atomic_read(&port->connected);

		if (!val) {

			pr_err("EP_LOOKUP failed - not connected");
@@ -517,18 +543,19 @@ static long rmnet_ctrl_ioctl(struct file *fp, unsigned cmd, unsigned long arg) 
			break;

		}



		if (port->ipa_prod_idx == -1 ||  port->ipa_cons_idx == -1) {

			pr_err("EP_LOOKUP failed - ipa pipes were not updated");

			ret = -EAGAIN;

			break;



		}



		info.ph_ep_info.ep_type = port->ep_type;

		info.ph_ep_info.peripheral_iface_id = port->intf;

		info.ipa_ep_pair.cons_pipe_num = port->ipa_cons_idx;

		info.ipa_ep_pair.prod_pipe_num = port->ipa_prod_idx;



		pr_debug("%s(): gtype:%d ep_type:%d intf:%d\n",

				__func__, port->gtype, info.ph_ep_info.ep_type,

				info.ph_ep_info.peripheral_iface_id);



		pr_debug("%s(): ipa_cons_idx:%d ipa_prod_idx:%d\n",

				__func__, info.ipa_ep_pair.cons_pipe_num,

				info.ipa_ep_pair.prod_pipe_num);



		ret = copy_to_user((void __user *)arg, &info,

			sizeof(info));

		if (ret) {
@@ -541,16 +568,16 @@ static long rmnet_ctrl_ioctl(struct file *fp, unsigned cmd, unsigned long arg) 
		ret = -EINVAL;

	}



	rmnet_ctrl_unlock(&port->ioctl_excl);

	qti_ctrl_unlock(&port->ioctl_excl);



	return ret;

}



static unsigned int rmnet_ctrl_poll(struct file *file, poll_table *wait)

static unsigned int qti_ctrl_poll(struct file *file, poll_table *wait)

{

	struct rmnet_ctrl_qti_port *port = container_of(file->private_data,

						struct rmnet_ctrl_qti_port,

						rmnet_device);

	struct qti_ctrl_port *port = container_of(file->private_data,

						struct qti_ctrl_port,

						ctrl_device);

	unsigned long flags;

	unsigned int mask = 0;
@@ -572,26 +599,26 @@ static unsigned int rmnet_ctrl_poll(struct file *file, poll_table *wait) 
}



/* file operations for rmnet device /dev/rmnet_ctrl */

static const struct file_operations rmnet_ctrl_fops = {

static const struct file_operations qti_ctrl_fops = {

	.owner = THIS_MODULE,

	.open = rmnet_ctrl_open,

	.release = rmnet_ctrl_release,

	.read = rmnet_ctrl_read,

	.write = rmnet_ctrl_write,

	.unlocked_ioctl = rmnet_ctrl_ioctl,

	.open = qti_ctrl_open,

	.release = qti_ctrl_release,

	.read = qti_ctrl_read,

	.write = qti_ctrl_write,

	.unlocked_ioctl = qti_ctrl_ioctl,

#ifdef CONFIG_COMPAT

	.compat_ioctl = rmnet_ctrl_ioctl,

	.compat_ioctl = qti_ctrl_ioctl,

#endif

	.poll = rmnet_ctrl_poll,

	.poll = qti_ctrl_poll,

};



static int __init gqti_ctrl_init(void)

{

	int ret, i, sz = sizeof(RMNET_CTRL_QTI_NAME)+2;

	struct rmnet_ctrl_qti_port *port = NULL;

	struct qti_ctrl_port *port = NULL;



	for (i = 0; i < NR_QTI_PORTS; i++) {

		port = kzalloc(sizeof(struct rmnet_ctrl_qti_port), GFP_KERNEL);

		port = kzalloc(sizeof(struct qti_ctrl_port), GFP_KERNEL);

		if (!port) {

			pr_err("Failed to allocate rmnet control device\n");

			ret = -ENOMEM;
@@ -621,11 +648,11 @@ static int __init gqti_ctrl_init(void) 
			snprintf(port->name, sz, "%s%d",

					RMNET_CTRL_QTI_NAME, i);



		port->rmnet_device.name = port->name;

		port->rmnet_device.fops = &rmnet_ctrl_fops;

		port->rmnet_device.minor = MISC_DYNAMIC_MINOR;

		port->ctrl_device.name = port->name;

		port->ctrl_device.fops = &qti_ctrl_fops;

		port->ctrl_device.minor = MISC_DYNAMIC_MINOR;



		ret = misc_register(&port->rmnet_device);

		ret = misc_register(&port->ctrl_device);

		if (ret) {

			pr_err("rmnet control driver failed to register");

			goto fail_init;
@@ -636,7 +663,7 @@ static int __init gqti_ctrl_init(void) 


fail_init:

	for (i--; i >= 0; i--) {

		misc_deregister(&ctrl_port[i]->rmnet_device);

		misc_deregister(&ctrl_port[i]->ctrl_device);

		kfree(ctrl_port[i]);

		ctrl_port[i] = NULL;

	}
@@ -649,7 +676,7 @@ static void __exit gqti_ctrl_cleanup(void) 
	int i;



	for (i = 0; i < NR_QTI_PORTS; i++) {

		misc_deregister(&ctrl_port[i]->rmnet_device);

		misc_deregister(&ctrl_port[i]->ctrl_device);

		kfree(ctrl_port[i]);

		ctrl_port[i] = NULL;

	}

drivers/usb/gadget/function/u_rmnet.h

+0 −6
Original line number Diff line number Diff line
@@ -69,10 +69,4 @@ int gsmd_ctrl_connect(struct grmnet *gr, int port_num); 
void gsmd_ctrl_disconnect(struct grmnet *gr, u8 port_num);

int gsmd_ctrl_setup(enum ctrl_client client_num, unsigned int count,

					u8 *first_port_idx);

int gqti_ctrl_connect(struct grmnet *gr, u8 port_num, unsigned intf,

			enum transport_type data_transport);

void gqti_ctrl_disconnect(struct grmnet *gr, u8 port_num);

void gqti_ctrl_update_ipa_pipes(struct grmnet *gr, u8 port_num,

					u32 ipa_prod, u32 ipa_cons);



#endif /* __U_RMNET_H*/