diff options
Diffstat (limited to 'drivers/usb/gadget/rawbulk.c')
| -rwxr-xr-x | drivers/usb/gadget/rawbulk.c | 1272 |
1 files changed, 1272 insertions, 0 deletions
diff --git a/drivers/usb/gadget/rawbulk.c b/drivers/usb/gadget/rawbulk.c new file mode 100755 index 00000000..5c027da4 --- /dev/null +++ b/drivers/usb/gadget/rawbulk.c @@ -0,0 +1,1272 @@ +/* + * Rawbulk Gadget Function Driver from VIA Telecom + * + * Copyright (C) 2011 VIA Telecom, Inc. + * Author: Karfield Chen (kfchen@via-telecom.com) + * + * This software is licensed under the terms of the GNU General Public + * License version 2, as published by the Free Software Foundation, and + * may be copied, distributed, and modified under those terms. + * + * 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. + * + */ + +/* #define DEBUG */ +/* #define VERBOSE_DEBUG */ + +#define DRIVER_AUTHOR "Karfield Chen <kfchen@via-telecom.com>" +#define DRIVER_DESC "Rawbulk Gadget - transport data from CP to Gadget" +#define DRIVER_VERSION "1.0.1" +#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/wakelock.h> +#include <linux/interrupt.h> +#include <linux/delay.h> +#include <linux/wait.h> +#include <linux/types.h> +#include <linux/device.h> + +#include <linux/tty.h> +#include <linux/tty_driver.h> +#include <linux/tty_flip.h> + +#include <linux/usb/composite.h> +#include <linux/usb/rawbulk.h> + +#ifdef DEBUG +#define ldbg(f, a...) printk(KERN_DEBUG "%s - " f "\n", __func__, ##a) +#else +#define ldbg(...) {} +#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_SPLIT, /** split option for downstream */ + ATTR_PUSHABLE, /** set to use push-way for upstream */ + ATTR_DTR, /** DTR control, only for Data-Call port */ +}; + +/* USB gadget framework is not strong enough, and not be compatiable with some + * controller, such as musb. + * in musb driver, the usb_request's member list is used internally, but in some + * applications it used in function driver too. to avoid this, here we + * re-wrap the usb_request */ +struct usb_request_wrapper { + struct list_head list; + struct usb_request *request; + int length; + struct rawbulk_function *fn; + char buffer[0]; +}; + +static struct usb_request_wrapper *get_wrapper(struct usb_request *req) { + if (!req->buf) + return NULL; + return container_of(req->buf, struct usb_request_wrapper, buffer); +} + +/* Internal TTY functions/data */ +static int rawbulk_tty_activate(struct tty_port *port, struct tty_struct + *tty); +static void rawbulk_tty_deactivate(struct tty_port *port); +static int rawbulk_tty_install(struct tty_driver *driver, struct tty_struct + *tty); +static void rawbulk_tty_cleanup(struct tty_struct *tty); +static int rawbulk_tty_open(struct tty_struct *tty, struct file *flip); +static void rawbulk_tty_hangup(struct tty_struct *tty); +static void rawbulk_tty_close(struct tty_struct *tty, struct file *flip); +static int rawbulk_tty_write(struct tty_struct *tty, const unsigned char *buf, + int count); +static int rawbulk_tty_write_room(struct tty_struct *tty); +static int rawbulk_tty_chars_in_buffer(struct tty_struct *tty); +static void rawbulk_tty_throttle(struct tty_struct *tty); +static void rawbulk_tty_unthrottle(struct tty_struct *tty); +static void rawbulk_tty_set_termios(struct tty_struct *tty, struct ktermios + *old); +static int rawbulk_tty_tiocmget(struct tty_struct *tty); +static int rawbulk_tty_tiocmset(struct tty_struct *tty, unsigned int set, + unsigned int clear); + +static struct tty_port_operations rawbulk_tty_port_ops = { + .activate = rawbulk_tty_activate, + .shutdown = rawbulk_tty_deactivate, +}; + +static struct tty_operations rawbulk_tty_ops = { + .open = rawbulk_tty_open, + .close = rawbulk_tty_close, + .write = rawbulk_tty_write, + .hangup = rawbulk_tty_hangup, + .write_room = rawbulk_tty_write_room, + .set_termios = rawbulk_tty_set_termios, + .throttle = rawbulk_tty_throttle, + .unthrottle = rawbulk_tty_unthrottle, + .chars_in_buffer = rawbulk_tty_chars_in_buffer, + .tiocmget = rawbulk_tty_tiocmget, + .tiocmset = rawbulk_tty_tiocmset, + .cleanup = rawbulk_tty_cleanup, + .install = rawbulk_tty_install, +}; + +struct tty_driver *rawbulk_tty_driver; + +struct rawbulk_function *prealloced_functions[_MAX_TID] = { NULL }; +struct rawbulk_function *rawbulk_lookup_function(int transfer_id) { + if (transfer_id >= 0 && transfer_id < _MAX_TID) + return prealloced_functions[transfer_id]; + return NULL; +} +EXPORT_SYMBOL_GPL(rawbulk_lookup_function); + +static struct rawbulk_function *lookup_by_tty_minor(int minor) { + int n; + struct rawbulk_function *fn; + for (n = 0; n < _MAX_TID; n ++) { + fn = prealloced_functions[n]; + if (fn->tty_minor == minor) + return fn; + } + return NULL; +} + +static inline int check_enable_state(struct rawbulk_function *fn) { + int enab; + unsigned long flags; + spin_lock_irqsave(&fn->lock, flags); + enab = fn->enable? 1: 0; + spin_unlock_irqrestore(&fn->lock, flags); + return enab; +} + +int rawbulk_check_enable(struct rawbulk_function *fn) { + return check_enable_state(fn); +} +EXPORT_SYMBOL_GPL(rawbulk_check_enable); + +static inline int check_tty_opened(struct rawbulk_function *fn) { + int opened; + unsigned long flags; + spin_lock_irqsave(&fn->lock, flags); + opened = fn->tty_opened? 1: 0; + spin_unlock_irqrestore(&fn->lock, flags); + return opened; +} + +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) { + set_enable_state(fn, 0); +} +EXPORT_SYMBOL_GPL(rawbulk_disable_function); + +static inline void set_tty_opened(struct rawbulk_function *fn, int opened) { + unsigned long flags; + spin_lock_irqsave(&fn->lock, flags); + fn->tty_opened = !!opened; + spin_unlock_irqrestore(&fn->lock, flags); +} + +#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 struct usb_request_wrapper *get_req(struct list_head *head, spinlock_t + *lock) { + unsigned long flags; + struct usb_request_wrapper *req = NULL; + spin_lock_irqsave(lock, flags); + if (!list_empty(head)) { + req = list_first_entry(head, struct usb_request_wrapper, list); + list_del(&req->list); + } + spin_unlock_irqrestore(lock, flags); + return req; +} + +static void put_req(struct usb_request_wrapper *req, struct list_head *head, + spinlock_t *lock) { + unsigned long flags; + spin_lock_irqsave(lock, flags); + list_add_tail(&req->list, head); + spin_unlock_irqrestore(lock, flags); +} + +static void move_req(struct usb_request_wrapper *req, struct list_head *head, + spinlock_t *lock) { + unsigned long flags; + spin_lock_irqsave(lock, flags); + list_move_tail(&req->list, head); + spin_unlock_irqrestore(lock, flags); +} + +static void insert_req(struct usb_request_wrapper *req, struct list_head *head, + spinlock_t *lock) { + unsigned long flags; + spin_lock_irqsave(lock, flags); + list_add(&req->list, head); + spin_unlock_irqrestore(lock, flags); +} + +static int control_dtr(int set) { + struct usb_ctrlrequest ctrl = { + .bRequestType = USB_DIR_OUT | USB_TYPE_VENDOR, //0x40 + .bRequest = 0x01, + .wLength = 0, + .wIndex = 0, + }; + + ctrl.wValue = cpu_to_le16(!!set); + return rawbulk_forward_ctrlrequest(&ctrl); +} + +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, int n, const char + *name, int mode) { + if (n < MAX_ATTRIBUTES) { + 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; + + for (n = 0; n < _MAX_TID; n ++) { + fn = rawbulk_lookup_function(n); + 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: + return sprintf(buf, "%d", enab); +#ifdef SUPPORT_LEGACY_CONTROL + case ATTR_ENABLE_C: + return sprintf(buf, "%s", enab? "gadget": "tty"); +#endif + case ATTR_AUTORECONN: + return sprintf(buf, "%d", fn->autoreconn); + case ATTR_STATISTICS: + return rawbulk_transfer_statistics(fn->transfer_id, buf); + case ATTR_NUPS: + return sprintf(buf, "%d", enab? fn->nups: -1); + case ATTR_NDOWNS: + return sprintf(buf, "%d", enab? fn->ndowns: -1); + case ATTR_UPSIZE: + return sprintf(buf, "%d", enab? fn->upsz: -1); + case ATTR_DOWNSIZE: + return sprintf(buf, "%d", enab? fn->downsz: -1); + case ATTR_SPLIT: + return sprintf(buf, "%d", enab? fn->splitsz: -1); + case ATTR_PUSHABLE: + return sprintf(buf, "%d", fn->pushable); + default: + break; + } + return 0; +} + +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; + int splitsz; + int pushable; + struct rawbulk_function *fn; + + for (n = 0; n < _MAX_TID; n ++) { + fn = rawbulk_lookup_function(n); + 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) { + printk(KERN_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; + splitsz = fn->splitsz; + pushable = fn->pushable; + + /* find out which attr(file) we write */ + +#ifdef SUPPORT_LEGACY_CONTROL + if (idx <= ATTR_ENABLE_C) +#else + if (idx == ATTR_ENABLE) +#endif + { + int enable; + if (idx == ATTR_ENABLE) { + enable = simple_strtoul(buf, NULL, 10); +#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 { + printk(KERN_ERR "invalid option(%s) for bypass, try again...\n", buf); + goto exit; + } +#endif /* SUPPORT_LEGACY_CONTROL */ + } else + goto exit; + + if (check_enable_state(fn) != (!!enable)) { + set_enable_state(fn, enable); + if (!!enable && fn->activated) { + printk(KERN_DEBUG "enable rawbulk %s channel, been 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 */ + control_dtr(1); + msleep(10); + control_dtr(0); + } + + /* Stop TTY i/o */ + rawbulk_tty_stop_io(fn); + + /* Start rawbulk transfer */ + wake_lock(&fn->keep_awake); + rc = rawbulk_start_transactions(fn->transfer_id, nups, + ndowns, upsz, downsz, splitsz, pushable); + if (rc < 0) { + set_enable_state(fn, !enable); + rawbulk_tty_start_io(fn); + } + } else { + /* Stop rawbulk transfer */ + printk(KERN_DEBUG "disable rawbulk %s channel, 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 */ + control_dtr(1); + msleep(10); + control_dtr(0); + } + wake_unlock(&fn->keep_awake); + + /* Start TTY i/o */ + rawbulk_tty_start_io(fn); + } + } + } else if (idx == ATTR_DTR) { + if (fn->transfer_id == RAWBULK_TID_MODEM) { + if (check_enable_state(fn)) + control_dtr(simple_strtoul(buf, NULL, 10)); + } + } else if (idx == ATTR_AUTORECONN) { + fn->autoreconn = !!simple_strtoul(buf, NULL, 10); + } else { + int val = simple_strtoul(buf, NULL, 10); + 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; + case ATTR_SPLIT: splitsz = val; break; + case ATTR_PUSHABLE: + pushable = !!val; + fn->pushable = pushable; + 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, splitsz, pushable); + if (rc >= 0) { + fn->nups = nups; + fn->ndowns = ndowns; + fn->upsz = upsz; + fn->downsz = downsz; + fn->splitsz = splitsz; + fn->pushable = pushable; + } else { + rawbulk_stop_transactions(fn->transfer_id); + wake_unlock(&fn->keep_awake); + 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]); + } +} + +#define RAWBULK_TTY_MINORS 255 +static int tty_minors[RAWBULK_TTY_MINORS] = { 0 }; +static int alloc_tty_minor(struct rawbulk_function *fn) { + int n; + if (check_tty_opened(fn)) + printk(KERN_WARNING "ttyRB%d has opened yet %s has been disconnected\n", + fn->tty_minor, fn->longname); + for (n = 0; n < RAWBULK_TTY_MINORS; n ++) { + if (tty_minors[n] == 0) { + tty_minors[n] = fn->transfer_id + 0x8000; + return n; + } + } + return -ENODEV; +} + +static void free_tty_minor(struct rawbulk_function *fn) { + int n; + struct tty_struct **ttys = rawbulk_tty_driver->ttys; + if (!check_tty_opened(fn)) + tty_minors[fn->tty_minor] = 0; + /* Clear the closed tty minors of this port */ + for (n = 0; n < RAWBULK_TTY_MINORS; n ++) { + if ((tty_minors[n] == fn->transfer_id + 0x8000) && ttys[n]) { + struct tty_struct *tty = ttys[n]; + if (tty->count > 0) + continue; /* Keep the minor while tty is being used */ + if (test_bit(TTY_CLOSING, &tty->flags)) { + /* FIXME: Cannot close the tty_struct! */ + printk(KERN_DEBUG "cannot recycle the minor %d because " \ + "the TTY_CLOSING flags is still on\n", n); + continue; + } + tty_minors[n] = 0; + } + } +} + +int rawbulk_register_tty(struct rawbulk_function *fn) { + struct device *dev; + + spin_lock_init(&fn->tx_lock); + spin_lock_init(&fn->rx_lock); + INIT_LIST_HEAD(&fn->tx_free); + INIT_LIST_HEAD(&fn->rx_free); + INIT_LIST_HEAD(&fn->tx_inproc); + INIT_LIST_HEAD(&fn->rx_inproc); + INIT_LIST_HEAD(&fn->rx_throttled); + + fn->tty_minor = alloc_tty_minor(fn); + if (fn->tty_minor < 0) + return -ENODEV; + fn->tty_opened = 0; + fn->last_pushed = 0; + tty_port_init(&fn->port); + fn->port.ops = &rawbulk_tty_port_ops; + + /* Bring up the tty device */ + dev = tty_register_device(rawbulk_tty_driver, fn->tty_minor, fn->dev); + if (IS_ERR(dev)) + printk(KERN_ERR "Failed to attach ttyRB%d to %s device.\n", + fn->tty_minor, fn->longname); + + return 0; +} +EXPORT_SYMBOL_GPL(rawbulk_register_tty); + +void rawbulk_unregister_tty(struct rawbulk_function *fn) { + tty_unregister_device(rawbulk_tty_driver, fn->tty_minor); + free_tty_minor(fn); +} +EXPORT_SYMBOL_GPL(rawbulk_unregister_tty); + +/******************************************************************************/ + +/* Call this after all request has detached! */ +void rawbulk_tty_free_request(struct rawbulk_function *fn) { + struct usb_request_wrapper *req; + + while ((req = get_req(&fn->rx_free, &fn->rx_lock))) { + usb_ep_free_request(fn->bulk_out, req->request); + kfree(req); + } + + while ((req = get_req(&fn->tx_free, &fn->tx_lock))) { + usb_ep_free_request(fn->bulk_in, req->request); + kfree(req); + } +} +EXPORT_SYMBOL_GPL(rawbulk_tty_free_request); + +static void rawbulk_tty_rx_complete(struct usb_ep *ep, struct usb_request *req); +static void rawbulk_tty_tx_complete(struct usb_ep *ep, struct usb_request *req); + +int rawbulk_tty_alloc_request(struct rawbulk_function *fn) { + int n; + struct usb_request_wrapper *req; + unsigned long flags; + + spin_lock_irqsave(&fn->lock, flags); + if (!fn->bulk_out || !fn->bulk_in) { + spin_unlock_irqrestore(&fn->lock, flags); + return -ENODEV; + } + spin_unlock_irqrestore(&fn->lock, flags); + + /* Allocate and init rx request */ + for (n = 0; n < MAX_TTY_RX; n ++) { + req = kmalloc(sizeof(struct usb_request_wrapper) + + MAX_TTY_RX_PACKAGE, GFP_KERNEL); + if (!req) + break; + + req->request = usb_ep_alloc_request(fn->bulk_out, GFP_KERNEL); + if (!req->request) { + kfree(req); + break; + } + + req->fn = fn; + INIT_LIST_HEAD(&req->list); + req->length = MAX_TTY_RX_PACKAGE; + req->request->buf = req->buffer; + req->request->length = MAX_TTY_RX_PACKAGE; + req->request->complete = rawbulk_tty_rx_complete; + put_req(req, &fn->rx_free, &fn->rx_lock); + } + + if (n < MAX_TTY_RX) { + /* free allocated request */ + rawbulk_tty_free_request(fn); + return -ENOMEM; + } + + /* Allocate and init tx request */ + for (n = 0; n < MAX_TTY_TX; n ++) { + req = kmalloc(sizeof(struct usb_request_wrapper) + + MAX_TTY_TX_PACKAGE, GFP_KERNEL); + if (!req) + break; + + req->request = usb_ep_alloc_request(fn->bulk_in, GFP_KERNEL); + if (!req->request) { + kfree(req); + break; + } + + req->fn = fn; + INIT_LIST_HEAD(&req->list); + req->length = MAX_TTY_TX_PACKAGE; + req->request->zero = 0; + req->request->buf = req->buffer; + req->request->complete = rawbulk_tty_tx_complete; + put_req(req, &fn->tx_free, &fn->tx_lock); + } + + if (n < MAX_TTY_TX) { + /* free allocated request */ + rawbulk_tty_free_request(fn); + return -ENOMEM; + } + + return 0; +} +EXPORT_SYMBOL_GPL(rawbulk_tty_alloc_request); + +int rawbulk_tty_stop_io(struct rawbulk_function *fn) { + struct usb_request_wrapper *req; + + if (!check_tty_opened(fn)) + return -ENODEV; + + while ((req = get_req(&fn->rx_inproc, &fn->rx_lock))) { + if (req->request->status == -EINPROGRESS) { + put_req(req, &fn->rx_inproc, &fn->rx_lock); + usb_ep_dequeue(fn->bulk_out, req->request); + } + } + + while ((req = get_req(&fn->tx_inproc, &fn->tx_lock))) { + if (req->request->status == -EINPROGRESS) { + put_req(req, &fn->tx_inproc, &fn->tx_lock); + usb_ep_dequeue(fn->bulk_in, req->request); + } + } + return 0; +} +EXPORT_SYMBOL_GPL(rawbulk_tty_stop_io); + +int rawbulk_tty_start_io(struct rawbulk_function *fn) { + int ret; + struct usb_request_wrapper *req; + + if (!check_tty_opened(fn)) + return -ENODEV; + + while ((req = get_req(&fn->rx_free, &fn->rx_lock))) { + put_req(req, &fn->rx_inproc, &fn->rx_lock); + ret = usb_ep_queue(fn->bulk_out, req->request, GFP_ATOMIC); + if (ret < 0) { + move_req(req, &fn->rx_free, &fn->rx_lock); + return ret; + } + } + + return 0; +} +EXPORT_SYMBOL_GPL(rawbulk_tty_start_io); + +/* Complete the data send stage */ +static void rawbulk_tty_tx_complete(struct usb_ep *ep, struct usb_request *req) { + struct usb_request_wrapper *r = get_wrapper(req); + struct rawbulk_function *fn = r->fn; + + move_req(r, &fn->tx_free, &fn->tx_lock); +} + +static void rawbulk_tty_push_data(struct rawbulk_function *fn) { + struct usb_request_wrapper *r; + struct tty_struct *tty; + + tty = tty_port_tty_get(&fn->port); + tty->minimum_to_wake = 1; /* wakeup to read even pushed only once */ + /* walk the throttled list, push all the data to TTY */ + while ((r = get_req(&fn->rx_throttled, &fn->rx_lock))) { + char *sbuf; + int push_count; + struct usb_request *req = r->request; + + if (req->status < 0) { + put_req(r, &fn->rx_free, &fn->rx_lock); + continue; + } + sbuf = req->buf + fn->last_pushed; + push_count = req->actual - fn->last_pushed; + if (push_count) { + int count = tty_insert_flip_string(tty, sbuf, push_count); + if (count < push_count) { + /* We met throttled again */ + fn->last_pushed += count; + if (count) + tty_flip_buffer_push(tty); + insert_req(r, &fn->rx_throttled, &fn->rx_lock); + break; + } + tty_flip_buffer_push(tty); + fn->last_pushed = 0; + } + put_req(r, &fn->rx_free, &fn->rx_lock); + } + tty_kref_put(tty); +} + +/* Recieve data from host */ +static void rawbulk_tty_rx_complete(struct usb_ep *ep, struct usb_request *req) { + int ret; + struct usb_request_wrapper *r = get_wrapper(req); + struct rawbulk_function *fn = r->fn; + struct tty_struct *tty = fn->tty; + + if (req->status < 0 || !check_tty_opened(fn)) { + move_req(r, &fn->rx_free, &fn->rx_lock); + return; + } + + if (test_bit(TTY_THROTTLED, &tty->flags)) { + /* Give up to resubmitted the request */ + move_req(r, &fn->rx_free, &fn->rx_lock); + return; + } else { + /* Move the request to the throttled queue */ + move_req(r, &fn->rx_throttled, &fn->rx_lock); + /* Start to push data */ + rawbulk_tty_push_data(fn); + } + + /* Re-queue the request again */ + while ((r = get_req(&fn->rx_free, &fn->rx_lock))) { + put_req(r, &fn->rx_inproc, &fn->rx_lock); + ret = usb_ep_queue(fn->bulk_out, r->request, GFP_ATOMIC); + if (ret < 0) { + move_req(r, &fn->rx_free, &fn->rx_lock); + break; + } + } +} + +/* Start to queue request on BULK OUT endpoint, when tty is try to open */ +static int rawbulk_tty_activate(struct tty_port *port, struct tty_struct + *tty) { + struct rawbulk_function *fn = port_to_rawbulk(port); + /* Low latency for tty */ + tty->low_latency = 1; + tty->termios->c_cc[VMIN] = 1; + return rawbulk_tty_start_io(fn); +} + +static void rawbulk_tty_deactivate(struct tty_port *port) { + struct usb_request_wrapper *req; + struct rawbulk_function *fn = port_to_rawbulk(port); + + /* This is a little different from stop_io */ + while ((req = get_req(&fn->rx_inproc, &fn->rx_lock))) { + put_req(req, &fn->rx_inproc, &fn->rx_lock); + usb_ep_dequeue(fn->bulk_out, req->request); + } + + while ((req = get_req(&fn->rx_throttled, &fn->rx_lock))) + put_req(req, &fn->rx_free, &fn->rx_lock); + + while ((req = get_req(&fn->tx_inproc, &fn->tx_lock))) { + put_req(req, &fn->tx_inproc, &fn->tx_lock); + usb_ep_dequeue(fn->bulk_in, req->request); + } +} + +static int rawbulk_tty_write(struct tty_struct *tty, const unsigned char *buf, + int count) { + int ret; + int submitted = 0; + struct usb_request_wrapper *req; + struct rawbulk_function *fn = tty->driver_data; + + if (check_enable_state(fn)) + return -EBUSY; + + /* Get new request(s) that freed, fill it, queue it to the endpoint */ + while ((req = get_req(&fn->tx_free, &fn->tx_lock))) { + int length = count - submitted; + if (length <= 0) { + put_req(req, &fn->tx_free, &fn->tx_lock); + break; + } + if (length > MAX_TTY_TX_PACKAGE) + length = MAX_TTY_TX_PACKAGE; + memcpy(req->buffer, buf + submitted, length); + req->request->length = length; + put_req(req, &fn->tx_inproc, &fn->tx_lock); + ret = usb_ep_queue(fn->bulk_in, req->request, GFP_ATOMIC); + if (ret < 0) { + move_req(req, &fn->tx_free, &fn->tx_lock); + return ret; + } + submitted += length; + } + + return submitted; +} + +static int rawbulk_tty_write_room(struct tty_struct *tty) { + int room = 0; + unsigned long flags; + struct usb_request_wrapper *req; + struct rawbulk_function *fn = tty->driver_data; + + if (check_enable_state(fn)) + return 0; + + spin_lock_irqsave(&fn->tx_lock, flags); + list_for_each_entry(req, &fn->tx_free, list) + room += req->length; + spin_unlock_irqrestore(&fn->tx_lock, flags); + + return room; +} + +static int rawbulk_tty_chars_in_buffer(struct tty_struct *tty) { + int chars = 0; + unsigned long flags; + struct usb_request_wrapper *req; + struct rawbulk_function *fn = tty->driver_data; + + if (check_enable_state(fn)) + return 0; + + spin_lock_irqsave(&fn->rx_lock, flags); + list_for_each_entry(req, &fn->rx_throttled, list) { + if (req->request->status < 0) + continue; + chars += req->request->actual; + } + chars -= fn->last_pushed; + spin_unlock_irqrestore(&fn->rx_lock, flags); + + return chars; +} + +static void rawbulk_tty_throttle(struct tty_struct *tty) { + struct usb_request_wrapper *req; + struct rawbulk_function *fn = tty->driver_data; + + /* Stop the processing requests */ + while ((req = get_req(&fn->rx_inproc, &fn->rx_lock))) { + if (req->request->status == -EINPROGRESS) { + put_req(req, &fn->rx_inproc, &fn->rx_lock); + usb_ep_dequeue(fn->bulk_out, req->request); + } + } +} + +static void rawbulk_tty_unthrottle(struct tty_struct *tty) { + int ret; + struct usb_request_wrapper *req; + struct rawbulk_function *fn = tty->driver_data; + + /* Try to push the throttled requests' data to TTY */ + rawbulk_tty_push_data(fn); + + /* Restart the free requests */ + while ((req = get_req(&fn->rx_free, &fn->rx_lock))) { + put_req(req, &fn->rx_inproc, &fn->rx_lock); + ret = usb_ep_queue(fn->bulk_out, req->request, GFP_ATOMIC); + if (ret < 0) { + move_req(req, &fn->rx_free, &fn->rx_lock); + break; + } + } +} + +static void rawbulk_tty_set_termios(struct tty_struct *tty, struct ktermios + *old) { + //struct rawbulk_function *fn = tty->driver_data; +} + +static int rawbulk_tty_tiocmget(struct tty_struct *tty) { + //struct rawbulk_function *fn = tty->driver_data; + return 0; +} + +static int rawbulk_tty_tiocmset(struct tty_struct *tty, unsigned int set, + unsigned int clear) { + //struct rawbulk_function *fn = tty->driver_data; + return 0; +} + +static int rawbulk_tty_install(struct tty_driver *driver, struct tty_struct + *tty) { + int ret = 0; + struct rawbulk_function *fn = lookup_by_tty_minor(tty->index); + + if (!fn) + return -ENODEV; + + ret = tty_init_termios(tty); + if (ret < 0) + return ret; + + tty->driver_data = fn; + fn->tty = tty; + + /* Final install (we use the default method) */ + tty_driver_kref_get(driver); + tty->count++; + driver->ttys[tty->index] = tty; + return ret; +} + +static void rawbulk_tty_cleanup(struct tty_struct *tty) { + struct rawbulk_function *fn = lookup_by_tty_minor(tty->index); + tty->driver_data = NULL; + if (fn) + fn->tty = NULL; +} + +static int rawbulk_tty_open(struct tty_struct *tty, struct file *flip) { + int ret; + struct rawbulk_function *fn = lookup_by_tty_minor(tty->index); + + if (!fn) + return -ENODEV; + + tty->driver_data = fn; + fn->tty = tty; + + if (check_enable_state(fn)) + return -EBUSY; + + if (check_tty_opened(fn)) + return -EBUSY; + + set_tty_opened(fn, 1); + + ret = tty_port_open(&fn->port, tty, flip); + if (ret < 0) + return ret; + return 0; +} + +static void rawbulk_tty_hangup(struct tty_struct *tty) { + struct rawbulk_function *fn = tty->driver_data; + if (!fn) + return; + tty_port_hangup(&fn->port); +} + +static void rawbulk_tty_close(struct tty_struct *tty, struct file *flip) { + struct rawbulk_function *fn = tty->driver_data; + if (!fn) + return; + set_tty_opened(fn, 0); + tty_port_close(&fn->port, tty, flip); +} + +static __init int rawbulk_tty_init(void) { + int ret; + struct tty_driver *drv = alloc_tty_driver(_MAX_TID); + if (!drv) + return -ENOMEM; + + drv->owner = THIS_MODULE; + drv->driver_name = "rawbulkport"; + drv->name = "ttyRB";//prefix + drv->type = TTY_DRIVER_TYPE_SERIAL; + drv->subtype = SERIAL_TYPE_NORMAL; + drv->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; + drv->init_termios = tty_std_termios; + drv->init_termios.c_cflag = + B9600 | CS8 | CREAD | HUPCL | CLOCAL; + drv->init_termios.c_lflag = 0; + drv->init_termios.c_ispeed = 9600; + drv->init_termios.c_ospeed = 9600; + + tty_set_operations(drv, &rawbulk_tty_ops); + + ret = tty_register_driver(drv); + if (ret < 0) { + put_tty_driver(drv); + } else + rawbulk_tty_driver = drv; + return ret; +} + +/******************************************************************************/ +static struct class *rawbulk_class; + +static struct _function_init_stuff { + const char *longname; + const char *shortname; + const char *iString; + unsigned int ep_maxpkg; + unsigned int nups; + unsigned int ndowns; + unsigned int upsz; + unsigned int downsz; + unsigned int splitsz; + bool autoreconn; + bool pushable; +} _init_params[] = { + {"rawbulk-modem", "data", "Modem Port", 64, 16, 16, PAGE_SIZE, PAGE_SIZE, PAGE_SIZE, true, false }, + {"rawbulk-ets", "ets", "ETS Port", 512, 4, 1, PAGE_SIZE, PAGE_SIZE, PAGE_SIZE, true, false }, + {"rawbulk-at", "atc", "AT Channel", 64, 1, 1, PAGE_SIZE, PAGE_SIZE, PAGE_SIZE, true, false }, + {"rawbulk-pcv", "pcv", "PCM Voice", 64, 1, 1, PAGE_SIZE, PAGE_SIZE, PAGE_SIZE, true, false }, + {"rawbulk-gps", "gps", "LBS GPS Port", 64, 1, 1, PAGE_SIZE, PAGE_SIZE, PAGE_SIZE, true, false }, + { }, /* End of configurations */ +}; + +static __init struct rawbulk_function *rawbulk_alloc_function(int transfer_id) { + int rc; + struct rawbulk_function *fn; + struct _function_init_stuff *_init = &_init_params[transfer_id]; + + if (transfer_id == _MAX_TID) + return NULL; + + fn = kzalloc(sizeof *fn, GFP_KERNEL); + if (IS_ERR(fn)) + return NULL; + + /* init default features of rawbulk functions */ + fn->longname = _init->longname; + fn->shortname = _init->shortname; + fn->string_defs[0].s = _init->iString; + fn->nups = _init->nups; + fn->ndowns = _init->ndowns; + fn->upsz = _init->upsz; + fn->downsz = _init->downsz; + fn->splitsz = _init->splitsz; + fn->autoreconn = _init->autoreconn; + fn->pushable = _init->pushable; + + fn->tty_minor = -1; + /* init descriptors */ + init_interface_desc(&fn->interface); + init_endpoint_desc(&fn->fs_bulkin_endpoint, 1, _init->ep_maxpkg); + init_endpoint_desc(&fn->hs_bulkin_endpoint, 1, _init->ep_maxpkg); + init_endpoint_desc(&fn->fs_bulkout_endpoint, 0, _init->ep_maxpkg); + init_endpoint_desc(&fn->hs_bulkout_endpoint, 0, _init->ep_maxpkg); + + 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; + + /* init function callbacks */ + fn->function.strings = fn->strings; + fn->function.descriptors = fn->fs_descs; + fn->function.hs_descriptors = fn->hs_descs; + + /* init device attributes */ + add_device_attr(fn, ATTR_ENABLE, "enable", 0755); +#ifdef SUPPORT_LEGACY_CONTROL + add_device_attr(fn, ATTR_ENABLE_C, fn->shortname, 0755); +#endif + add_device_attr(fn, ATTR_AUTORECONN, "autoreconn", 0755); + add_device_attr(fn, ATTR_STATISTICS, "statistics", 0644); + add_device_attr(fn, ATTR_NUPS, "nups", 0755); + add_device_attr(fn, ATTR_NDOWNS, "ndowns", 0755); + add_device_attr(fn, ATTR_UPSIZE, "ups_size", 0755); + add_device_attr(fn, ATTR_DOWNSIZE, "downs_size", 0755); + add_device_attr(fn, ATTR_SPLIT, "split_size", 0755); + add_device_attr(fn, ATTR_PUSHABLE, "pushable", 0755); + + fn->max_attrs = ATTR_PUSHABLE + 1; + + if (transfer_id == RAWBULK_TID_MODEM) { + // printk(" kevin chagnge dtr for 200 for cts, disable usb est bypass \n"); + add_device_attr(fn, ATTR_DTR, "dtr", 0200); + 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); + wake_lock_init(&fn->keep_awake, WAKE_LOCK_SUSPEND, fn->longname); + return fn; +} + +static void rawbulk_destory_function(struct rawbulk_function *fn) { + if (!fn) + return; + wake_lock_destroy(&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; + + printk(KERN_INFO "rawbulk functions init.\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_destory_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) + printk(KERN_ERR "failed to create legacy bypass sys-stuff, but continue...\n"); + } +#endif /* SUPPORT_LEGACY_CONTROL */ + + rc = rawbulk_tty_init(); + if (rc < 0) { + printk(KERN_ERR "failed to init rawbulk tty driver.\n"); + return rc; + } + + for (n = 0; n < _MAX_TID; n ++) { + struct rawbulk_function *fn = prealloced_functions[n]; + rc = rawbulk_register_tty(fn); + if (rc < 0) { + printk(KERN_ERR "fatal error: we cannot create ttyRB%d for %s\n", + n, fn->longname); + return rc; + } + } + + return 0; +} + +module_init(init); + +MODULE_AUTHOR(DRIVER_AUTHOR); +MODULE_DESCRIPTION(DRIVER_DESC); +MODULE_VERSION(DRIVER_VERSION); +MODULE_LICENSE("GPL"); + |