blob: 4ecfeacaf601084ae2e71298b028cfbd40eddc93 [file] [log] [blame]
/*
* f_qdss.c -- QDSS function Driver
*
* Copyright (c) 2012-2014, The Linux Foundation. All rights reserved.
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details
*/
#include <linux/kernel.h>
#include <linux/device.h>
#include <linux/usb/usb_qdss.h>
#include <linux/usb/msm_hsusb.h>
#include "gadget_chips.h"
#include "f_qdss.h"
#include "u_qdss.c"
static DEFINE_SPINLOCK(d_lock);
static LIST_HEAD(usb_qdss_ch_list);
static struct usb_interface_descriptor qdss_data_intf_desc = {
.bLength = sizeof qdss_data_intf_desc,
.bDescriptorType = USB_DT_INTERFACE,
.bAlternateSetting = 0,
.bNumEndpoints = 1,
.bInterfaceClass = 0xff,
.bInterfaceSubClass = 0xff,
.bInterfaceProtocol = 0xff,
};
static struct usb_endpoint_descriptor qdss_hs_data_desc = {
.bLength = USB_DT_ENDPOINT_SIZE,
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = USB_DIR_IN,
.bmAttributes = USB_ENDPOINT_XFER_BULK,
.wMaxPacketSize = __constant_cpu_to_le16(512),
};
static struct usb_endpoint_descriptor qdss_ss_data_desc = {
.bLength = USB_DT_ENDPOINT_SIZE,
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = USB_DIR_IN,
.bmAttributes = USB_ENDPOINT_XFER_BULK,
.wMaxPacketSize = __constant_cpu_to_le16(1024),
};
static struct usb_ss_ep_comp_descriptor qdss_data_ep_comp_desc = {
.bLength = sizeof qdss_data_ep_comp_desc,
.bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
.bMaxBurst = 1,
.bmAttributes = 0,
.wBytesPerInterval = 0,
};
static struct usb_interface_descriptor qdss_ctrl_intf_desc = {
.bLength = sizeof qdss_ctrl_intf_desc,
.bDescriptorType = USB_DT_INTERFACE,
.bAlternateSetting = 0,
.bNumEndpoints = 2,
.bInterfaceClass = 0xff,
.bInterfaceSubClass = 0xff,
.bInterfaceProtocol = 0xff,
};
static struct usb_endpoint_descriptor qdss_hs_ctrl_in_desc = {
.bLength = USB_DT_ENDPOINT_SIZE,
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = USB_DIR_IN,
.bmAttributes = USB_ENDPOINT_XFER_BULK,
.wMaxPacketSize = __constant_cpu_to_le16(512),
};
static struct usb_endpoint_descriptor qdss_ss_ctrl_in_desc = {
.bLength = USB_DT_ENDPOINT_SIZE,
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = USB_DIR_IN,
.bmAttributes = USB_ENDPOINT_XFER_BULK,
.wMaxPacketSize = __constant_cpu_to_le16(1024),
};
static struct usb_endpoint_descriptor qdss_hs_ctrl_out_desc = {
.bLength = USB_DT_ENDPOINT_SIZE,
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = USB_DIR_OUT,
.bmAttributes = USB_ENDPOINT_XFER_BULK,
.wMaxPacketSize = __constant_cpu_to_le16(512),
};
static struct usb_endpoint_descriptor qdss_ss_ctrl_out_desc = {
.bLength = USB_DT_ENDPOINT_SIZE,
.bDescriptorType = USB_DT_ENDPOINT,
.bEndpointAddress = USB_DIR_OUT,
.bmAttributes = USB_ENDPOINT_XFER_BULK,
.wMaxPacketSize = __constant_cpu_to_le16(0x400),
};
static struct usb_ss_ep_comp_descriptor qdss_ctrl_in_ep_comp_desc = {
.bLength = sizeof qdss_ctrl_in_ep_comp_desc,
.bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
.bMaxBurst = 0,
.bmAttributes = 0,
.wBytesPerInterval = 0,
};
static struct usb_ss_ep_comp_descriptor qdss_ctrl_out_ep_comp_desc = {
.bLength = sizeof qdss_ctrl_out_ep_comp_desc,
.bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
.bMaxBurst = 0,
.bmAttributes = 0,
.wBytesPerInterval = 0,
};
static struct usb_descriptor_header *qdss_hs_desc[] = {
(struct usb_descriptor_header *) &qdss_data_intf_desc,
(struct usb_descriptor_header *) &qdss_hs_data_desc,
(struct usb_descriptor_header *) &qdss_ctrl_intf_desc,
(struct usb_descriptor_header *) &qdss_hs_ctrl_in_desc,
(struct usb_descriptor_header *) &qdss_hs_ctrl_out_desc,
NULL,
};
static struct usb_descriptor_header *qdss_ss_desc[] = {
(struct usb_descriptor_header *) &qdss_data_intf_desc,
(struct usb_descriptor_header *) &qdss_ss_data_desc,
(struct usb_descriptor_header *) &qdss_data_ep_comp_desc,
(struct usb_descriptor_header *) &qdss_ctrl_intf_desc,
(struct usb_descriptor_header *) &qdss_ss_ctrl_in_desc,
(struct usb_descriptor_header *) &qdss_ctrl_in_ep_comp_desc,
(struct usb_descriptor_header *) &qdss_ss_ctrl_out_desc,
(struct usb_descriptor_header *) &qdss_ctrl_out_ep_comp_desc,
NULL,
};
/* string descriptors: */
#define QDSS_DATA_IDX 0
#define QDSS_CTRL_IDX 1
static struct usb_string qdss_string_defs[] = {
[QDSS_DATA_IDX].s = "QDSS DATA",
[QDSS_CTRL_IDX].s = "QDSS CTRL",
{}, /* end of list */
};
static struct usb_gadget_strings qdss_string_table = {
.language = 0x0409,
.strings = qdss_string_defs,
};
static struct usb_gadget_strings *qdss_strings[] = {
&qdss_string_table,
NULL,
};
static inline struct f_qdss *func_to_qdss(struct usb_function *f)
{
return container_of(f, struct f_qdss, function);
}
/*----------------------------------------------------------------------*/
static void qdss_ctrl_write_complete(struct usb_ep *ep,
struct usb_request *req)
{
struct f_qdss *qdss = ep->driver_data;
struct qdss_request *d_req = req->context;
unsigned long flags;
pr_debug("qdss_ctrl_write_complete\n");
if (!req->status) {
/* send zlp */
if ((req->length >= ep->maxpacket) &&
((req->length % ep->maxpacket) == 0)) {
req->length = 0;
d_req->actual = req->actual;
d_req->status = req->status;
usb_ep_queue(qdss->ctrl_in, req, GFP_ATOMIC);
return;
}
}
spin_lock_irqsave(&qdss->lock, flags);
list_add_tail(&req->list, &qdss->ctrl_write_pool);
if (req->length != 0) {
d_req->actual = req->actual;
d_req->status = req->status;
}
spin_unlock_irqrestore(&qdss->lock, flags);
if (qdss->ch.notify)
qdss->ch.notify(qdss->ch.priv, USB_QDSS_CTRL_WRITE_DONE, d_req,
NULL);
}
static void qdss_ctrl_read_complete(struct usb_ep *ep,
struct usb_request *req)
{
struct f_qdss *qdss = ep->driver_data;
struct qdss_request *d_req = req->context;
unsigned long flags;
pr_debug("qdss_ctrl_read_complete\n");
d_req->actual = req->actual;
d_req->status = req->status;
spin_lock_irqsave(&qdss->lock, flags);
list_add_tail(&req->list, &qdss->ctrl_read_pool);
spin_unlock_irqrestore(&qdss->lock, flags);
if (qdss->ch.notify)
qdss->ch.notify(qdss->ch.priv, USB_QDSS_CTRL_READ_DONE, d_req,
NULL);
}
void usb_qdss_free_req(struct usb_qdss_ch *ch)
{
struct f_qdss *qdss;
struct usb_request *req;
struct list_head *act, *tmp;
pr_debug("usb_qdss_free_req\n");
qdss = ch->priv_usb;
if (!qdss) {
pr_err("usb_qdss_free_req: qdss ctx is NULL\n");
return;
}
list_for_each_safe(act, tmp, &qdss->ctrl_write_pool) {
req = list_entry(act, struct usb_request, list);
list_del(&req->list);
usb_ep_free_request(qdss->ctrl_in, req);
}
list_for_each_safe(act, tmp, &qdss->ctrl_read_pool) {
req = list_entry(act, struct usb_request, list);
list_del(&req->list);
usb_ep_free_request(qdss->ctrl_out, req);
}
}
EXPORT_SYMBOL(usb_qdss_free_req);
int usb_qdss_alloc_req(struct usb_qdss_ch *ch, int no_write_buf,
int no_read_buf)
{
struct f_qdss *qdss = ch->priv_usb;
struct usb_request *req;
int i;
pr_debug("usb_qdss_alloc_req\n");
if (no_write_buf <= 0 || no_read_buf <= 0 || !qdss) {
pr_err("usb_qdss_alloc_req: missing params\n");
return -ENODEV;
}
for (i = 0; i < no_write_buf; i++) {
req = usb_ep_alloc_request(qdss->ctrl_in, GFP_ATOMIC);
if (!req) {
pr_err("usb_qdss_alloc_req: ctrl_in allocation err\n");
goto fail;
}
req->complete = qdss_ctrl_write_complete;
list_add_tail(&req->list, &qdss->ctrl_write_pool);
}
for (i = 0; i < no_read_buf; i++) {
req = usb_ep_alloc_request(qdss->ctrl_out, GFP_ATOMIC);
if (!req) {
pr_err("usb_qdss_alloc_req:ctrl_out allocation err\n");
goto fail;
}
req->complete = qdss_ctrl_read_complete;
list_add_tail(&req->list, &qdss->ctrl_read_pool);
}
return 0;
fail:
usb_qdss_free_req(ch);
return -ENOMEM;
}
EXPORT_SYMBOL(usb_qdss_alloc_req);
static void clear_eps(struct usb_function *f)
{
struct f_qdss *qdss = func_to_qdss(f);
pr_debug("clear_eps\n");
if (qdss->ctrl_in)
qdss->ctrl_in->driver_data = NULL;
if (qdss->ctrl_out)
qdss->ctrl_out->driver_data = NULL;
if (qdss->data)
qdss->data->driver_data = NULL;
}
static void clear_desc(struct usb_gadget *gadget, struct usb_function *f)
{
pr_debug("clear_desc\n");
if (gadget_is_superspeed(gadget) && f->ss_descriptors)
usb_free_descriptors(f->ss_descriptors);
if (gadget_is_dualspeed(gadget) && f->hs_descriptors)
usb_free_descriptors(f->hs_descriptors);
}
static int qdss_bind(struct usb_configuration *c, struct usb_function *f)
{
struct usb_gadget *gadget = c->cdev->gadget;
struct f_qdss *qdss = func_to_qdss(f);
struct usb_ep *ep;
int iface;
pr_debug("qdss_bind\n");
if (!gadget_is_dualspeed(gadget) && !gadget_is_superspeed(gadget)) {
pr_err("qdss_bind: full-speed is not supported\n");
return -ENOTSUPP;
}
/* Allocate data I/F */
iface = usb_interface_id(c, f);
if (iface < 0) {
pr_err("interface allocation error\n");
return iface;
}
qdss_data_intf_desc.bInterfaceNumber = iface;
qdss->data_iface_id = iface;
/* Allocate ctrl I/F */
iface = usb_interface_id(c, f);
if (iface < 0) {
pr_err("interface allocation error\n");
return iface;
}
qdss_ctrl_intf_desc.bInterfaceNumber = iface;
qdss->ctrl_iface_id = iface;
ep = usb_ep_autoconfig_ss(gadget, &qdss_ss_data_desc,
&qdss_data_ep_comp_desc);
if (!ep) {
pr_err("ep_autoconfig error\n");
goto fail;
}
qdss->data = ep;
ep->driver_data = qdss;
ep = usb_ep_autoconfig_ss(gadget, &qdss_ss_ctrl_in_desc,
&qdss_ctrl_in_ep_comp_desc);
if (!ep) {
pr_err("ep_autoconfig error\n");
goto fail;
}
qdss->ctrl_in = ep;
ep->driver_data = qdss;
ep = usb_ep_autoconfig_ss(gadget, &qdss_ss_ctrl_out_desc,
&qdss_ctrl_out_ep_comp_desc);
if (!ep) {
pr_err("ep_autoconfig error\n");
goto fail;
}
qdss->ctrl_out = ep;
ep->driver_data = qdss;
/*update descriptors*/
qdss_hs_data_desc.bEndpointAddress =
qdss_ss_data_desc.bEndpointAddress;
qdss_hs_ctrl_in_desc.bEndpointAddress =
qdss_ss_ctrl_in_desc.bEndpointAddress;
qdss_hs_ctrl_out_desc.bEndpointAddress =
qdss_ss_ctrl_out_desc.bEndpointAddress;
f->hs_descriptors = usb_copy_descriptors(qdss_hs_desc);
if (!f->hs_descriptors) {
pr_err("usb_copy_descriptors error\n");
goto fail;
}
/* update ss descriptors */
if (gadget_is_superspeed(gadget)) {
f->ss_descriptors = usb_copy_descriptors(qdss_ss_desc);
if (!f->ss_descriptors) {
pr_err("usb_copy_descriptors error\n");
goto fail;
}
}
if (gadget_is_dwc3(gadget))
dwc3_tx_fifo_resize_request(qdss->data, true);
return 0;
fail:
clear_eps(f);
clear_desc(gadget, f);
return -ENOTSUPP;
}
static void qdss_unbind(struct usb_configuration *c, struct usb_function *f)
{
struct f_qdss *qdss = func_to_qdss(f);
struct usb_gadget *gadget = c->cdev->gadget;
pr_debug("qdss_unbind\n");
flush_workqueue(qdss->wq);
if (gadget_is_dwc3(gadget))
dwc3_tx_fifo_resize_request(qdss->data, false);
clear_eps(f);
clear_desc(gadget, f);
}
static void qdss_eps_disable(struct usb_function *f)
{
struct f_qdss *qdss = func_to_qdss(f);
pr_debug("qdss_eps_disable\n");
if (qdss->ctrl_in_enabled) {
usb_ep_disable(qdss->ctrl_in);
qdss->ctrl_in_enabled = 0;
}
if (qdss->ctrl_out_enabled) {
usb_ep_disable(qdss->ctrl_out);
qdss->ctrl_out_enabled = 0;
}
if (qdss->data_enabled) {
usb_ep_disable(qdss->data);
qdss->data_enabled = 0;
}
}
static void usb_qdss_disconnect_work(struct work_struct *work)
{
struct f_qdss *qdss = container_of(work, struct f_qdss, disconnect_w);
int status;
pr_debug("usb_qdss_disconnect_work\n");
status = uninit_data(qdss->data);
if (status)
pr_err("%s: uninit_data error\n", __func__);
/* notify qdss to cancell all active transfers*/
if (qdss->ch.notify) {
qdss->ch.notify(qdss->ch.priv, USB_QDSS_DISCONNECT, NULL,
NULL);
/* If the app was never started, we can skip USB BAM reset */
status = set_qdss_data_connection(qdss->cdev->gadget,
qdss->data, qdss->data->address, 0);
if (status)
pr_err("qdss_disconnect error");
}
}
static void qdss_disable(struct usb_function *f)
{
struct f_qdss *qdss = func_to_qdss(f);
unsigned long flags;
pr_debug("qdss_disable\n");
spin_lock_irqsave(&qdss->lock, flags);
if (!qdss->usb_connected) {
spin_unlock_irqrestore(&qdss->lock, flags);
return;
}
qdss->usb_connected = 0;
spin_unlock_irqrestore(&qdss->lock, flags);
/*cancell all active xfers*/
qdss_eps_disable(f);
queue_work(qdss->wq, &qdss->disconnect_w);
}
static void usb_qdss_connect_work(struct work_struct *work)
{
struct f_qdss *qdss = container_of(work, struct f_qdss, connect_w);
int status;
pr_debug("usb_qdss_connect_work\n");
status = init_data(qdss->data);
if (status) {
pr_err("init_data error");
return;
}
status = set_qdss_data_connection(qdss->cdev->gadget, qdss->data,
qdss->data->address, 1);
if (status) {
pr_err("set_qdss_data_connection error");
return;
}
if (qdss->ch.notify)
qdss->ch.notify(qdss->ch.priv, USB_QDSS_CONNECT, NULL,
&qdss->ch);
status = send_sps_req(qdss->data);
if (status) {
pr_err("send_sps_req error\n");
return;
}
}
static int qdss_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
{
struct f_qdss *qdss = func_to_qdss(f);
struct usb_gadget *gadget = f->config->cdev->gadget;
struct usb_qdss_ch *ch = &qdss->ch;
int ret = 0;
pr_debug("qdss_set_alt\n");
if (alt != 0)
goto fail;
if (gadget->speed != USB_SPEED_SUPER &&
gadget->speed != USB_SPEED_HIGH) {
pr_err("qdss_st_alt: qdss supportes HS or SS only\n");
ret = -EINVAL;
goto fail;
}
if (intf == qdss->data_iface_id) {
if (config_ep_by_speed(gadget, f, qdss->data))
return -EINVAL;
ret = usb_ep_enable(qdss->data);
if (ret)
goto fail;
qdss->data->driver_data = qdss;
qdss->data_enabled = 1;
} else if (intf == qdss->ctrl_iface_id) {
if (config_ep_by_speed(gadget, f, qdss->ctrl_in))
return -EINVAL;
ret = usb_ep_enable(qdss->ctrl_in);
if (ret)
goto fail;
qdss->ctrl_in->driver_data = qdss;
qdss->ctrl_in_enabled = 1;
if (config_ep_by_speed(gadget, f, qdss->ctrl_out))
return -EINVAL;
ret = usb_ep_enable(qdss->ctrl_out);
if (ret)
goto fail;
qdss->ctrl_out->driver_data = qdss;
qdss->ctrl_out_enabled = 1;
}
if (qdss->ctrl_out_enabled && qdss->ctrl_in_enabled &&
qdss->data_enabled)
qdss->usb_connected = 1;
if (qdss->usb_connected && ch->app_conn)
queue_work(qdss->wq, &qdss->connect_w);
return 0;
fail:
pr_err("qdss_set_alt failed\n");
qdss_eps_disable(f);
return ret;
}
static int qdss_bind_config(struct usb_configuration *c, const char *name)
{
struct f_qdss *qdss;
int status, found = 0;
struct usb_qdss_ch *ch;
unsigned long flags;
pr_debug("qdss_bind_config\n");
if (qdss_string_defs[QDSS_DATA_IDX].id == 0) {
status = usb_string_id(c->cdev);
if (status < 0)
return status;
qdss_string_defs[QDSS_DATA_IDX].id = status;
qdss_data_intf_desc.iInterface = status;
status = usb_string_id(c->cdev);
if (status < 0)
return status;
qdss_string_defs[QDSS_CTRL_IDX].id = status;
qdss_ctrl_intf_desc.iInterface = status;
}
spin_lock_irqsave(&d_lock, flags);
list_for_each_entry(ch, &usb_qdss_ch_list, list) {
if (!strcmp(name, ch->name)) {
found = 1;
break;
}
}
if (!found) {
pr_debug("qdss_bind_config allocating channel\n");
qdss = kzalloc(sizeof *qdss, GFP_ATOMIC);
if (!qdss) {
pr_err("qdss_bind_config: allocating channel failed\n");
spin_unlock_irqrestore(&d_lock, flags);
return -ENOMEM;
}
spin_unlock_irqrestore(&d_lock, flags);
qdss->wq = create_singlethread_workqueue(name);
if (!qdss->wq) {
kfree(qdss);
return -ENOMEM;
}
spin_lock_irqsave(&d_lock, flags);
ch = &qdss->ch;
ch->name = name;
list_add_tail(&ch->list, &usb_qdss_ch_list);
} else {
qdss = container_of(ch, struct f_qdss, ch);
ch->priv_usb = qdss;
}
spin_unlock_irqrestore(&d_lock, flags);
qdss->cdev = c->cdev;
qdss->function.name = name;
qdss->function.descriptors = qdss_hs_desc;
qdss->function.hs_descriptors = qdss_hs_desc;
qdss->function.strings = qdss_strings;
qdss->function.bind = qdss_bind;
qdss->function.unbind = qdss_unbind;
qdss->function.set_alt = qdss_set_alt;
qdss->function.disable = qdss_disable;
spin_lock_init(&qdss->lock);
INIT_LIST_HEAD(&qdss->ctrl_read_pool);
INIT_LIST_HEAD(&qdss->ctrl_write_pool);
INIT_WORK(&qdss->connect_w, usb_qdss_connect_work);
INIT_WORK(&qdss->disconnect_w, usb_qdss_disconnect_work);
status = usb_add_function(c, &qdss->function);
if (status) {
pr_err("qdss usb_add_function failed\n");
ch->priv_usb = NULL;
kfree(qdss);
}
return status;
}
int usb_qdss_ctrl_read(struct usb_qdss_ch *ch, struct qdss_request *d_req)
{
struct f_qdss *qdss = ch->priv_usb;
unsigned long flags;
struct usb_request *req = NULL;
pr_debug("usb_qdss_ctrl_read\n");
if (!qdss)
return -ENODEV;
spin_lock_irqsave(&qdss->lock, flags);
if (qdss->usb_connected == 0) {
spin_unlock_irqrestore(&qdss->lock, flags);
return -EIO;
}
if (list_empty(&qdss->ctrl_read_pool)) {
spin_unlock_irqrestore(&qdss->lock, flags);
pr_err("error: usb_qdss_ctrl_read list is empty\n");
return -EAGAIN;
}
req = list_first_entry(&qdss->ctrl_read_pool, struct usb_request, list);
list_del(&req->list);
spin_unlock_irqrestore(&qdss->lock, flags);
req->buf = d_req->buf;
req->length = d_req->length;
req->context = d_req;
if (usb_ep_queue(qdss->ctrl_out, req, GFP_ATOMIC)) {
/* If error add the link to linked list again*/
spin_lock_irqsave(&qdss->lock, flags);
list_add_tail(&req->list, &qdss->ctrl_read_pool);
spin_unlock_irqrestore(&qdss->lock, flags);
pr_err("qdss usb_ep_queue failed\n");
return -EIO;
}
return 0;
}
EXPORT_SYMBOL(usb_qdss_ctrl_read);
int usb_qdss_ctrl_write(struct usb_qdss_ch *ch, struct qdss_request *d_req)
{
struct f_qdss *qdss = ch->priv_usb;
unsigned long flags;
struct usb_request *req = NULL;
pr_debug("usb_qdss_ctrl_write\n");
if (!qdss)
return -ENODEV;
spin_lock_irqsave(&qdss->lock, flags);
if (qdss->usb_connected == 0) {
spin_unlock_irqrestore(&qdss->lock, flags);
return -EIO;
}
if (list_empty(&qdss->ctrl_write_pool)) {
pr_err("error: usb_qdss_ctrl_write list is empty\n");
spin_unlock_irqrestore(&qdss->lock, flags);
return -EAGAIN;
}
req = list_first_entry(&qdss->ctrl_write_pool, struct usb_request,
list);
list_del(&req->list);
spin_unlock_irqrestore(&qdss->lock, flags);
req->buf = d_req->buf;
req->length = d_req->length;
req->context = d_req;
if (usb_ep_queue(qdss->ctrl_in, req, GFP_ATOMIC)) {
spin_lock_irqsave(&qdss->lock, flags);
list_add_tail(&req->list, &qdss->ctrl_write_pool);
spin_unlock_irqrestore(&qdss->lock, flags);
pr_err("qdss usb_ep_queue failed\n");
return -EIO;
}
return 0;
}
EXPORT_SYMBOL(usb_qdss_ctrl_write);
struct usb_qdss_ch *usb_qdss_open(const char *name, void *priv,
void (*notify)(void *, unsigned, struct qdss_request *,
struct usb_qdss_ch *))
{
struct usb_qdss_ch *ch;
struct f_qdss *qdss;
unsigned long flags;
int found = 0;
pr_debug("usb_qdss_open\n");
if (!notify) {
pr_err("usb_qdss_open: notification func is missing\n");
return NULL;
}
spin_lock_irqsave(&d_lock, flags);
/* Check if we already have a channel with this name */
list_for_each_entry(ch, &usb_qdss_ch_list, list) {
if (!strcmp(name, ch->name)) {
found = 1;
break;
}
}
if (!found) {
pr_debug("usb_qdss_open: allocation qdss ctx\n");
qdss = kzalloc(sizeof(*qdss), GFP_ATOMIC);
if (!qdss) {
spin_unlock_irqrestore(&d_lock, flags);
return ERR_PTR(-ENOMEM);
}
spin_unlock_irqrestore(&d_lock, flags);
qdss->wq = create_singlethread_workqueue(name);
if (!qdss->wq) {
kfree(qdss);
return ERR_PTR(-ENOMEM);
}
spin_lock_irqsave(&d_lock, flags);
ch = &qdss->ch;
list_add_tail(&ch->list, &usb_qdss_ch_list);
} else {
pr_debug("usb_qdss_open: qdss ctx found\n");
qdss = container_of(ch, struct f_qdss, ch);
ch->priv_usb = qdss;
}
ch->name = name;
ch->priv = priv;
ch->notify = notify;
ch->app_conn = 1;
spin_unlock_irqrestore(&d_lock, flags);
/* the case USB cabel was connected befor qdss called qdss_open*/
if (qdss->usb_connected == 1)
queue_work(qdss->wq, &qdss->connect_w);
return ch;
}
EXPORT_SYMBOL(usb_qdss_open);
void usb_qdss_close(struct usb_qdss_ch *ch)
{
struct f_qdss *qdss = ch->priv_usb;
struct usb_gadget *gadget = qdss->cdev->gadget;
unsigned long flags;
pr_debug("usb_qdss_close\n");
spin_lock_irqsave(&d_lock, flags);
usb_ep_dequeue(qdss->data, qdss->endless_req);
usb_ep_free_request(qdss->data, qdss->endless_req);
qdss->endless_req = NULL;
ch->app_conn = 0;
spin_unlock_irqrestore(&d_lock, flags);
if (gadget_is_dwc3(gadget))
msm_dwc3_restart_usb_session(gadget);
}
EXPORT_SYMBOL(usb_qdss_close);
static void qdss_cleanup(void)
{
struct f_qdss *qdss;
struct list_head *act, *tmp;
struct usb_qdss_ch *_ch;
unsigned long flags;
pr_debug("qdss_cleanup\n");
list_for_each_safe(act, tmp, &usb_qdss_ch_list) {
_ch = list_entry(act, struct usb_qdss_ch, list);
qdss = container_of(_ch, struct f_qdss, ch);
spin_lock_irqsave(&d_lock, flags);
destroy_workqueue(qdss->wq);
if (!_ch->priv) {
list_del(&_ch->list);
kfree(qdss);
}
spin_unlock_irqrestore(&d_lock, flags);
}
}
static int qdss_setup(void)
{
return 0;
}