Merge "USB: QTI: Make changes to use QTI as transport with other USB functions" (ac5565ef) · Commits · e / devices / android_kernel_sony_msm8994

drivers/usb/gadget/android.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -50,7 +50,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 "u_ctrl_hsuart.c"

drivers/usb/gadget/f_rmnet.c

+2 −1

Original line number	Diff line number	Diff line
		@@ -413,7 +413,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/u_bam.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -25,7 +25,7 @@
		#include <soc/qcom/bam_dmux.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/u_rmnet_ctrl_qti.c→drivers/usb/gadget/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/u_rmnet.h

+0 −6

Original line number	Diff line number	Diff line
		@@ -70,10 +70,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*/