/drivers/net/usb/hso.c
https://bitbucket.org/wisechild/galaxy-nexus · C · 3382 lines · 2562 code · 481 blank · 339 comment · 377 complexity · 88f0ffc9b21c9569e95c46b489fb372b MD5 · raw file
Large files are truncated click here to view the full file
- /******************************************************************************
- *
- * Driver for Option High Speed Mobile Devices.
- *
- * Copyright (C) 2008 Option International
- * Filip Aben <f.aben@option.com>
- * Denis Joseph Barrow <d.barow@option.com>
- * Jan Dumon <j.dumon@option.com>
- * Copyright (C) 2007 Andrew Bird (Sphere Systems Ltd)
- * <ajb@spheresystems.co.uk>
- * Copyright (C) 2008 Greg Kroah-Hartman <gregkh@suse.de>
- * Copyright (C) 2008 Novell, Inc.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
- * USA
- *
- *
- *****************************************************************************/
- /******************************************************************************
- *
- * Description of the device:
- *
- * Interface 0: Contains the IP network interface on the bulk end points.
- * The multiplexed serial ports are using the interrupt and
- * control endpoints.
- * Interrupt contains a bitmap telling which multiplexed
- * serialport needs servicing.
- *
- * Interface 1: Diagnostics port, uses bulk only, do not submit urbs until the
- * port is opened, as this have a huge impact on the network port
- * throughput.
- *
- * Interface 2: Standard modem interface - circuit switched interface, this
- * can be used to make a standard ppp connection however it
- * should not be used in conjunction with the IP network interface
- * enabled for USB performance reasons i.e. if using this set
- * ideally disable_net=1.
- *
- *****************************************************************************/
- #include <linux/sched.h>
- #include <linux/slab.h>
- #include <linux/init.h>
- #include <linux/delay.h>
- #include <linux/netdevice.h>
- #include <linux/module.h>
- #include <linux/ethtool.h>
- #include <linux/usb.h>
- #include <linux/timer.h>
- #include <linux/tty.h>
- #include <linux/tty_driver.h>
- #include <linux/tty_flip.h>
- #include <linux/kmod.h>
- #include <linux/rfkill.h>
- #include <linux/ip.h>
- #include <linux/uaccess.h>
- #include <linux/usb/cdc.h>
- #include <net/arp.h>
- #include <asm/byteorder.h>
- #include <linux/serial_core.h>
- #include <linux/serial.h>
- #define MOD_AUTHOR "Option Wireless"
- #define MOD_DESCRIPTION "USB High Speed Option driver"
- #define MOD_LICENSE "GPL"
- #define HSO_MAX_NET_DEVICES 10
- #define HSO__MAX_MTU 2048
- #define DEFAULT_MTU 1500
- #define DEFAULT_MRU 1500
- #define CTRL_URB_RX_SIZE 1024
- #define CTRL_URB_TX_SIZE 64
- #define BULK_URB_RX_SIZE 4096
- #define BULK_URB_TX_SIZE 8192
- #define MUX_BULK_RX_BUF_SIZE HSO__MAX_MTU
- #define MUX_BULK_TX_BUF_SIZE HSO__MAX_MTU
- #define MUX_BULK_RX_BUF_COUNT 4
- #define USB_TYPE_OPTION_VENDOR 0x20
- /* These definitions are used with the struct hso_net flags element */
- /* - use *_bit operations on it. (bit indices not values.) */
- #define HSO_NET_RUNNING 0
- #define HSO_NET_TX_TIMEOUT (HZ*10)
- #define HSO_SERIAL_MAGIC 0x48534f31
- /* Number of ttys to handle */
- #define HSO_SERIAL_TTY_MINORS 256
- #define MAX_RX_URBS 2
- static inline struct hso_serial *get_serial_by_tty(struct tty_struct *tty)
- {
- if (tty)
- return tty->driver_data;
- return NULL;
- }
- /*****************************************************************************/
- /* Debugging functions */
- /*****************************************************************************/
- #define D__(lvl_, fmt, arg...) \
- do { \
- printk(lvl_ "[%d:%s]: " fmt "\n", \
- __LINE__, __func__, ## arg); \
- } while (0)
- #define D_(lvl, args...) \
- do { \
- if (lvl & debug) \
- D__(KERN_INFO, args); \
- } while (0)
- #define D1(args...) D_(0x01, ##args)
- #define D2(args...) D_(0x02, ##args)
- #define D3(args...) D_(0x04, ##args)
- #define D4(args...) D_(0x08, ##args)
- #define D5(args...) D_(0x10, ##args)
- /*****************************************************************************/
- /* Enumerators */
- /*****************************************************************************/
- enum pkt_parse_state {
- WAIT_IP,
- WAIT_DATA,
- WAIT_SYNC
- };
- /*****************************************************************************/
- /* Structs */
- /*****************************************************************************/
- struct hso_shared_int {
- struct usb_endpoint_descriptor *intr_endp;
- void *shared_intr_buf;
- struct urb *shared_intr_urb;
- struct usb_device *usb;
- int use_count;
- int ref_count;
- struct mutex shared_int_lock;
- };
- struct hso_net {
- struct hso_device *parent;
- struct net_device *net;
- struct rfkill *rfkill;
- struct usb_endpoint_descriptor *in_endp;
- struct usb_endpoint_descriptor *out_endp;
- struct urb *mux_bulk_rx_urb_pool[MUX_BULK_RX_BUF_COUNT];
- struct urb *mux_bulk_tx_urb;
- void *mux_bulk_rx_buf_pool[MUX_BULK_RX_BUF_COUNT];
- void *mux_bulk_tx_buf;
- struct sk_buff *skb_rx_buf;
- struct sk_buff *skb_tx_buf;
- enum pkt_parse_state rx_parse_state;
- spinlock_t net_lock;
- unsigned short rx_buf_size;
- unsigned short rx_buf_missing;
- struct iphdr rx_ip_hdr;
- unsigned long flags;
- };
- enum rx_ctrl_state{
- RX_IDLE,
- RX_SENT,
- RX_PENDING
- };
- #define BM_REQUEST_TYPE (0xa1)
- #define B_NOTIFICATION (0x20)
- #define W_VALUE (0x0)
- #define W_INDEX (0x2)
- #define W_LENGTH (0x2)
- #define B_OVERRUN (0x1<<6)
- #define B_PARITY (0x1<<5)
- #define B_FRAMING (0x1<<4)
- #define B_RING_SIGNAL (0x1<<3)
- #define B_BREAK (0x1<<2)
- #define B_TX_CARRIER (0x1<<1)
- #define B_RX_CARRIER (0x1<<0)
- struct hso_serial_state_notification {
- u8 bmRequestType;
- u8 bNotification;
- u16 wValue;
- u16 wIndex;
- u16 wLength;
- u16 UART_state_bitmap;
- } __packed;
- struct hso_tiocmget {
- struct mutex mutex;
- wait_queue_head_t waitq;
- int intr_completed;
- struct usb_endpoint_descriptor *endp;
- struct urb *urb;
- struct hso_serial_state_notification serial_state_notification;
- u16 prev_UART_state_bitmap;
- struct uart_icount icount;
- };
- struct hso_serial {
- struct hso_device *parent;
- int magic;
- u8 minor;
- struct hso_shared_int *shared_int;
- /* rx/tx urb could be either a bulk urb or a control urb depending
- on which serial port it is used on. */
- struct urb *rx_urb[MAX_RX_URBS];
- u8 num_rx_urbs;
- u8 *rx_data[MAX_RX_URBS];
- u16 rx_data_length; /* should contain allocated length */
- struct urb *tx_urb;
- u8 *tx_data;
- u8 *tx_buffer;
- u16 tx_data_length; /* should contain allocated length */
- u16 tx_data_count;
- u16 tx_buffer_count;
- struct usb_ctrlrequest ctrl_req_tx;
- struct usb_ctrlrequest ctrl_req_rx;
- struct usb_endpoint_descriptor *in_endp;
- struct usb_endpoint_descriptor *out_endp;
- enum rx_ctrl_state rx_state;
- u8 rts_state;
- u8 dtr_state;
- unsigned tx_urb_used:1;
- /* from usb_serial_port */
- struct tty_struct *tty;
- int open_count;
- spinlock_t serial_lock;
- int (*write_data) (struct hso_serial *serial);
- struct hso_tiocmget *tiocmget;
- /* Hacks required to get flow control
- * working on the serial receive buffers
- * so as not to drop characters on the floor.
- */
- int curr_rx_urb_idx;
- u16 curr_rx_urb_offset;
- u8 rx_urb_filled[MAX_RX_URBS];
- struct tasklet_struct unthrottle_tasklet;
- struct work_struct retry_unthrottle_workqueue;
- };
- struct hso_device {
- union {
- struct hso_serial *dev_serial;
- struct hso_net *dev_net;
- } port_data;
- u32 port_spec;
- u8 is_active;
- u8 usb_gone;
- struct work_struct async_get_intf;
- struct work_struct async_put_intf;
- struct work_struct reset_device;
- struct usb_device *usb;
- struct usb_interface *interface;
- struct device *dev;
- struct kref ref;
- struct mutex mutex;
- };
- /* Type of interface */
- #define HSO_INTF_MASK 0xFF00
- #define HSO_INTF_MUX 0x0100
- #define HSO_INTF_BULK 0x0200
- /* Type of port */
- #define HSO_PORT_MASK 0xFF
- #define HSO_PORT_NO_PORT 0x0
- #define HSO_PORT_CONTROL 0x1
- #define HSO_PORT_APP 0x2
- #define HSO_PORT_GPS 0x3
- #define HSO_PORT_PCSC 0x4
- #define HSO_PORT_APP2 0x5
- #define HSO_PORT_GPS_CONTROL 0x6
- #define HSO_PORT_MSD 0x7
- #define HSO_PORT_VOICE 0x8
- #define HSO_PORT_DIAG2 0x9
- #define HSO_PORT_DIAG 0x10
- #define HSO_PORT_MODEM 0x11
- #define HSO_PORT_NETWORK 0x12
- /* Additional device info */
- #define HSO_INFO_MASK 0xFF000000
- #define HSO_INFO_CRC_BUG 0x01000000
- /*****************************************************************************/
- /* Prototypes */
- /*****************************************************************************/
- /* Serial driver functions */
- static int hso_serial_tiocmset(struct tty_struct *tty,
- unsigned int set, unsigned int clear);
- static void ctrl_callback(struct urb *urb);
- static int put_rxbuf_data(struct urb *urb, struct hso_serial *serial);
- static void hso_kick_transmit(struct hso_serial *serial);
- /* Helper functions */
- static int hso_mux_submit_intr_urb(struct hso_shared_int *mux_int,
- struct usb_device *usb, gfp_t gfp);
- static void handle_usb_error(int status, const char *function,
- struct hso_device *hso_dev);
- static struct usb_endpoint_descriptor *hso_get_ep(struct usb_interface *intf,
- int type, int dir);
- static int hso_get_mux_ports(struct usb_interface *intf, unsigned char *ports);
- static void hso_free_interface(struct usb_interface *intf);
- static int hso_start_serial_device(struct hso_device *hso_dev, gfp_t flags);
- static int hso_stop_serial_device(struct hso_device *hso_dev);
- static int hso_start_net_device(struct hso_device *hso_dev);
- static void hso_free_shared_int(struct hso_shared_int *shared_int);
- static int hso_stop_net_device(struct hso_device *hso_dev);
- static void hso_serial_ref_free(struct kref *ref);
- static void hso_std_serial_read_bulk_callback(struct urb *urb);
- static int hso_mux_serial_read(struct hso_serial *serial);
- static void async_get_intf(struct work_struct *data);
- static void async_put_intf(struct work_struct *data);
- static int hso_put_activity(struct hso_device *hso_dev);
- static int hso_get_activity(struct hso_device *hso_dev);
- static void tiocmget_intr_callback(struct urb *urb);
- static void reset_device(struct work_struct *data);
- /*****************************************************************************/
- /* Helping functions */
- /*****************************************************************************/
- /* #define DEBUG */
- static inline struct hso_net *dev2net(struct hso_device *hso_dev)
- {
- return hso_dev->port_data.dev_net;
- }
- static inline struct hso_serial *dev2ser(struct hso_device *hso_dev)
- {
- return hso_dev->port_data.dev_serial;
- }
- /* Debugging functions */
- #ifdef DEBUG
- static void dbg_dump(int line_count, const char *func_name, unsigned char *buf,
- unsigned int len)
- {
- static char name[255];
- sprintf(name, "hso[%d:%s]", line_count, func_name);
- print_hex_dump_bytes(name, DUMP_PREFIX_NONE, buf, len);
- }
- #define DUMP(buf_, len_) \
- dbg_dump(__LINE__, __func__, (unsigned char *)buf_, len_)
- #define DUMP1(buf_, len_) \
- do { \
- if (0x01 & debug) \
- DUMP(buf_, len_); \
- } while (0)
- #else
- #define DUMP(buf_, len_)
- #define DUMP1(buf_, len_)
- #endif
- /* module parameters */
- static int debug;
- static int tty_major;
- static int disable_net;
- /* driver info */
- static const char driver_name[] = "hso";
- static const char tty_filename[] = "ttyHS";
- static const char *version = __FILE__ ": " MOD_AUTHOR;
- /* the usb driver itself (registered in hso_init) */
- static struct usb_driver hso_driver;
- /* serial structures */
- static struct tty_driver *tty_drv;
- static struct hso_device *serial_table[HSO_SERIAL_TTY_MINORS];
- static struct hso_device *network_table[HSO_MAX_NET_DEVICES];
- static spinlock_t serial_table_lock;
- static const s32 default_port_spec[] = {
- HSO_INTF_MUX | HSO_PORT_NETWORK,
- HSO_INTF_BULK | HSO_PORT_DIAG,
- HSO_INTF_BULK | HSO_PORT_MODEM,
- 0
- };
- static const s32 icon321_port_spec[] = {
- HSO_INTF_MUX | HSO_PORT_NETWORK,
- HSO_INTF_BULK | HSO_PORT_DIAG2,
- HSO_INTF_BULK | HSO_PORT_MODEM,
- HSO_INTF_BULK | HSO_PORT_DIAG,
- 0
- };
- #define default_port_device(vendor, product) \
- USB_DEVICE(vendor, product), \
- .driver_info = (kernel_ulong_t)default_port_spec
- #define icon321_port_device(vendor, product) \
- USB_DEVICE(vendor, product), \
- .driver_info = (kernel_ulong_t)icon321_port_spec
- /* list of devices we support */
- static const struct usb_device_id hso_ids[] = {
- {default_port_device(0x0af0, 0x6711)},
- {default_port_device(0x0af0, 0x6731)},
- {default_port_device(0x0af0, 0x6751)},
- {default_port_device(0x0af0, 0x6771)},
- {default_port_device(0x0af0, 0x6791)},
- {default_port_device(0x0af0, 0x6811)},
- {default_port_device(0x0af0, 0x6911)},
- {default_port_device(0x0af0, 0x6951)},
- {default_port_device(0x0af0, 0x6971)},
- {default_port_device(0x0af0, 0x7011)},
- {default_port_device(0x0af0, 0x7031)},
- {default_port_device(0x0af0, 0x7051)},
- {default_port_device(0x0af0, 0x7071)},
- {default_port_device(0x0af0, 0x7111)},
- {default_port_device(0x0af0, 0x7211)},
- {default_port_device(0x0af0, 0x7251)},
- {default_port_device(0x0af0, 0x7271)},
- {default_port_device(0x0af0, 0x7311)},
- {default_port_device(0x0af0, 0xc031)}, /* Icon-Edge */
- {icon321_port_device(0x0af0, 0xd013)}, /* Module HSxPA */
- {icon321_port_device(0x0af0, 0xd031)}, /* Icon-321 */
- {icon321_port_device(0x0af0, 0xd033)}, /* Icon-322 */
- {USB_DEVICE(0x0af0, 0x7301)}, /* GE40x */
- {USB_DEVICE(0x0af0, 0x7361)}, /* GE40x */
- {USB_DEVICE(0x0af0, 0x7381)}, /* GE40x */
- {USB_DEVICE(0x0af0, 0x7401)}, /* GI 0401 */
- {USB_DEVICE(0x0af0, 0x7501)}, /* GTM 382 */
- {USB_DEVICE(0x0af0, 0x7601)}, /* GE40x */
- {USB_DEVICE(0x0af0, 0x7701)},
- {USB_DEVICE(0x0af0, 0x7706)},
- {USB_DEVICE(0x0af0, 0x7801)},
- {USB_DEVICE(0x0af0, 0x7901)},
- {USB_DEVICE(0x0af0, 0x7A01)},
- {USB_DEVICE(0x0af0, 0x7A05)},
- {USB_DEVICE(0x0af0, 0x8200)},
- {USB_DEVICE(0x0af0, 0x8201)},
- {USB_DEVICE(0x0af0, 0x8300)},
- {USB_DEVICE(0x0af0, 0x8302)},
- {USB_DEVICE(0x0af0, 0x8304)},
- {USB_DEVICE(0x0af0, 0x8400)},
- {USB_DEVICE(0x0af0, 0x8600)},
- {USB_DEVICE(0x0af0, 0x8800)},
- {USB_DEVICE(0x0af0, 0x8900)},
- {USB_DEVICE(0x0af0, 0x9000)},
- {USB_DEVICE(0x0af0, 0xd035)},
- {USB_DEVICE(0x0af0, 0xd055)},
- {USB_DEVICE(0x0af0, 0xd155)},
- {USB_DEVICE(0x0af0, 0xd255)},
- {USB_DEVICE(0x0af0, 0xd057)},
- {USB_DEVICE(0x0af0, 0xd157)},
- {USB_DEVICE(0x0af0, 0xd257)},
- {USB_DEVICE(0x0af0, 0xd357)},
- {USB_DEVICE(0x0af0, 0xd058)},
- {USB_DEVICE(0x0af0, 0xc100)},
- {}
- };
- MODULE_DEVICE_TABLE(usb, hso_ids);
- /* Sysfs attribute */
- static ssize_t hso_sysfs_show_porttype(struct device *dev,
- struct device_attribute *attr,
- char *buf)
- {
- struct hso_device *hso_dev = dev_get_drvdata(dev);
- char *port_name;
- if (!hso_dev)
- return 0;
- switch (hso_dev->port_spec & HSO_PORT_MASK) {
- case HSO_PORT_CONTROL:
- port_name = "Control";
- break;
- case HSO_PORT_APP:
- port_name = "Application";
- break;
- case HSO_PORT_APP2:
- port_name = "Application2";
- break;
- case HSO_PORT_GPS:
- port_name = "GPS";
- break;
- case HSO_PORT_GPS_CONTROL:
- port_name = "GPS Control";
- break;
- case HSO_PORT_PCSC:
- port_name = "PCSC";
- break;
- case HSO_PORT_DIAG:
- port_name = "Diagnostic";
- break;
- case HSO_PORT_DIAG2:
- port_name = "Diagnostic2";
- break;
- case HSO_PORT_MODEM:
- port_name = "Modem";
- break;
- case HSO_PORT_NETWORK:
- port_name = "Network";
- break;
- default:
- port_name = "Unknown";
- break;
- }
- return sprintf(buf, "%s\n", port_name);
- }
- static DEVICE_ATTR(hsotype, S_IRUGO, hso_sysfs_show_porttype, NULL);
- static int hso_urb_to_index(struct hso_serial *serial, struct urb *urb)
- {
- int idx;
- for (idx = 0; idx < serial->num_rx_urbs; idx++)
- if (serial->rx_urb[idx] == urb)
- return idx;
- dev_err(serial->parent->dev, "hso_urb_to_index failed\n");
- return -1;
- }
- /* converts mux value to a port spec value */
- static u32 hso_mux_to_port(int mux)
- {
- u32 result;
- switch (mux) {
- case 0x1:
- result = HSO_PORT_CONTROL;
- break;
- case 0x2:
- result = HSO_PORT_APP;
- break;
- case 0x4:
- result = HSO_PORT_PCSC;
- break;
- case 0x8:
- result = HSO_PORT_GPS;
- break;
- case 0x10:
- result = HSO_PORT_APP2;
- break;
- default:
- result = HSO_PORT_NO_PORT;
- }
- return result;
- }
- /* converts port spec value to a mux value */
- static u32 hso_port_to_mux(int port)
- {
- u32 result;
- switch (port & HSO_PORT_MASK) {
- case HSO_PORT_CONTROL:
- result = 0x0;
- break;
- case HSO_PORT_APP:
- result = 0x1;
- break;
- case HSO_PORT_PCSC:
- result = 0x2;
- break;
- case HSO_PORT_GPS:
- result = 0x3;
- break;
- case HSO_PORT_APP2:
- result = 0x4;
- break;
- default:
- result = 0x0;
- }
- return result;
- }
- static struct hso_serial *get_serial_by_shared_int_and_type(
- struct hso_shared_int *shared_int,
- int mux)
- {
- int i, port;
- port = hso_mux_to_port(mux);
- for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++) {
- if (serial_table[i] &&
- (dev2ser(serial_table[i])->shared_int == shared_int) &&
- ((serial_table[i]->port_spec & HSO_PORT_MASK) == port)) {
- return dev2ser(serial_table[i]);
- }
- }
- return NULL;
- }
- static struct hso_serial *get_serial_by_index(unsigned index)
- {
- struct hso_serial *serial = NULL;
- unsigned long flags;
- spin_lock_irqsave(&serial_table_lock, flags);
- if (serial_table[index])
- serial = dev2ser(serial_table[index]);
- spin_unlock_irqrestore(&serial_table_lock, flags);
- return serial;
- }
- static int get_free_serial_index(void)
- {
- int index;
- unsigned long flags;
- spin_lock_irqsave(&serial_table_lock, flags);
- for (index = 0; index < HSO_SERIAL_TTY_MINORS; index++) {
- if (serial_table[index] == NULL) {
- spin_unlock_irqrestore(&serial_table_lock, flags);
- return index;
- }
- }
- spin_unlock_irqrestore(&serial_table_lock, flags);
- printk(KERN_ERR "%s: no free serial devices in table\n", __func__);
- return -1;
- }
- static void set_serial_by_index(unsigned index, struct hso_serial *serial)
- {
- unsigned long flags;
- spin_lock_irqsave(&serial_table_lock, flags);
- if (serial)
- serial_table[index] = serial->parent;
- else
- serial_table[index] = NULL;
- spin_unlock_irqrestore(&serial_table_lock, flags);
- }
- static void handle_usb_error(int status, const char *function,
- struct hso_device *hso_dev)
- {
- char *explanation;
- switch (status) {
- case -ENODEV:
- explanation = "no device";
- break;
- case -ENOENT:
- explanation = "endpoint not enabled";
- break;
- case -EPIPE:
- explanation = "endpoint stalled";
- break;
- case -ENOSPC:
- explanation = "not enough bandwidth";
- break;
- case -ESHUTDOWN:
- explanation = "device disabled";
- break;
- case -EHOSTUNREACH:
- explanation = "device suspended";
- break;
- case -EINVAL:
- case -EAGAIN:
- case -EFBIG:
- case -EMSGSIZE:
- explanation = "internal error";
- break;
- case -EILSEQ:
- case -EPROTO:
- case -ETIME:
- case -ETIMEDOUT:
- explanation = "protocol error";
- if (hso_dev)
- schedule_work(&hso_dev->reset_device);
- break;
- default:
- explanation = "unknown status";
- break;
- }
- /* log a meaningful explanation of an USB status */
- D1("%s: received USB status - %s (%d)", function, explanation, status);
- }
- /* Network interface functions */
- /* called when net interface is brought up by ifconfig */
- static int hso_net_open(struct net_device *net)
- {
- struct hso_net *odev = netdev_priv(net);
- unsigned long flags = 0;
- if (!odev) {
- dev_err(&net->dev, "No net device !\n");
- return -ENODEV;
- }
- odev->skb_tx_buf = NULL;
- /* setup environment */
- spin_lock_irqsave(&odev->net_lock, flags);
- odev->rx_parse_state = WAIT_IP;
- odev->rx_buf_size = 0;
- odev->rx_buf_missing = sizeof(struct iphdr);
- spin_unlock_irqrestore(&odev->net_lock, flags);
- /* We are up and running. */
- set_bit(HSO_NET_RUNNING, &odev->flags);
- hso_start_net_device(odev->parent);
- /* Tell the kernel we are ready to start receiving from it */
- netif_start_queue(net);
- return 0;
- }
- /* called when interface is brought down by ifconfig */
- static int hso_net_close(struct net_device *net)
- {
- struct hso_net *odev = netdev_priv(net);
- /* we don't need the queue anymore */
- netif_stop_queue(net);
- /* no longer running */
- clear_bit(HSO_NET_RUNNING, &odev->flags);
- hso_stop_net_device(odev->parent);
- /* done */
- return 0;
- }
- /* USB tells is xmit done, we should start the netqueue again */
- static void write_bulk_callback(struct urb *urb)
- {
- struct hso_net *odev = urb->context;
- int status = urb->status;
- /* Sanity check */
- if (!odev || !test_bit(HSO_NET_RUNNING, &odev->flags)) {
- dev_err(&urb->dev->dev, "%s: device not running\n", __func__);
- return;
- }
- /* Do we still have a valid kernel network device? */
- if (!netif_device_present(odev->net)) {
- dev_err(&urb->dev->dev, "%s: net device not present\n",
- __func__);
- return;
- }
- /* log status, but don't act on it, we don't need to resubmit anything
- * anyhow */
- if (status)
- handle_usb_error(status, __func__, odev->parent);
- hso_put_activity(odev->parent);
- /* Tell the network interface we are ready for another frame */
- netif_wake_queue(odev->net);
- }
- /* called by kernel when we need to transmit a packet */
- static netdev_tx_t hso_net_start_xmit(struct sk_buff *skb,
- struct net_device *net)
- {
- struct hso_net *odev = netdev_priv(net);
- int result;
- /* Tell the kernel, "No more frames 'til we are done with this one." */
- netif_stop_queue(net);
- if (hso_get_activity(odev->parent) == -EAGAIN) {
- odev->skb_tx_buf = skb;
- return NETDEV_TX_OK;
- }
- /* log if asked */
- DUMP1(skb->data, skb->len);
- /* Copy it from kernel memory to OUR memory */
- memcpy(odev->mux_bulk_tx_buf, skb->data, skb->len);
- D1("len: %d/%d", skb->len, MUX_BULK_TX_BUF_SIZE);
- /* Fill in the URB for shipping it out. */
- usb_fill_bulk_urb(odev->mux_bulk_tx_urb,
- odev->parent->usb,
- usb_sndbulkpipe(odev->parent->usb,
- odev->out_endp->
- bEndpointAddress & 0x7F),
- odev->mux_bulk_tx_buf, skb->len, write_bulk_callback,
- odev);
- /* Deal with the Zero Length packet problem, I hope */
- odev->mux_bulk_tx_urb->transfer_flags |= URB_ZERO_PACKET;
- /* Send the URB on its merry way. */
- result = usb_submit_urb(odev->mux_bulk_tx_urb, GFP_ATOMIC);
- if (result) {
- dev_warn(&odev->parent->interface->dev,
- "failed mux_bulk_tx_urb %d\n", result);
- net->stats.tx_errors++;
- netif_start_queue(net);
- } else {
- net->stats.tx_packets++;
- net->stats.tx_bytes += skb->len;
- }
- dev_kfree_skb(skb);
- /* we're done */
- return NETDEV_TX_OK;
- }
- static const struct ethtool_ops ops = {
- .get_link = ethtool_op_get_link
- };
- /* called when a packet did not ack after watchdogtimeout */
- static void hso_net_tx_timeout(struct net_device *net)
- {
- struct hso_net *odev = netdev_priv(net);
- if (!odev)
- return;
- /* Tell syslog we are hosed. */
- dev_warn(&net->dev, "Tx timed out.\n");
- /* Tear the waiting frame off the list */
- if (odev->mux_bulk_tx_urb &&
- (odev->mux_bulk_tx_urb->status == -EINPROGRESS))
- usb_unlink_urb(odev->mux_bulk_tx_urb);
- /* Update statistics */
- net->stats.tx_errors++;
- }
- /* make a real packet from the received USB buffer */
- static void packetizeRx(struct hso_net *odev, unsigned char *ip_pkt,
- unsigned int count, unsigned char is_eop)
- {
- unsigned short temp_bytes;
- unsigned short buffer_offset = 0;
- unsigned short frame_len;
- unsigned char *tmp_rx_buf;
- /* log if needed */
- D1("Rx %d bytes", count);
- DUMP(ip_pkt, min(128, (int)count));
- while (count) {
- switch (odev->rx_parse_state) {
- case WAIT_IP:
- /* waiting for IP header. */
- /* wanted bytes - size of ip header */
- temp_bytes =
- (count <
- odev->rx_buf_missing) ? count : odev->
- rx_buf_missing;
- memcpy(((unsigned char *)(&odev->rx_ip_hdr)) +
- odev->rx_buf_size, ip_pkt + buffer_offset,
- temp_bytes);
- odev->rx_buf_size += temp_bytes;
- buffer_offset += temp_bytes;
- odev->rx_buf_missing -= temp_bytes;
- count -= temp_bytes;
- if (!odev->rx_buf_missing) {
- /* header is complete allocate an sk_buffer and
- * continue to WAIT_DATA */
- frame_len = ntohs(odev->rx_ip_hdr.tot_len);
- if ((frame_len > DEFAULT_MRU) ||
- (frame_len < sizeof(struct iphdr))) {
- dev_err(&odev->net->dev,
- "Invalid frame (%d) length\n",
- frame_len);
- odev->rx_parse_state = WAIT_SYNC;
- continue;
- }
- /* Allocate an sk_buff */
- odev->skb_rx_buf = netdev_alloc_skb(odev->net,
- frame_len);
- if (!odev->skb_rx_buf) {
- /* We got no receive buffer. */
- D1("could not allocate memory");
- odev->rx_parse_state = WAIT_SYNC;
- return;
- }
- /* Copy what we got so far. make room for iphdr
- * after tail. */
- tmp_rx_buf =
- skb_put(odev->skb_rx_buf,
- sizeof(struct iphdr));
- memcpy(tmp_rx_buf, (char *)&(odev->rx_ip_hdr),
- sizeof(struct iphdr));
- /* ETH_HLEN */
- odev->rx_buf_size = sizeof(struct iphdr);
- /* Filip actually use .tot_len */
- odev->rx_buf_missing =
- frame_len - sizeof(struct iphdr);
- odev->rx_parse_state = WAIT_DATA;
- }
- break;
- case WAIT_DATA:
- temp_bytes = (count < odev->rx_buf_missing)
- ? count : odev->rx_buf_missing;
- /* Copy the rest of the bytes that are left in the
- * buffer into the waiting sk_buf. */
- /* Make room for temp_bytes after tail. */
- tmp_rx_buf = skb_put(odev->skb_rx_buf, temp_bytes);
- memcpy(tmp_rx_buf, ip_pkt + buffer_offset, temp_bytes);
- odev->rx_buf_missing -= temp_bytes;
- count -= temp_bytes;
- buffer_offset += temp_bytes;
- odev->rx_buf_size += temp_bytes;
- if (!odev->rx_buf_missing) {
- /* Packet is complete. Inject into stack. */
- /* We have IP packet here */
- odev->skb_rx_buf->protocol = cpu_to_be16(ETH_P_IP);
- skb_reset_mac_header(odev->skb_rx_buf);
- /* Ship it off to the kernel */
- netif_rx(odev->skb_rx_buf);
- /* No longer our buffer. */
- odev->skb_rx_buf = NULL;
- /* update out statistics */
- odev->net->stats.rx_packets++;
- odev->net->stats.rx_bytes += odev->rx_buf_size;
- odev->rx_buf_size = 0;
- odev->rx_buf_missing = sizeof(struct iphdr);
- odev->rx_parse_state = WAIT_IP;
- }
- break;
- case WAIT_SYNC:
- D1(" W_S");
- count = 0;
- break;
- default:
- D1(" ");
- count--;
- break;
- }
- }
- /* Recovery mechanism for WAIT_SYNC state. */
- if (is_eop) {
- if (odev->rx_parse_state == WAIT_SYNC) {
- odev->rx_parse_state = WAIT_IP;
- odev->rx_buf_size = 0;
- odev->rx_buf_missing = sizeof(struct iphdr);
- }
- }
- }
- static void fix_crc_bug(struct urb *urb, __le16 max_packet_size)
- {
- static const u8 crc_check[4] = { 0xDE, 0xAD, 0xBE, 0xEF };
- u32 rest = urb->actual_length % le16_to_cpu(max_packet_size);
- if (((rest == 5) || (rest == 6)) &&
- !memcmp(((u8 *)urb->transfer_buffer) + urb->actual_length - 4,
- crc_check, 4)) {
- urb->actual_length -= 4;
- }
- }
- /* Moving data from usb to kernel (in interrupt state) */
- static void read_bulk_callback(struct urb *urb)
- {
- struct hso_net *odev = urb->context;
- struct net_device *net;
- int result;
- int status = urb->status;
- /* is al ok? (Filip: Who's Al ?) */
- if (status) {
- handle_usb_error(status, __func__, odev->parent);
- return;
- }
- /* Sanity check */
- if (!odev || !test_bit(HSO_NET_RUNNING, &odev->flags)) {
- D1("BULK IN callback but driver is not active!");
- return;
- }
- usb_mark_last_busy(urb->dev);
- net = odev->net;
- if (!netif_device_present(net)) {
- /* Somebody killed our network interface... */
- return;
- }
- if (odev->parent->port_spec & HSO_INFO_CRC_BUG)
- fix_crc_bug(urb, odev->in_endp->wMaxPacketSize);
- /* do we even have a packet? */
- if (urb->actual_length) {
- /* Handle the IP stream, add header and push it onto network
- * stack if the packet is complete. */
- spin_lock(&odev->net_lock);
- packetizeRx(odev, urb->transfer_buffer, urb->actual_length,
- (urb->transfer_buffer_length >
- urb->actual_length) ? 1 : 0);
- spin_unlock(&odev->net_lock);
- }
- /* We are done with this URB, resubmit it. Prep the USB to wait for
- * another frame. Reuse same as received. */
- usb_fill_bulk_urb(urb,
- odev->parent->usb,
- usb_rcvbulkpipe(odev->parent->usb,
- odev->in_endp->
- bEndpointAddress & 0x7F),
- urb->transfer_buffer, MUX_BULK_RX_BUF_SIZE,
- read_bulk_callback, odev);
- /* Give this to the USB subsystem so it can tell us when more data
- * arrives. */
- result = usb_submit_urb(urb, GFP_ATOMIC);
- if (result)
- dev_warn(&odev->parent->interface->dev,
- "%s failed submit mux_bulk_rx_urb %d\n", __func__,
- result);
- }
- /* Serial driver functions */
- static void hso_init_termios(struct ktermios *termios)
- {
- /*
- * The default requirements for this device are:
- */
- termios->c_iflag &=
- ~(IGNBRK /* disable ignore break */
- | BRKINT /* disable break causes interrupt */
- | PARMRK /* disable mark parity errors */
- | ISTRIP /* disable clear high bit of input characters */
- | INLCR /* disable translate NL to CR */
- | IGNCR /* disable ignore CR */
- | ICRNL /* disable translate CR to NL */
- | IXON); /* disable enable XON/XOFF flow control */
- /* disable postprocess output characters */
- termios->c_oflag &= ~OPOST;
- termios->c_lflag &=
- ~(ECHO /* disable echo input characters */
- | ECHONL /* disable echo new line */
- | ICANON /* disable erase, kill, werase, and rprnt
- special characters */
- | ISIG /* disable interrupt, quit, and suspend special
- characters */
- | IEXTEN); /* disable non-POSIX special characters */
- termios->c_cflag &=
- ~(CSIZE /* no size */
- | PARENB /* disable parity bit */
- | CBAUD /* clear current baud rate */
- | CBAUDEX); /* clear current buad rate */
- termios->c_cflag |= CS8; /* character size 8 bits */
- /* baud rate 115200 */
- tty_termios_encode_baud_rate(termios, 115200, 115200);
- }
- static void _hso_serial_set_termios(struct tty_struct *tty,
- struct ktermios *old)
- {
- struct hso_serial *serial = get_serial_by_tty(tty);
- struct ktermios *termios;
- if (!serial) {
- printk(KERN_ERR "%s: no tty structures", __func__);
- return;
- }
- D4("port %d", serial->minor);
- /*
- * Fix up unsupported bits
- */
- termios = tty->termios;
- termios->c_iflag &= ~IXON; /* disable enable XON/XOFF flow control */
- termios->c_cflag &=
- ~(CSIZE /* no size */
- | PARENB /* disable parity bit */
- | CBAUD /* clear current baud rate */
- | CBAUDEX); /* clear current buad rate */
- termios->c_cflag |= CS8; /* character size 8 bits */
- /* baud rate 115200 */
- tty_encode_baud_rate(tty, 115200, 115200);
- }
- static void hso_resubmit_rx_bulk_urb(struct hso_serial *serial, struct urb *urb)
- {
- int result;
- /* We are done with this URB, resubmit it. Prep the USB to wait for
- * another frame */
- usb_fill_bulk_urb(urb, serial->parent->usb,
- usb_rcvbulkpipe(serial->parent->usb,
- serial->in_endp->
- bEndpointAddress & 0x7F),
- urb->transfer_buffer, serial->rx_data_length,
- hso_std_serial_read_bulk_callback, serial);
- /* Give this to the USB subsystem so it can tell us when more data
- * arrives. */
- result = usb_submit_urb(urb, GFP_ATOMIC);
- if (result) {
- dev_err(&urb->dev->dev, "%s failed submit serial rx_urb %d\n",
- __func__, result);
- }
- }
- static void put_rxbuf_data_and_resubmit_bulk_urb(struct hso_serial *serial)
- {
- int count;
- struct urb *curr_urb;
- while (serial->rx_urb_filled[serial->curr_rx_urb_idx]) {
- curr_urb = serial->rx_urb[serial->curr_rx_urb_idx];
- count = put_rxbuf_data(curr_urb, serial);
- if (count == -1)
- return;
- if (count == 0) {
- serial->curr_rx_urb_idx++;
- if (serial->curr_rx_urb_idx >= serial->num_rx_urbs)
- serial->curr_rx_urb_idx = 0;
- hso_resubmit_rx_bulk_urb(serial, curr_urb);
- }
- }
- }
- static void put_rxbuf_data_and_resubmit_ctrl_urb(struct hso_serial *serial)
- {
- int count = 0;
- struct urb *urb;
- urb = serial->rx_urb[0];
- if (serial->open_count > 0) {
- count = put_rxbuf_data(urb, serial);
- if (count == -1)
- return;
- }
- /* Re issue a read as long as we receive data. */
- if (count == 0 && ((urb->actual_length != 0) ||
- (serial->rx_state == RX_PENDING))) {
- serial->rx_state = RX_SENT;
- hso_mux_serial_read(serial);
- } else
- serial->rx_state = RX_IDLE;
- }
- /* read callback for Diag and CS port */
- static void hso_std_serial_read_bulk_callback(struct urb *urb)
- {
- struct hso_serial *serial = urb->context;
- int status = urb->status;
- /* sanity check */
- if (!serial) {
- D1("serial == NULL");
- return;
- } else if (status) {
- handle_usb_error(status, __func__, serial->parent);
- return;
- }
- D4("\n--- Got serial_read_bulk callback %02x ---", status);
- D1("Actual length = %d\n", urb->actual_length);
- DUMP1(urb->transfer_buffer, urb->actual_length);
- /* Anyone listening? */
- if (serial->open_count == 0)
- return;
- if (status == 0) {
- if (serial->parent->port_spec & HSO_INFO_CRC_BUG)
- fix_crc_bug(urb, serial->in_endp->wMaxPacketSize);
- /* Valid data, handle RX data */
- spin_lock(&serial->serial_lock);
- serial->rx_urb_filled[hso_urb_to_index(serial, urb)] = 1;
- put_rxbuf_data_and_resubmit_bulk_urb(serial);
- spin_unlock(&serial->serial_lock);
- } else if (status == -ENOENT || status == -ECONNRESET) {
- /* Unlinked - check for throttled port. */
- D2("Port %d, successfully unlinked urb", serial->minor);
- spin_lock(&serial->serial_lock);
- serial->rx_urb_filled[hso_urb_to_index(serial, urb)] = 0;
- hso_resubmit_rx_bulk_urb(serial, urb);
- spin_unlock(&serial->serial_lock);
- } else {
- D2("Port %d, status = %d for read urb", serial->minor, status);
- return;
- }
- }
- /*
- * This needs to be a tasklet otherwise we will
- * end up recursively calling this function.
- */
- static void hso_unthrottle_tasklet(struct hso_serial *serial)
- {
- unsigned long flags;
- spin_lock_irqsave(&serial->serial_lock, flags);
- if ((serial->parent->port_spec & HSO_INTF_MUX))
- put_rxbuf_data_and_resubmit_ctrl_urb(serial);
- else
- put_rxbuf_data_and_resubmit_bulk_urb(serial);
- spin_unlock_irqrestore(&serial->serial_lock, flags);
- }
- static void hso_unthrottle(struct tty_struct *tty)
- {
- struct hso_serial *serial = get_serial_by_tty(tty);
- tasklet_hi_schedule(&serial->unthrottle_tasklet);
- }
- static void hso_unthrottle_workfunc(struct work_struct *work)
- {
- struct hso_serial *serial =
- container_of(work, struct hso_serial,
- retry_unthrottle_workqueue);
- hso_unthrottle_tasklet(serial);
- }
- /* open the requested serial port */
- static int hso_serial_open(struct tty_struct *tty, struct file *filp)
- {
- struct hso_serial *serial = get_serial_by_index(tty->index);
- int result;
- /* sanity check */
- if (serial == NULL || serial->magic != HSO_SERIAL_MAGIC) {
- WARN_ON(1);
- tty->driver_data = NULL;
- D1("Failed to open port");
- return -ENODEV;
- }
- mutex_lock(&serial->parent->mutex);
- result = usb_autopm_get_interface(serial->parent->interface);
- if (result < 0)
- goto err_out;
- D1("Opening %d", serial->minor);
- kref_get(&serial->parent->ref);
- /* setup */
- spin_lock_irq(&serial->serial_lock);
- tty->driver_data = serial;
- tty_kref_put(serial->tty);
- serial->tty = tty_kref_get(tty);
- spin_unlock_irq(&serial->serial_lock);
- /* check for port already opened, if not set the termios */
- serial->open_count++;
- if (serial->open_count == 1) {
- serial->rx_state = RX_IDLE;
- /* Force default termio settings */
- _hso_serial_set_termios(tty, NULL);
- tasklet_init(&serial->unthrottle_tasklet,
- (void (*)(unsigned long))hso_unthrottle_tasklet,
- (unsigned long)serial);
- INIT_WORK(&serial->retry_unthrottle_workqueue,
- hso_unthrottle_workfunc);
- result = hso_start_serial_device(serial->parent, GFP_KERNEL);
- if (result) {
- hso_stop_serial_device(serial->parent);
- serial->open_count--;
- kref_put(&serial->parent->ref, hso_serial_ref_free);
- }
- } else {
- D1("Port was already open");
- }
- usb_autopm_put_interface(serial->parent->interface);
- /* done */
- if (result)
- hso_serial_tiocmset(tty, TIOCM_RTS | TIOCM_DTR, 0);
- err_out:
- mutex_unlock(&serial->parent->mutex);
- return result;
- }
- /* close the requested serial port */
- static void hso_serial_close(struct tty_struct *tty, struct file *filp)
- {
- struct hso_serial *serial = tty->driver_data;
- u8 usb_gone;
- D1("Closing serial port");
- /* Open failed, no close cleanup required */
- if (serial == NULL)
- return;
- mutex_lock(&serial->parent->mutex);
- usb_gone = serial->parent->usb_gone;
- if (!usb_gone)
- usb_autopm_get_interface(serial->parent->interface);
- /* reset the rts and dtr */
- /* do the actual close */
- serial->open_count--;
- if (serial->open_count <= 0) {
- serial->open_count = 0;
- spin_lock_irq(&serial->serial_lock);
- if (serial->tty == tty) {
- serial->tty->driver_data = NULL;
- serial->tty = NULL;
- tty_kref_put(tty);
- }
- spin_unlock_irq(&serial->serial_lock);
- if (!usb_gone)
- hso_stop_serial_device(serial->parent);
- tasklet_kill(&serial->unthrottle_tasklet);
- cancel_work_sync(&serial->retry_unthrottle_workqueue);
- }
- if (!usb_gone)
- usb_autopm_put_interface(serial->parent->interface);
- mutex_unlock(&serial->parent->mutex);
- kref_put(&serial->parent->ref, hso_serial_ref_free);
- }
- /* close the requested serial port */
- static int hso_serial_write(struct tty_struct *tty, const unsigned char *buf,
- int count)
- {
- struct hso_serial *serial = get_serial_by_tty(tty);
- int space, tx_bytes;
- unsigned long flags;
- /* sanity check */
- if (serial == NULL) {
- printk(KERN_ERR "%s: serial is NULL\n", __func__);
- return -ENODEV;
- }
- spin_lock_irqsave(&serial->serial_lock, flags);
- space = serial->tx_data_length - serial->tx_buffer_count;
- tx_bytes = (count < space) ? count : space;
- if (!tx_bytes)
- goto out;
- memcpy(serial->tx_buffer + serial->tx_buffer_count, buf, tx_bytes);
- serial->tx_buffer_count += tx_bytes;
- out:
- spin_unlock_irqrestore(&serial->serial_lock, flags);
- hso_kick_transmit(serial);
- /* done */
- return tx_bytes;
- }
- /* how much room is there for writing */
- static int hso_serial_write_room(struct tty_struct *tty)
- {
- struct hso_serial *serial = get_serial_by_tty(tty);
- int room;
- unsigned long flags;
- spin_lock_irqsave(&serial->serial_lock, flags);
- room = serial->tx_data_length - serial->tx_buffer_count;
- spin_unlock_irqrestore(&serial->serial_lock, flags);
- /* return free room */
- return room;
- }
- /* setup the term */
- static void hso_serial_set_termios(struct tty_struct *tty, struct ktermios *old)
- {
- struct hso_serial *serial = get_serial_by_tty(tty);
- unsigned long flags;
- if (old)
- D5("Termios called with: cflags new[%d] - old[%d]",
- tty->termios->c_cflag, old->c_cflag);
- /* the actual setup */
- spin_lock_irqsave(&serial->serial_lock, flags);
- if (serial->open_count)
- _hso_serial_set_termios(tty, old);
- else
- tty->termios = old;
- spin_unlock_irqrestore(&serial->serial_lock, flags);
- /* done */
- }
- /* how many characters in the buffer */
- static int hso_serial_chars_in_buffer(struct tty_struct *tty)
- {
- struct hso_serial *serial = get_serial_by_tty(tty);
- int chars;
- unsigned long flags;
- /* sanity check */
- if (serial == NULL)
- return 0;
- spin_lock_irqsave(&serial->serial_lock, flags);
- chars = serial->tx_buffer_count;
- spin_unlock_irqrestore(&serial->serial_lock, flags);
- return chars;
- }
- static int tiocmget_submit_urb(struct hso_serial *serial,
- struct hso_tiocmget *tiocmget,
- struct usb_device *usb)
- {
- int result;
- if (serial->parent->usb_gone)
- return -ENODEV;
- usb_fill_int_urb(tiocmget->urb, usb,
- usb_rcvintpipe(usb,
- tiocmget->endp->
- bEndpointAddress & 0x7F),
- &tiocmget->serial_state_notification,
- sizeof(struct hso_serial_state_notification),
- tiocmget_intr_callback, serial,
- tiocmget->endp->bInterval);
- result = usb_submit_urb(tiocmget->urb, GFP_ATOMIC);
- if (result) {
- dev_warn(&usb->dev, "%s usb_submit_urb failed %d\n", __func__,
- result);
- }
- return result;
- }
- static void tiocmget_intr_callback(struct urb *urb)
- {
- struct hso_serial *serial = urb->context;
- struct hso_tiocmget *tiocmget;
- int status = urb->status;
- u16 UART_state_bitmap, prev_UART_state_bitmap;
- struct uart_icount *icount;
- struct hso_serial_state_notification *serial_state_notification;
- struct usb_device *usb;
- /* Sanity checks */
- if (!serial)
- return;
- if (status) {
- handle_usb_error(status, __func__, serial->parent);
- return;
- }
- tiocmget = serial->tiocmget;
- if (!tiocmget)
- return;
- usb = serial->parent->usb;
- serial_state_notification = &tiocmget->serial_state_notification;
- if (serial_state_notification->bmRequestType != BM_REQUEST_TYPE ||
- serial_state_notification->bNotification != B_NOTIFICATION ||
- le16_to_cpu(serial_state_notification->wValue) != W_VALUE ||
- le16_to_cpu(serial_state_notification->wIndex) != W_INDEX ||
- le16_to_cpu(serial_state_notification->wLength) != W_LENGTH) {
- dev_warn(&usb->dev,
- "hso received invalid serial state notification\n");
- DUMP(serial_state_notification,
- sizeof(struct hso_serial_state_notification));
- } else {
- UART_state_bitmap = le16_to_cpu(serial_state_notification->
- UART_state_bitmap);
- prev_UART_state_bitmap = tiocmget->prev_UART_state_bitmap;
- icount = &tiocmget->icount;
- spin_lock(&serial->serial_lock);
- if ((UART_state_bitmap & B_OVERRUN) !=
- (prev_UART_state_bitmap & B_OVERRUN))
- icount->parity++;
- if ((UART_state_bitmap & B_PARITY) !=
- (prev_UART_state_bitmap & B_PARITY))
- icount->parity++;
- if ((UART_state_bitmap & B_FRAMING) !=
- (prev_UART_state_bitmap & B_FRAMING))
- icount->frame++;
- if ((UART_state_bitmap & B_RING_SIGNAL) &&
- !(prev_UART_state_bitmap & B_RING_SIGNAL))
- icount->rng++;
- if ((UART_state_bitmap & B_BREAK) !=
- (prev_UART_state_bitmap & B_BREAK))
- icount->brk++;
- if ((UART_state_bitmap & B_TX_CARRIER) !=
- (prev_UART_state_bitmap & B_TX_CARRIER))
- icount->dsr++;
- if ((UART_state_bitmap & B_RX_CARRIER) !=
- (prev_UART_state_bitmap & B_RX_CARRIER))
- icount->dcd++;
- tiocmget->prev_UART_state_bitmap = UART_state_bitmap;
- spin_unlock(&serial->serial_lock);
- tiocmget->intr_completed = 1;
- wake_up_interruptible(&tiocmget->waitq);
- }
- memset(serial_state_notification, 0,
- sizeof(struct hso_serial_state_notification));
- tiocmget_submit_urb(serial,
- tiocmget,
- serial->parent->usb);
- }
- /*
- * next few functions largely stolen from drivers/serial/serial_core.c
- */
- /* Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
- * - mask passed in arg for lines of interest
- * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
- * Caller should use TIOCGICOUNT to see which one it was
- */
- static int
- hso_wait_modem_status(struct hso_serial *serial, unsigned long arg)
- {
- DECLARE_WAITQUEUE(wait, current);
- struct uart_icount cprev, cnow;
- struct hso_tiocmget *tiocmget;
- int ret;
- tiocmget = serial->tiocmget;
- if (!tiocmget)
- return -ENOENT;
- /*
- * note the counters on entry
- */
- spin_lock_irq(&serial->serial_lock);
- memcpy(&cprev, &tiocmget->icount, sizeof(struct uart_icount));
- spin_unlock_irq(&serial->serial_lock);
- add_wait_queue(&tiocmget->waitq, &wait);
- for (;;) {
- spin_lock_irq(&serial->serial_lock);
- memcpy(&cnow, &tiocmget->icount, sizeof(struct uart_icount));
- spin_unlock_irq(&serial->serial_lock);
- set_current_state(TASK_INTERRUPTIBLE);
- if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
- ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
- ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd))) {
- ret = 0;
- break;
- }
- schedule();
- /* see if a signal did it */
- if (signal_pending(current)) {
- ret = -ERESTARTSYS;
- break;
- }
- cprev = cnow;
- }
- current->state = TASK_RUNNING;
- remove_wait_queue(&tiocmget->waitq, &wait);
- return ret;
- }
- /*
- * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
- * Return: write counters to the user passed counter struct
- * NB: both 1->0 and 0->1 transitions are counted except for
- * RI where only 0->1 is counted.
- */
- static int hso_get_count(struct tty_struct *tty,
- struct serial_icounter_struct *icount)
- {
- struct uart_icount cnow;
- struct hso_serial *serial = get_serial_by_tty(tty);
- struct hso_tiocmget *tiocmget = serial->tiocmget;
- memset(&icount, 0, sizeof(struct serial_icounter_struct));
- if (!tiocmget)
- return -ENOENT;
- spin_lock_irq(&serial->serial_lock);
- memcpy(&cnow, &tiocmget->icount, sizeof(struct uart_icount));
- spin_unlock_irq(&serial->serial_lock);
- icount->cts = cnow.cts;
- icount->dsr = cnow.dsr;
- icount->rng = cnow.rng;
- icount->dcd = cnow.dcd;
- icount->rx = cnow.rx;
- icount->tx = cnow.tx;
- icount->frame = cnow.frame;
- icount->overrun = cnow.overrun;
- icount->parity = cnow.parity;
- icount->brk = cnow.brk;
- icount->buf_overrun = cnow.buf_overrun;
- return 0;
- }
- static int hso_serial_tiocmget(struct tty_struct *tty)
- {
- int retval;
- struct hso_serial *serial = get_serial_by_tty(tty);
- struct hso_tiocmget *tiocmget;
- u16 UART_state_bitmap;
- /* sanity check */
- if (!serial) {
- D1("no tty structures");
- return -EINVAL;
- }
- spin_lock_irq(&serial->serial_lock);
- retval = ((serial->rts_state) ? TIOCM_RTS : 0) |
- ((serial->dtr_state) ? TIOCM_DTR : 0);
- tiocmget = serial->tiocmget;
- if (tiocmget) {
- UART_state_bitmap = le16_to_cpu(
- tiocmget->prev_UART_state_bitmap);
- if (UART_state_bitmap & B_RING_SIGNAL)
- retval |= TIOCM_RNG;
- if (UART_state_bitmap & B_RX_CARRIER)
- retval |= TIOCM_CD;
- if (UART_state_bitmap & B_TX_CARRIER)
- retval |= TIOCM_DSR;
- }
- spin_unlock_irq(&serial->serial_lock);
- return retval;
- }
- static int hso_serial_tiocmset(struct tty_struct *tty,
- unsigned int set, unsigned int clear)
- {
- int val = 0;
- unsigned long flags;
- int if_num;
- struct hso_serial *serial = get_serial_by_tty(tty);
- /* sanity check */
- if (!serial) {
- D1("no tty structures");
- return -EINVAL;
- }
- if ((serial->parent->port_spec & HSO_PORT_MASK) != HSO_PORT_MODEM)
- return -EINVAL;
- if_num = serial->parent->interface->altsetting->desc.bInterfaceNumber;
- spin_lock_irqsave(&serial->serial_lock, flags);
- if (set & TIOCM_RTS)
- serial->rts_state = 1;
- if (set & TIOCM_DTR)
- serial->dtr_state = 1;
- if (clear & TIOCM_RTS)
- serial->rts_state = 0;
- if (clear & TIOCM_DTR)
- serial->dtr_state = 0;
- if (serial->dtr_state)
- val |= 0x01;
- if (serial->rts_state)
- val |= 0x02;
- spin_unlock_irqrestore(&serial->serial_lock, flags);
- return usb_control_msg(serial->parent->usb,
- usb_rcvctrlpipe(serial->parent->usb, 0), 0x22,
- 0x21, val, if_num, NULL, 0,
- USB_CTRL_SET_TIMEOUT);
- }
- static int hso_serial_ioctl(struct tty_struct *tty,
- unsigned int cmd, unsigned long arg)
- {
- struct hso_serial *serial = get_serial_by_tty(tty);
- int ret = 0;
- D4("IOCTL cmd: %d, arg: %ld", cmd, arg);
- if (!serial)
- return -ENODEV;
- switch (cmd) {
- case TIOCMIWAIT:
- ret = hso_wait_modem_status(serial, arg);
- break;
- default:
- ret = -ENOIOCTLCMD;
- break;
- }
- return ret;
- }
- /* starts a transmit */
- static void hso_kick_transmit(struct hso_serial *serial)
- {
- u8 *temp;
- unsigned long flags;
- int res;
- spin_lock_irqsave(&serial->serial_lock, flags);
- if (!serial->tx_buffer_count)
- goto out;
- if (serial->tx_urb_used)
- goto out;
- /* Wakeup USB interface if necessary */
- if (hso_get_activity(serial->parent) == -EAGAIN)
- goto out;
- /* Switch pointers around to avoid memcpy */
- temp = serial->tx_buffer;
- serial->tx_buffer = serial->tx_data;
- serial->tx_data = temp;
- serial->tx_data_count = serial->tx_buffer_count;
- serial->tx_buffer_count = 0;
- /* If temp is set, it means we switched buffers */
- if (temp && serial->write_data) {
- res = serial->write_data(serial);
- if (res >= 0)
- serial->tx_urb_used = 1;
- }
- out:
- spin_unlock_irqrestore(&serial->serial_lock, flags);
- }
- /* make a request (for reading and writing data to muxed serial port) */
- static int mux_device_request(struct hso_serial *serial, u8 type, u16 port,
- struct urb *ctrl_urb,
- struct usb_ctrlrequest *ctrl_req,
- u8 *ctrl_urb_data, u32 size)
- {
- int result;
- int pipe;
- /* Sanity check */
- if (!serial || !ctrl_urb || !ctrl_req) {
- printk(KERN_ERR "%s: Wrong arguments\n", __func__);
- return -EINVAL;
- }
- /* initialize */
- ctrl_req->wValue = 0;
- ctrl_req->wIndex = cpu_to_le16(hso_port_to_mux(port));
- ctrl_req->wLength = cpu_to_le16(size);
- if (type == USB_CDC_GET_ENCAPSULATED_RESPONSE) {
- /* Reading command */
- ctrl_req->bRequestType = USB_DIR_IN |
- USB_TYPE_OPTION_VENDOR |
- USB_RECIP_INTERFACE;
- ctrl_req->bRequest = USB_CDC_GET_ENCAPSULATED_RESPONSE;
- pipe = usb_rcvctrlpipe(serial->parent->usb, 0);
- } else {
- /* Writing command */
- ctrl_req->bRequestType = USB_DIR_OUT |
- USB_TYPE_OPTION_VENDOR |
- USB_RECIP_INTERFACE;
- ctrl_req->bRequest = USB_CDC_SEND_ENCAPSULATED_COMMAND;
- pipe = usb_sndctrlpipe(serial->parent->usb, 0);
- }
- /* syslog */
- D2("%s command (%02x) len: %d, port: %d",
- type == USB_CDC_GET_ENCAPSULATED_RESPONSE ? "Read" : "Write",
- ctrl_req->bRequestType, ctrl_req->wLength, port);
- /* Load ctrl urb */
- ctrl_urb->transfer_flags = 0;
- usb_fill_control_urb(ctrl_urb,
- serial->parent->usb,
- pipe,
- (u8 *) ctrl_req,
- ctrl_urb_data, size, ctrl_callback, serial);
- /* Send it on merry way */
- result = usb_submit_urb(ctrl_urb, GFP_ATOMIC);
- if (result) {
- dev_err(&ctrl_urb->dev->dev,
- "%s failed submit ctrl_urb %d type %d\n", __func__,
- result, type);
- return result;
- }
- /* done */
- return size;
- }
- /* called by intr_callback when read occurs */
- static int hso_mux_serial_read(struct hso_serial *serial)
- {
- if (!serial)
- return -EINVAL;
- /* clean data */
- memset(serial->rx_data[0], 0, CTRL_URB_RX_SIZE);
- /* make the request */
- if (serial->num_rx_urbs != 1) {
- dev_err(&serial->parent->interfa…