diff options
Diffstat (limited to 'drivers/staging')
24 files changed, 1501 insertions, 2529 deletions
diff --git a/drivers/staging/Kconfig b/drivers/staging/Kconfig index 7e0e5e4317a8..05e33c700750 100644 --- a/drivers/staging/Kconfig +++ b/drivers/staging/Kconfig @@ -66,8 +66,6 @@ source "drivers/staging/octeon/Kconfig" source "drivers/staging/serqt_usb2/Kconfig" -source "drivers/staging/quatech_usb2/Kconfig" - source "drivers/staging/vt6655/Kconfig" source "drivers/staging/vt6656/Kconfig" @@ -128,6 +126,8 @@ source "drivers/staging/ramster/Kconfig" source "drivers/staging/ozwpan/Kconfig" +source "drivers/staging/ccg/Kconfig" + source "drivers/staging/ipack/Kconfig" source "drivers/staging/gdm72xx/Kconfig" diff --git a/drivers/staging/Makefile b/drivers/staging/Makefile index 30901057bd1a..a987b3ad380b 100644 --- a/drivers/staging/Makefile +++ b/drivers/staging/Makefile @@ -25,7 +25,6 @@ obj-$(CONFIG_TRANZPORT) += frontier/ obj-$(CONFIG_IDE_PHISON) += phison/ obj-$(CONFIG_LINE6_USB) += line6/ obj-$(CONFIG_USB_SERIAL_QUATECH2) += serqt_usb2/ -obj-$(CONFIG_USB_SERIAL_QUATECH_USB2) += quatech_usb2/ obj-$(CONFIG_OCTEON_ETHERNET) += octeon/ obj-$(CONFIG_VT6655) += vt6655/ obj-$(CONFIG_VT6656) += vt6656/ @@ -57,4 +56,5 @@ obj-$(CONFIG_ANDROID) += android/ obj-$(CONFIG_PHONE) += telephony/ obj-$(CONFIG_RAMSTER) += ramster/ obj-$(CONFIG_USB_WPAN_HCD) += ozwpan/ +obj-$(CONFIG_USB_G_CCG) += ccg/ obj-$(CONFIG_WIMAX_GDM72XX) += gdm72xx/ diff --git a/drivers/staging/android/Kconfig b/drivers/staging/android/Kconfig index 63f98223760b..0e16b594460f 100644 --- a/drivers/staging/android/Kconfig +++ b/drivers/staging/android/Kconfig @@ -45,8 +45,6 @@ config ANDROID_LOW_MEMORY_KILLER ---help--- Register processes to be killed when memory is low -source "drivers/staging/android/switch/Kconfig" - config ANDROID_INTF_ALARM_DEV bool "Android alarm driver" depends on RTC_CLASS diff --git a/drivers/staging/android/Makefile b/drivers/staging/android/Makefile index 4677e7b0e07a..98711e2b2afa 100644 --- a/drivers/staging/android/Makefile +++ b/drivers/staging/android/Makefile @@ -5,5 +5,4 @@ obj-$(CONFIG_ANDROID_RAM_CONSOLE) += ram_console.o obj-$(CONFIG_ANDROID_TIMED_OUTPUT) += timed_output.o obj-$(CONFIG_ANDROID_TIMED_GPIO) += timed_gpio.o obj-$(CONFIG_ANDROID_LOW_MEMORY_KILLER) += lowmemorykiller.o -obj-$(CONFIG_ANDROID_SWITCH) += switch/ obj-$(CONFIG_ANDROID_INTF_ALARM_DEV) += alarm-dev.o diff --git a/drivers/staging/android/switch/Kconfig b/drivers/staging/android/switch/Kconfig deleted file mode 100644 index 36846f62f4bc..000000000000 --- a/drivers/staging/android/switch/Kconfig +++ /dev/null @@ -1,11 +0,0 @@ -menuconfig ANDROID_SWITCH - tristate "Android Switch class support" - help - Say Y here to enable Android switch class support. This allows - monitoring switches by userspace via sysfs and uevent. - -config ANDROID_SWITCH_GPIO - tristate "Android GPIO Switch support" - depends on GENERIC_GPIO && ANDROID_SWITCH - help - Say Y here to enable GPIO based switch support. diff --git a/drivers/staging/android/switch/Makefile b/drivers/staging/android/switch/Makefile deleted file mode 100644 index d76bfdcedfaf..000000000000 --- a/drivers/staging/android/switch/Makefile +++ /dev/null @@ -1,4 +0,0 @@ -# Android Switch Class Driver -obj-$(CONFIG_ANDROID_SWITCH) += switch_class.o -obj-$(CONFIG_ANDROID_SWITCH_GPIO) += switch_gpio.o - diff --git a/drivers/staging/android/switch/switch.h b/drivers/staging/android/switch/switch.h deleted file mode 100644 index 4fcb3109875a..000000000000 --- a/drivers/staging/android/switch/switch.h +++ /dev/null @@ -1,53 +0,0 @@ -/* - * Switch class driver - * - * Copyright (C) 2008 Google, Inc. - * Author: Mike Lockwood <lockwood@android.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. - * -*/ - -#ifndef __LINUX_SWITCH_H__ -#define __LINUX_SWITCH_H__ - -struct switch_dev { - const char *name; - struct device *dev; - int index; - int state; - - ssize_t (*print_name)(struct switch_dev *sdev, char *buf); - ssize_t (*print_state)(struct switch_dev *sdev, char *buf); -}; - -struct gpio_switch_platform_data { - const char *name; - unsigned gpio; - - /* if NULL, switch_dev.name will be printed */ - const char *name_on; - const char *name_off; - /* if NULL, "0" or "1" will be printed */ - const char *state_on; - const char *state_off; -}; - -extern int switch_dev_register(struct switch_dev *sdev); -extern void switch_dev_unregister(struct switch_dev *sdev); - -static inline int switch_get_state(struct switch_dev *sdev) -{ - return sdev->state; -} - -extern void switch_set_state(struct switch_dev *sdev, int state); - -#endif /* __LINUX_SWITCH_H__ */ diff --git a/drivers/staging/android/switch/switch_class.c b/drivers/staging/android/switch/switch_class.c deleted file mode 100644 index 74680446fc66..000000000000 --- a/drivers/staging/android/switch/switch_class.c +++ /dev/null @@ -1,174 +0,0 @@ -/* - * switch_class.c - * - * Copyright (C) 2008 Google, Inc. - * Author: Mike Lockwood <lockwood@android.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. - * -*/ - -#include <linux/module.h> -#include <linux/types.h> -#include <linux/init.h> -#include <linux/device.h> -#include <linux/fs.h> -#include <linux/err.h> -#include "switch.h" - -struct class *switch_class; -static atomic_t device_count; - -static ssize_t state_show(struct device *dev, struct device_attribute *attr, - char *buf) -{ - struct switch_dev *sdev = (struct switch_dev *) - dev_get_drvdata(dev); - - if (sdev->print_state) { - int ret = sdev->print_state(sdev, buf); - if (ret >= 0) - return ret; - } - return sprintf(buf, "%d\n", sdev->state); -} - -static ssize_t name_show(struct device *dev, struct device_attribute *attr, - char *buf) -{ - struct switch_dev *sdev = (struct switch_dev *) - dev_get_drvdata(dev); - - if (sdev->print_name) { - int ret = sdev->print_name(sdev, buf); - if (ret >= 0) - return ret; - } - return sprintf(buf, "%s\n", sdev->name); -} - -static DEVICE_ATTR(state, S_IRUGO | S_IWUSR, state_show, NULL); -static DEVICE_ATTR(name, S_IRUGO | S_IWUSR, name_show, NULL); - -void switch_set_state(struct switch_dev *sdev, int state) -{ - char name_buf[120]; - char state_buf[120]; - char *prop_buf; - char *envp[3]; - int env_offset = 0; - int length; - - if (sdev->state != state) { - sdev->state = state; - - prop_buf = (char *)get_zeroed_page(GFP_KERNEL); - if (prop_buf) { - length = name_show(sdev->dev, NULL, prop_buf); - if (length > 0) { - if (prop_buf[length - 1] == '\n') - prop_buf[length - 1] = 0; - snprintf(name_buf, sizeof(name_buf), - "SWITCH_NAME=%s", prop_buf); - envp[env_offset++] = name_buf; - } - length = state_show(sdev->dev, NULL, prop_buf); - if (length > 0) { - if (prop_buf[length - 1] == '\n') - prop_buf[length - 1] = 0; - snprintf(state_buf, sizeof(state_buf), - "SWITCH_STATE=%s", prop_buf); - envp[env_offset++] = state_buf; - } - envp[env_offset] = NULL; - kobject_uevent_env(&sdev->dev->kobj, KOBJ_CHANGE, envp); - free_page((unsigned long)prop_buf); - } else { - printk(KERN_ERR "out of memory in switch_set_state\n"); - kobject_uevent(&sdev->dev->kobj, KOBJ_CHANGE); - } - } -} -EXPORT_SYMBOL_GPL(switch_set_state); - -static int create_switch_class(void) -{ - if (!switch_class) { - switch_class = class_create(THIS_MODULE, "switch"); - if (IS_ERR(switch_class)) - return PTR_ERR(switch_class); - atomic_set(&device_count, 0); - } - - return 0; -} - -int switch_dev_register(struct switch_dev *sdev) -{ - int ret; - - if (!switch_class) { - ret = create_switch_class(); - if (ret < 0) - return ret; - } - - sdev->index = atomic_inc_return(&device_count); - sdev->dev = device_create(switch_class, NULL, - MKDEV(0, sdev->index), NULL, sdev->name); - if (IS_ERR(sdev->dev)) - return PTR_ERR(sdev->dev); - - ret = device_create_file(sdev->dev, &dev_attr_state); - if (ret < 0) - goto err_create_file_1; - ret = device_create_file(sdev->dev, &dev_attr_name); - if (ret < 0) - goto err_create_file_2; - - dev_set_drvdata(sdev->dev, sdev); - sdev->state = 0; - return 0; - -err_create_file_2: - device_remove_file(sdev->dev, &dev_attr_state); -err_create_file_1: - device_destroy(switch_class, MKDEV(0, sdev->index)); - printk(KERN_ERR "switch: Failed to register driver %s\n", sdev->name); - - return ret; -} -EXPORT_SYMBOL_GPL(switch_dev_register); - -void switch_dev_unregister(struct switch_dev *sdev) -{ - device_remove_file(sdev->dev, &dev_attr_name); - device_remove_file(sdev->dev, &dev_attr_state); - device_destroy(switch_class, MKDEV(0, sdev->index)); - dev_set_drvdata(sdev->dev, NULL); -} -EXPORT_SYMBOL_GPL(switch_dev_unregister); - -static int __init switch_class_init(void) -{ - return create_switch_class(); -} - -static void __exit switch_class_exit(void) -{ - class_destroy(switch_class); -} - -module_init(switch_class_init); -module_exit(switch_class_exit); - -MODULE_AUTHOR("Mike Lockwood <lockwood@android.com>"); -MODULE_DESCRIPTION("Switch class driver"); -MODULE_LICENSE("GPL"); diff --git a/drivers/staging/android/switch/switch_gpio.c b/drivers/staging/android/switch/switch_gpio.c deleted file mode 100644 index 38b2c2f6004e..000000000000 --- a/drivers/staging/android/switch/switch_gpio.c +++ /dev/null @@ -1,172 +0,0 @@ -/* - * switch_gpio.c - * - * Copyright (C) 2008 Google, Inc. - * Author: Mike Lockwood <lockwood@android.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. - * -*/ - -#include <linux/module.h> -#include <linux/kernel.h> -#include <linux/init.h> -#include <linux/interrupt.h> -#include <linux/platform_device.h> -#include <linux/slab.h> -#include <linux/workqueue.h> -#include <linux/gpio.h> -#include "switch.h" - -struct gpio_switch_data { - struct switch_dev sdev; - unsigned gpio; - const char *name_on; - const char *name_off; - const char *state_on; - const char *state_off; - int irq; - struct work_struct work; -}; - -static void gpio_switch_work(struct work_struct *work) -{ - int state; - struct gpio_switch_data *data = - container_of(work, struct gpio_switch_data, work); - - state = gpio_get_value(data->gpio); - switch_set_state(&data->sdev, state); -} - -static irqreturn_t gpio_irq_handler(int irq, void *dev_id) -{ - struct gpio_switch_data *switch_data = - (struct gpio_switch_data *)dev_id; - - schedule_work(&switch_data->work); - return IRQ_HANDLED; -} - -static ssize_t switch_gpio_print_state(struct switch_dev *sdev, char *buf) -{ - struct gpio_switch_data *switch_data = - container_of(sdev, struct gpio_switch_data, sdev); - const char *state; - if (switch_get_state(sdev)) - state = switch_data->state_on; - else - state = switch_data->state_off; - - if (state) - return sprintf(buf, "%s\n", state); - return -1; -} - -static int gpio_switch_probe(struct platform_device *pdev) -{ - struct gpio_switch_platform_data *pdata = pdev->dev.platform_data; - struct gpio_switch_data *switch_data; - int ret = 0; - - if (!pdata) - return -EBUSY; - - switch_data = kzalloc(sizeof(struct gpio_switch_data), GFP_KERNEL); - if (!switch_data) - return -ENOMEM; - - switch_data->sdev.name = pdata->name; - switch_data->gpio = pdata->gpio; - switch_data->name_on = pdata->name_on; - switch_data->name_off = pdata->name_off; - switch_data->state_on = pdata->state_on; - switch_data->state_off = pdata->state_off; - switch_data->sdev.print_state = switch_gpio_print_state; - - ret = switch_dev_register(&switch_data->sdev); - if (ret < 0) - goto err_switch_dev_register; - - ret = gpio_request(switch_data->gpio, pdev->name); - if (ret < 0) - goto err_request_gpio; - - ret = gpio_direction_input(switch_data->gpio); - if (ret < 0) - goto err_set_gpio_input; - - INIT_WORK(&switch_data->work, gpio_switch_work); - - switch_data->irq = gpio_to_irq(switch_data->gpio); - if (switch_data->irq < 0) { - ret = switch_data->irq; - goto err_detect_irq_num_failed; - } - - ret = request_irq(switch_data->irq, gpio_irq_handler, - IRQF_TRIGGER_LOW, pdev->name, switch_data); - if (ret < 0) - goto err_request_irq; - - /* Perform initial detection */ - gpio_switch_work(&switch_data->work); - - return 0; - -err_request_irq: -err_detect_irq_num_failed: -err_set_gpio_input: - gpio_free(switch_data->gpio); -err_request_gpio: - switch_dev_unregister(&switch_data->sdev); -err_switch_dev_register: - kfree(switch_data); - - return ret; -} - -static int __devexit gpio_switch_remove(struct platform_device *pdev) -{ - struct gpio_switch_data *switch_data = platform_get_drvdata(pdev); - - cancel_work_sync(&switch_data->work); - gpio_free(switch_data->gpio); - switch_dev_unregister(&switch_data->sdev); - kfree(switch_data); - - return 0; -} - -static struct platform_driver gpio_switch_driver = { - .probe = gpio_switch_probe, - .remove = __devexit_p(gpio_switch_remove), - .driver = { - .name = "switch-gpio", - .owner = THIS_MODULE, - }, -}; - -static int __init gpio_switch_init(void) -{ - return platform_driver_register(&gpio_switch_driver); -} - -static void __exit gpio_switch_exit(void) -{ - platform_driver_unregister(&gpio_switch_driver); -} - -module_init(gpio_switch_init); -module_exit(gpio_switch_exit); - -MODULE_AUTHOR("Mike Lockwood <lockwood@android.com>"); -MODULE_DESCRIPTION("GPIO Switch driver"); -MODULE_LICENSE("GPL"); diff --git a/drivers/staging/ccg/Kconfig b/drivers/staging/ccg/Kconfig new file mode 100644 index 000000000000..ff05e52392bf --- /dev/null +++ b/drivers/staging/ccg/Kconfig @@ -0,0 +1,20 @@ +if USB_GADGET + +config USB_G_CCG + tristate "Configurable Composite Gadget (STAGING)" + depends on STAGING && !USB_ZERO && !USB_ZERO_HNPTEST && !USB_AUDIO && !GADGET_UAC1 && !USB_ETH && !USB_ETH_RNDIS && !USB_ETH_EEM && !USB_G_NCM && !USB_GADGETFS && !USB_FUNCTIONFS && !USB_FUNCTIONFS_ETH && !USB_FUNCTIONFS_RNDIS && !USB_FUNCTIONFS_GENERIC && !USB_FILE_STORAGE && !USB_FILE_STORAGE_TEST && !USB_MASS_STORAGE && !USB_G_SERIAL && !USB_MIDI_GADGET && !USB_G_PRINTER && !USB_CDC_COMPOSITE && !USB_G_NOKIA && !USB_G_ACM_MS && !USB_G_MULTI && !USB_G_MULTI_RNDIS && !USB_G_MULTI_CDC && !USB_G_HID && !USB_G_DBGP && !USB_G_WEBCAM + help + The Configurable Composite Gadget supports multiple USB + functions: acm, mass storage, rndis and FunctionFS. + Each function can be configured and enabled/disabled + dynamically from userspace through a sysfs interface. + + In order to compile this (either as a module or built-in), + "USB Gadget Drivers" and anything under it must not be + selected compiled-in in + Device Drivers->USB Support->USB Gadget Support. + However, you can say "M" there, if you do, the + Configurable Composite Gadget can be compiled "M" only + or not at all. + +endif # USB_GADGET diff --git a/drivers/staging/ccg/Makefile b/drivers/staging/ccg/Makefile new file mode 100644 index 000000000000..693da637a6d8 --- /dev/null +++ b/drivers/staging/ccg/Makefile @@ -0,0 +1,4 @@ +g_ccg-y := ccg.o +ccflags-y += -Idrivers/usb/gadget + +obj-$(CONFIG_USB_G_CCG) += g_ccg.o diff --git a/drivers/staging/ccg/TODO b/drivers/staging/ccg/TODO new file mode 100644 index 000000000000..18612fe70171 --- /dev/null +++ b/drivers/staging/ccg/TODO @@ -0,0 +1,6 @@ +TODO: + - change configuration interface from sysfs to configfs + +Please send patches to Greg Kroah-Hartmann <gregkh@linuxfoundation.org>, +Andrzej Pietrasiewicz <andrzej.p@samsung.com>, and +Cc: Mike Lockwood <lockwood@android.com> diff --git a/drivers/staging/ccg/ccg.c b/drivers/staging/ccg/ccg.c new file mode 100644 index 000000000000..a5b36a97598d --- /dev/null +++ b/drivers/staging/ccg/ccg.c @@ -0,0 +1,1299 @@ +/* + * Configurable Composite Gadget + * + * Initially contributed as "Android Composite Gdaget" by: + * + * Copyright (C) 2008 Google, Inc. + * Author: Mike Lockwood <lockwood@android.com> + * Benoit Goby <benoit@android.com> + * + * Tailoring it to become a generic Configurable Composite Gadget is + * + * Copyright (C) 2012 Samsung Electronics + * Author: Andrzej Pietrasiewicz <andrzej.p@samsung.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. + * + */ + +#include <linux/init.h> +#include <linux/module.h> +#include <linux/fs.h> +#include <linux/delay.h> +#include <linux/kernel.h> +#include <linux/utsname.h> +#include <linux/platform_device.h> + +#include <linux/usb/ch9.h> +#include <linux/usb/composite.h> +#include <linux/usb/gadget.h> + +#include "gadget_chips.h" + +/* + * Kbuild is not very cooperative with respect to linking separately + * compiled library objects into one module. So for now we won't use + * separate compilation ... ensuring init/exit sections work to shrink + * the runtime footprint, and giving us at least some parts of what + * a "gcc --combine ... part1.c part2.c part3.c ... " build would. + */ +#include "../../usb/gadget/usbstring.c" +#include "../../usb/gadget/config.c" +#include "../../usb/gadget/epautoconf.c" +#include "../../usb/gadget/composite.c" + +#include "../../usb/gadget/f_mass_storage.c" +#include "../../usb/gadget/u_serial.c" +#include "../../usb/gadget/f_acm.c" +#define USB_ETH_RNDIS y +#include "../../usb/gadget/f_rndis.c" +#include "../../usb/gadget/rndis.c" +#include "../../usb/gadget/u_ether.c" +#include "../../usb/gadget/f_fs.c" + +MODULE_AUTHOR("Mike Lockwood, Andrzej Pietrasiewicz"); +MODULE_DESCRIPTION("Configurable Composite USB Gadget"); +MODULE_LICENSE("GPL"); +MODULE_VERSION("1.0"); + +static const char longname[] = "Configurable Composite Gadget"; + +/* Default vendor and product IDs, overridden by userspace */ +#define VENDOR_ID 0x1d6b /* Linux Foundation */ +#define PRODUCT_ID 0x0107 +#define GFS_MAX_DEVS 10 + +struct ccg_usb_function { + char *name; + void *config; + + struct device *dev; + char *dev_name; + struct device_attribute **attributes; + + /* for ccg_dev.enabled_functions */ + struct list_head enabled_list; + + /* Optional: initialization during gadget bind */ + int (*init)(struct ccg_usb_function *, struct usb_composite_dev *); + /* Optional: cleanup during gadget unbind */ + void (*cleanup)(struct ccg_usb_function *); + + int (*bind_config)(struct ccg_usb_function *, + struct usb_configuration *); + + /* Optional: called when the configuration is removed */ + void (*unbind_config)(struct ccg_usb_function *, + struct usb_configuration *); + /* Optional: handle ctrl requests before the device is configured */ + int (*ctrlrequest)(struct ccg_usb_function *, + struct usb_composite_dev *, + const struct usb_ctrlrequest *); +}; + +struct ffs_obj { + const char *name; + bool mounted; + bool desc_ready; + bool used; + struct ffs_data *ffs_data; +}; + +struct ccg_dev { + struct ccg_usb_function **functions; + struct list_head enabled_functions; + struct usb_composite_dev *cdev; + struct device *dev; + + bool enabled; + struct mutex mutex; + bool connected; + bool sw_connected; + struct work_struct work; + + unsigned int max_func_num; + unsigned int func_num; + struct ffs_obj ffs_tab[GFS_MAX_DEVS]; +}; + +static struct class *ccg_class; +static struct ccg_dev *_ccg_dev; +static int ccg_bind_config(struct usb_configuration *c); +static void ccg_unbind_config(struct usb_configuration *c); + +static char func_names_buf[256]; + +static struct usb_device_descriptor device_desc = { + .bLength = sizeof(device_desc), + .bDescriptorType = USB_DT_DEVICE, + .bcdUSB = __constant_cpu_to_le16(0x0200), + .bDeviceClass = USB_CLASS_PER_INTERFACE, + .idVendor = __constant_cpu_to_le16(VENDOR_ID), + .idProduct = __constant_cpu_to_le16(PRODUCT_ID), + .bcdDevice = __constant_cpu_to_le16(0xffff), + .bNumConfigurations = 1, +}; + +static struct usb_configuration ccg_config_driver = { + .label = "ccg", + .unbind = ccg_unbind_config, + .bConfigurationValue = 1, + .bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER, + .bMaxPower = 0xFA, /* 500ma */ +}; + +static void ccg_work(struct work_struct *data) +{ + struct ccg_dev *dev = container_of(data, struct ccg_dev, work); + struct usb_composite_dev *cdev = dev->cdev; + static char *disconnected[2] = { "USB_STATE=DISCONNECTED", NULL }; + static char *connected[2] = { "USB_STATE=CONNECTED", NULL }; + static char *configured[2] = { "USB_STATE=CONFIGURED", NULL }; + char **uevent_envp = NULL; + unsigned long flags; + + spin_lock_irqsave(&cdev->lock, flags); + if (cdev->config) + uevent_envp = configured; + else if (dev->connected != dev->sw_connected) + uevent_envp = dev->connected ? connected : disconnected; + dev->sw_connected = dev->connected; + spin_unlock_irqrestore(&cdev->lock, flags); + + if (uevent_envp) { + kobject_uevent_env(&dev->dev->kobj, KOBJ_CHANGE, uevent_envp); + pr_info("%s: sent uevent %s\n", __func__, uevent_envp[0]); + } else { + pr_info("%s: did not send uevent (%d %d %p)\n", __func__, + dev->connected, dev->sw_connected, cdev->config); + } +} + + +/*-------------------------------------------------------------------------*/ +/* Supported functions initialization */ + +static struct ffs_obj *functionfs_find_dev(struct ccg_dev *dev, + const char *dev_name) +{ + int i; + + for (i = 0; i < dev->max_func_num; i++) + if (strcmp(dev->ffs_tab[i].name, dev_name) == 0) + return &dev->ffs_tab[i]; + + return NULL; +} + +static bool functionfs_all_ready(struct ccg_dev *dev) +{ + int i; + + for (i = 0; i < dev->max_func_num; i++) + if (dev->ffs_tab[i].used && !dev->ffs_tab[i].desc_ready) + return false; + + return true; +} + +static int functionfs_ready_callback(struct ffs_data *ffs) +{ + struct ffs_obj *ffs_obj; + int ret; + + mutex_lock(&_ccg_dev->mutex); + + ffs_obj = ffs->private_data; + if (!ffs_obj) { + ret = -EINVAL; + goto done; + } + if (WARN_ON(ffs_obj->desc_ready)) { + ret = -EBUSY; + goto done; + } + ffs_obj->ffs_data = ffs; + + if (functionfs_all_ready(_ccg_dev)) { + ret = -EBUSY; + goto done; + } + ffs_obj->desc_ready = true; + +done: + mutex_unlock(&_ccg_dev->mutex); + return ret; +} + +static void reset_usb(struct ccg_dev *dev) +{ + /* Cancel pending control requests */ + usb_ep_dequeue(dev->cdev->gadget->ep0, dev->cdev->req); + usb_remove_config(dev->cdev, &ccg_config_driver); + dev->enabled = false; + usb_gadget_disconnect(dev->cdev->gadget); +} + +static void functionfs_closed_callback(struct ffs_data *ffs) +{ + struct ffs_obj *ffs_obj; + + mutex_lock(&_ccg_dev->mutex); + + ffs_obj = ffs->private_data; + if (!ffs_obj) + goto done; + + ffs_obj->desc_ready = false; + + if (_ccg_dev->enabled) + reset_usb(_ccg_dev); + +done: + mutex_unlock(&_ccg_dev->mutex); +} + +static void *functionfs_acquire_dev_callback(const char *dev_name) +{ + struct ffs_obj *ffs_dev; + + mutex_lock(&_ccg_dev->mutex); + + ffs_dev = functionfs_find_dev(_ccg_dev, dev_name); + if (!ffs_dev) { + ffs_dev = ERR_PTR(-ENODEV); + goto done; + } + + if (ffs_dev->mounted) { + ffs_dev = ERR_PTR(-EBUSY); + goto done; + } + ffs_dev->mounted = true; + +done: + mutex_unlock(&_ccg_dev->mutex); + return ffs_dev; +} + +static void functionfs_release_dev_callback(struct ffs_data *ffs_data) +{ + struct ffs_obj *ffs_dev; + + mutex_lock(&_ccg_dev->mutex); + + ffs_dev = ffs_data->private_data; + if (ffs_dev) + ffs_dev->mounted = false; + + mutex_unlock(&_ccg_dev->mutex); +} + +static int functionfs_function_init(struct ccg_usb_function *f, + struct usb_composite_dev *cdev) +{ + return functionfs_init(); +} + +static void functionfs_function_cleanup(struct ccg_usb_function *f) +{ + functionfs_cleanup(); +} + +static int functionfs_function_bind_config(struct ccg_usb_function *f, + struct usb_configuration *c) +{ + struct ccg_dev *dev = _ccg_dev; + int i, ret; + + for (i = dev->max_func_num; i--; ) { + if (!dev->ffs_tab[i].used) + continue; + ret = functionfs_bind(dev->ffs_tab[i].ffs_data, c->cdev); + if (unlikely(ret < 0)) { + while (++i < dev->max_func_num) + functionfs_unbind(dev->ffs_tab[i].ffs_data); + return ret; + } + } + + for (i = dev->max_func_num; i--; ) { + if (!dev->ffs_tab[i].used) + continue; + ret = functionfs_bind_config(c->cdev, c, + dev->ffs_tab[i].ffs_data); + if (unlikely(ret < 0)) + return ret; + } + + return 0; +} + +static void functionfs_function_unbind_config(struct ccg_usb_function *f, + struct usb_configuration *c) +{ + struct ccg_dev *dev = _ccg_dev; + int i; + + for (i = dev->max_func_num; i--; ) + if (dev->ffs_tab[i].ffs_data) + functionfs_unbind(dev->ffs_tab[i].ffs_data); +} + +static ssize_t functionfs_user_functions_show(struct device *_dev, + struct device_attribute *attr, + char *buf) +{ + struct ccg_dev *dev = _ccg_dev; + char *buff = buf; + int i; + + mutex_lock(&dev->mutex); + + for (i = 0; i < dev->max_func_num; i++) + buff += snprintf(buff, PAGE_SIZE + buf - buff, "%s,", + dev->ffs_tab[i].name); + + mutex_unlock(&dev->mutex); + + if (buff != buf) + *(buff - 1) = '\n'; + return buff - buf; +} + +static ssize_t functionfs_user_functions_store(struct device *_dev, + struct device_attribute *attr, + const char *buff, size_t size) +{ + struct ccg_dev *dev = _ccg_dev; + char *name, *b; + ssize_t ret = size; + int i; + + buff = skip_spaces(buff); + if (!*buff) + return -EINVAL; + + mutex_lock(&dev->mutex); + + if (dev->enabled) { + ret = -EBUSY; + goto end; + } + + for (i = 0; i < dev->max_func_num; i++) + if (dev->ffs_tab[i].mounted) { + ret = -EBUSY; + goto end; + } + + strlcpy(func_names_buf, buff, sizeof(func_names_buf)); + b = strim(func_names_buf); + + /* replace the list of functions */ + dev->max_func_num = 0; + while (b) { + name = strsep(&b, ","); + if (dev->max_func_num == GFS_MAX_DEVS) { + ret = -ENOSPC; + goto end; + } + if (functionfs_find_dev(dev, name)) { + ret = -EEXIST; + continue; + } + dev->ffs_tab[dev->max_func_num++].name = name; + } + +end: + mutex_unlock(&dev->mutex); + return ret; +} + +static DEVICE_ATTR(user_functions, S_IRUGO | S_IWUSR, + functionfs_user_functions_show, + functionfs_user_functions_store); + +static ssize_t functionfs_max_user_functions_show(struct device *_dev, + struct device_attribute *attr, + char *buf) +{ + return sprintf(buf, "%d", GFS_MAX_DEVS); +} + +static DEVICE_ATTR(max_user_functions, S_IRUGO, + functionfs_max_user_functions_show, NULL); + +static struct device_attribute *functionfs_function_attributes[] = { + &dev_attr_user_functions, + &dev_attr_max_user_functions, + NULL +}; + +static struct ccg_usb_function functionfs_function = { + .name = "fs", + .init = functionfs_function_init, + .cleanup = functionfs_function_cleanup, + .bind_config = functionfs_function_bind_config, + .unbind_config = functionfs_function_unbind_config, + .attributes = functionfs_function_attributes, +}; + +#define MAX_ACM_INSTANCES 4 +struct acm_function_config { + int instances; +}; + +static int +acm_function_init(struct ccg_usb_function *f, struct usb_composite_dev *cdev) +{ + f->config = kzalloc(sizeof(struct acm_function_config), GFP_KERNEL); + if (!f->config) + return -ENOMEM; + + return gserial_setup(cdev->gadget, MAX_ACM_INSTANCES); +} + +static void acm_function_cleanup(struct ccg_usb_function *f) +{ + gserial_cleanup(); + kfree(f->config); + f->config = NULL; +} + +static int +acm_function_bind_config(struct ccg_usb_function *f, + struct usb_configuration *c) +{ + int i; + int ret = 0; + struct acm_function_config *config = f->config; + + for (i = 0; i < config->instances; i++) { + ret = acm_bind_config(c, i); + if (ret) { + pr_err("Could not bind acm%u config\n", i); + break; + } + } + + return ret; +} + +static ssize_t acm_instances_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct ccg_usb_function *f = dev_get_drvdata(dev); + struct acm_function_config *config = f->config; + return sprintf(buf, "%d\n", config->instances); +} + +static ssize_t acm_instances_store(struct device *dev, + struct device_attribute *attr, const char *buf, size_t size) +{ + struct ccg_usb_function *f = dev_get_drvdata(dev); + struct acm_function_config *config = f->config; + int value; + int ret = 0; + + ret = kstrtoint(buf, 10, &value); + if (ret) + return ret; + + if (value > MAX_ACM_INSTANCES) + return -EINVAL; + + config->instances = value; + + return size; +} + +static DEVICE_ATTR(instances, S_IRUGO | S_IWUSR, acm_instances_show, + acm_instances_store); +static struct device_attribute *acm_function_attributes[] = { + &dev_attr_instances, + NULL +}; + +static struct ccg_usb_function acm_function = { + .name = "acm", + .init = acm_function_init, + .cleanup = acm_function_cleanup, + .bind_config = acm_function_bind_config, + .attributes = acm_function_attributes, +}; + +struct rndis_function_config { + u8 ethaddr[ETH_ALEN]; + u32 vendorID; + char manufacturer[256]; + /* "Wireless" RNDIS; auto-detected by Windows */ + bool wceis; +}; + +static int rndis_function_init(struct ccg_usb_function *f, + struct usb_composite_dev *cdev) +{ + f->config = kzalloc(sizeof(struct rndis_function_config), GFP_KERNEL); + if (!f->config) + return -ENOMEM; + return 0; +} + +static void rndis_function_cleanup(struct ccg_usb_function *f) +{ + kfree(f->config); + f->config = NULL; +} + +static int rndis_function_bind_config(struct ccg_usb_function *f, + struct usb_configuration *c) +{ + int ret; + struct rndis_function_config *rndis = f->config; + + if (!rndis) { + pr_err("%s: rndis_pdata\n", __func__); + return -1; + } + + pr_info("%s MAC: %02X:%02X:%02X:%02X:%02X:%02X\n", __func__, + rndis->ethaddr[0], rndis->ethaddr[1], rndis->ethaddr[2], + rndis->ethaddr[3], rndis->ethaddr[4], rndis->ethaddr[5]); + + ret = gether_setup_name(c->cdev->gadget, rndis->ethaddr, "rndis"); + if (ret) { + pr_err("%s: gether_setup failed\n", __func__); + return ret; + } + + if (rndis->wceis) { + /* "Wireless" RNDIS; auto-detected by Windows */ + rndis_iad_descriptor.bFunctionClass = + USB_CLASS_WIRELESS_CONTROLLER; + rndis_iad_descriptor.bFunctionSubClass = 0x01; + rndis_iad_descriptor.bFunctionProtocol = 0x03; + rndis_control_intf.bInterfaceClass = + USB_CLASS_WIRELESS_CONTROLLER; + rndis_control_intf.bInterfaceSubClass = 0x01; + rndis_control_intf.bInterfaceProtocol = 0x03; + } + + return rndis_bind_config_vendor(c, rndis->ethaddr, rndis->vendorID, + rndis->manufacturer); +} + +static void rndis_function_unbind_config(struct ccg_usb_function *f, + struct usb_configuration *c) +{ + gether_cleanup(); +} + +static ssize_t rndis_manufacturer_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct ccg_usb_function *f = dev_get_drvdata(dev); + struct rndis_function_config *config = f->config; + return sprintf(buf, "%s\n", config->manufacturer); +} + +static ssize_t rndis_manufacturer_store(struct device *dev, + struct device_attribute *attr, const char *buf, size_t size) +{ + struct ccg_usb_function *f = dev_get_drvdata(dev); + struct rndis_function_config *config = f->config; + + if (size >= sizeof(config->manufacturer)) + return -EINVAL; + memcpy(config->manufacturer, buf, size); + config->manufacturer[size] = 0; + + return size; +} + +static DEVICE_ATTR(manufacturer, S_IRUGO | S_IWUSR, rndis_manufacturer_show, + rndis_manufacturer_store); + +static ssize_t rndis_wceis_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct ccg_usb_function *f = dev_get_drvdata(dev); + struct rndis_function_config *config = f->config; + return sprintf(buf, "%d\n", config->wceis); +} + +static ssize_t rndis_wceis_store(struct device *dev, + struct device_attribute *attr, const char *buf, size_t size) +{ + struct ccg_usb_function *f = dev_get_drvdata(dev); + struct rndis_function_config *config = f->config; + int value; + int ret; + + ret = kstrtoint(buf, 10, &value); + if (ret) + return ret; + + config->wceis = value; + + return size; +} + +static DEVICE_ATTR(wceis, S_IRUGO | S_IWUSR, rndis_wceis_show, + rndis_wceis_store); + +static ssize_t rndis_ethaddr_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct ccg_usb_function *f = dev_get_drvdata(dev); + struct rndis_function_config *rndis = f->config; + return sprintf(buf, "%02x:%02x:%02x:%02x:%02x:%02x\n", + rndis->ethaddr[0], rndis->ethaddr[1], rndis->ethaddr[2], + rndis->ethaddr[3], rndis->ethaddr[4], rndis->ethaddr[5]); +} + +static ssize_t rndis_ethaddr_store(struct device *dev, + struct device_attribute *attr, const char *buf, size_t size) +{ + struct ccg_usb_function *f = dev_get_drvdata(dev); + struct rndis_function_config *rndis = f->config; + unsigned char tmp[6]; + + if (sscanf(buf, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", + tmp + 0, tmp + 1, tmp + 2, tmp + 3, tmp + 4, tmp + 5) != + ETH_ALEN) + return -EINVAL; + + memcpy(rndis->ethaddr, tmp, ETH_ALEN); + + return ETH_ALEN; + +} + +static DEVICE_ATTR(ethaddr, S_IRUGO | S_IWUSR, rndis_ethaddr_show, + rndis_ethaddr_store); + +static ssize_t rndis_vendorID_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct ccg_usb_function *f = dev_get_drvdata(dev); + struct rndis_function_config *config = f->config; + return sprintf(buf, "%04x\n", config->vendorID); +} + +static ssize_t rndis_vendorID_store(struct device *dev, + struct device_attribute *attr, const char *buf, size_t size) +{ + struct ccg_usb_function *f = dev_get_drvdata(dev); + struct rndis_function_config *config = f->config; + int value; + int ret; + + ret = kstrtou32(buf, 16, &value); + if (ret) + return ret; + + config->vendorID = value; + + return size; +} + +static DEVICE_ATTR(vendorID, S_IRUGO | S_IWUSR, rndis_vendorID_show, + rndis_vendorID_store); + +static struct device_attribute *rndis_function_attributes[] = { + &dev_attr_manufacturer, + &dev_attr_wceis, + &dev_attr_ethaddr, + &dev_attr_vendorID, + NULL +}; + +static struct ccg_usb_function rndis_function = { + .name = "rndis", + .init = rndis_function_init, + .cleanup = rndis_function_cleanup, + .bind_config = rndis_function_bind_config, + .unbind_config = rndis_function_unbind_config, + .attributes = rndis_function_attributes, +}; + +static int mass_storage_function_init(struct ccg_usb_function *f, + struct usb_composite_dev *cdev) +{ + struct fsg_config fsg; + struct fsg_common *common; + int err; + + memset(&fsg, 0, sizeof fsg); + fsg.nluns = 1; + fsg.luns[0].removable = 1; + fsg.vendor_name = iManufacturer; + fsg.product_name = iProduct; + + common = fsg_common_init(NULL, cdev, &fsg); + if (IS_ERR(common)) + return PTR_ERR(common); + + err = sysfs_create_link(&f->dev->kobj, + &common->luns[0].dev.kobj, + "lun"); + if (err) { + fsg_common_put(common); + return err; + } + + f->config = common; + return 0; +} + +static void mass_storage_function_cleanup(struct ccg_usb_function *f) +{ + fsg_common_put(f->config); + f->config = NULL; +} + +static int mass_storage_function_bind_config(struct ccg_usb_function *f, + struct usb_configuration *c) +{ + struct fsg_common *common = f->config; + return fsg_bind_config(c->cdev, c, common); +} + +static struct ccg_usb_function mass_storage_function = { + .name = "mass_storage", + .init = mass_storage_function_init, + .cleanup = mass_storage_function_cleanup, + .bind_config = mass_storage_function_bind_config, +}; + +static struct ccg_usb_function *supported_functions[] = { + &functionfs_function, + &acm_function, + &rndis_function, + &mass_storage_function, + NULL +}; + + +static int ccg_init_functions(struct ccg_usb_function **functions, + struct usb_composite_dev *cdev) +{ + struct ccg_dev *dev = _ccg_dev; + struct ccg_usb_function *f; + struct device_attribute **attrs; + struct device_attribute *attr; + int err; + int index = 0; + + for (; (f = *functions++); index++) { + f->dev_name = kasprintf(GFP_KERNEL, "f_%s", f->name); + if (!f->dev_name) { + pr_err("%s: Failed to alloc name %s", __func__, + f->name); + err = -ENOMEM; + goto err_alloc; + } + f->dev = device_create(ccg_class, dev->dev, + MKDEV(0, index), f, f->dev_name); + if (IS_ERR(f->dev)) { + pr_err("%s: Failed to create dev %s", __func__, + f->dev_name); + err = PTR_ERR(f->dev); + f->dev = NULL; + goto err_create; + } + + if (f->init) { + err = f->init(f, cdev); + if (err) { + pr_err("%s: Failed to init %s", __func__, + f->name); + goto err_out; + } + } + + attrs = f->attributes; + if (attrs) { + while ((attr = *attrs++) && !err) + err = device_create_file(f->dev, attr); + } + if (err) { + pr_err("%s: Failed to create function %s attributes", + __func__, f->name); + goto err_uninit; + } + } + return 0; + +err_uninit: + if (f->cleanup) + f->cleanup(f); +err_out: + device_destroy(ccg_class, f->dev->devt); + f->dev = NULL; +err_create: + kfree(f->dev_name); +err_alloc: + return err; +} + +static void ccg_cleanup_functions(struct ccg_usb_function **functions) +{ + struct ccg_usb_function *f; + + while (*functions) { + f = *functions++; + + if (f->dev) { + if (f->cleanup) + f->cleanup(f); + device_destroy(ccg_class, f->dev->devt); + kfree(f->dev_name); + } + } +} + +static int ccg_bind_enabled_functions(struct ccg_dev *dev, + struct usb_configuration *c) +{ + struct ccg_usb_function *f; + int ret; + + list_for_each_entry(f, &dev->enabled_functions, enabled_list) { + ret = f->bind_config(f, c); + if (ret) { + pr_err("%s: %s failed", __func__, f->name); + return ret; + } + } + return 0; +} + +static void ccg_unbind_enabled_functions(struct ccg_dev *dev, + struct usb_configuration *c) +{ + struct ccg_usb_function *f; + + list_for_each_entry(f, &dev->enabled_functions, enabled_list) + if (f->unbind_config) + f->unbind_config(f, c); +} + +static int ccg_enable_function(struct ccg_dev *dev, char *name) +{ + struct ccg_usb_function **functions = dev->functions; + struct ccg_usb_function *f; + while ((f = *functions++)) { + if (!strcmp(name, f->name)) { + list_add_tail(&f->enabled_list, + &dev->enabled_functions); + return 0; + } + } + return -EINVAL; +} + +/*-------------------------------------------------------------------------*/ +/* /sys/class/ccg_usb/ccg%d/ interface */ + +static ssize_t +functions_show(struct device *pdev, struct device_attribute *attr, char *buf) +{ + struct ccg_dev *dev = dev_get_drvdata(pdev); + struct ccg_usb_function *f; + char *buff = buf; + int i; + + mutex_lock(&dev->mutex); + + list_for_each_entry(f, &dev->enabled_functions, enabled_list) + buff += sprintf(buff, "%s,", f->name); + for (i = 0; i < dev->max_func_num; i++) + if (dev->ffs_tab[i].used) + buff += sprintf(buff, "%s", dev->ffs_tab[i].name); + + mutex_unlock(&dev->mutex); + + if (buff != buf) + *(buff-1) = '\n'; + return buff - buf; +} + +static ssize_t +functions_store(struct device *pdev, struct device_attribute *attr, + const char *buff, size_t size) +{ + struct ccg_dev *dev = dev_get_drvdata(pdev); + char *name; + char buf[256], *b; + int err, i; + bool functionfs_enabled; + + buff = skip_spaces(buff); + if (!*buff) + return -EINVAL; + + mutex_lock(&dev->mutex); + + if (dev->enabled) { + mutex_unlock(&dev->mutex); + return -EBUSY; + } + + INIT_LIST_HEAD(&dev->enabled_functions); + functionfs_enabled = false; + for (i = 0; i < dev->max_func_num; i++) + dev->ffs_tab[i].used = false; + + strlcpy(buf, buff, sizeof(buf)); + b = strim(buf); + + while (b) { + struct ffs_obj *user_func; + + name = strsep(&b, ","); + /* handle FunctionFS implicitly */ + if (!strcmp(name, functionfs_function.name)) { + pr_err("ccg_usb: Cannot explicitly enable '%s'", name); + continue; + } + user_func = functionfs_find_dev(dev, name); + if (user_func) + name = functionfs_function.name; + err = 0; + if (!user_func || !functionfs_enabled) + err = ccg_enable_function(dev, name); + if (err) + pr_err("ccg_usb: Cannot enable '%s'", name); + else if (user_func) { + user_func->used = true; + dev->func_num++; + functionfs_enabled = true; + } + } + + mutex_unlock(&dev->mutex); + + return size; +} + +static ssize_t enable_show(struct device *pdev, struct device_attribute *attr, + char *buf) +{ + struct ccg_dev *dev = dev_get_drvdata(pdev); + return sprintf(buf, "%d\n", dev->enabled); +} + +static ssize_t enable_store(struct device *pdev, struct device_attribute *attr, + const char *buff, size_t size) +{ + struct ccg_dev *dev = dev_get_drvdata(pdev); + struct usb_composite_dev *cdev = dev->cdev; + int enabled = 0; + + mutex_lock(&dev->mutex); + sscanf(buff, "%d", &enabled); + if (enabled && dev->func_num && !functionfs_all_ready(dev)) { + mutex_unlock(&dev->mutex); + return -ENODEV; + } + + if (enabled && !dev->enabled) { + int ret; + + cdev->next_string_id = 0; + /* + * Update values in composite driver's copy of + * device descriptor. + */ + cdev->desc.bDeviceClass = device_desc.bDeviceClass; + cdev->desc.bDeviceSubClass = device_desc.bDeviceSubClass; + cdev->desc.bDeviceProtocol = device_desc.bDeviceProtocol; + cdev->desc.idVendor = idVendor; + cdev->desc.idProduct = idProduct; + cdev->desc.bcdDevice = bcdDevice; + + usb_add_config(cdev, &ccg_config_driver, ccg_bind_config); + dev->enabled = true; + ret = usb_gadget_connect(cdev->gadget); + if (ret) { + dev->enabled = false; + usb_remove_config(cdev, &ccg_config_driver); + } + } else if (!enabled && dev->enabled) { + reset_usb(dev); + } else { + pr_err("ccg_usb: already %s\n", + dev->enabled ? "enabled" : "disabled"); + } + + mutex_unlock(&dev->mutex); + return size; +} + +static ssize_t state_show(struct device *pdev, struct device_attribute *attr, + char *buf) +{ + struct ccg_dev *dev = dev_get_drvdata(pdev); + struct usb_composite_dev *cdev = dev->cdev; + char *state = "DISCONNECTED"; + unsigned long flags; + + if (!cdev) + goto out; + + spin_lock_irqsave(&cdev->lock, flags); + if (cdev->config) + state = "CONFIGURED"; + else if (dev->connected) + state = "CONNECTED"; + spin_unlock_irqrestore(&cdev->lock, flags); +out: + return sprintf(buf, "%s\n", state); +} + +#define DESCRIPTOR_ATTR(field, format_string) \ +static ssize_t \ +field ## _show(struct device *dev, struct device_attribute *attr, \ + char *buf) \ +{ \ + return sprintf(buf, format_string, device_desc.field); \ +} \ +static ssize_t \ +field ## _store(struct device *dev, struct device_attribute *attr, \ + const char *buf, size_t size) \ +{ \ + int value; \ + if (sscanf(buf, format_string, &value) == 1) { \ + device_desc.field = value; \ + return size; \ + } \ + return -1; \ +} \ +static DEVICE_ATTR(field, S_IRUGO | S_IWUSR, field ## _show, field ## _store); + +DESCRIPTOR_ATTR(bDeviceClass, "%d\n") +DESCRIPTOR_ATTR(bDeviceSubClass, "%d\n") +DESCRIPTOR_ATTR(bDeviceProtocol, "%d\n") + +static DEVICE_ATTR(functions, S_IRUGO | S_IWUSR, functions_show, + functions_store); +static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR, enable_show, enable_store); +static DEVICE_ATTR(state, S_IRUGO, state_show, NULL); + +static struct device_attribute *ccg_usb_attributes[] = { + &dev_attr_bDeviceClass, + &dev_attr_bDeviceSubClass, + &dev_attr_bDeviceProtocol, + &dev_attr_functions, + &dev_attr_enable, + &dev_attr_state, + NULL +}; + +/*-------------------------------------------------------------------------*/ +/* Composite driver */ + +static int ccg_bind_config(struct usb_configuration *c) +{ + struct ccg_dev *dev = _ccg_dev; + int ret = 0; + + ret = ccg_bind_enabled_functions(dev, c); + if (ret) + return ret; + + return 0; +} + +static void ccg_unbind_config(struct usb_configuration *c) +{ + struct ccg_dev *dev = _ccg_dev; + + ccg_unbind_enabled_functions(dev, c); + + usb_ep_autoconfig_reset(dev->cdev->gadget); +} + +static int ccg_bind(struct usb_composite_dev *cdev) +{ + struct ccg_dev *dev = _ccg_dev; + struct usb_gadget *gadget = cdev->gadget; + int gcnum, ret; + + /* + * Start disconnected. Userspace will connect the gadget once + * it is done configuring the functions. + */ + usb_gadget_disconnect(gadget); + + ret = ccg_init_functions(dev->functions, cdev); + if (ret) + return ret; + + gcnum = usb_gadget_controller_number(gadget); + if (gcnum >= 0) + device_desc.bcdDevice = cpu_to_le16(0x0200 + gcnum); + else { + pr_warning("%s: controller '%s' not recognized\n", + longname, gadget->name); + device_desc.bcdDevice = __constant_cpu_to_le16(0x9999); + } + + usb_gadget_set_selfpowered(gadget); + dev->cdev = cdev; + + return 0; +} + +static int ccg_usb_unbind(struct usb_composite_dev *cdev) +{ + struct ccg_dev *dev = _ccg_dev; + + cancel_work_sync(&dev->work); + ccg_cleanup_functions(dev->functions); + return 0; +} + +static struct usb_composite_driver ccg_usb_driver = { + .name = "configurable_usb", + .dev = &device_desc, + .unbind = ccg_usb_unbind, + .needs_serial = true, + .iManufacturer = "Linux Foundation", + .iProduct = longname, + .iSerialNumber = "1234567890123456", +}; + +static int ccg_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *c) +{ + struct ccg_dev *dev = _ccg_dev; + struct usb_composite_dev *cdev = get_gadget_data(gadget); + struct usb_request *req = cdev->req; + struct ccg_usb_function *f; + int value = -EOPNOTSUPP; + unsigned long flags; + + req->zero = 0; + req->complete = composite_setup_complete; + req->length = 0; + gadget->ep0->driver_data = cdev; + + list_for_each_entry(f, &dev->enabled_functions, enabled_list) { + if (f->ctrlrequest) { + value = f->ctrlrequest(f, cdev, c); + if (value >= 0) + break; + } + } + + if (value < 0) + value = composite_setup(gadget, c); + + spin_lock_irqsave(&cdev->lock, flags); + if (!dev->connected) { + dev->connected = 1; + schedule_work(&dev->work); + } else if (c->bRequest == USB_REQ_SET_CONFIGURATION && + cdev->config) { + schedule_work(&dev->work); + } + spin_unlock_irqrestore(&cdev->lock, flags); + + return value; +} + +static void ccg_disconnect(struct usb_gadget *gadget) +{ + struct ccg_dev *dev = _ccg_dev; + struct usb_composite_dev *cdev = get_gadget_data(gadget); + unsigned long flags; + + composite_disconnect(gadget); + + spin_lock_irqsave(&cdev->lock, flags); + dev->connected = 0; + schedule_work(&dev->work); + spin_unlock_irqrestore(&cdev->lock, flags); +} + +static int ccg_create_device(struct ccg_dev *dev) +{ + struct device_attribute **attrs = ccg_usb_attributes; + struct device_attribute *attr; + int err; + + dev->dev = device_create(ccg_class, NULL, MKDEV(0, 0), NULL, "ccg0"); + if (IS_ERR(dev->dev)) + return PTR_ERR(dev->dev); + + dev_set_drvdata(dev->dev, dev); + + while ((attr = *attrs++)) { + err = device_create_file(dev->dev, attr); + if (err) { + device_destroy(ccg_class, dev->dev->devt); + return err; + } + } + return 0; +} + + +static int __init init(void) +{ + struct ccg_dev *dev; + int err; + + ccg_class = class_create(THIS_MODULE, "ccg_usb"); + if (IS_ERR(ccg_class)) + return PTR_ERR(ccg_class); + + dev = kzalloc(sizeof(*dev), GFP_KERNEL); + if (!dev) + return -ENOMEM; + + dev->functions = supported_functions; + INIT_LIST_HEAD(&dev->enabled_functions); + INIT_WORK(&dev->work, ccg_work); + mutex_init(&dev->mutex); + + err = ccg_create_device(dev); + if (err) { + class_destroy(ccg_class); + kfree(dev); + return err; + } + + _ccg_dev = dev; + + /* Override composite driver functions */ + composite_driver.setup = ccg_setup; + composite_driver.disconnect = ccg_disconnect; + + err = usb_composite_probe(&ccg_usb_driver, ccg_bind); + if (err) { + class_destroy(ccg_class); + kfree(dev); + } + + return err; +} +module_init(init); + +static void __exit cleanup(void) +{ + usb_composite_unregister(&ccg_usb_driver); + class_destroy(ccg_class); + kfree(_ccg_dev); + _ccg_dev = NULL; +} +module_exit(cleanup); diff --git a/drivers/staging/ccg/sysfs-class-ccg_usb b/drivers/staging/ccg/sysfs-class-ccg_usb new file mode 100644 index 000000000000..dd12a332fb00 --- /dev/null +++ b/drivers/staging/ccg/sysfs-class-ccg_usb @@ -0,0 +1,158 @@ +What: /sys/class/ccg_usb +Date: May 2012 +KernelVersion: 3.4 +Contact: linux-usb@vger.kernel.org +Description: + The ccg_usb/ class subdirectory belongs to ccg + USB gadget. + +What: /sys/class/ccg_usb/ccgX +Date: May 2012 +KernelVersion: 3.4 +Contact: linux-usb@vger.kernel.org +Description: + The /sys/class/ccg_usb/ccg{0,1,2,3...} class + subdirectories correspond to each ccg gadget device; + at the time of this writing there is only ccg0 and it + represents the ccg gadget. + +What: /sys/class/ccg_usb/ccgX/functions +Date: May 2012 +KernelVersion: 3.4 +Contact: linux-usb@vger.kernel.org +Description: + A comma-separated list of USB function names to be activated + in this ccg gadget. It includes both the functions provided + in-kernel by the ccg gadget and the functions provided from + userspace through FunctionFS. + +What: /sys/class/ccg_usb/ccgX/enable +Date: May 2012 +KernelVersion: 3.4 +Contact: linux-usb@vger.kernel.org +Description: + A flag activating/deactivating the ccg usb gadget. + +What: /sys/class/ccg_usb/ccgX/state +Date: May 2012 +KernelVersion: 3.4 +Contact: linux-usb@vger.kernel.org +Description: + Configurable usb gadget state: + + DISCONNECTED + CONNECTED + CONFIGURED + +What: /sys/class/ccg_usb/ccgX/f_acm/ +Date: May 2012 +KernelVersion: 3.4 +Contact: linux-usb@vger.kernel.org +Description: + The /sys/class/ccg_usb/ccgX/f_acm subdirectory + corresponds to the gadget's USB CDC serial (ACM) function + driver. + +What: /sys/class/ccg_usb/ccgX/f_acm/instances +Date: May 2012 +KernelVersion: 3.4 +Contact: linux-usb@vger.kernel.org +Description: + Maximum number of the /dev/ttyGS<X> interface the driver uses. + +What: /sys/class/ccg_usb/ccgX/f_fs +Date: May 2012 +KernelVersion: 3.4 +Contact: linux-usb@vger.kernel.org +Description: + The /sys/class/ccg_usb/ccgX/f_fs subdirectory + corresponds to the gadget's FunctionFS driver. + +What: /sys/class/ccg_usb/ccgX/f_fs/user_functions +Date: May 2012 +KernelVersion: 3.4 +Contact: linux-usb@vger.kernel.org +Description: + A comma-separeted list of USB function names to be supported + from userspace. No other userspace FunctionFS functions can + be supported than listed here. However, the actual activation + of these functions is still done through + /sys/class/ccg_usb/ccgX/functions, where it is possible + to specify any subset (including maximum and empty) of + /sys/class/ccg_usb/ccgX/f_fs/user_functions. + +What: /sys/class/ccg_usb/ccgX/f_fs/max_user_functions +Date: May 2012 +KernelVersion: 3.4 +Contact: linux-usb@vger.kernel.org +Description: + Maximum number of USB functions to be supported from userspace. + +What: /sys/class/ccg_usb/ccgX/f_rndis +Date: May 2012 +KernelVersion: 3.4 +Contact: linux-usb@vger.kernel.org +Description: + The /sys/class/ccg_usb/ccgX/f_rndis subdirectory + corresponds to the gadget's RNDIS driver. + +What: /sys/class/ccg_usb/ccgX/f_rndis/manufacturer +Date: May 2012 +KernelVersion: 3.4 +Contact: linux-usb@vger.kernel.org +Description: + RNDIS Ethernet port manufacturer string. + +What: /sys/class/ccg_usb/ccgX/f_rndis/wceis +Date: May 2012 +KernelVersion: 3.4 +Contact: linux-usb@vger.kernel.org +Description: + RNDIS Ethernet port wireless flag. + +What: /sys/class/ccg_usb/ccgX/f_rndis/ethaddr +Date: May 2012 +KernelVersion: 3.4 +Contact: linux-usb@vger.kernel.org +Description: + RNDIS Ethernet port Ethernet address. + +What: /sys/class/ccg_usb/ccgX/f_rndis/vendorID +Date: May 2012 +KernelVersion: 3.4 +Contact: linux-usb@vger.kernel.org +Description: + RNDIS Ethernet port vendor ID. + +What: /sys/class/ccg_usb/ccgX/f_mass_storage +Date: May 2012 +KernelVersion: 3.4 +Contact: linux-usb@vger.kernel.org +Description: + The /sys/class/ccg_usb/ccgX/f_mass_storage subdirectory + corresponds to the gadget's USB mass storage driver. + +What: /sys/class/ccg_usb/ccgX/f_mass_storage/lun +Date: May 2012 +KernelVersion: 3.4 +Contact: linux-usb@vger.kernel.org +Description: + The /sys/class/ccg_usb/ccgX/f_mass_storage/lun + subdirectory corresponds to the gadget's USB mass storage + driver and its underlying storage. + +What: /sys/class/ccg_usb/ccgX/f_mass_storage/lun +Date: May 2012 +KernelVersion: 3.4 +Contact: linux-usb@vger.kernel.org +Description: + The /sys/class/ccg_usb/ccgX/f_mass_storage/lun + subdirectory corresponds to the gadget's USB mass storage + driver and its underlying storage. + +What: /sys/class/ccg_usb/ccgX/f_mass_storage/lun/file +Date: May 2012 +KernelVersion: 3.4 +Contact: linux-usb@vger.kernel.org +Description: + Gadget's USB mass storage underlying file. diff --git a/drivers/staging/media/as102/as102_drv.c b/drivers/staging/media/as102/as102_drv.c index ea4f992de235..ac92eaf6c74b 100644 --- a/drivers/staging/media/as102/as102_drv.c +++ b/drivers/staging/media/as102/as102_drv.c @@ -279,40 +279,8 @@ void as102_dvb_unregister(struct as102_dev_t *as102_dev) pr_info("Unregistered device %s", as102_dev->name); } -static int __init as102_driver_init(void) -{ - int ret; - - /* register this driver with the low level subsystem */ - ret = usb_register(&as102_usb_driver); - if (ret) - err("usb_register failed (ret = %d)", ret); - - return ret; -} - -/* - * Mandatory function : Adds a special section to the module indicating - * where initialisation function is defined - */ -module_init(as102_driver_init); - -/** - * as102_driver_exit - as102 driver exit point - * - * This function is called when device has to be removed. - */ -static void __exit as102_driver_exit(void) -{ - /* deregister this driver with the low level bus subsystem */ - usb_deregister(&as102_usb_driver); -} +module_usb_driver(as102_usb_driver); -/* - * required function for unload: Adds a special section to the module - * indicating where unload function is defined - */ -module_exit(as102_driver_exit); /* modinfo details */ MODULE_DESCRIPTION(DRIVER_FULL_NAME); MODULE_LICENSE("GPL"); diff --git a/drivers/staging/media/as102/as102_usb_drv.c b/drivers/staging/media/as102/as102_usb_drv.c index 36150e5c62de..aaf1bc2ad1b2 100644 --- a/drivers/staging/media/as102/as102_usb_drv.c +++ b/drivers/staging/media/as102/as102_usb_drv.c @@ -375,7 +375,7 @@ static int as102_usb_probe(struct usb_interface *intf, as102_dev = kzalloc(sizeof(struct as102_dev_t), GFP_KERNEL); if (as102_dev == NULL) { - err("%s: kzalloc failed", __func__); + dev_err(&intf->dev, "%s: kzalloc failed\n", __func__); return -ENOMEM; } @@ -410,8 +410,9 @@ static int as102_usb_probe(struct usb_interface *intf, ret = usb_register_dev(intf, &as102_usb_class_driver); if (ret < 0) { /* something prevented us from registering this driver */ - err("%s: usb_register_dev() failed (errno = %d)", - __func__, ret); + dev_err(&intf->dev, + "%s: usb_register_dev() failed (errno = %d)\n", + __func__, ret); goto failed; } diff --git a/drivers/staging/media/go7007/go7007.txt b/drivers/staging/media/go7007/go7007.txt index 9db1f3952fd2..fcb3e235abbf 100644 --- a/drivers/staging/media/go7007/go7007.txt +++ b/drivers/staging/media/go7007/go7007.txt @@ -87,7 +87,6 @@ kernel as built-in or modules: CONFIG_SOUND - Sound card support CONFIG_SND - Advanced Linux Sound Architecture CONFIG_USB - Support for Host-side USB - CONFIG_USB_DEVICEFS - USB device filesystem CONFIG_USB_EHCI_HCD - EHCI HCD (USB 2.0) support Additionally, to use the example application, the following options need to diff --git a/drivers/staging/octeon/ethernet-tx.c b/drivers/staging/octeon/ethernet-tx.c index 2d4fcea892f7..5631dd9f8201 100644 --- a/drivers/staging/octeon/ethernet-tx.c +++ b/drivers/staging/octeon/ethernet-tx.c @@ -345,7 +345,7 @@ int cvm_oct_xmit(struct sk_buff *skb, struct net_device *dev) } if (unlikely (skb->truesize != - sizeof(*skb) + skb_end_pointer(skb) - skb->head)) { + sizeof(*skb) + skb_end_offset(skb))) { /* printk("TX buffer truesize has been changed\n"); */ diff --git a/drivers/staging/quatech_usb2/Kconfig b/drivers/staging/quatech_usb2/Kconfig deleted file mode 100644 index 1494f42f3da0..000000000000 --- a/drivers/staging/quatech_usb2/Kconfig +++ /dev/null @@ -1,15 +0,0 @@ -config USB_SERIAL_QUATECH_USB2 - tristate "USB Quatech xSU2-[14]00 USB Serial Driver" - depends on USB_SERIAL - help - Say Y here if you want to use a Quatech USB2.0 to serial adaptor. This - driver supports the SSU2-100, DSU2-100, DSU2-400, QSU2-100, QSU2-400, - ESU2-400 and ESU2-100 USB2.0 to RS232 / 485 / 422 serial adaptors. - - Some hardware has an incorrect product string and announces itself as - ESU-100 (which uses the serqt driver) even though it is an ESU2-100. - Check the label on the bottom of your device. - - To compile this driver as a module, choose M here: the module will be - called quatech_usb2 . - diff --git a/drivers/staging/quatech_usb2/Makefile b/drivers/staging/quatech_usb2/Makefile deleted file mode 100644 index bcd1f890d163..000000000000 --- a/drivers/staging/quatech_usb2/Makefile +++ /dev/null @@ -1 +0,0 @@ -obj-$(CONFIG_USB_SERIAL_QUATECH_USB2) += quatech_usb2.o diff --git a/drivers/staging/quatech_usb2/TODO b/drivers/staging/quatech_usb2/TODO deleted file mode 100644 index 67f61dbe14ac..000000000000 --- a/drivers/staging/quatech_usb2/TODO +++ /dev/null @@ -1,8 +0,0 @@ -Incomplete list of things that this driver does not yet implement completely or -at all. some of these may not be possible to implement because the hardware -support does not exist. Others may be possible, but the magic control codes to -make them happen are unknown, and some may just need the driver support to -implement them writing. - -* Mark/Space parity is not implemented (reported back correctly) -* IXANY flow control mode is not implemented (flag ignored completely) diff --git a/drivers/staging/quatech_usb2/quatech_usb2.c b/drivers/staging/quatech_usb2/quatech_usb2.c deleted file mode 100644 index 801b50d3bc31..000000000000 --- a/drivers/staging/quatech_usb2/quatech_usb2.c +++ /dev/null @@ -1,1976 +0,0 @@ -/* - * Driver for Quatech Inc USB2.0 to serial adaptors. Largely unrelated to the - * serqt_usb driver, based on a re-write of the vendor supplied serqt_usb2 code, - * which is unrelated to the serqt_usb2 in the staging kernel - */ - -#include <linux/errno.h> -#include <linux/init.h> -#include <linux/slab.h> -#include <linux/tty.h> -#include <linux/tty_driver.h> -#include <linux/tty_flip.h> -#include <linux/module.h> -#include <linux/serial.h> -#include <linux/usb.h> -#include <linux/usb/serial.h> -#include <linux/uaccess.h> - -static bool debug; - -/* Version Information */ -#define DRIVER_VERSION "v2.00" -#define DRIVER_AUTHOR "Tim Gobeli, Quatech, Inc" -#define DRIVER_DESC "Quatech USB 2.0 to Serial Driver" - -/* vendor and device IDs */ -#define USB_VENDOR_ID_QUATECH 0x061d /* Quatech VID */ -#define QUATECH_SSU2_100 0xC120 /* RS232 single port */ -#define QUATECH_DSU2_100 0xC140 /* RS232 dual port */ -#define QUATECH_DSU2_400 0xC150 /* RS232/422/485 dual port */ -#define QUATECH_QSU2_100 0xC160 /* RS232 four port */ -#define QUATECH_QSU2_400 0xC170 /* RS232/422/485 four port */ -#define QUATECH_ESU2_100 0xC1A0 /* RS232 eight port */ -#define QUATECH_ESU2_400 0xC180 /* RS232/422/485 eight port */ - -/* magic numbers go here, when we find out which ones are needed */ - -#define QU2BOXPWRON 0x8000 /* magic number to turn FPGA power on */ -#define QU2BOX232 0x40 /* RS232 mode on MEI devices */ -#define QU2BOXSPD9600 0x60 /* set speed to 9600 baud */ -#define QT2_FIFO_DEPTH 1024 /* size of hardware fifos */ -#define QT2_TX_HEADER_LENGTH 5 -/* length of the header sent to the box with each write URB */ - -/* directions for USB transfers */ -#define USBD_TRANSFER_DIRECTION_IN 0xc0 -#define USBD_TRANSFER_DIRECTION_OUT 0x40 - -/* special Quatech command IDs. These are pushed down the - USB control pipe to get the box on the end to do things */ -#define QT_SET_GET_DEVICE 0xc2 -#define QT_OPEN_CLOSE_CHANNEL 0xca -/*#define QT_GET_SET_PREBUF_TRIG_LVL 0xcc -#define QT_SET_ATF 0xcd*/ -#define QT2_GET_SET_REGISTER 0xc0 -#define QT2_GET_SET_UART 0xc1 -#define QT2_HW_FLOW_CONTROL_MASK 0xc5 -#define QT2_SW_FLOW_CONTROL_MASK 0xc6 -#define QT2_SW_FLOW_CONTROL_DISABLE 0xc7 -#define QT2_BREAK_CONTROL 0xc8 -#define QT2_STOP_RECEIVE 0xe0 -#define QT2_FLUSH_DEVICE 0xc4 -#define QT2_GET_SET_QMCR 0xe1 - -/* sorts of flush we can do on */ -#define QT2_FLUSH_RX 0x00 -#define QT2_FLUSH_TX 0x01 - -/* port setting constants, used to set up serial port speeds, flow - * control and so on */ -#define QT2_SERIAL_MCR_DTR 0x01 -#define QT2_SERIAL_MCR_RTS 0x02 -#define QT2_SERIAL_MCR_LOOP 0x10 - -#define QT2_SERIAL_MSR_CTS 0x10 -#define QT2_SERIAL_MSR_CD 0x80 -#define QT2_SERIAL_MSR_RI 0x40 -#define QT2_SERIAL_MSR_DSR 0x20 -#define QT2_SERIAL_MSR_MASK 0xf0 - -#define QT2_SERIAL_8_DATA 0x03 -#define QT2_SERIAL_7_DATA 0x02 -#define QT2_SERIAL_6_DATA 0x01 -#define QT2_SERIAL_5_DATA 0x00 - -#define QT2_SERIAL_ODD_PARITY 0x08 -#define QT2_SERIAL_EVEN_PARITY 0x18 -#define QT2_SERIAL_TWO_STOPB 0x04 -#define QT2_SERIAL_ONE_STOPB 0x00 - -#define QT2_MAX_BAUD_RATE 921600 -#define QT2_MAX_BAUD_REMAINDER 4608 - -#define QT2_SERIAL_LSR_OE 0x02 -#define QT2_SERIAL_LSR_PE 0x04 -#define QT2_SERIAL_LSR_FE 0x08 -#define QT2_SERIAL_LSR_BI 0x10 - -/* value of Line Status Register when UART has completed - * emptying data out on the line */ -#define QT2_LSR_TEMT 0x40 - -/* register numbers on each UART, for use with qt2_box_[get|set]_register*/ -#define QT2_XMT_HOLD_REGISTER 0x00 -#define QT2_XVR_BUFFER_REGISTER 0x00 -#define QT2_FIFO_CONTROL_REGISTER 0x02 -#define QT2_LINE_CONTROL_REGISTER 0x03 -#define QT2_MODEM_CONTROL_REGISTER 0x04 -#define QT2_LINE_STATUS_REGISTER 0x05 -#define QT2_MODEM_STATUS_REGISTER 0x06 - -/* handy macros for doing escape sequence parsing on data reads */ -#define THISCHAR ((unsigned char *)(urb->transfer_buffer))[i] -#define NEXTCHAR ((unsigned char *)(urb->transfer_buffer))[i + 1] -#define THIRDCHAR ((unsigned char *)(urb->transfer_buffer))[i + 2] -#define FOURTHCHAR ((unsigned char *)(urb->transfer_buffer))[i + 3] -#define FIFTHCHAR ((unsigned char *)(urb->transfer_buffer))[i + 4] - -static const struct usb_device_id quausb2_id_table[] = { - {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_SSU2_100)}, - {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU2_100)}, - {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU2_400)}, - {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU2_100)}, - {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU2_400)}, - {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU2_100)}, - {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU2_400)}, - {} /* Terminating entry */ -}; - -MODULE_DEVICE_TABLE(usb, quausb2_id_table); - -/* custom structures we need go here */ -static struct usb_driver quausb2_usb_driver = { - .name = "quatech-usb2-serial", - .probe = usb_serial_probe, - .disconnect = usb_serial_disconnect, - .id_table = quausb2_id_table, -}; - -/** - * quatech2_port: Structure in which to keep all the messy stuff that this - * driver needs alongside the usb_serial_port structure - * @read_urb_busy: Flag indicating that port->read_urb is in use - * @close_pending: flag indicating that this port is in the process of - * being closed (and so no new reads / writes should be started). - * @shadowLSR: Last received state of the line status register, holds the - * value of the line status flags from the port - * @shadowMSR: Last received state of the modem status register, holds - * the value of the modem status received from the port - * @rcv_flush: Flag indicating that a receive flush has occurred on - * the hardware. - * @xmit_flush: Flag indicating that a transmit flush has been processed by - * the hardware. - * @tx_pending_bytes: Number of bytes waiting to be sent. This total - * includes the size (excluding header) of URBs that have been submitted but - * have not yet been sent to to the device, and bytes that have been sent out - * of the port but not yet reported sent by the "xmit_empty" messages (which - * indicate the number of bytes sent each time they are received, despite the - * misleading name). - * - Starts at zero when port is initialised. - * - is incremented by the size of the data to be written (no headers) - * each time a write urb is dispatched. - * - is decremented each time a "transmit empty" message is received - * by the driver in the data stream. - * @lock: Mutex to lock access to this structure when we need to ensure that - * races don't occur to access bits of it. - * @open_count: The number of uses of the port currently having - * it open, i.e. the reference count. - */ -struct quatech2_port { - int magic; - bool read_urb_busy; - bool close_pending; - __u8 shadowLSR; - __u8 shadowMSR; - bool rcv_flush; - bool xmit_flush; - int tx_pending_bytes; - struct mutex modelock; - int open_count; - - char active; /* someone has this device open */ - unsigned char *xfer_to_tty_buffer; - wait_queue_head_t wait; - __u8 shadowLCR; /* last LCR value received */ - __u8 shadowMCR; /* last MCR value received */ - char RxHolding; - struct semaphore pend_xmit_sem; /* locks this structure */ - spinlock_t lock; -}; - -/** - * Structure to hold device-wide internal status information - * @param ReadBulkStopped The last bulk read attempt ended in tears - * @param open_ports The number of serial ports currently in use on the box - * @param current_port Pointer to the serial port structure of the port which - * the read stream is currently directed to. Escape sequences in the read - * stream will change this around as data arrives from different ports on the - * box - * @buffer_size: The max size buffer each URB can take, used to set the size of - * the buffers allocated for writing to each port on the device (we need to - * store this because it is known only to the endpoint, but used each time a - * port is opened and a new buffer is allocated. - */ -struct quatech2_dev { - bool ReadBulkStopped; - char open_ports; - struct usb_serial_port *current_port; - int buffer_size; -}; - -/* structure which holds line and modem status flags */ -struct qt2_status_data { - __u8 line_status; - __u8 modem_status; -}; - -/* Function prototypes */ -static int qt2_boxpoweron(struct usb_serial *serial); -static int qt2_boxsetQMCR(struct usb_serial *serial, __u16 Uart_Number, - __u8 QMCR_Value); -static int port_paranoia_check(struct usb_serial_port *port, - const char *function); -static int serial_paranoia_check(struct usb_serial *serial, - const char *function); -static inline struct quatech2_port *qt2_get_port_private(struct usb_serial_port - *port); -static inline void qt2_set_port_private(struct usb_serial_port *port, - struct quatech2_port *data); -static inline struct quatech2_dev *qt2_get_dev_private(struct usb_serial - *serial); -static inline void qt2_set_dev_private(struct usb_serial *serial, - struct quatech2_dev *data); -static int qt2_openboxchannel(struct usb_serial *serial, __u16 - Uart_Number, struct qt2_status_data *pDeviceData); -static int qt2_closeboxchannel(struct usb_serial *serial, __u16 - Uart_Number); -static int qt2_conf_uart(struct usb_serial *serial, unsigned short Uart_Number, - unsigned short divisor, unsigned char LCR); -static void qt2_read_bulk_callback(struct urb *urb); -static void qt2_write_bulk_callback(struct urb *urb); -static void qt2_process_line_status(struct usb_serial_port *port, - unsigned char LineStatus); -static void qt2_process_modem_status(struct usb_serial_port *port, - unsigned char ModemStatus); -static void qt2_process_xmit_empty(struct usb_serial_port *port, - unsigned char fourth_char, unsigned char fifth_char); -static void qt2_process_port_change(struct usb_serial_port *port, - unsigned char New_Current_Port); -static void qt2_process_rcv_flush(struct usb_serial_port *port); -static void qt2_process_xmit_flush(struct usb_serial_port *port); -static void qt2_process_rx_char(struct usb_serial_port *port, - unsigned char data); -static int qt2_box_get_register(struct usb_serial *serial, - unsigned char uart_number, unsigned short register_num, - __u8 *pValue); -static int qt2_box_set_register(struct usb_serial *serial, - unsigned short Uart_Number, unsigned short Register_Num, - unsigned short Value); -static int qt2_boxsetuart(struct usb_serial *serial, unsigned short Uart_Number, - unsigned short default_divisor, unsigned char default_LCR); -static int qt2_boxsethw_flowctl(struct usb_serial *serial, - unsigned int UartNumber, bool bSet); -static int qt2_boxsetsw_flowctl(struct usb_serial *serial, __u16 UartNumber, - unsigned char stop_char, unsigned char start_char); -static int qt2_boxunsetsw_flowctl(struct usb_serial *serial, __u16 UartNumber); -static int qt2_boxstoprx(struct usb_serial *serial, unsigned short uart_number, - unsigned short stop); - -/* implementation functions, roughly in order of use, are here */ -static int qt2_calc_num_ports(struct usb_serial *serial) -{ - int num_ports; - int flag_as_400; - switch (serial->dev->descriptor.idProduct) { - case QUATECH_SSU2_100: - num_ports = 1; - break; - - case QUATECH_DSU2_400: - flag_as_400 = true; - case QUATECH_DSU2_100: - num_ports = 2; - break; - - case QUATECH_QSU2_400: - flag_as_400 = true; - case QUATECH_QSU2_100: - num_ports = 4; - break; - - case QUATECH_ESU2_400: - flag_as_400 = true; - case QUATECH_ESU2_100: - num_ports = 8; - break; - default: - num_ports = 1; - break; - } - return num_ports; -} - -static int qt2_attach(struct usb_serial *serial) -{ - struct usb_serial_port *port; - struct quatech2_port *qt2_port; /* port-specific private data pointer */ - struct quatech2_dev *qt2_dev; /* dev-specific private data pointer */ - int i; - /* stuff for storing endpoint addresses now */ - struct usb_endpoint_descriptor *endpoint; - struct usb_host_interface *iface_desc; - struct usb_serial_port *port0; /* first port structure on device */ - - /* check how many endpoints there are on the device, for - * sanity's sake */ - dbg("%s(): Endpoints: %d bulk in, %d bulk out, %d interrupt in", - __func__, serial->num_bulk_in, - serial->num_bulk_out, serial->num_interrupt_in); - if ((serial->num_bulk_in != 1) || (serial->num_bulk_out != 1)) { - dbg("Device has wrong number of bulk endpoints!"); - return -ENODEV; - } - iface_desc = serial->interface->cur_altsetting; - - /* Set up per-device private data, storing extra data alongside - * struct usb_serial */ - qt2_dev = kzalloc(sizeof(*qt2_dev), GFP_KERNEL); - if (!qt2_dev) { - dbg("%s: kmalloc for quatech2_dev failed!", - __func__); - return -ENOMEM; - } - qt2_dev->open_ports = 0; /* no ports open */ - qt2_set_dev_private(serial, qt2_dev); /* store private data */ - - /* Now setup per port private data, which replaces all the things - * that quatech added to standard kernel structures in their driver */ - for (i = 0; i < serial->num_ports; i++) { - port = serial->port[i]; - qt2_port = kzalloc(sizeof(*qt2_port), GFP_KERNEL); - if (!qt2_port) { - dbg("%s: kmalloc for quatech2_port (%d) failed!.", - __func__, i); - return -ENOMEM; - } - /* initialise stuff in the structure */ - qt2_port->open_count = 0; /* port is not open */ - spin_lock_init(&qt2_port->lock); - mutex_init(&qt2_port->modelock); - qt2_set_port_private(port, qt2_port); - } - - /* gain access to port[0]'s structure because we want to store - * device-level stuff in it */ - if (serial_paranoia_check(serial, __func__)) - return -ENODEV; - port0 = serial->port[0]; /* get the first port's device structure */ - - /* print endpoint addresses so we can check them later - * by hand */ - for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { - endpoint = &iface_desc->endpoint[i].desc; - if ((endpoint->bEndpointAddress & 0x80) && - ((endpoint->bmAttributes & 3) == 0x02)) { - /* we found a bulk in endpoint */ - dbg("found bulk in at %#.2x", - endpoint->bEndpointAddress); - } - - if (((endpoint->bEndpointAddress & 0x80) == 0x00) && - ((endpoint->bmAttributes & 3) == 0x02)) { - /* we found a bulk out endpoint */ - dbg("found bulk out at %#.2x", - endpoint->bEndpointAddress); - qt2_dev->buffer_size = endpoint->wMaxPacketSize; - /* max size of URB needs recording for the device */ - } - } /* end printing endpoint addresses */ - - /* switch on power to the hardware */ - if (qt2_boxpoweron(serial) < 0) { - dbg("qt2_boxpoweron() failed"); - goto startup_error; - } - /* set all ports to RS232 mode */ - for (i = 0; i < serial->num_ports; ++i) { - if (qt2_boxsetQMCR(serial, i, QU2BOX232) < 0) { - dbg("qt2_boxsetQMCR() on port %d failed", - i); - goto startup_error; - } - } - - return 0; - -startup_error: - for (i = 0; i < serial->num_ports; i++) { - port = serial->port[i]; - qt2_port = qt2_get_port_private(port); - kfree(qt2_port); - qt2_set_port_private(port, NULL); - } - qt2_dev = qt2_get_dev_private(serial); - kfree(qt2_dev); - qt2_set_dev_private(serial, NULL); - - dbg("Exit fail %s\n", __func__); - return -EIO; -} - -static void qt2_release(struct usb_serial *serial) -{ - struct usb_serial_port *port; - struct quatech2_port *qt_port; - int i; - - dbg("enterting %s", __func__); - - for (i = 0; i < serial->num_ports; i++) { - port = serial->port[i]; - if (!port) - continue; - - qt_port = usb_get_serial_port_data(port); - kfree(qt_port); - usb_set_serial_port_data(port, NULL); - } -} -/* This function is called once per serial port on the device, when - * that port is opened by a userspace application. - * The tty_struct and the usb_serial_port belong to this port, - * i.e. there are multiple ones for a multi-port device. - * However the usb_serial_port structure has a back-pointer - * to the parent usb_serial structure which belongs to the device, - * so we can access either the device-wide information or - * any other port's information (because there are also forward - * pointers) via that pointer. - * This is most helpful if the device shares resources (e.g. end - * points) between different ports - */ -int qt2_open(struct tty_struct *tty, struct usb_serial_port *port) -{ - struct usb_serial *serial; /* device structure */ - struct usb_serial_port *port0; /* first port structure on device */ - struct quatech2_port *port_extra; /* extra data for this port */ - struct quatech2_port *port0_extra; /* extra data for first port */ - struct quatech2_dev *dev_extra; /* extra data for the device */ - struct qt2_status_data ChannelData; - unsigned short default_divisor = QU2BOXSPD9600; - unsigned char default_LCR = QT2_SERIAL_8_DATA; - int status; - int result; - - if (port_paranoia_check(port, __func__)) - return -ENODEV; - - dbg("%s(): port %d", __func__, port->number); - - serial = port->serial; /* get the parent device structure */ - if (serial_paranoia_check(serial, __func__)) { - dbg("usb_serial struct failed sanity check"); - return -ENODEV; - } - dev_extra = qt2_get_dev_private(serial); - /* get the device private data */ - if (dev_extra == NULL) { - dbg("device extra data pointer is null"); - return -ENODEV; - } - port0 = serial->port[0]; /* get the first port's device structure */ - if (port_paranoia_check(port0, __func__)) { - dbg("port0 usb_serial_port struct failed sanity check"); - return -ENODEV; - } - - port_extra = qt2_get_port_private(port); - port0_extra = qt2_get_port_private(port0); - if (port_extra == NULL || port0_extra == NULL) { - dbg("failed to get private data for port or port0"); - return -ENODEV; - } - - /* FIXME: are these needed? Does it even do anything useful? */ - /* get the modem and line status values from the UART */ - status = qt2_openboxchannel(serial, port->number, - &ChannelData); - if (status < 0) { - dbg("qt2_openboxchannel on channel %d failed", - port->number); - return status; - } - port_extra->shadowLSR = ChannelData.line_status & - (QT2_SERIAL_LSR_OE | QT2_SERIAL_LSR_PE | - QT2_SERIAL_LSR_FE | QT2_SERIAL_LSR_BI); - port_extra->shadowMSR = ChannelData.modem_status & - (QT2_SERIAL_MSR_CTS | QT2_SERIAL_MSR_DSR | - QT2_SERIAL_MSR_RI | QT2_SERIAL_MSR_CD); - -/* port_extra->fifo_empty_flag = true;*/ - dbg("qt2_openboxchannel on channel %d completed.", - port->number); - - /* Set Baud rate to default and turn off flow control here */ - status = qt2_conf_uart(serial, port->number, default_divisor, - default_LCR); - if (status < 0) { - dbg("qt2_conf_uart() failed on channel %d", - port->number); - return status; - } - dbg("qt2_conf_uart() completed on channel %d", - port->number); - - /* - * At this point we will need some end points to make further progress. - * Handlily, the correct endpoint addresses have been filled out into - * the usb_serial_port structure for us by the driver core, so we - * already have access to them. - * As there is only one bulk in and one bulk out end-point, these are in - * port[0]'s structure, and the rest are uninitialised. Handily, - * when we do a write to a port, we will use the same endpoint - * regardless of the port, with a 5-byte header added on to - * tell the box which port it should eventually come out of, so we only - * need the one set of endpoints. We will have one URB per port for - * writing, so that multiple ports can be writing at once. - * Finally we need a bulk in URB to use for background reads from the - * device, which will deal with uplink data from the box to host. - */ - dbg("port0 bulk in endpoint is %#.2x", port0->bulk_in_endpointAddress); - dbg("port0 bulk out endpoint is %#.2x", - port0->bulk_out_endpointAddress); - - /* set up write_urb for bulk out transfers on this port. The USB - * serial framework will have allocated a blank URB, buffer etc for - * port0 when it put the endpoints there, but not for any of the other - * ports on the device because there are no more endpoints. Thus we - * have to allocate our own URBs for ports 1-7 - */ - if (port->write_urb == NULL) { - dbg("port->write_urb == NULL, allocating one"); - port->write_urb = usb_alloc_urb(0, GFP_KERNEL); - if (!port->write_urb) { - dev_err(&port->dev, "Allocating write URB failed\n"); - return -ENOMEM; - } - /* buffer same size as port0 */ - port->bulk_out_size = dev_extra->buffer_size; - port->bulk_out_buffer = kmalloc(port->bulk_out_size, - GFP_KERNEL); - if (!port->bulk_out_buffer) { - dev_err(&port->dev, "Couldn't allocate bulk_out_buffer\n"); - return -ENOMEM; - } - } - if (serial->dev == NULL) - dbg("serial->dev == NULL"); - dbg("port->bulk_out_size is %d", port->bulk_out_size); - - usb_fill_bulk_urb(port->write_urb, serial->dev, - usb_sndbulkpipe(serial->dev, - port0->bulk_out_endpointAddress), - port->bulk_out_buffer, - port->bulk_out_size, - qt2_write_bulk_callback, - port); - port_extra->tx_pending_bytes = 0; - - if (dev_extra->open_ports == 0) { - /* this is first port to be opened, so need the read URB - * initialised for bulk in transfers (this is shared amongst - * all the ports on the device) */ - usb_fill_bulk_urb(port0->read_urb, serial->dev, - usb_rcvbulkpipe(serial->dev, - port0->bulk_in_endpointAddress), - port0->bulk_in_buffer, - port0->bulk_in_size, - qt2_read_bulk_callback, serial); - dbg("port0 bulk in URB initialised"); - - /* submit URB, i.e. start reading from device (async) */ - dev_extra->ReadBulkStopped = false; - port_extra->read_urb_busy = true; - result = usb_submit_urb(port->read_urb, GFP_KERNEL); - if (result) { - dev_err(&port->dev, - "%s(): Error %d submitting bulk in urb", - __func__, result); - port_extra->read_urb_busy = false; - dev_extra->ReadBulkStopped = true; - } - - /* When the first port is opened, initialise the value of - * current_port in dev_extra to this port, so it is set - * to something. Once the box sends data it will send the - * relevant escape sequences to get it to the right port anyway - */ - dev_extra->current_port = port; - } - - /* initialize our wait queues */ - init_waitqueue_head(&port_extra->wait); - /* increment the count of openings of this port by one */ - port_extra->open_count++; - - /* remember to store dev_extra, port_extra and port0_extra back again at - * end !*/ - qt2_set_port_private(port, port_extra); - qt2_set_port_private(serial->port[0], port0_extra); - qt2_set_dev_private(serial, dev_extra); - - dev_extra->open_ports++; /* one more port opened */ - - return 0; -} - -/* called when a port is closed by userspace. It won't be called, however, - * until calls to chars_in_buffer() reveal that the port has completed - * sending buffered data, and there is nothing else to do. Thus we don't have - * to rely on forcing data through in this function. */ -/* Setting close_pending should keep new data from being written out, - * once all the data in the enpoint buffers is moved out we won't get - * any more. */ -/* BoxStopReceive would keep any more data from coming from a given - * port, but isn't called by the vendor driver, although their comments - * mention it. Should it be used here to stop the inbound data - * flow? - */ -static void qt2_close(struct usb_serial_port *port) -{ - /* time out value for flush loops */ - unsigned long jift; - struct quatech2_port *port_extra; /* extra data for this port */ - struct usb_serial *serial; /* device structure */ - struct quatech2_dev *dev_extra; /* extra data for the device */ - __u8 lsr_value = 0; /* value of Line Status Register */ - int status; /* result of last USB comms function */ - - dbg("%s(): port %d", __func__, port->number); - serial = port->serial; /* get the parent device structure */ - dev_extra = qt2_get_dev_private(serial); - /* get the device private data */ - port_extra = qt2_get_port_private(port); /* port private data */ - - /* we can now (and only now) stop reading data */ - port_extra->close_pending = true; - dbg("%s(): port_extra->close_pending = true", __func__); - /* although the USB side is now empty, the UART itself may - * still be pushing characters out over the line, so we have to - * wait testing the actual line status until the lines change - * indicating that the data is done transferring. */ - /* FIXME: slow this polling down so it doesn't run the USB bus flat out - * if it actually has to spend any time in this loop (which it normally - * doesn't because the buffer is nearly empty) */ - jift = jiffies + (10 * HZ); /* 10 sec timeout */ - do { - status = qt2_box_get_register(serial, port->number, - QT2_LINE_STATUS_REGISTER, &lsr_value); - if (status < 0) { - dbg("%s(): qt2_box_get_register failed", __func__); - break; - } - if ((lsr_value & QT2_LSR_TEMT)) { - dbg("UART done sending"); - break; - } - schedule(); - } while (jiffies <= jift); - - status = qt2_closeboxchannel(serial, port->number); - if (status < 0) - dbg("%s(): port %d qt2_box_open_close_channel failed", - __func__, port->number); - /* to avoid leaking URBs, we should now free the write_urb for this - * port and set the pointer to null so that next time the port is opened - * a new URB is allocated. This avoids leaking URBs when the device is - * removed */ - usb_free_urb(port->write_urb); - kfree(port->bulk_out_buffer); - port->bulk_out_buffer = NULL; - port->bulk_out_size = 0; - - /* decrement the count of openings of this port by one */ - port_extra->open_count--; - /* one less overall open as well */ - dev_extra->open_ports--; - dbg("%s(): Exit, dev_extra->open_ports = %d", __func__, - dev_extra->open_ports); -} - -/** - * qt2_write - write bytes from the tty layer out to the USB device. - * @buf: The data to be written, size at least count. - * @count: The number of bytes requested for transmission. - * @return The number of bytes actually accepted for transmission to the device. - */ -static int qt2_write(struct tty_struct *tty, struct usb_serial_port *port, - const unsigned char *buf, int count) -{ - struct usb_serial *serial; /* parent device struct */ - __u8 header_array[5]; /* header used to direct writes to the correct - port on the device */ - struct quatech2_port *port_extra; /* extra data for this port */ - int result; - - serial = port->serial; /* get the parent device of the port */ - port_extra = qt2_get_port_private(port); /* port extra info */ - if (serial == NULL) - return -ENODEV; - dbg("%s(): port %d, requested to write %d bytes, %d already pending", - __func__, port->number, count, port_extra->tx_pending_bytes); - - if (count <= 0) { - dbg("%s(): write request of <= 0 bytes", __func__); - return 0; /* no bytes written */ - } - - /* check if the write urb is already in use, i.e. data already being - * sent to this port */ - if ((port->write_urb->status == -EINPROGRESS)) { - /* Fifo hasn't been emptied since last write to this port */ - dbg("%s(): already writing, port->write_urb->status == " - "-EINPROGRESS", __func__); - /* schedule_work(&port->work); commented in vendor driver */ - return 0; - } else if (port_extra->tx_pending_bytes >= QT2_FIFO_DEPTH) { - /* buffer is full (==). > should not occur, but would indicate - * that an overflow had occurred */ - dbg("%s(): port transmit buffer is full!", __func__); - /* schedule_work(&port->work); commented in vendor driver */ - return 0; - } - - /* We must fill the first 5 bytes of anything we sent with a transmit - * header which directs the data to the correct port. The maximum - * size we can send out in one URB is port->bulk_out_size, which caps - * the number of bytes of real data we can send in each write. As the - * semantics of write allow us to write less than we were give, we cap - * the maximum we will ever write to the device as 5 bytes less than - * one URB's worth, by reducing the value of the count argument - * appropriately*/ - if (count > port->bulk_out_size - QT2_TX_HEADER_LENGTH) { - count = port->bulk_out_size - QT2_TX_HEADER_LENGTH; - dbg("%s(): write request bigger than urb, only accepting " - "%d bytes", __func__, count); - } - /* we must also ensure that the FIFO at the other end can cope with the - * URB we send it, otherwise it will have problems. As above, we can - * restrict the write size by just shrinking count.*/ - if (count > (QT2_FIFO_DEPTH - port_extra->tx_pending_bytes)) { - count = QT2_FIFO_DEPTH - port_extra->tx_pending_bytes; - dbg("%s(): not enough room in buffer, only accepting %d bytes", - __func__, count); - } - /* now build the header for transmission */ - header_array[0] = 0x1b; - header_array[1] = 0x1b; - header_array[2] = (__u8)port->number; - header_array[3] = (__u8)count; - header_array[4] = (__u8)count >> 8; - /* copy header into URB */ - memcpy(port->write_urb->transfer_buffer, header_array, - QT2_TX_HEADER_LENGTH); - /* and actual data to write */ - memcpy(port->write_urb->transfer_buffer + 5, buf, count); - - dbg("%s(): first data byte to send = %#.2x", __func__, *buf); - - /* set up our urb */ - usb_fill_bulk_urb(port->write_urb, serial->dev, - usb_sndbulkpipe(serial->dev, - port->bulk_out_endpointAddress), - port->write_urb->transfer_buffer, count + 5, - (qt2_write_bulk_callback), port); - /* send the data out the bulk port */ - result = usb_submit_urb(port->write_urb, GFP_ATOMIC); - if (result) { - /* error couldn't submit urb */ - result = 0; /* return 0 as nothing got written */ - dbg("%s(): failed submitting write urb, error %d", - __func__, result); - } else { - port_extra->tx_pending_bytes += count; - result = count; /* return number of bytes written, i.e. count */ - dbg("%s(): submitted write urb, wrote %d bytes, " - "total pending bytes %d", - __func__, result, port_extra->tx_pending_bytes); - } - return result; -} - -/* This is used by the next layer up to know how much space is available - * in the buffer on the device. It is used on a device closure to avoid - * calling close() until the buffer is reported to be empty. - * The returned value must never go down by more than the number of bytes - * written for correct behaviour further up the driver stack, i.e. if I call - * it, then write 6 bytes, then call again I should get 6 less, or possibly - * only 5 less if one was written in the meantime, etc. I should never get 7 - * less (or any bigger number) because I only wrote 6 bytes. - */ -static int qt2_write_room(struct tty_struct *tty) -{ - struct usb_serial_port *port = tty->driver_data; - /* parent usb_serial_port pointer */ - struct quatech2_port *port_extra; /* extra data for this port */ - int room = 0; - port_extra = qt2_get_port_private(port); - - if (port_extra->close_pending == true) { - dbg("%s(): port_extra->close_pending == true", __func__); - return -ENODEV; - } - /* Q: how many bytes would a write() call actually succeed in writing - * if it happened now? - * A: one QT2_FIFO_DEPTH, less the number of bytes waiting to be sent - * out of the port, unless this is more than the size of the - * write_urb output buffer less the header, which is the maximum - * size write we can do. - - * Most of the implementation of this is done when writes to the device - * are started or terminate. When we send a write to the device, we - * reduce the free space count by the size of the dispatched write. - * When a "transmit empty" message comes back up the USB read stream, - * we decrement the count by the number of bytes reported sent, thus - * keeping track of the difference between sent and received bytes. - */ - - room = (QT2_FIFO_DEPTH - port_extra->tx_pending_bytes); - /* space in FIFO */ - if (room > port->bulk_out_size - QT2_TX_HEADER_LENGTH) - room = port->bulk_out_size - QT2_TX_HEADER_LENGTH; - /* if more than the URB can hold, then cap to that limit */ - - dbg("%s(): port %d: write room is %d", __func__, port->number, room); - return room; -} - -static int qt2_chars_in_buffer(struct tty_struct *tty) -{ - struct usb_serial_port *port = tty->driver_data; - /* parent usb_serial_port pointer */ - struct quatech2_port *port_extra; /* extra data for this port */ - port_extra = qt2_get_port_private(port); - - dbg("%s(): port %d: chars_in_buffer = %d", __func__, - port->number, port_extra->tx_pending_bytes); - return port_extra->tx_pending_bytes; -} - -/* called when userspace does an ioctl() on the device. Note that - * TIOCMGET and TIOCMSET are filtered off to their own methods before they get - * here, so we don't have to handle them. - */ -static int qt2_ioctl(struct tty_struct *tty, - unsigned int cmd, unsigned long arg) -{ - struct usb_serial_port *port = tty->driver_data; - struct usb_serial *serial = port->serial; - __u8 mcr_value; /* Modem Control Register value */ - __u8 msr_value; /* Modem Status Register value */ - unsigned short prev_msr_value; /* Previous value of Modem Status - * Register used to implement waiting for a line status change to - * occur */ - struct quatech2_port *port_extra; /* extra data for this port */ - DECLARE_WAITQUEUE(wait, current); - /* Declare a wait queue named "wait" */ - - unsigned int value; - unsigned int UartNumber; - - if (serial == NULL) - return -ENODEV; - UartNumber = tty->index - serial->minor; - port_extra = qt2_get_port_private(port); - - dbg("%s(): port %d, UartNumber %d, tty =0x%p", __func__, - port->number, UartNumber, tty); - - if (cmd == TIOCMBIS || cmd == TIOCMBIC) { - if (qt2_box_get_register(port->serial, UartNumber, - QT2_MODEM_CONTROL_REGISTER, &mcr_value) < 0) - return -ESPIPE; - if (copy_from_user(&value, (unsigned int *)arg, - sizeof(value))) - return -EFAULT; - - switch (cmd) { - case TIOCMBIS: - if (value & TIOCM_RTS) - mcr_value |= QT2_SERIAL_MCR_RTS; - if (value & TIOCM_DTR) - mcr_value |= QT2_SERIAL_MCR_DTR; - if (value & TIOCM_LOOP) - mcr_value |= QT2_SERIAL_MCR_LOOP; - break; - case TIOCMBIC: - if (value & TIOCM_RTS) - mcr_value &= ~QT2_SERIAL_MCR_RTS; - if (value & TIOCM_DTR) - mcr_value &= ~QT2_SERIAL_MCR_DTR; - if (value & TIOCM_LOOP) - mcr_value &= ~QT2_SERIAL_MCR_LOOP; - break; - default: - break; - } /* end of local switch on cmd */ - if (qt2_box_set_register(port->serial, UartNumber, - QT2_MODEM_CONTROL_REGISTER, mcr_value) < 0) { - return -ESPIPE; - } else { - port_extra->shadowMCR = mcr_value; - return 0; - } - } else if (cmd == TIOCMIWAIT) { - dbg("%s() port %d, cmd == TIOCMIWAIT enter", - __func__, port->number); - prev_msr_value = port_extra->shadowMSR & QT2_SERIAL_MSR_MASK; - barrier(); - __set_current_state(TASK_INTERRUPTIBLE); - while (1) { - add_wait_queue(&port_extra->wait, &wait); - schedule(); - dbg("%s(): port %d, cmd == TIOCMIWAIT here\n", - __func__, port->number); - remove_wait_queue(&port_extra->wait, &wait); - /* see if a signal woke us up */ - if (signal_pending(current)) - return -ERESTARTSYS; - set_current_state(TASK_INTERRUPTIBLE); - msr_value = port_extra->shadowMSR & QT2_SERIAL_MSR_MASK; - if (msr_value == prev_msr_value) { - __set_current_state(TASK_RUNNING); - return -EIO; /* no change - error */ - } - if ((arg & TIOCM_RNG && - ((prev_msr_value & QT2_SERIAL_MSR_RI) == - (msr_value & QT2_SERIAL_MSR_RI))) || - (arg & TIOCM_DSR && - ((prev_msr_value & QT2_SERIAL_MSR_DSR) == - (msr_value & QT2_SERIAL_MSR_DSR))) || - (arg & TIOCM_CD && - ((prev_msr_value & QT2_SERIAL_MSR_CD) == - (msr_value & QT2_SERIAL_MSR_CD))) || - (arg & TIOCM_CTS && - ((prev_msr_value & QT2_SERIAL_MSR_CTS) == - (msr_value & QT2_SERIAL_MSR_CTS)))) { - __set_current_state(TASK_RUNNING); - return 0; - } - } /* end inifinite while */ - /* FIXME: This while loop needs a way to break out if the device - * is disconnected while a process is waiting for the MSR to - * change, because once it's disconnected, it isn't going to - * change state ... */ - } else { - /* any other ioctls we don't know about come here */ - dbg("%s(): No ioctl for that one. port = %d", __func__, - port->number); - return -ENOIOCTLCMD; - } -} - -/* Called when the user wishes to change the port settings using the termios - * userspace interface */ -static void qt2_set_termios(struct tty_struct *tty, - struct usb_serial_port *port, struct ktermios *old_termios) -{ - struct usb_serial *serial; /* parent serial device */ - int baud, divisor, remainder; - unsigned char LCR_change_to = 0; - int status; - __u16 UartNumber; - - dbg("%s(): port %d", __func__, port->number); - - serial = port->serial; - - UartNumber = port->number; - - if (old_termios && !tty_termios_hw_change(old_termios, tty->termios)) - return; - - switch (tty->termios->c_cflag) { - case CS5: - LCR_change_to |= QT2_SERIAL_5_DATA; - break; - case CS6: - LCR_change_to |= QT2_SERIAL_6_DATA; - break; - case CS7: - LCR_change_to |= QT2_SERIAL_7_DATA; - break; - default: - case CS8: - LCR_change_to |= QT2_SERIAL_8_DATA; - break; - } - - /* Parity stuff */ - if (tty->termios->c_cflag & PARENB) { - if (tty->termios->c_cflag & PARODD) - LCR_change_to |= QT2_SERIAL_ODD_PARITY; - else - LCR_change_to |= QT2_SERIAL_EVEN_PARITY; - } - /* Because LCR_change_to is initialised to zero, we don't have to worry - * about the case where PARENB is not set or clearing bits, because by - * default all of them are cleared, turning parity off. - * as we don't support mark/space parity, we should clear the - * mark/space parity bit in c_cflag, so the caller can tell we have - * ignored the request */ - tty->termios->c_cflag &= ~CMSPAR; - - if (tty->termios->c_cflag & CSTOPB) - LCR_change_to |= QT2_SERIAL_TWO_STOPB; - else - LCR_change_to |= QT2_SERIAL_ONE_STOPB; - - /* Thats the LCR stuff, next we need to work out the divisor as the - * LCR and the divisor are set together */ - baud = tty_get_baud_rate(tty); - if (!baud) { - /* pick a default, any default... */ - baud = 9600; - } - dbg("%s(): got baud = %d", __func__, baud); - - divisor = QT2_MAX_BAUD_RATE / baud; - remainder = QT2_MAX_BAUD_RATE % baud; - /* Round to nearest divisor */ - if (((remainder * 2) >= baud) && (baud != 110)) - divisor++; - dbg("%s(): setting divisor = %d, QT2_MAX_BAUD_RATE = %d , LCR = %#.2x", - __func__, divisor, QT2_MAX_BAUD_RATE, LCR_change_to); - - status = qt2_boxsetuart(serial, UartNumber, (unsigned short) divisor, - LCR_change_to); - if (status < 0) { - dbg("qt2_boxsetuart() failed"); - return; - } else { - /* now encode the baud rate we actually set, which may be - * different to the request */ - baud = QT2_MAX_BAUD_RATE / divisor; - tty_encode_baud_rate(tty, baud, baud); - } - - /* Now determine flow control */ - if (tty->termios->c_cflag & CRTSCTS) { - dbg("%s(): Enabling HW flow control port %d", __func__, - port->number); - /* Enable RTS/CTS flow control */ - status = qt2_boxsethw_flowctl(serial, UartNumber, true); - if (status < 0) { - dbg("qt2_boxsethw_flowctl() failed"); - return; - } - } else { - /* Disable RTS/CTS flow control */ - dbg("%s(): disabling HW flow control port %d", __func__, - port->number); - status = qt2_boxsethw_flowctl(serial, UartNumber, false); - if (status < 0) { - dbg("qt2_boxsethw_flowctl failed"); - return; - } - } - /* if we are implementing XON/XOFF, set the start and stop character - * in the device */ - if (I_IXOFF(tty) || I_IXON(tty)) { - unsigned char stop_char = STOP_CHAR(tty); - unsigned char start_char = START_CHAR(tty); - status = qt2_boxsetsw_flowctl(serial, UartNumber, stop_char, - start_char); - if (status < 0) - dbg("qt2_boxsetsw_flowctl (enabled) failed"); - } else { - /* disable SW flow control */ - status = qt2_boxunsetsw_flowctl(serial, UartNumber); - if (status < 0) - dbg("qt2_boxunsetsw_flowctl (disabling) failed"); - } -} - -static int qt2_tiocmget(struct tty_struct *tty) -{ - struct usb_serial_port *port = tty->driver_data; - struct usb_serial *serial = port->serial; - - __u8 mcr_value; /* Modem Control Register value */ - __u8 msr_value; /* Modem Status Register value */ - unsigned int result = 0; - int status; - unsigned int UartNumber; - - if (serial == NULL) - return -ENODEV; - - dbg("%s(): port %d, tty =0x%p", __func__, port->number, tty); - UartNumber = tty->index - serial->minor; - dbg("UartNumber is %d", UartNumber); - - status = qt2_box_get_register(port->serial, UartNumber, - QT2_MODEM_CONTROL_REGISTER, &mcr_value); - if (status >= 0) { - status = qt2_box_get_register(port->serial, UartNumber, - QT2_MODEM_STATUS_REGISTER, &msr_value); - } - if (status >= 0) { - result = ((mcr_value & QT2_SERIAL_MCR_DTR) ? TIOCM_DTR : 0) - /*DTR set */ - | ((mcr_value & QT2_SERIAL_MCR_RTS) ? TIOCM_RTS : 0) - /*RTS set */ - | ((msr_value & QT2_SERIAL_MSR_CTS) ? TIOCM_CTS : 0) - /* CTS set */ - | ((msr_value & QT2_SERIAL_MSR_CD) ? TIOCM_CAR : 0) - /*Carrier detect set */ - | ((msr_value & QT2_SERIAL_MSR_RI) ? TIOCM_RI : 0) - /* Ring indicator set */ - | ((msr_value & QT2_SERIAL_MSR_DSR) ? TIOCM_DSR : 0); - /* DSR set */ - return result; - } else { - return -ESPIPE; - } -} - -static int qt2_tiocmset(struct tty_struct *tty, - unsigned int set, unsigned int clear) -{ - struct usb_serial_port *port = tty->driver_data; - struct usb_serial *serial = port->serial; - __u8 mcr_value; /* Modem Control Register value */ - int status; - unsigned int UartNumber; - - if (serial == NULL) - return -ENODEV; - - UartNumber = tty->index - serial->minor; - dbg("%s(): port %d, UartNumber %d", __func__, port->number, UartNumber); - - status = qt2_box_get_register(port->serial, UartNumber, - QT2_MODEM_CONTROL_REGISTER, &mcr_value); - if (status < 0) - return -ESPIPE; - - /* Turn off RTS, DTR and loopback, then only turn on what was asked - * for */ - mcr_value &= ~(QT2_SERIAL_MCR_RTS | QT2_SERIAL_MCR_DTR | - QT2_SERIAL_MCR_LOOP); - if (set & TIOCM_RTS) - mcr_value |= QT2_SERIAL_MCR_RTS; - if (set & TIOCM_DTR) - mcr_value |= QT2_SERIAL_MCR_DTR; - if (set & TIOCM_LOOP) - mcr_value |= QT2_SERIAL_MCR_LOOP; - - status = qt2_box_set_register(port->serial, UartNumber, - QT2_MODEM_CONTROL_REGISTER, mcr_value); - if (status < 0) - return -ESPIPE; - else - return 0; -} - -/** qt2_break - Turn BREAK on and off on the UARTs - */ -static void qt2_break(struct tty_struct *tty, int break_state) -{ - struct usb_serial_port *port = tty->driver_data; /* parent port */ - struct usb_serial *serial = port->serial; /* parent device */ - struct quatech2_port *port_extra; /* extra data for this port */ - __u16 break_value; - unsigned int result; - - port_extra = qt2_get_port_private(port); - if (!serial) { - dbg("%s(): port %d: no serial object", __func__, port->number); - return; - } - - if (break_state == -1) - break_value = 1; - else - break_value = 0; - dbg("%s(): port %d, break_value %d", __func__, port->number, - break_value); - - mutex_lock(&port_extra->modelock); - if (!port_extra->open_count) { - dbg("%s(): port not open", __func__); - goto exit; - } - - result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), - QT2_BREAK_CONTROL, 0x40, break_value, - port->number, NULL, 0, 300); -exit: - mutex_unlock(&port_extra->modelock); - dbg("%s(): exit port %d", __func__, port->number); - -} -/** - * qt2_throttle: - stop reading new data from the port - */ -static void qt2_throttle(struct tty_struct *tty) -{ - struct usb_serial_port *port = tty->driver_data; - struct usb_serial *serial = port->serial; - struct quatech2_port *port_extra; /* extra data for this port */ - dbg("%s(): port %d", __func__, port->number); - - port_extra = qt2_get_port_private(port); - if (!serial) { - dbg("%s(): enter port %d no serial object", __func__, - port->number); - return; - } - - mutex_lock(&port_extra->modelock); /* lock structure */ - if (!port_extra->open_count) { - dbg("%s(): port not open", __func__); - goto exit; - } - /* Send command to box to stop receiving stuff. This will stop this - * particular UART from filling the endpoint - in the multiport case the - * FPGA UART will handle any flow control implemented, but for the single - * port it's handed differently and we just quit submitting urbs - */ - if (serial->dev->descriptor.idProduct != QUATECH_SSU2_100) - qt2_boxstoprx(serial, port->number, 1); - - port->throttled = 1; -exit: - mutex_unlock(&port_extra->modelock); - dbg("%s(): port %d: setting port->throttled", __func__, port->number); - return; -} - -/** - * qt2_unthrottle: - start receiving data through the port again after being - * throttled - */ -static void qt2_unthrottle(struct tty_struct *tty) -{ - struct usb_serial_port *port = tty->driver_data; - struct usb_serial *serial = port->serial; - struct quatech2_port *port_extra; /* extra data for this port */ - struct usb_serial_port *port0; /* first port structure on device */ - struct quatech2_dev *dev_extra; /* extra data for the device */ - - if (!serial) { - dbg("%s() enter port %d no serial object!", __func__, - port->number); - return; - } - dbg("%s(): enter port %d", __func__, port->number); - dev_extra = qt2_get_dev_private(serial); - port_extra = qt2_get_port_private(port); - port0 = serial->port[0]; /* get the first port's device structure */ - - mutex_lock(&port_extra->modelock); - if (!port_extra->open_count) { - dbg("%s(): port %d not open", __func__, port->number); - goto exit; - } - - if (port->throttled != 0) { - dbg("%s(): port %d: unsetting port->throttled", __func__, - port->number); - port->throttled = 0; - /* Send command to box to start receiving stuff */ - if (serial->dev->descriptor.idProduct != QUATECH_SSU2_100) { - qt2_boxstoprx(serial, port->number, 0); - } else if (dev_extra->ReadBulkStopped == true) { - usb_fill_bulk_urb(port0->read_urb, serial->dev, - usb_rcvbulkpipe(serial->dev, - port0->bulk_in_endpointAddress), - port0->bulk_in_buffer, - port0->bulk_in_size, - qt2_read_bulk_callback, - serial); - } - } -exit: - mutex_unlock(&port_extra->modelock); - dbg("%s(): exit port %d", __func__, port->number); - return; -} - -/* internal, private helper functions for the driver */ - -/* Power up the FPGA in the box to get it working */ -static int qt2_boxpoweron(struct usb_serial *serial) -{ - int result; - __u8 Direcion; - unsigned int pipe; - Direcion = USBD_TRANSFER_DIRECTION_OUT; - pipe = usb_rcvctrlpipe(serial->dev, 0); - result = usb_control_msg(serial->dev, pipe, QT_SET_GET_DEVICE, - Direcion, QU2BOXPWRON, 0x00, NULL, 0x00, - 5000); - return result; -} - -/* - * qt2_boxsetQMCR Issue a QT2_GET_SET_QMCR vendor-spcific request on the - * default control pipe. If successful return the number of bytes written, - * otherwise return a negative error number of the problem. - */ -static int qt2_boxsetQMCR(struct usb_serial *serial, __u16 Uart_Number, - __u8 QMCR_Value) -{ - int result; - __u16 PortSettings; - - PortSettings = (__u16)(QMCR_Value); - - dbg("%s(): Port = %d, PortSettings = 0x%x", __func__, - Uart_Number, PortSettings); - - result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), - QT2_GET_SET_QMCR, 0x40, PortSettings, - (__u16)Uart_Number, NULL, 0, 5000); - return result; -} - -static int port_paranoia_check(struct usb_serial_port *port, - const char *function) -{ - if (!port) { - dbg("%s - port == NULL", function); - return -1; - } - if (!port->serial) { - dbg("%s - port->serial == NULL\n", function); - return -1; - } - return 0; -} - -static int serial_paranoia_check(struct usb_serial *serial, - const char *function) -{ - if (!serial) { - dbg("%s - serial == NULL\n", function); - return -1; - } - - if (!serial->type) { - dbg("%s - serial->type == NULL!", function); - return -1; - } - - return 0; -} - -static inline struct quatech2_port *qt2_get_port_private(struct usb_serial_port - *port) -{ - return (struct quatech2_port *)usb_get_serial_port_data(port); -} - -static inline void qt2_set_port_private(struct usb_serial_port *port, - struct quatech2_port *data) -{ - usb_set_serial_port_data(port, (void *)data); -} - -static inline struct quatech2_dev *qt2_get_dev_private(struct usb_serial - *serial) -{ - return (struct quatech2_dev *)usb_get_serial_data(serial); -} -static inline void qt2_set_dev_private(struct usb_serial *serial, - struct quatech2_dev *data) -{ - usb_set_serial_data(serial, (void *)data); -} - -static int qt2_openboxchannel(struct usb_serial *serial, __u16 - Uart_Number, struct qt2_status_data *status) -{ - int result; - __u16 length; - __u8 Direcion; - unsigned int pipe; - length = sizeof(struct qt2_status_data); - Direcion = USBD_TRANSFER_DIRECTION_IN; - pipe = usb_rcvctrlpipe(serial->dev, 0); - result = usb_control_msg(serial->dev, pipe, QT_OPEN_CLOSE_CHANNEL, - Direcion, 0x00, Uart_Number, status, length, 5000); - return result; -} -static int qt2_closeboxchannel(struct usb_serial *serial, __u16 Uart_Number) -{ - int result; - __u8 direcion; - unsigned int pipe; - direcion = USBD_TRANSFER_DIRECTION_OUT; - pipe = usb_sndctrlpipe(serial->dev, 0); - result = usb_control_msg(serial->dev, pipe, QT_OPEN_CLOSE_CHANNEL, - direcion, 0, Uart_Number, NULL, 0, 5000); - return result; -} - -/* qt2_conf_uart Issue a SET_UART vendor-spcific request on the default - * control pipe. If successful sets baud rate divisor and LCR value - */ -static int qt2_conf_uart(struct usb_serial *serial, unsigned short Uart_Number, - unsigned short divisor, unsigned char LCR) -{ - int result; - unsigned short UartNumandLCR; - - UartNumandLCR = (LCR << 8) + Uart_Number; - - result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), - QT2_GET_SET_UART, 0x40, divisor, UartNumandLCR, - NULL, 0, 300); - return result; -} - -/** @brief Callback for asynchronous submission of read URBs on bulk in - * endpoints - * - * Registered in qt2_open_port(), used to deal with incomming data - * from the box. - */ -static void qt2_read_bulk_callback(struct urb *urb) -{ - /* Get the device pointer (struct usb_serial) back out of the URB */ - struct usb_serial *serial = urb->context; - /* get the extra struct for the device */ - struct quatech2_dev *dev_extra = qt2_get_dev_private(serial); - /* Get first port structure from the device */ - struct usb_serial_port *port0 = serial->port[0]; - /* Get the currently active port structure from serial struct */ - struct usb_serial_port *active = dev_extra->current_port; - /* get the extra struct for port 0 */ - struct quatech2_port *port0_extra = qt2_get_port_private(port0); - /* and for the currently active port */ - struct quatech2_port *active_extra = qt2_get_port_private(active); - /* When we finally get to doing some tty stuff, we will need this */ - struct tty_struct *tty_st; - unsigned int RxCount; /* the length of the data to process */ - unsigned int i; /* loop counter over the data to process */ - int result; /* return value cache variable */ - bool escapeflag; /* flag set to true if this loop iteration is - * parsing an escape sequence, rather than - * ordinary data */ - dbg("%s(): callback running, active port is %d", __func__, - active->number); - - if (urb->status) { - /* read didn't go well */ - dev_extra->ReadBulkStopped = true; - dbg("%s(): nonzero bulk read status received: %d", - __func__, urb->status); - return; - } - - /* inline port_sofrint() here */ - if (port_paranoia_check(port0, __func__) != 0) { - dbg("%s - port_paranoia_check on port0 failed, exiting\n", -__func__); - return; - } - if (port_paranoia_check(active, __func__) != 0) { - dbg("%s - port_paranoia_check on current_port " - "failed, exiting", __func__); - return; - } - -/* This single callback function has to do for all the ports on - * the device. Data being read up the USB can contain certain - * escape sequences which are used to communicate out-of-band - * information from the serial port in-band over the USB. - * These escapes include sending modem and flow control line - * status, and switching the port. The concept of a "Current Port" - * is used, which is where data is going until a port change - * escape seqence is received. This Current Port is kept between - * callbacks so that when this function enters we know which the - * currently active port is and can get to work right away without - * the box having to send repeat escape sequences (anyway, how - * would it know to do so?). - */ - - if (active_extra->close_pending == true) { - /* We are closing , stop reading */ - dbg("%s - (active->close_pending == true", __func__); - if (dev_extra->open_ports <= 0) { - /* If this is the only port left open - stop the - * bulk read */ - dev_extra->ReadBulkStopped = true; - dbg("%s - (ReadBulkStopped == true;", __func__); - return; - } - } - - /* - * RxHolding is asserted by throttle, if we assert it, we're not - * receiving any more characters and let the box handle the flow - * control - */ - if ((port0_extra->RxHolding == true) && - (serial->dev->descriptor.idProduct == QUATECH_SSU2_100)) { - /* single port device, input is already stopped, so we don't - * need any more input data */ - dev_extra->ReadBulkStopped = true; - return; - } - /* finally, we are in a situation where we might consider the data - * that is contained within the URB, and what to do about it. - * This is likely to involved communicating up to the TTY layer, so - * we will need to get hold of the tty for the port we are currently - * dealing with */ - - /* active is a usb_serial_port. It has a member port which is a - * tty_port. From this we get a tty_struct pointer which is what we - * actually wanted, and keep it on tty_st */ - tty_st = tty_port_tty_get(&active->port); - if (!tty_st) { - dbg("%s - bad tty pointer - exiting", __func__); - return; - } - RxCount = urb->actual_length; /* grab length of data handy */ - - if (RxCount) { - /* skip all this if no data to process */ - for (i = 0; i < RxCount ; ++i) { - /* Look ahead code here -works on several bytes at onc*/ - if ((i <= (RxCount - 3)) && (THISCHAR == 0x1b) - && (NEXTCHAR == 0x1b)) { - /* we are in an escape sequence, type - * determined by the 3rd char */ - escapeflag = false; - switch (THIRDCHAR) { - case 0x00: - /* Line status change 4th byte must - * follow */ - if (i > (RxCount - 4)) { - dbg("Illegal escape sequences " - "in received data"); - break; - } - qt2_process_line_status(active, - FOURTHCHAR); - i += 3; - escapeflag = true; - break; - case 0x01: - /* Modem status status change 4th byte - * must follow */ - if (i > (RxCount - 4)) { - dbg("Illegal escape sequences " - "in received data"); - break; - } - qt2_process_modem_status(active, - FOURTHCHAR); - i += 3; - escapeflag = true; - break; - case 0x02: - /* xmit hold empty 4th byte - * must follow */ - if (i > (RxCount - 4)) { - dbg("Illegal escape sequences " - "in received data"); - break; - } - qt2_process_xmit_empty(active, - FOURTHCHAR, FIFTHCHAR); - i += 4; - escapeflag = true; - break; - case 0x03: - /* Port number change 4th byte - * must follow */ - if (i > (RxCount - 4)) { - dbg("Illegal escape sequences " - "in received data"); - break; - } - /* Port change. If port open push - * current data up to tty layer */ - if (active_extra->open_count > 0) - tty_flip_buffer_push(tty_st); - - dbg("Port Change: new port = %d", - FOURTHCHAR); - qt2_process_port_change(active, - FOURTHCHAR); - i += 3; - escapeflag = true; - /* having changed port, the pointers for - * the currently active port are all out - * of date and need updating */ - active = dev_extra->current_port; - active_extra = - qt2_get_port_private(active); - tty_st = tty_port_tty_get( - &active->port); - break; - case 0x04: - /* Recv flush 3rd byte must - * follow */ - if (i > (RxCount - 3)) { - dbg("Illegal escape sequences " - "in received data"); - break; - } - qt2_process_rcv_flush(active); - i += 2; - escapeflag = true; - break; - case 0x05: - /* xmit flush 3rd byte must follow */ - if (i > (RxCount - 3)) { - dbg("Illegal escape sequences " - "in received data"); - break; - } - qt2_process_xmit_flush(active); - i += 2; - escapeflag = true; - break; - case 0xff: - dbg("No status sequence"); - qt2_process_rx_char(active, THISCHAR); - qt2_process_rx_char(active, NEXTCHAR); - i += 2; - break; - default: - qt2_process_rx_char(active, THISCHAR); - i += 1; - break; - } /*end switch*/ - if (escapeflag == true) - continue; - /* if we did an escape char, we don't need - * to mess around pushing data through the - * tty layer, and can go round again */ - } /*endif*/ - if (tty_st && urb->actual_length) { - tty_buffer_request_room(tty_st, 1); - tty_insert_flip_string(tty_st, &( - (unsigned char *) - (urb->transfer_buffer) - )[i], 1); - } - } /*endfor*/ - tty_flip_buffer_push(tty_st); - } /*endif*/ - - /* at this point we have complete dealing with the data for this - * callback. All we have to do now is to start the async read process - * back off again. */ - - usb_fill_bulk_urb(port0->read_urb, serial->dev, - usb_rcvbulkpipe(serial->dev, port0->bulk_in_endpointAddress), - port0->bulk_in_buffer, port0->bulk_in_size, - qt2_read_bulk_callback, serial); - result = usb_submit_urb(port0->read_urb, GFP_ATOMIC); - if (result) { - dbg("%s(): failed resubmitting read urb, error %d", - __func__, result); - } else { - dbg("%s() successfully resubmitted read urb", __func__); - if (tty_st && RxCount) { - /* if some inbound data was processed, then - * we need to push that through the tty layer - */ - tty_flip_buffer_push(tty_st); - tty_schedule_flip(tty_st); - } - } - - /* cribbed from serqt_usb2 driver, but not sure which work needs - * scheduling - port0 or currently active port? */ - /* schedule_work(&port->work); */ - dbg("%s() completed", __func__); - return; -} - -/** @brief Callback for asynchronous submission of write URBs on bulk in - * endpoints - * - * Registered in qt2_write(), used to deal with outgoing data - * to the box. - */ -static void qt2_write_bulk_callback(struct urb *urb) -{ - struct usb_serial_port *port = (struct usb_serial_port *)urb->context; - struct usb_serial *serial = port->serial; - dbg("%s(): port %d", __func__, port->number); - if (!serial) { - dbg("%s(): bad serial pointer, exiting", __func__); - return; - } - if (urb->status) { - dbg("%s(): nonzero write bulk status received: %d", - __func__, urb->status); - return; - } - /* FIXME What is supposed to be going on here? - * does this actually do anything useful, and should it? - */ - /*port_softint((void *) serial); commented in vendor driver */ - schedule_work(&port->work); - dbg("%s(): port %d exit", __func__, port->number); - return; -} - -static void qt2_process_line_status(struct usb_serial_port *port, - unsigned char LineStatus) -{ - /* obtain the private structure for the port */ - struct quatech2_port *port_extra = qt2_get_port_private(port); - port_extra->shadowLSR = LineStatus & (QT2_SERIAL_LSR_OE | - QT2_SERIAL_LSR_PE | QT2_SERIAL_LSR_FE | QT2_SERIAL_LSR_BI); -} -static void qt2_process_modem_status(struct usb_serial_port *port, - unsigned char ModemStatus) -{ - /* obtain the private structure for the port */ - struct quatech2_port *port_extra = qt2_get_port_private(port); - port_extra->shadowMSR = ModemStatus; - wake_up_interruptible(&port_extra->wait); - /* this wakes up the otherwise indefinitely waiting code for - * the TIOCMIWAIT ioctl, so that it can notice that - * port_extra->shadowMSR has changed and the ioctl needs to return. - */ -} - -static void qt2_process_xmit_empty(struct usb_serial_port *port, - unsigned char fourth_char, unsigned char fifth_char) -{ - int byte_count; - /* obtain the private structure for the port */ - struct quatech2_port *port_extra = qt2_get_port_private(port); - - byte_count = (int)(fifth_char * 16); - byte_count += (int)fourth_char; - /* byte_count indicates how many bytes the device has written out. This - * message appears to occur regularly, and is used in the vendor driver - * to keep track of the fill state of the port transmit buffer */ - port_extra->tx_pending_bytes -= byte_count; - /* reduce the stored data queue length by the known number of bytes - * sent */ - dbg("port %d: %d bytes reported sent, %d still pending", port->number, - byte_count, port_extra->tx_pending_bytes); - - /*port_extra->xmit_fifo_room_bytes = FIFO_DEPTH; ???*/ -} - -static void qt2_process_port_change(struct usb_serial_port *port, - unsigned char New_Current_Port) -{ - /* obtain the parent usb serial device structure */ - struct usb_serial *serial = port->serial; - /* obtain the private structure for the device */ - struct quatech2_dev *dev_extra = qt2_get_dev_private(serial); - dev_extra->current_port = serial->port[New_Current_Port]; - /* what should I do with this? commented out in upstream - * driver */ - /*schedule_work(&port->work);*/ -} - -static void qt2_process_rcv_flush(struct usb_serial_port *port) -{ - /* obtain the private structure for the port */ - struct quatech2_port *port_extra = qt2_get_port_private(port); - port_extra->rcv_flush = true; -} -static void qt2_process_xmit_flush(struct usb_serial_port *port) -{ - /* obtain the private structure for the port */ - struct quatech2_port *port_extra = qt2_get_port_private(port); - port_extra->xmit_flush = true; -} - -static void qt2_process_rx_char(struct usb_serial_port *port, - unsigned char data) -{ - /* get the tty_struct for this port */ - struct tty_struct *tty = tty_port_tty_get(&(port->port)); - /* get the URB with the data in to push */ - struct urb *urb = port->serial->port[0]->read_urb; - - if (tty && urb->actual_length) { - tty_buffer_request_room(tty, 1); - tty_insert_flip_string(tty, &data, 1); - /* should this be commented out here? */ - /*tty_flip_buffer_push(tty);*/ - } -} - -/** @brief Retrieve the value of a register from the device - * - * Issues a GET_REGISTER vendor-spcific request over the USB control - * pipe to obtain a value back from a specific register on a specific - * UART - * @param serial Serial device handle to access the device through - * @param uart_number Which UART the value is wanted from - * @param register_num Which register to read the value from - * @param pValue Pointer to somewhere to put the retrieved value - */ -static int qt2_box_get_register(struct usb_serial *serial, - unsigned char uart_number, unsigned short register_num, - __u8 *pValue) -{ - int result; - result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), - QT2_GET_SET_REGISTER, 0xC0, register_num, - uart_number, (void *)pValue, sizeof(*pValue), 300); - return result; -} - -/** qt2_box_set_register - * Issue a SET_REGISTER vendor-specific request on the default control pipe - */ -static int qt2_box_set_register(struct usb_serial *serial, - unsigned short Uart_Number, unsigned short Register_Num, - unsigned short Value) -{ - int result; - unsigned short reg_and_byte; - - reg_and_byte = Value; - reg_and_byte = reg_and_byte << 8; - reg_and_byte = reg_and_byte + Register_Num; - - result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), - QT2_GET_SET_REGISTER, 0x40, reg_and_byte, - Uart_Number, NULL, 0, 300); - return result; -} - -/** qt2_boxsetuart - Issue a SET_UART vendor-spcific request on the default - * control pipe. If successful sets baud rate divisor and LCR value. - */ -static int qt2_boxsetuart(struct usb_serial *serial, unsigned short Uart_Number, - unsigned short default_divisor, unsigned char default_LCR) -{ - unsigned short UartNumandLCR; - - UartNumandLCR = (default_LCR << 8) + Uart_Number; - - return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), - QT2_GET_SET_UART, 0x40, default_divisor, UartNumandLCR, - NULL, 0, 300); -} - -/** qt2_boxsethw_flowctl - Turn hardware (RTS/CTS) flow control on and off for - * a hardware UART. - */ -static int qt2_boxsethw_flowctl(struct usb_serial *serial, - unsigned int UartNumber, bool bSet) -{ - __u8 MCR_Value = 0; - __u8 MSR_Value = 0; - __u16 MOUT_Value = 0; - - if (bSet == true) { - MCR_Value = QT2_SERIAL_MCR_RTS; - /* flow control, box will clear RTS line to prevent remote - * device from transmitting more chars */ - } else { - /* no flow control to remote device */ - MCR_Value = 0; - } - MOUT_Value = MCR_Value << 8; - - if (bSet == true) { - MSR_Value = QT2_SERIAL_MSR_CTS; - /* flow control on, box will inhibit tx data if CTS line is - * asserted */ - } else { - /* Box will not inhibit tx data due to CTS line */ - MSR_Value = 0; - } - MOUT_Value |= MSR_Value; - return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), - QT2_HW_FLOW_CONTROL_MASK, 0x40, MOUT_Value, UartNumber, - NULL, 0, 300); -} - -/** qt2_boxsetsw_flowctl - Turn software (XON/XOFF) flow control on for - * a hardware UART, and set the XON and XOFF characters. - */ -static int qt2_boxsetsw_flowctl(struct usb_serial *serial, __u16 UartNumber, - unsigned char stop_char, unsigned char start_char) -{ - __u16 nSWflowout; - - nSWflowout = start_char << 8; - nSWflowout = (unsigned short)stop_char; - return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), - QT2_SW_FLOW_CONTROL_MASK, 0x40, nSWflowout, UartNumber, - NULL, 0, 300); -} - -/** qt2_boxunsetsw_flowctl - Turn software (XON/XOFF) flow control off for - * a hardware UART. - */ -static int qt2_boxunsetsw_flowctl(struct usb_serial *serial, __u16 UartNumber) -{ - return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), - QT2_SW_FLOW_CONTROL_DISABLE, 0x40, 0, UartNumber, NULL, - 0, 300); -} - -/** - * qt2_boxstoprx - Start and stop reception of data by the FPGA UART in - * response to requests from the tty layer - * @serial: pointer to the usb_serial structure for the parent device - * @uart_number: which UART on the device we are addressing - * @stop: Whether to start or stop data reception. Set to 1 to stop data being - * received, and to 0 to start it being received. - */ -static int qt2_boxstoprx(struct usb_serial *serial, unsigned short uart_number, - unsigned short stop) -{ - return usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), - QT2_STOP_RECEIVE, 0x40, stop, uart_number, NULL, 0, 300); -} - - -/* - * last things in file: stuff to register this driver into the generic - * USB serial framework. - */ - -static struct usb_serial_driver quatech2_device = { - .driver = { - .owner = THIS_MODULE, - .name = "quatech_usb2", - }, - .description = DRIVER_DESC, - .id_table = quausb2_id_table, - .num_ports = 8, - .open = qt2_open, - .close = qt2_close, - .write = qt2_write, - .write_room = qt2_write_room, - .chars_in_buffer = qt2_chars_in_buffer, - .throttle = qt2_throttle, - .unthrottle = qt2_unthrottle, - .calc_num_ports = qt2_calc_num_ports, - .ioctl = qt2_ioctl, - .set_termios = qt2_set_termios, - .break_ctl = qt2_break, - .tiocmget = qt2_tiocmget, - .tiocmset = qt2_tiocmset, - .attach = qt2_attach, - .release = qt2_release, - .read_bulk_callback = qt2_read_bulk_callback, - .write_bulk_callback = qt2_write_bulk_callback, -}; - -static struct usb_serial_driver * const serial_drivers[] = { - &quatech2_device, NULL -}; - -module_usb_serial_driver(quausb2_usb_driver, serial_drivers); - -MODULE_AUTHOR(DRIVER_AUTHOR); -MODULE_DESCRIPTION(DRIVER_DESC); -MODULE_LICENSE("GPL"); - -module_param(debug, bool, S_IRUGO | S_IWUSR); -MODULE_PARM_DESC(debug, "Debug enabled or not"); diff --git a/drivers/staging/ramster/cluster/tcp.c b/drivers/staging/ramster/cluster/tcp.c index 3490192f8ca2..d0a07d722b61 100644 --- a/drivers/staging/ramster/cluster/tcp.c +++ b/drivers/staging/ramster/cluster/tcp.c @@ -2106,7 +2106,7 @@ static int r2net_open_listening_sock(__be32 addr, __be16 port) r2net_listen_sock = sock; INIT_WORK(&r2net_listen_work, r2net_accept_many); - sock->sk->sk_reuse = 1; + sock->sk->sk_reuse = SK_CAN_REUSE; ret = sock->ops->bind(sock, (struct sockaddr *)&sin, sizeof(sin)); if (ret < 0) { printk(KERN_ERR "ramster: Error %d while binding socket at " diff --git a/drivers/staging/serqt_usb2/serqt_usb2.c b/drivers/staging/serqt_usb2/serqt_usb2.c index 0ec83aacee79..43045db982d4 100644 --- a/drivers/staging/serqt_usb2/serqt_usb2.c +++ b/drivers/staging/serqt_usb2/serqt_usb2.c @@ -41,13 +41,6 @@ static bool debug; #define QUATECH_HSU200B 0xC0B1 /* HSU200B */ #define QUATECH_HSU200C 0xC0B2 /* HSU200C */ #define QUATECH_HSU200D 0xC0B3 /* HSU200D */ -#define QUATECH_SSU100_2 0xC120 /* SSU100_2 */ -#define QUATECH_DSU100_2 0xC140 /* DSU100_2 */ -#define QUATECH_DSU400_2 0xC150 /* DSU400_2 */ -#define QUATECH_QSU100_2 0xC160 /* QSU100_2 */ -#define QUATECH_QSU400_2 0xC170 /* QSU400_2 */ -#define QUATECH_ESU400_2 0xC180 /* ESU400_2 */ -#define QUATECH_ESU100_2 0xC1A0 /* ESU100_2 */ #define QT_SET_GET_DEVICE 0xc2 #define QT_OPEN_CLOSE_CHANNEL 0xca @@ -125,7 +118,7 @@ static bool debug; #define MODEM_CTRL 0x40 #define RS232_MODE 0x00 -static const struct usb_device_id serqt_id_table[] = { +static const struct usb_device_id id_table[] = { {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_SSU200)}, {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU100)}, {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU200)}, @@ -143,17 +136,9 @@ static const struct usb_device_id serqt_id_table[] = { {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU200B)}, {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU200C)}, {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU200D)}, - {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_SSU100_2)}, - {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU100_2)}, - {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU400_2)}, - {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU100_2)}, - {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU400_2)}, - {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU400_2)}, - {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU100_2)}, {} /* Terminating entry */ }; - -MODULE_DEVICE_TABLE(usb, serqt_id_table); +MODULE_DEVICE_TABLE(usb, id_table); struct qt_get_device_data { __u8 porta; @@ -195,13 +180,6 @@ struct quatech_port { char closePending; }; -static struct usb_driver serqt_usb_driver = { - .name = "quatech-usb-serial", - .probe = usb_serial_probe, - .disconnect = usb_serial_disconnect, - .id_table = serqt_id_table, -}; - static int port_paranoia_check(struct usb_serial_port *port, const char *function) { @@ -304,8 +282,6 @@ static void qt_write_bulk_callback(struct urb *urb) quatech_port = urb->context; - dbg("%s - port %d\n", __func__, quatech_port->port_num); - tty = tty_port_tty_get(&quatech_port->port->port); if (tty) @@ -351,7 +327,6 @@ static void qt_read_bulk_callback(struct urb *urb) /* index = MINOR(port->tty->device) - serial->minor; */ index = tty->index - serial->minor; - dbg("%s - port %d\n", __func__, port->number); dbg("%s - port->RxHolding = %d\n", __func__, qt_port->RxHolding); if (port_paranoia_check(port, __func__) != 0) { @@ -726,8 +701,6 @@ static int qt_startup(struct usb_serial *serial) int i; int status; - dbg("enterting %s", __func__); - /* Now setup per port private data */ for (i = 0; i < serial->num_ports; i++) { port = serial->port[i]; @@ -855,8 +828,6 @@ static void qt_release(struct usb_serial *serial) struct quatech_port *qt_port; int i; - dbg("enterting %s", __func__); - for (i = 0; i < serial->num_ports; i++) { port = serial->port[i]; if (!port) @@ -882,8 +853,6 @@ static int qt_open(struct tty_struct *tty, if (port_paranoia_check(port, __func__)) return -ENODEV; - dbg("%s - port %d\n", __func__, port->number); - serial = port->serial; if (serial_paranoia_check(serial, __func__)) @@ -1006,8 +975,6 @@ static int qt_chars_in_buffer(struct tty_struct *tty) serial = get_usb_serial(port, __func__); - dbg("%s - port %d\n", __func__, port->number); - if (serial->num_bulk_out) { if (port->write_urb->status == -EINPROGRESS) chars = port->write_urb->transfer_buffer_length; @@ -1054,8 +1021,6 @@ static void qt_close(struct usb_serial_port *port) unsigned int index; status = 0; - dbg("%s - port %d\n", __func__, port->number); - tty = tty_port_tty_get(&port->port); index = tty->index - serial->minor; @@ -1109,8 +1074,6 @@ static int qt_write(struct tty_struct *tty, struct usb_serial_port *port, if (serial == NULL) return -ENODEV; - dbg("%s - port %d\n", __func__, port->number); - if (count == 0) { dbg("%s - write request of 0 bytes\n", __func__); return 0; @@ -1173,8 +1136,6 @@ static int qt_write_room(struct tty_struct *tty) mutex_lock(&qt_port->lock); - dbg("%s - port %d\n", __func__, port->number); - if (serial->num_bulk_out) { if (port->write_urb->status != -EINPROGRESS) retval = port->bulk_out_size; @@ -1241,8 +1202,6 @@ static void qt_set_termios(struct tty_struct *tty, int baud, divisor, remainder; int status; - dbg("%s", __func__); - index = tty->index - port->serial->minor; switch (cflag) { @@ -1365,8 +1324,6 @@ static void qt_break(struct tty_struct *tty, int break_state) mutex_lock(&qt_port->lock); - dbg("%s - port %d\n", __func__, port->number); - result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), QT_BREAK_CONTROL, 0x40, onoff, index, NULL, 0, 300); @@ -1385,8 +1342,6 @@ static inline int qt_real_tiocmget(struct tty_struct *tty, int status; unsigned int index; - dbg("%s - port %d, tty =0x%p\n", __func__, port->number, tty); - index = tty->index - serial->minor; status = BoxGetRegister(port->serial, index, MODEM_CONTROL_REGISTER, &mcr); @@ -1426,8 +1381,6 @@ static inline int qt_real_tiocmset(struct tty_struct *tty, int status; unsigned int index; - dbg("%s - port %d\n", __func__, port->number); - index = tty->index - serial->minor; status = BoxGetRegister(port->serial, index, MODEM_CONTROL_REGISTER, &mcr); @@ -1461,18 +1414,11 @@ static int qt_tiocmget(struct tty_struct *tty) struct quatech_port *qt_port = qt_get_port_private(port); int retval = -ENODEV; - dbg("In %s\n", __func__); - if (!serial) return -ENODEV; mutex_lock(&qt_port->lock); - - dbg("%s - port %d\n", __func__, port->number); - dbg("%s - port->RxHolding = %d\n", __func__, qt_port->RxHolding); - retval = qt_real_tiocmget(tty, port, serial); - mutex_unlock(&qt_port->lock); return retval; } @@ -1486,18 +1432,11 @@ static int qt_tiocmset(struct tty_struct *tty, struct quatech_port *qt_port = qt_get_port_private(port); int retval = -ENODEV; - dbg("In %s\n", __func__); - if (!serial) return -ENODEV; mutex_lock(&qt_port->lock); - - dbg("%s - port %d\n", __func__, port->number); - dbg("%s - qt_port->RxHolding = %d\n", __func__, qt_port->RxHolding); - retval = qt_real_tiocmset(tty, port, serial, set); - mutex_unlock(&qt_port->lock); return retval; } @@ -1508,8 +1447,6 @@ static void qt_throttle(struct tty_struct *tty) struct usb_serial *serial = get_usb_serial(port, __func__); struct quatech_port *qt_port; - dbg("%s - port %d\n", __func__, port->number); - if (!serial) return; @@ -1519,7 +1456,6 @@ static void qt_throttle(struct tty_struct *tty) /* pass on to the driver specific version of this function */ qt_port->RxHolding = 1; - dbg("%s - port->RxHolding = 1\n", __func__); mutex_unlock(&qt_port->lock); return; @@ -1539,8 +1475,6 @@ static void qt_unthrottle(struct tty_struct *tty) mutex_lock(&qt_port->lock); - dbg("%s - port %d\n", __func__, port->number); - if (qt_port->RxHolding == 1) { dbg("%s -qt_port->RxHolding == 1\n", __func__); @@ -1590,7 +1524,7 @@ static struct usb_serial_driver quatech_device = { .name = "serqt", }, .description = DRIVER_DESC, - .id_table = serqt_id_table, + .id_table = id_table, .num_ports = 8, .open = qt_open, .close = qt_close, @@ -1613,7 +1547,7 @@ static struct usb_serial_driver * const serial_drivers[] = { &quatech_device, NULL }; -module_usb_serial_driver(serqt_usb_driver, serial_drivers); +module_usb_serial_driver(serial_drivers, id_table); MODULE_AUTHOR(DRIVER_AUTHOR); MODULE_DESCRIPTION(DRIVER_DESC); |