Initial commit: Linux kernel 4.19 for Unplugged OS

This commit is contained in:
ziv committed 2025-10-06 13:52:42 +00:00
commit d30235b04c
80519 files changed
+35800681

No files matched your search

+31
View File
@@ -0,0 +1,31 @@
# SPDX-License-Identifier: GPL-2.0
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License 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.
#
ifeq ($(CONFIG_MTK_ECCCI_C2K), y)
#ccflags-y += -DC2K_USB_UT
ccflags-y += -I$(srctree)/drivers/usb/gadget
ccflags-y += -I$(srctree)/drivers/misc/mediatek/usb_boost/
obj-$(CONFIG_MTK_ECCCI_C2K) += c2k_usb.o
c2k_usb-y := f_rawbulk.o rawbulk.o rawbulk_transfer.o
else
obj- :=dummy.o
endif
+530
View File
@@ -0,0 +1,530 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2017 MediaTek Inc.
*/
#define DRIVER_AUTHOR "jlguo <jlguo@via-telecom.com>"
#define DRIVER_DESC "Rawbulk Gadget - transport data from CP to Gadget"
#define DRIVER_VERSION "1.0.2"
#include <linux/err.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/wait.h>
#include <linux/version.h>
#include <linux/types.h>
#include <linux/device.h>
#include <linux/usb/composite.h>
#include "viatel_rawbulk.h"
#include <linux/module.h>
#include <linux/configfs.h>
#include "configfs.h"
/* int setdtr, data_connect; */
/* struct work_struct flow_control; */
/* struct work_struct dtr_status; */
#define function_to_rbf(f) container_of(f, struct rawbulk_function, function)
static int usb_state;
void simple_setup_complete(struct usb_ep *ep, struct usb_request *req)
{
; /* DO NOTHING */
}
#define FINISH_DISABLE 0
#define START_DISABLE 1
int rawbulk_function_setup(struct usb_function *f, const struct
usb_ctrlrequest * ctrl)
{
struct rawbulk_function *fn = function_to_rbf(f);
unsigned int setdtr = 0;
unsigned int data_connect = 0;
struct usb_composite_dev *cdev = f->config->cdev;
struct usb_request *req = cdev->req;
int value = -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);
C2K_NOTE("%s\n", __func__);
if (ctrl->bRequest) {
C2K_NOTE("ctrl->bRequestType = %0x ctrl->bRequest = %0x\n",
ctrl->bRequestType, ctrl->bRequest);
}
switch (ctrl->bRequest) {
case 0x01:
if (ctrl->bRequestType == (USB_DIR_OUT | USB_TYPE_VENDOR)) {
/* set/clear DTR 0x40 */
C2K_NOTE("setdtr = %d, wvalue =%d\n", setdtr, w_value);
if (fn->activated) {
setdtr = w_value & 0x01;
/* schedule_work(&flow_control); */
modem_dtr_set(setdtr, 0);
modem_dcd_state();
}
value = 0;
}
break;
case 0x02:
if (ctrl->bRequestType == (USB_DIR_IN | USB_TYPE_VENDOR)) {
/* DSR | CD109 0xC0 */
/* schedule_work(&dtr_status); */
data_connect = modem_dcd_state();
/* modem_dtr_query(&data_connect, 0); */
if (fn->activated) {
if (data_connect && fn->enable) {
*((unsigned char *)req->buf) = 0x3;
C2K_NOTE("connect %d\n", data_connect);
} else {
*((unsigned char *)req->buf) = 0x2;
C2K_NOTE("disconnect=%d, setdtr=%d\n",
data_connect, setdtr);
}
} else /* set CD CSR state to 0 if modem bypass not
* inactive
*/
*((unsigned char *)req->buf) = 0x0;
value = 1;
}
break;
case 0x03:
if (ctrl->bRequestType == (USB_DIR_OUT | USB_TYPE_VENDOR)) {
/* xcvr 0x40 */
C2K_NOTE("CTRL SET XCVR 0x%02x\n", w_value);
value = 0;
}
break;
case 0x04:
if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_VENDOR) {
if (ctrl->bRequestType & USB_DIR_IN) { /* 0xC0 */
/* return ID */
sprintf(req->buf, "CBP_8.2");
value = 1;
} else { /* 0x40 */
value = 0;
}
}
break;
case 0x05:
if (ctrl->bRequestType == (USB_DIR_IN | USB_TYPE_VENDOR)) {
/* connect status 0xC0 */
C2K_NOTE("CTRL CONNECT STATUS\n");
*((unsigned char *)req->buf) = 0x0;
value = 1;
}
break;
default:
C2K_NOTE("invalid control req%02x.%02x v%04x i%04x l%d\n",
ctrl->bRequestType, ctrl->bRequest, w_value, w_index,
w_length);
}
/* respond with data transfer or status phase? */
if (value >= 0) {
req->zero = 0;
req->length = value;
req->complete = simple_setup_complete;
value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
if (value < 0)
C2K_ERR("response err %d\n", value);
}
/* device either stalls (value < 0) or reports success */
return value;
}
static void rawbulk_auto_reconnect(int transfer_id)
{
int rc;
struct rawbulk_function *fn = rawbulk_lookup_function(transfer_id);
C2K_NOTE("%s\n", __func__);
if (!fn || fn->autoreconn == 0)
return;
if (rawbulk_check_enable(fn) && fn->activated) {
C2K_ERR("start %s again automatically.\n", fn->longname);
rc = rawbulk_start_transactions(transfer_id, fn->nups,
fn->ndowns, fn->upsz,
fn->downsz);
if (rc < 0)
rawbulk_disable_function(fn);
}
}
int rawbulk_function_bind(struct usb_configuration *c, struct
usb_function * f)
{
int rc, ifnum;
struct rawbulk_function *fn = function_to_rbf(f);
struct usb_gadget *gadget = c->cdev->gadget;
struct usb_ep *ep_out, *ep_in;
C2K_ERR("%s\n", __func__);
rc = usb_interface_id(c, f);
if (rc < 0)
return rc;
ifnum = rc;
fn->interface.bInterfaceNumber = cpu_to_le16(ifnum);
if (fn->string_defs[0].id == 0) {
rc = usb_string_id(c->cdev);
if (rc < 0)
return rc;
fn->string_defs[0].id = rc;
fn->interface.iInterface = rc;
}
ep_out = usb_ep_autoconfig(gadget, (struct usb_endpoint_descriptor *)
fn->fs_descs[BULKOUT_DESC]);
if (!ep_out) {
C2K_ERR("%s %d config ep_out error\n", __func__, __LINE__);
return -ENOMEM;
}
ep_in = usb_ep_autoconfig(gadget, (struct usb_endpoint_descriptor *)
fn->fs_descs[BULKIN_DESC]);
if (!ep_in) {
usb_ep_disable(ep_out);
C2K_ERR("%s %d config ep_in error\n", __func__, __LINE__);
return -ENOMEM;
}
ep_out->driver_data = fn;
ep_in->driver_data = fn;
fn->bulk_out = ep_out;
fn->bulk_in = ep_in;
f->fs_descriptors = usb_copy_descriptors(fn->fs_descs);
if (unlikely(!f->fs_descriptors))
return -ENOMEM;
if (gadget_is_dualspeed(gadget)) {
fn->hs_bulkin_endpoint.bEndpointAddress =
fn->fs_bulkin_endpoint.bEndpointAddress;
fn->hs_bulkout_endpoint.bEndpointAddress =
fn->fs_bulkout_endpoint.bEndpointAddress;
}
fn->cdev = c->cdev;
fn->activated = 0;
return rawbulk_bind_function(fn->transfer_id, f, ep_out, ep_in,
rawbulk_auto_reconnect);
}
void rawbulk_function_unbind(struct usb_configuration *c, struct
usb_function * f)
{
struct rawbulk_function *fn = function_to_rbf(f);
C2K_NOTE("%s\n", __func__);
/* cancel_work_sync(&fn->activator); */
/* cancel_work_sync(&flow_control); */
/* cancel_work_sync(&dtr_status); */
rawbulk_unbind_function(fn->transfer_id);
}
static void do_activate(struct work_struct *data)
{
struct rawbulk_function *fn = container_of(data,
struct rawbulk_function, activator);
int rc;
struct usb_function *functionp = &(fn->function);
C2K_ERR("%s usb state %s, <%d>\n", __func__,
(fn->activated ? "connect" : "disconnect"), fn->transfer_id);
if (fn->activated) { /* enumerated */
/* enabled endpoints */
rc = config_ep_by_speed(fn->cdev->gadget, functionp,
fn->bulk_out);
if (rc < 0) {
C2K_ERR("failed to config speed rawbulk %s %d\n",
fn->bulk_out->name, rc);
return;
}
rc = usb_ep_enable(fn->bulk_out);
if (rc < 0) {
C2K_ERR("failed to enable rawbulk %s %d\n",
fn->bulk_out->name, rc);
return;
}
rc = config_ep_by_speed(fn->cdev->gadget, functionp,
fn->bulk_in);
if (rc < 0) {
C2K_ERR("failed to config speed rawbulk %s %d\n",
fn->bulk_in->name, rc);
return;
}
rc = usb_ep_enable(fn->bulk_in);
if (rc < 0) {
C2K_ERR("failed to enable rawbulk %s %d\n",
fn->bulk_in->name, rc);
usb_ep_disable(fn->bulk_out);
return;
}
/* start rawbulk if enabled */
if (rawbulk_check_enable(fn)) {
__pm_stay_awake(fn->keep_awake);
rc = rawbulk_start_transactions(fn->transfer_id,
fn->nups, fn->ndowns,
fn->upsz, fn->downsz);
if (rc < 0)
/* rawbulk_disable_function(fn); */
C2K_ERR("%s: failed bypass, channel id = %d\n",
__func__, fn->transfer_id);
}
} else { /* disconnect */
if (rawbulk_check_enable(fn)) {
if (fn->transfer_id == RAWBULK_TID_MODEM) {
/* this in interrupt, but DTR need be set
* firstly then clear it
*/
modem_dtr_set(1, 1);
modem_dtr_set(0, 1);
modem_dtr_set(1, 1);
modem_dcd_state();
}
rawbulk_stop_transactions(fn->transfer_id);
/* keep the enable state, so we can enable again in
* next time
*/
/* set_enable_state(fn, 0); */
__pm_relax(fn->keep_awake);
}
usb_ep_disable(fn->bulk_out);
usb_ep_disable(fn->bulk_in);
fn->bulk_out->driver_data = NULL;
fn->bulk_in->driver_data = NULL;
}
}
static void rawbulk_usb_state_set(int state)
{
usb_state = state ? 1 : 0;
C2K_ERR("%s usb_state = %d\n", __func__, usb_state);
}
int rawbulk_usb_state_check(void)
{
return usb_state ? 1 : 0;
}
EXPORT_SYMBOL_GPL(rawbulk_usb_state_check);
static int rawbulk_function_setalt(struct usb_function *f, unsigned int intf,
unsigned int alt)
{
struct rawbulk_function *fn = function_to_rbf(f);
C2K_NOTE("%s\n", __func__);
fn->activated = 1;
rawbulk_usb_state_set(fn->activated);
schedule_work(&fn->activator);
return 0;
}
static void rawbulk_function_disable(struct usb_function *f)
{
struct rawbulk_function *fn = function_to_rbf(f);
C2K_NOTE("%s, %s\n", __func__, f->name);
fn->activated = 0;
rawbulk_usb_state_set(fn->activated);
schedule_work(&fn->activator);
}
int rawbulk_bind_config(struct usb_configuration *c, int transfer_id)
{
int rc;
struct rawbulk_function *fn = rawbulk_lookup_function(transfer_id);
if (!fn)
return -ENOMEM;
C2K_ERR("add %s to config.\n", fn->longname);
if (fn->string_defs[0].id == 0) {
rc = usb_string_id(c->cdev);
if (rc < 0)
return rc;
fn->string_defs[0].id = rc;
fn->interface.iInterface = rc;
}
if (!fn->initialized) {
fn->function.name = fn->longname;
fn->function.setup = rawbulk_function_setup;
fn->function.bind = rawbulk_function_bind;
fn->function.unbind = rawbulk_function_unbind;
fn->function.set_alt = rawbulk_function_setalt;
fn->function.disable = rawbulk_function_disable;
INIT_WORK(&fn->activator, do_activate);
fn->initialized = 1;
}
rc = usb_add_function(c, &fn->function);
if (rc < 0)
C2K_ERR("%s - failed to config %d.\n", __func__, rc);
return rc;
}
static struct rawbulk_instance *to_rawbulk_instance(struct config_item *item)
{
return container_of(to_config_group(item), struct rawbulk_instance,
func_inst.group);
}
static void rawbulk_attr_release(struct config_item *item)
{
struct rawbulk_instance *fi_rawbulk = to_rawbulk_instance(item);
usb_put_function_instance(&fi_rawbulk->func_inst);
}
static struct configfs_item_operations rawbulk_item_ops = {
.release = rawbulk_attr_release,
};
static struct config_item_type rawbulk_func_type = {
.ct_item_ops = &rawbulk_item_ops,
.ct_owner = THIS_MODULE,
};
static void rawbulk_free_inst(struct usb_function_instance *fi)
{
struct rawbulk_instance *fi_rawbulk;
fi_rawbulk = container_of(fi, struct rawbulk_instance, func_inst);
kfree(fi_rawbulk);
}
static void rawbulk_free(struct usb_function *f)
{
/*NO-OP: no function specific resource allocation in rawbulk_alloc*/
}
struct usb_function_instance *alloc_inst_rawbulk(int transfer_id)
{
struct rawbulk_instance *fi_rawbulk;
fi_rawbulk = kzalloc(sizeof(*fi_rawbulk), GFP_KERNEL);
if (!fi_rawbulk)
return ERR_PTR(-ENOMEM);
fi_rawbulk->func_inst.free_func_inst = rawbulk_free_inst;
config_group_init_type_name(&fi_rawbulk->func_inst.group,
"", &rawbulk_func_type);
return &fi_rawbulk->func_inst;
}
static struct usb_function *rawbulk_alloc(struct usb_function_instance *fi,
int transfer_id)
{
struct rawbulk_function *fn = rawbulk_lookup_function(transfer_id);
if (!fn)
return ERR_PTR(-ENOMEM);
C2K_ERR("add %s to config.\n", fn->longname);
if (!fn->initialized) {
fn->function.name = fn->longname;
fn->function.setup = rawbulk_function_setup;
fn->function.bind = rawbulk_function_bind;
fn->function.unbind = rawbulk_function_unbind;
fn->function.set_alt = rawbulk_function_setalt;
fn->function.disable = rawbulk_function_disable;
fn->function.free_func = rawbulk_free;
INIT_WORK(&fn->activator, do_activate);
fn->initialized = 1;
}
return &fn->function;
}
static struct usb_function_instance *via_modem_alloc_inst(void)
{
return alloc_inst_rawbulk(RAWBULK_TID_MODEM);
}
static struct usb_function *via_modem_alloc(struct usb_function_instance *fi)
{
return rawbulk_alloc(fi, RAWBULK_TID_MODEM);
}
DECLARE_USB_FUNCTION_INIT(via_modem, via_modem_alloc_inst, via_modem_alloc);
MODULE_LICENSE("GPL");
static struct usb_function_instance *via_ets_alloc_inst(void)
{
return alloc_inst_rawbulk(RAWBULK_TID_ETS);
}
static struct usb_function *via_ets_alloc(struct usb_function_instance *fi)
{
return rawbulk_alloc(fi, RAWBULK_TID_ETS);
}
DECLARE_USB_FUNCTION_INIT(via_ets, via_ets_alloc_inst, via_ets_alloc);
MODULE_LICENSE("GPL");
static struct usb_function_instance *via_atc_alloc_inst(void)
{
return alloc_inst_rawbulk(RAWBULK_TID_AT);
}
static struct usb_function *via_atc_alloc(struct usb_function_instance *fi)
{
return rawbulk_alloc(fi, RAWBULK_TID_AT);
}
DECLARE_USB_FUNCTION_INIT(via_atc, via_atc_alloc_inst, via_atc_alloc);
MODULE_LICENSE("GPL");
static struct usb_function_instance *via_pcv_alloc_inst(void)
{
return alloc_inst_rawbulk(RAWBULK_TID_PCV);
}
static struct usb_function *via_pcv_alloc(struct usb_function_instance *fi)
{
return rawbulk_alloc(fi, RAWBULK_TID_PCV);
}
DECLARE_USB_FUNCTION_INIT(via_pcv, via_pcv_alloc_inst, via_pcv_alloc);
MODULE_LICENSE("GPL");
static struct usb_function_instance *via_gps_alloc_inst(void)
{
return alloc_inst_rawbulk(RAWBULK_TID_GPS);
}
static struct usb_function *via_gps_alloc(struct usb_function_instance *fi)
{
return rawbulk_alloc(fi, RAWBULK_TID_GPS);
}
DECLARE_USB_FUNCTION_INIT(via_gps, via_gps_alloc_inst, via_gps_alloc);
MODULE_LICENSE("GPL");
+758
View File
@@ -0,0 +1,758 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2017 MediaTek Inc.
*/
/* #define DEBUG */
/* #define VERBOSE_DEBUG */
#define DRIVER_AUTHOR "Juelun Guo <jlguo@via-telecom.com>"
#define DRIVER_DESC "Rawbulk Gadget - transport data from CP to Gadget"
#define DRIVER_VERSION "1.0.2"
#define DRIVER_NAME "usb_rawbulk"
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/err.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/wait.h>
#include <linux/types.h>
#include <linux/device.h>
#include <linux/version.h>
#include <linux/usb/composite.h>
#include "viatel_rawbulk.h"
#define C2K_TTY_USB_SKIP
#ifdef C2K_USB_UT
#include <linux/random.h>
#include <linux/sched/signal.h>
#define UT_CMD 3
#define UT_CLR_ERR 4
#define SZ 4096
int ut_err;
#endif
/* sysfs attr idx assignment */
enum _attr_idx {
ATTR_ENABLE = 0, /** enable switch for Rawbulk */
#ifdef SUPPORT_LEGACY_CONTROL
ATTR_ENABLE_C, /** enable switch too, but for legacy */
#endif
ATTR_AUTORECONN, /** enable to rebind cp when it reconnect */
ATTR_STATISTICS, /** Rawbulk summary/statistics for one pipe */
ATTR_NUPS, /** upstream transfers count */
ATTR_NDOWNS, /** downstram transfers count */
ATTR_UPSIZE, /** upstream buffer for each transaction */
ATTR_DOWNSIZE, /** downstram buffer for each transaction */
ATTR_DTR, /** DTR control, only for Data-Call port */
};
struct rawbulk_function *prealloced_functions[_MAX_TID] = { NULL };
struct rawbulk_function *rawbulk_lookup_function(int transfer_id)
{
C2K_DBG("%s\n", __func__);
if (transfer_id >= 0 && transfer_id < _MAX_TID)
return prealloced_functions[transfer_id];
return NULL;
}
EXPORT_SYMBOL_GPL(rawbulk_lookup_function);
static inline int check_enable_state(struct rawbulk_function *fn)
{
int enab;
unsigned long flags;
C2K_DBG("%s\n", __func__);
spin_lock_irqsave(&fn->lock, flags);
enab = fn->enable ? 1 : 0;
C2K_DBG("enab(%d)\n", enab);
spin_unlock_irqrestore(&fn->lock, flags);
return enab;
}
int rawbulk_check_enable(struct rawbulk_function *fn)
{
C2K_DBG("%s\n", __func__);
return check_enable_state(fn);
}
EXPORT_SYMBOL_GPL(rawbulk_check_enable);
static inline void set_enable_state(struct rawbulk_function *fn, int enab)
{
unsigned long flags;
spin_lock_irqsave(&fn->lock, flags);
fn->enable = !!enab;
spin_unlock_irqrestore(&fn->lock, flags);
}
void rawbulk_disable_function(struct rawbulk_function *fn)
{
C2K_NOTE("enable to 0\n");
set_enable_state(fn, 0);
}
EXPORT_SYMBOL_GPL(rawbulk_disable_function);
#define port_to_rawbulk(p) container_of(p, struct rawbulk_function, port)
#define function_to_rawbulk(f) container_of(f, struct rawbulk_function,\
function)
static void init_endpoint_desc(struct usb_endpoint_descriptor *epdesc, int in,
int maxpacksize)
{
struct usb_endpoint_descriptor template = {
.bLength = USB_DT_ENDPOINT_SIZE,
.bDescriptorType = USB_DT_ENDPOINT,
.bmAttributes = USB_ENDPOINT_XFER_BULK,
};
*epdesc = template;
if (in)
epdesc->bEndpointAddress = USB_DIR_IN;
else
epdesc->bEndpointAddress = USB_DIR_OUT;
epdesc->wMaxPacketSize = cpu_to_le16(maxpacksize);
}
static void init_interface_desc(struct usb_interface_descriptor *ifdesc)
{
struct usb_interface_descriptor template = {
.bLength = USB_DT_INTERFACE_SIZE,
.bDescriptorType = USB_DT_INTERFACE,
.bInterfaceNumber = 0,
.bAlternateSetting = 0,
.bNumEndpoints = 2,
.bInterfaceClass = 0xff, /* USB_CLASS_VENDOR_SPEC, */
.bInterfaceSubClass = 0xff,
.bInterfaceProtocol = 0xff,
.iInterface = 0,
};
*ifdesc = template;
}
static ssize_t rawbulk_attr_show(struct device *dev, struct device_attribute
*attr, char *buf);
static ssize_t rawbulk_attr_store(struct device *dev, struct device_attribute
*attr, const char *buf, size_t count);
static inline void add_device_attr(struct rawbulk_function *fn, unsigned int n,
const char *name, int mode)
{
if (n < MAX_ATTRIBUTES) {
sysfs_attr_init(&fn->attr[n].attr);
fn->attr[n].attr.name = name;
fn->attr[n].attr.mode = mode;
fn->attr[n].show = rawbulk_attr_show;
fn->attr[n].store = rawbulk_attr_store;
}
}
static int which_attr(struct rawbulk_function *fn, struct device_attribute
*attr)
{
int n;
for (n = 0; n < fn->max_attrs; n++) {
if (attr == &fn->attr[n])
return n;
}
return -1;
}
static ssize_t rawbulk_attr_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
int n;
int idx;
int enab;
struct rawbulk_function *fn;
ssize_t count = 0;
for (n = 0; n < _MAX_TID; n++) {
fn = rawbulk_lookup_function(n);
if (IS_ERR_OR_NULL(fn)) {
C2K_ERR("Null or error rawbulk_function! (n = %d)\n", n);
return 0;
}
if (fn->dev == dev) {
idx = which_attr(fn, attr);
break;
}
#ifdef SUPPORT_LEGACY_CONTROL
if (!strcmp(attr->attr.name, fn->shortname)) {
idx = ATTR_ENABLE_C;
break;
}
#endif
}
if (n == _MAX_TID)
return 0;
enab = check_enable_state(fn);
switch (idx) {
case ATTR_ENABLE:
count = snprintf(buf, PAGE_SIZE, "%d", enab);
break;
#ifdef SUPPORT_LEGACY_CONTROL
case ATTR_ENABLE_C:
count = snprintf(buf, PAGE_SIZE, "%s", en ? "gadget" : "tty");
break;
#endif
case ATTR_AUTORECONN:
count = snprintf(buf, PAGE_SIZE, "%d", fn->autoreconn);
break;
case ATTR_STATISTICS:
count = rawbulk_transfer_statistics(fn->transfer_id, buf);
break;
case ATTR_NUPS:
count = snprintf(buf, PAGE_SIZE,
"nups<%d>,udata<%d>,ucnt<%d>,drop<%d>,aloc_fai<%d>,tran<%d>\n",
enab ? fn->nups : -1,
upstream_data[fn->transfer_id],
upstream_cnt[fn->transfer_id],
total_drop[fn->transfer_id],
alloc_fail[fn->transfer_id],
total_tran[fn->transfer_id]);
break;
case ATTR_NDOWNS:
count = snprintf(buf, PAGE_SIZE, "%d", enab ? fn->ndowns : -1);
break;
case ATTR_UPSIZE:
count = snprintf(buf, PAGE_SIZE, "%d", enab ? fn->upsz : -1);
break;
case ATTR_DOWNSIZE:
count = snprintf(buf, PAGE_SIZE, "%d", enab ? fn->downsz : -1);
break;
default:
break;
}
return count;
}
#ifdef C2K_USB_UT
int total_cnt;
void do_push_upstream(int transfer_id, char *buf, int len)
{
int ret;
while (1) {
ret = rawbulk_push_upstream_buffer(transfer_id, buf, len);
if (ret == len || ret == 0) {
C2K_DBG("push ret(%d)\n", ret);
#ifdef C2K_USB_PERF
total_cnt += 1;
if (total_cnt == 1024) {
C2K_NOTE("4MB got\n");
total_cnt = 0;
}
#endif
break;
}
C2K_DBG("push ret(%d)\n", ret);
#ifndef C2K_USB_PERF
udelay(1000);
#endif
}
}
#endif
static ssize_t rawbulk_attr_store(struct device *dev,
struct device_attribute *attr, const char *buf,
size_t count)
{
int n;
int rc = 0;
int idx = -1;
int nups;
int ndowns;
int upsz;
int downsz;
struct rawbulk_function *fn;
for (n = 0; n < _MAX_TID; n++) {
fn = rawbulk_lookup_function(n);
if (IS_ERR_OR_NULL(fn))
break;
if (fn->dev == dev) {
idx = which_attr(fn, attr);
break;
}
#ifdef SUPPORT_LEGACY_CONTROL
if (!strcmp(attr->attr.name, fn->shortname)) {
idx = ATTR_ENABLE_C;
break;
}
#endif
}
if (idx < 0) {
C2K_ERR("sorry, I cannot find rawbulk fn '%s'\n",
attr->attr.name);
goto exit;
}
nups = fn->nups;
ndowns = fn->ndowns;
upsz = fn->upsz;
downsz = fn->downsz;
/* find out which attr(file) we write */
#ifdef SUPPORT_LEGACY_CONTROL
if (idx <= ATTR_ENABLE_C) {
#else
if (idx == ATTR_ENABLE) {
#endif
int enable;
long tmp = 0;
#ifdef SUPPORT_LEGACY_CONTROL
if (idx == ATTR_ENABLE) {
#else
{
#endif
int ret;
ret = kstrtol(buf, 0, &tmp);
enable = (int)tmp;
C2K_NOTE("enable:%d\n", enable);
#ifdef C2K_USB_UT
if (enable == UT_CMD) {
int i;
unsigned int len;
int transfer_id = n;
static char last_end;
char *buf = kmalloc(SZ, GFP_KERNEL);
C2K_NOTE("buf(%p)\n", buf);
/* #define C2K_USB_PERF */
#ifdef C2K_USB_PERF
total_cnt = 0;
memset(buf, 0x41, SZ);
#endif
while (!signal_pending(current)) {
#ifdef C2K_USB_PERF
len = SZ;
#else
if (ut_err) {
C2K_NOTE("errrrrrrrrrrrrrr\n");
break;
}
get_random_bytes(&len, sizeof(len));
C2K_NOTE("len before(%d)\n", len);
len %= SZ;
len += 1;
C2K_NOTE("len after(%d)\n", len);
buf[0] = last_end + 1;
for (i = 1; i < len; i++)
buf[i] = buf[i - 1] + 1;
last_end = buf[i - 1];
#endif
do_push_upstream(transfer_id, buf, len)
;
#ifdef C2K_USB_PERF
/* simulate 4MB per sec */
udelay(delay_set);
#endif
}
if (buf) {
C2K_NOTE("free buf\n");
kfree(buf);
}
ut_err = 0;
C2K_NOTE("exit UT\n");
goto exit;
} else if (enable == UT_CLR_ERR) {
ut_err = 0;
goto exit;
}
#endif
#ifdef SUPPORT_LEGACY_CONTROL
} else if (idx == ATTR_ENABLE_C) {
if (!strncmp(buf, "tty", 3))
enable = 0;
else if (!strncmp(buf, "gadget", 6))
enable = 1;
else {
C2K_ERR("invalid option(%s) for bypas\n", buf);
goto exit;
}
} else
goto exit;
#else
}
#endif /* SUPPORT_LEGACY_CONTROL */
if ((check_enable_state(fn) != (!!enable))) {
C2K_NOTE("enable:%d\n", enable);
set_enable_state(fn, enable);
if (!!enable && fn->activated) {
C2K_NOTE("enable rb %s channel,activated %s\n",
fn->shortname, fn->activated ?
"yes" : "no");
if (fn->transfer_id == RAWBULK_TID_MODEM) {
/* clear DTR to endup last session
* between AP and CP
*/
modem_dtr_set(1, 1);
modem_dtr_set(0, 1);
modem_dtr_set(1, 1);
modem_dcd_state();
}
/* Start rawbulk transfer */
__pm_stay_awake(fn->keep_awake);
rc = rawbulk_start_transactions(
fn->transfer_id, nups, ndowns, upsz,
downsz);
if (rc < 0)
C2K_ERR("%s rc = %d bypass failed\n",
__func__, rc);
} else {
/* Stop rawbulk transfer */
C2K_NOTE("D.S rb %s chan,been activated %s\n",
fn->shortname,
fn->activated ? "yes" : "no");
rawbulk_stop_transactions(fn->transfer_id);
if (fn->transfer_id == RAWBULK_TID_MODEM) {
/* clear DTR automatically when disable
* modem rawbulk
*/
modem_dtr_set(1, 1);
modem_dtr_set(0, 1);
modem_dtr_set(1, 1);
modem_dcd_state();
}
__pm_relax(fn->keep_awake);
}
}
} else if (idx == ATTR_DTR) {
if (fn->transfer_id == RAWBULK_TID_MODEM) {
if (check_enable_state(fn)) {
int val, ret;
long tmp = 0;
ret = kstrtol(buf, 0, &tmp);
val = (int)tmp;
modem_dtr_set(val, 1);
}
}
} else if (idx == ATTR_AUTORECONN) {
int val, ret;
long tmp = 0;
ret = kstrtol(buf, 0, &tmp);
val = (int)tmp;
fn->autoreconn = !!val;
} else {
int val, ret;
long tmp = 0;
ret = kstrtol(buf, 0, &tmp);
val = (int)tmp;
switch (idx) {
case ATTR_NUPS:
nups = val;
break;
case ATTR_NDOWNS:
ndowns = val;
break;
case ATTR_UPSIZE:
upsz = val;
break;
case ATTR_DOWNSIZE:
downsz = val;
break;
default:
goto exit;
}
if (!check_enable_state(fn))
goto exit;
if (!fn->activated)
goto exit;
rawbulk_stop_transactions(fn->transfer_id);
rc = rawbulk_start_transactions(fn->transfer_id, nups, ndowns,
upsz, downsz);
if (rc >= 0) {
fn->nups = nups;
fn->ndowns = ndowns;
fn->upsz = upsz;
fn->downsz = downsz;
} else {
rawbulk_stop_transactions(fn->transfer_id);
__pm_relax(fn->keep_awake);
C2K_NOTE("enable to 0\n");
set_enable_state(fn, 0);
}
}
exit:
return count;
}
static int rawbulk_create_files(struct rawbulk_function *fn)
{
int n, rc;
for (n = 0; n < fn->max_attrs; n++) {
#ifdef SUPPORT_LEGACY_CONTROL
if (n == ATTR_ENABLE_C)
continue;
#endif
rc = device_create_file(fn->dev, &fn->attr[n]);
if (rc < 0) {
while (--n >= 0) {
#ifdef SUPPORT_LEGACY_CONTROL
if (n == ATTR_ENABLE_C)
continue;
#endif
device_remove_file(fn->dev, &fn->attr[n]);
}
return rc;
}
}
return 0;
}
static void rawbulk_remove_files(struct rawbulk_function *fn)
{
int n = fn->max_attrs;
while (--n >= 0) {
#ifdef SUPPORT_LEGACY_CONTROL
if (n == ATTR_ENABLE_C)
continue;
#endif
device_remove_file(fn->dev, &fn->attr[n]);
}
}
/*****************************************************************************/
static struct class *rawbulk_class;
static struct _function_init_stuff {
const char *longname;
const char *shortname;
const char *iString;
unsigned int nups;
unsigned int ndowns;
unsigned int upsz;
unsigned int downsz;
bool autoreconn;
bool pushable;
} _init_params[] = {
#ifdef CONFIG_EVDO_DT_VIA_SUPPORT
{
"rawbulk-modem", "data", "Modem Port", 32, 32, 4096, 4096, true, false}
, {
"rawbulk-ets", "ets", "ETS Port", 32, 32, 4096, 4096, true, false}, {
"rawbulk-at", "atc", "AT Channel", 3, 3, 4096, 4096, true, false}, {
"rawbulk-pcv", "pcv", "PCM Voice", 1, 1, 4096, 4096, true, false}, {
"rawbulk-gps", "gps", "LBS GPS Port", 1, 1, 4096, 4096, true, false}, {
}, /* End of configurations */
#else
{
"rawbulk-pcv", "pcv", "PCM Voice", 1, 1, 4096, 4096, true, false}, {
"rawbulk-modem", "data", "Modem Port", 32, 32, 4096, 4096, true, false}
, {
"rawbulk-dummy0", "dummy0", "DUMMY0", 1, 1, 4096, 4096, true, false}, {
"rawbulk-at", "atc", "AT Channel", 3, 3, 4096, 4096, true, false}, {
"rawbulk-gps", "gps", "LBS GPS Port", 1, 1, 4096, 4096, true, false}, {
"rawbulk-dummy1", "dummy1", "DUMMY1", 1, 1, 4096, 4096, true, false}, {
"rawbulk-dummy2", "dummy2", "DUMMY2", 1, 1, 4096, 4096, true, false}, {
"rawbulk-ets", "ets", "ETS Port", 32, 32, 4096, 4096, true, false}, {
}, /* End of configurations */
#endif
};
static __init struct rawbulk_function *rawbulk_alloc_function(int transfer_id)
{
int rc;
struct rawbulk_function *fn;
C2K_NOTE("%s\n", __func__);
if (transfer_id == _MAX_TID)
return NULL;
fn = kzalloc(sizeof(*fn), GFP_KERNEL);
if (IS_ERR_OR_NULL(fn))
return NULL;
/* init default features of rawbulk functions */
fn->longname = _init_params[transfer_id].longname;
fn->shortname = _init_params[transfer_id].shortname;
fn->string_defs[0].s = _init_params[transfer_id].iString;
fn->nups = _init_params[transfer_id].nups;
fn->ndowns = _init_params[transfer_id].ndowns;
fn->upsz = _init_params[transfer_id].upsz;
fn->downsz = _init_params[transfer_id].downsz;
fn->autoreconn = _init_params[transfer_id].autoreconn;
fn->tty_minor = -1;
/* init descriptors */
init_interface_desc(&fn->interface);
init_endpoint_desc(&fn->fs_bulkin_endpoint, 1, 512);
init_endpoint_desc(&fn->hs_bulkin_endpoint, 1, 512);
init_endpoint_desc(&fn->fs_bulkout_endpoint, 0, 512);
init_endpoint_desc(&fn->hs_bulkout_endpoint, 0, 512);
fn->fs_descs[INTF_DESC] = (struct usb_descriptor_header *)
&fn->interface;
fn->fs_descs[BULKIN_DESC] = (struct usb_descriptor_header *)
&fn->fs_bulkin_endpoint;
fn->fs_descs[BULKOUT_DESC] = (struct usb_descriptor_header *)
&fn->fs_bulkout_endpoint;
fn->hs_descs[INTF_DESC] = (struct usb_descriptor_header *)
&fn->interface;
fn->hs_descs[BULKIN_DESC] = (struct usb_descriptor_header *)
&fn->hs_bulkin_endpoint;
fn->hs_descs[BULKOUT_DESC] = (struct usb_descriptor_header *)
&fn->hs_bulkout_endpoint;
fn->string_table.language = 0x0409;
fn->string_table.strings = fn->string_defs;
fn->strings[0] = &fn->string_table;
fn->strings[1] = NULL;
fn->transfer_id = transfer_id;
fn->tty_throttled = 0;
/* init function callbacks */
fn->function.strings = fn->strings;
fn->function.fs_descriptors = fn->fs_descs;
fn->function.hs_descriptors = fn->hs_descs;
/* init device attributes */
add_device_attr(fn, ATTR_ENABLE, "enable", 0660);
#ifdef SUPPORT_LEGACY_CONTROL
add_device_attr(fn, ATTR_ENABLE_C, fn->shortname, 0660);
#endif
add_device_attr(fn, ATTR_AUTORECONN, "autoreconn", 0660);
add_device_attr(fn, ATTR_STATISTICS, "statistics", 0660);
add_device_attr(fn, ATTR_NUPS, "nups", 0660);
add_device_attr(fn, ATTR_NDOWNS, "ndowns", 0660);
add_device_attr(fn, ATTR_UPSIZE, "ups_size", 0660);
add_device_attr(fn, ATTR_DOWNSIZE, "downs_size", 0660);
fn->max_attrs = ATTR_DOWNSIZE + 1;
if (transfer_id == RAWBULK_TID_MODEM) {
add_device_attr(fn, ATTR_DTR, "dtr", 0220);
fn->max_attrs++;
}
fn->dev = device_create(rawbulk_class, NULL, MKDEV(0,
fn->transfer_id), NULL, fn->shortname);
if (IS_ERR(fn->dev)) {
kfree(fn);
return NULL;
}
rc = rawbulk_create_files(fn);
if (rc < 0) {
device_destroy(rawbulk_class, fn->dev->devt);
kfree(fn);
return NULL;
}
spin_lock_init(&fn->lock);
fn->keep_awake = wakeup_source_register(fn->dev, fn->longname);
return fn;
}
static void rawbulk_destroy_function(struct rawbulk_function *fn)
{
C2K_DBG("%s\n", __func__);
if (!fn)
return;
wakeup_source_remove(fn->keep_awake);
rawbulk_remove_files(fn);
device_destroy(rawbulk_class, fn->dev->devt);
kfree(fn);
}
#ifdef SUPPORT_LEGACY_CONTROL
static struct attribute *legacy_sysfs[_MAX_TID + 1] = { NULL };
static struct attribute_group legacy_sysfs_group = {
.attrs = legacy_sysfs,
};
struct kobject *legacy_sysfs_stuff;
#endif /* SUPPORT_LEGACY_CONTROL */
static int __init init(void)
{
int n;
int rc = 0;
C2K_NOTE("rawbulk functions go!!!\n");
rawbulk_class = class_create(THIS_MODULE, "usb_rawbulk");
if (IS_ERR(rawbulk_class))
return PTR_ERR(rawbulk_class);
for (n = 0; n < _MAX_TID; n++) {
struct rawbulk_function *fn = rawbulk_alloc_function(n);
if (IS_ERR(fn)) {
while (n--)
rawbulk_destroy_function
(prealloced_functions[n]);
rc = PTR_ERR(fn);
break;
}
prealloced_functions[n] = fn;
#ifdef SUPPORT_LEGACY_CONTROL
legacy_sysfs[n] = &fn->attr[ATTR_ENABLE_C].attr;
#endif
}
if (rc < 0) {
class_destroy(rawbulk_class);
return rc;
}
#ifdef SUPPORT_LEGACY_CONTROL
/* make compatiable with old bypass sysfs access */
legacy_sysfs_stuff = kobject_create_and_add("usb_bypass", NULL);
if (legacy_sysfs_stuff) {
rc = sysfs_create_group(legacy_sysfs_stuff,
&legacy_sysfs_group);
if (rc < 0)
C2K_ERR("failed to create legacy bypass,continue\n");
}
#endif /* SUPPORT_LEGACY_CONTROL */
return 0;
}
module_init(init);
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_VERSION(DRIVER_VERSION);
MODULE_LICENSE("GPL");
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,253 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2017 MediaTek Inc.
*/
#ifndef __RAWBULK_H__
#define __RAWBULK_H__
#include <linux/usb.h>
#include <linux/usb/ch9.h>
#include <linux/usb/composite.h>
#include <linux/usb/gadget.h>
#include <linux/workqueue.h>
#include <linux/device.h>
#include <linux/tty.h>
#include <linux/tty_driver.h>
#include <linux/workqueue.h>
#include <linux/kthread.h>
#include <linux/wait.h>
#include <linux/sched.h>
#define INTF_DESC 0
#define BULKIN_DESC 1
#define BULKOUT_DESC 2
#define MAX_DESC_ARRAY 4
#define NAME_BUFFSIZE 64
#define MAX_ATTRIBUTES 10
#define MAX_TTY_RX 8
#define MAX_TTY_RX_PACKAGE 512
#define MAX_TTY_TX 8
#define MAX_TTY_TX_PACKAGE 512
/* #define CONFIG_EVDO_DT_VIA_SUPPORT */
#ifdef CONFIG_EVDO_DT_VIA_SUPPORT
enum transfer_id {
RAWBULK_TID_MODEM,
RAWBULK_TID_ETS,
RAWBULK_TID_AT,
RAWBULK_TID_PCV,
RAWBULK_TID_GPS,
_MAX_TID
};
#else
enum transfer_id {
RAWBULK_TID_PCV,
RAWBULK_TID_MODEM,
RAWBULK_TID_DUMMY0,
RAWBULK_TID_AT,
RAWBULK_TID_GPS,
RAWBULK_TID_DUMMY1,
RAWBULK_TID_DUMMY2,
RAWBULK_TID_ETS,
_MAX_TID
};
#endif
struct rawbulk_instance {
struct usb_function_instance func_inst;
};
struct rawbulk_function {
int transfer_id;
const char *longname;
const char *shortname;
struct device *dev;
/* Controls */
spinlock_t lock;
int enable:1;
int activated:1; /* set when usb enabled */
int tty_opened:1;
int initialized:1; /* init-flag for activator worker */
struct work_struct activator; /* asynic transaction starter */
struct wakeup_source *keep_awake;
/* USB Gadget related */
struct usb_function function;
struct usb_composite_dev *cdev;
struct usb_ep *bulk_out, *bulk_in;
int rts_state; /* Handshaking pins (outputs) */
int dtr_state;
int cts_state; /* Handshaking pins (inputs) */
int dsr_state;
int dcd_state;
int ri_state;
/* TTY related */
struct tty_struct *tty;
int tty_minor;
struct tty_port port;
spinlock_t tx_lock;
struct list_head tx_free;
struct list_head tx_inproc;
spinlock_t rx_lock;
struct list_head rx_free;
struct list_head rx_inproc;
struct list_head rx_throttled;
unsigned int last_pushed;
struct workqueue_struct *tty_push_wq;
struct work_struct tty_push_work;
int tty_throttled;
/* Transfer Controls */
int nups;
int ndowns;
int upsz;
int downsz;
/* int splitsz; */
int autoreconn;
int pushable; /* Set to use push-way for upstream */
int cbp_reset;
/* Descriptors and Strings */
struct usb_descriptor_header *fs_descs[MAX_DESC_ARRAY];
struct usb_descriptor_header *hs_descs[MAX_DESC_ARRAY];
struct usb_string string_defs[2];
struct usb_gadget_strings string_table;
struct usb_gadget_strings *strings[2];
struct usb_interface_descriptor interface;
struct usb_endpoint_descriptor fs_bulkin_endpoint;
struct usb_endpoint_descriptor hs_bulkin_endpoint;
struct usb_endpoint_descriptor fs_bulkout_endpoint;
struct usb_endpoint_descriptor hs_bulkout_endpoint;
/* Sysfs Accesses */
int max_attrs;
struct device_attribute attr[MAX_ATTRIBUTES];
};
typedef void (*rawbulk_autoreconn_callback_t) (int transfer_id);
/* bind/unbind host interfaces */
int rawbulk_bind_sdio_channel(int transfer_id);
void rawbulk_unbind_sdio_channel(int transfer_id);
struct rawbulk_function *rawbulk_lookup_function(int transfer_id);
/* rawbulk tty io */
int rawbulk_register_tty(struct rawbulk_function *fn);
void rawbulk_unregister_tty(struct rawbulk_function *fn);
int rawbulk_tty_stop_io(struct rawbulk_function *fn);
int rawbulk_tty_start_io(struct rawbulk_function *fn);
int rawbulk_tty_alloc_request(struct rawbulk_function *fn);
void rawbulk_tty_free_request(struct rawbulk_function *fn);
/* bind/unbind for gadget */
int rawbulk_bind_function(int transfer_id, struct usb_function *function,
struct usb_ep *bulk_out, struct usb_ep *bulk_in,
rawbulk_autoreconn_callback_t autoreconn_callback);
void rawbulk_unbind_function(int transfer_id);
int rawbulk_check_enable(struct rawbulk_function *fn);
void rawbulk_disable_function(struct rawbulk_function *fn);
/* operations for transactions */
int rawbulk_start_transactions(int transfer_id, int nups, int ndowns, int upsz,
int downsz);
void rawbulk_stop_transactions(int transfer_id);
int rawbulk_push_upstream_buffer(int transfer_id, const void *buffer,
unsigned int length);
int rawbulk_transfer_statistics(int transfer_id, char *buf);
int rawbulk_transfer_state(int transfer_id);
/* debug mechanism */
extern unsigned int c2k_usb_dbg_level; /* refer to rawbulk_transfer.c */
static inline int c2k_dbg_level(unsigned int level)
{
return c2k_usb_dbg_level >= level;
}
#define C2K_LOG_EMERG 0
#define C2K_LOG_ALERT 1
#define C2K_LOG_CRIT 2
#define C2K_LOG_ERR 3
#define C2K_LOG_WARN 4
#define C2K_LOG_NOTICE 5
#define C2K_LOG_INFO 6
#define C2K_LOG_DBG 7
#define C2K_USB_DBG_ON
#ifdef C2K_USB_DBG_ON
#define C2K_ERR(format, args...) do {if (c2k_dbg_level(C2K_LOG_ERR)) \
pr_notice("C2K_USB_ERR,<%s %d>, " format, __func__, __LINE__, \
## args); } \
while (0)
#define C2K_WARN(format, args...) do {if (c2k_dbg_level(C2K_LOG_WARN)) \
pr_notice("C2K_USB_WARN,<%s %d>, " format, __func__, __LINE__, \
## args); } \
while (0)
#define C2K_NOTE(format, args...) do {if (c2k_dbg_level(C2K_LOG_NOTICE)) \
pr_notice("C2K_USB_NOTE,<%s %d>, " format, __func__, __LINE__, \
## args); } \
while (0)
#define C2K_INFO(format, args...) do {if (c2k_dbg_level(C2K_LOG_INFO)) \
pr_notice("C2K_USB_INFO,<%s %d>, " format, __func__, __LINE__, \
## args); } \
while (0)
#define C2K_DBG(format, args...) do {if (c2k_dbg_level(C2K_LOG_DBG)) \
pr_notice("C2K_USB_DBG,<%s %d>, " format, __func__, __LINE__, \
## args); } \
while (0)
#else
#define C2K_ERR(format, args...) do {} while (0)
#define C2K_WARN(format, args...) do {} while (0)
#define C2K_NOTE(format, args...) do {} while (0)
#define C2K_INFO(format, args...) do {} while (0)
#define C2K_DBG(format, args...) do {} while (0)
#endif
extern unsigned int upstream_data[_MAX_TID];
extern unsigned int upstream_cnt[_MAX_TID];
extern unsigned int total_drop[_MAX_TID];
extern unsigned int alloc_fail[_MAX_TID];
extern unsigned int total_tran[_MAX_TID];
#ifdef C2K_USB_UT
extern int delay_set;
extern int ut_err;
static inline int modem_dtr_set(int on, int low_latency)
{
return 0;
}
static inline int modem_dcd_state(void)
{
return 0;
}
static inline int ccci_c2k_buffer_push(int port_num, void *buf, int count)
{
return 0;
}
static inline int ccci_c2k_rawbulk_intercept(int port_num,
unsigned int inception)
{
return 0;
}
#else
extern int modem_dtr_set(int on, int low_latency);
extern int modem_dcd_state(void);
#endif
extern int rawbulk_bind_config(struct usb_configuration *c, int transfer_id);
extern int rawbulk_function_setup(struct usb_function *f,
const struct usb_ctrlrequest *ctrl);
#endif /* __RAWBULK_HEADER_FILE__ */