* [RFC] updated Patch to option HSO driver to the kernel
@ 2008-04-17 21:47 Greg KH
[not found] ` <20080417214719.GF17664-U8xfFu+wG4EAvxtiuMwx3w@public.gmane.org>
0 siblings, 1 reply; 22+ messages in thread
From: Greg KH @ 2008-04-17 21:47 UTC (permalink / raw)
To: Oliver Neukum, Filip Aben, linux-usb-u79uwXL29TY76Z2rM5mHXA,
netdev-u79uwXL29TY76Z2rM5mHXA, Alan Cox,
Paulius Zaleckas <paulius.za
Thanks for all of the help with this, here's the latest version of the
driver so that everyone can sync up with it. I removed a lot of the
function declarations by moving some of the code around, but I think
more can still be done.
I'm going to be with shaky email access for the next week, due to
cross-atlantic travel and conference fun, so my responses might be a bit
slow.
thanks,
greg k-h
--------------
Subject: USB: add option hso driver
This driver is for a number of different Option devices. Originally
written by Option and Andrew Bird, but cleaned up massivly for
acceptance into mainline by me (Greg).
TODO:
- remove proc files and move to debugfs
- review network interfaces
- add better changelog information
- Use netif_msg_ for the message level rather than module parameter
- net_device_stats are now available in dev->stats
Many thanks to the following for their help in cleaning up the driver by
providing feedback and patches to it:
- Paulius Zaleckas <paulius.zaleckas-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
- Oliver Neukum <oliver-GvhC2dPhHPQdnm+yROfE0A@public.gmane.org>
- Alan Cox <alan-qBU/x9rampVanCEyBjwyrvXRex20P6io@public.gmane.org>
Cc: Andrew Bird <ajb-5+cxppFmGx6/3pe1ocb+s/XRex20P6io@public.gmane.org>
Cc: Alan Cox <alan-qBU/x9rampVanCEyBjwyrvXRex20P6io@public.gmane.org>
Cc: Filip Aben <f.aben-x9gZzRpC1QbQT0dZR+AlfA@public.gmane.org>
Cc: Paulius Zaleckas <paulius.zaleckas-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
Cc: Oliver Neukum <oliver-GvhC2dPhHPQdnm+yROfE0A@public.gmane.org>
Signed-off-by: Greg Kroah-Hartman <gregkh-l3A5Bk7waGM@public.gmane.org>
---
drivers/net/usb/Kconfig | 10
drivers/net/usb/Makefile | 1
drivers/net/usb/hso.c | 3153 +++++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 3164 insertions(+)
create mode 100644 drivers/net/usb/hso.c
--- a/drivers/net/usb/Kconfig
+++ b/drivers/net/usb/Kconfig
@@ -154,6 +154,16 @@ config USB_NET_AX8817X
This driver creates an interface named "ethX", where X depends on
what other networking devices you have in use.
+config USB_HSO
+ tristate "Option USB High Speed Mobile Devices"
+ depends on USB
+ default n
+ help
+ Choose this option if you have an Option HSDPA/HSUPA card.
+ These cards support downlink speeds of 7.2Mbps or greater.
+
+ To compile this driver as a module, choose M here: the
+ module will be called hso.
config USB_NET_CDCETHER
tristate "CDC Ethernet support (smart devices such as cable modems)"
--- a/drivers/net/usb/Makefile
+++ b/drivers/net/usb/Makefile
@@ -6,6 +6,7 @@ obj-$(CONFIG_USB_CATC) += catc.o
obj-$(CONFIG_USB_KAWETH) += kaweth.o
obj-$(CONFIG_USB_PEGASUS) += pegasus.o
obj-$(CONFIG_USB_RTL8150) += rtl8150.o
+obj-$(CONFIG_USB_HSO) += hso.o
obj-$(CONFIG_USB_NET_AX8817X) += asix.o
obj-$(CONFIG_USB_NET_CDCETHER) += cdc_ether.o
obj-$(CONFIG_USB_NET_DM9601) += dm9601.o
--- /dev/null
+++ b/drivers/net/usb/hso.c
@@ -0,0 +1,3153 @@
+/******************************************************************************
+ *
+ * Driver for Option High Speed Mobile Devices.
+ *
+ * Copyright (C) 2008 Option International
+ * Copyright (C) 2007 Andrew Bird (Sphere Systems Ltd)
+ * <ajb-5+cxppFmGx6/3pe1ocb+s/XRex20P6io@public.gmane.org>
+ *
+ * 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, should
+ * not be used.
+ *
+ *****************************************************************************/
+
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/netdevice.h>
+#include <linux/inetdevice.h>
+#include <linux/etherdevice.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/proc_fs.h>
+#include <linux/uaccess.h>
+#include <linux/usb/cdc.h>
+#include <net/arp.h>
+#include <asm/byteorder.h>
+
+
+#define DRIVER_VERSION "1.2"
+#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_INTR_BUF_SIZE 16
+#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_BUSY 1
+#define HSO_TERMINATE 2
+
+#define HSO_NET_TX_TIMEOUT (HZ*10)
+
+/* Serial port defines and structs. */
+#define HSO_THRESHOLD_THROTTLE (7*1024)
+#define HSO_THRESHOLD_UNTHROTTLE (2*1024)
+
+#define HSO_SERIAL_FLAG_THROTTLED 0
+#define HSO_SERIAL_FLAG_TX_SENT 1
+#define HSO_SERIAL_FLAG_RX_SENT 2
+
+#define HSO_SERIAL_MAGIC 0x48534f31
+
+/* Number of ttys to handle */
+#define HSO_SERIAL_TTY_MINORS 256
+
+#define MAX_RX_URBS 2
+
+#define get_serial_by_tty(x) \
+ (x ? (struct hso_serial *)x->driver_data : 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_stats stats;
+ struct net_device *net;
+
+ 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;
+ struct ethhdr dummy_eth_head;
+
+ __u16 bcdCDC;
+ __u16 wMaxSegmentSize;
+ __u16 wNumberMCFilters;
+ __u16 mode_flags;
+ unsigned long flags;
+
+};
+
+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;
+ spinlock_t buffer_lock;
+ struct usb_ctrlrequest ctrl_req_tx;
+ struct usb_ctrlrequest ctrl_req_rx;
+
+ struct usb_endpoint_descriptor *in_endp;
+ struct usb_endpoint_descriptor *out_endp;
+
+ unsigned long flags;
+ 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;
+ void *private;
+
+ int (*write_data) (struct hso_serial *serial);
+};
+
+struct hso_device {
+ union {
+ struct hso_serial *dev_serial;
+ struct hso_net *dev_net;
+ } port_data;
+
+ u32 port_spec;
+
+ u8 is_active;
+ u8 suspend_disabled;
+ u8 usb_gone;
+ struct work_struct async_get_intf;
+ struct work_struct async_put_intf;
+
+ struct usb_device *usb;
+ struct usb_interface *interface;
+ struct rfkill *rfkill;
+
+ struct device *dev;
+ struct kref ref;
+ struct mutex mutex;
+
+ /* TODO: Not sure about the ones below */
+ struct proc_dir_entry *ourproc;
+};
+
+/* 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, struct file *file,
+ unsigned int set, unsigned int clear);
+static void ctrl_callback(struct urb *urb);
+static void 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 log_usb_status(int status, const char *function);
+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 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);
+
+/*****************************************************************************/
+/* Helping functions */
+/*****************************************************************************/
+
+/* convert a character representing a hex value to a number */
+static unsigned char hex2dec(unsigned char digit)
+{
+ if ((digit >= '0') && (digit <= '9'))
+ return (digit - '0');
+ /* Map all characters to 0-15 */
+ if ((digit >= 'a') && (digit <= 'z'))
+ return (digit - 'a' + 10) % 16;
+ if ((digit >= 'A') && (digit <= 'Z'))
+ return (digit - 'A' + 10) % 16;
+ return 0;
+}
+
+#define SIOCSETRADIO (SIOCDEVPRIVATE+4)
+
+/* #define DEBUG */
+
+#define dev2net(x) (x->port_data.dev_net)
+#define dev2ser(x) (x->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)
+{
+ u8 i = 0;
+
+ printk(KERN_DEBUG "[%d:%s]: len %d", line_count, func_name, len);
+
+ for (i = 0; i < len; i++) {
+ if (!(i % 16))
+ printk("\n 0x%03x: ", i);
+ printk("%02x ", (unsigned char)buf[i]);
+ }
+ printk("\n");
+}
+
+#define DUMP(buf_, len_) \
+ dbg_dump(__LINE__, __func__, 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 procfs = 1;
+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__ ": " DRIVER_VERSION " " MOD_AUTHOR;
+/* the usb driver itself (registered in hso_init) */
+static struct usb_driver hso_driver;
+/* the procfs vars (if procfs enabled as parameter) */
+static struct proc_dir_entry *hso_proc_dir;
+static struct proc_dir_entry *hso_proc_dir_devices;
+/* 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 struct ktermios *hso_serial_termios[HSO_SERIAL_TTY_MINORS];
+static struct ktermios *hso_serial_termios_locked[HSO_SERIAL_TTY_MINORS];
+
+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 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 */
+ {default_port_device(0x0af0, 0xd033)}, /* Icon-322 */
+ {USB_DEVICE(0x0af0, 0x7301)}, /* GE40x */
+ {USB_DEVICE(0x0af0, 0x7361)}, /* GE40x */
+ {USB_DEVICE(0x0af0, 0x7401)}, /* GI 0401 */
+ {USB_DEVICE(0x0af0, 0x7501)}, /* GTM 382 */
+ {USB_DEVICE(0x0af0, 0x7601)}, /* GE40x */
+ {}
+};
+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->driver_data;
+ 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);
+
+/* 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;
+
+ if (!serial_table[index])
+ return NULL;
+ spin_lock_irqsave(&serial_table_lock, flags);
+ serial = dev2ser(serial_table[index]);
+ spin_unlock_irqrestore(&serial_table_lock, flags);
+
+ return serial;
+}
+
+static int get_free_serial_index(void)
+{
+ int index = 0;
+ 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);
+}
+
+/* log a meaningfull explanation of an USB status to syslog */
+static void log_usb_status(int status, const char *function)
+{
+ char *explanation = NULL;
+
+ 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;
+ default:
+ explanation = "unknown status";
+ break;
+ }
+ D1("%s: received USB status - %s (%d)", function, explanation, status);
+}
+
+/* Procfs functions */
+
+static int hso_proc_options(char *buf, char **start, off_t offset, int count,
+ int *eof, void *data)
+{
+ int len = 0;
+ /* get the module parameters */
+ len +=
+ snprintf(buf + len, count - len, "Version: %s\n", DRIVER_VERSION);
+ len += snprintf(buf + len, count - len, "debug: 0x%02x\n", debug);
+ len += snprintf(buf + len, count - len, "procfs: 0x%02x\n", procfs);
+ len +=
+ snprintf(buf + len, count - len, "tty_major: 0x%02x\n", tty_major);
+ len +=
+ snprintf(buf + len, count - len, "disable_net: 0x%02x\n",
+ disable_net);
+ return len;
+}
+
+static int hso_proc_port_info(char *buf, char **start, off_t offset, int count,
+ int *eof, void *data)
+{
+ int len = 0;
+ struct hso_device *hso_dev = (struct hso_device *)data;
+ char *port_name = NULL;
+
+ D1("count: %d", count);
+
+ 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_GPS:
+ port_name = "GPS";
+ break;
+ case HSO_PORT_GPS_CONTROL:
+ port_name = "GPS Control";
+ break;
+ case HSO_PORT_APP2:
+ port_name = "Application2";
+ 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;
+ }
+
+ len += snprintf(buf + len, count - len, "%s\n", port_name);
+
+ /* return the device id to the user, for use in scripts for autopm */
+ len +=
+ snprintf(buf + len, count - len, "USB bus ID:\t%s\n",
+ hso_dev->usb->dev.bus_id);
+ return len;
+}
+
+/* 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;
+ }
+ /* reset read counter. */
+ odev->stats.rx_packets = 0;
+ 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);
+
+ hso_start_net_device(odev->parent);
+
+ /* We are up and running. */
+ set_bit(HSO_NET_RUNNING, &odev->flags);
+
+ /* 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)
+ log_usb_status(status, __func__);
+
+ 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 int hso_net_start_xmit(struct sk_buff *skb, struct net_device *net)
+{
+ struct hso_net *odev = netdev_priv(net);
+ int result = 0;
+
+ /* 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 0;
+ }
+
+ /* fetch the packet */
+ skb_pull(skb, ETH_HLEN);
+ /* 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", result);
+ odev->stats.tx_errors++;
+ netif_start_queue(net);
+ } else {
+ odev->stats.tx_packets++;
+ odev->stats.tx_bytes += skb->len;
+ /* And tell the kernel when the last transmit started. */
+ net->trans_start = jiffies;
+ }
+ dev_kfree_skb(skb);
+ /* we're done */
+ return result;
+}
+
+static void hso_get_drvinfo(struct net_device *net, struct ethtool_drvinfo *info)
+{
+ struct hso_net *odev = netdev_priv(net);
+
+ strncpy(info->driver, driver_name, ETHTOOL_BUSINFO_LEN);
+ strncpy(info->version, DRIVER_VERSION, ETHTOOL_BUSINFO_LEN);
+ usb_make_path(odev->parent->usb, info->bus_info, sizeof info->bus_info);
+ snprintf(info->fw_version, ETHTOOL_BUSINFO_LEN, "%s %x.%x", driver_name,
+ ((odev->bcdCDC & 0xff00) >> 8), (odev->bcdCDC & 0x00ff));
+}
+
+static struct ethtool_ops ops = {
+ .get_drvinfo = hso_get_drvinfo,
+ .get_link = ethtool_op_get_link
+};
+
+static struct net_device_stats *hso_net_get_stats(struct net_device *net)
+{
+ return &((struct hso_net *)netdev_priv(net))->stats;
+}
+
+/* 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 */
+ odev->stats.tx_errors++;
+}
+
+/* setup the multicast filters */
+static void hso_net_set_multicast(struct net_device *net)
+{
+ struct hso_net *odev = netdev_priv(net);
+ int i = 0;
+ __u8 *buf = NULL;
+
+ /* Tell the kernel to stop sending us frames while we get this all set
+ * up. */
+ netif_stop_queue(net);
+
+ /* Note: do not reorder, GCC is clever about common statements. */
+ if (net->flags & IFF_PROMISC) {
+ /* Unconditionally log net taps. */
+ D1("%s: Promiscuous mode enabled", net->name);
+ odev->mode_flags = USB_CDC_PACKET_TYPE_ALL_MULTICAST |
+ USB_CDC_PACKET_TYPE_DIRECTED |
+ USB_CDC_PACKET_TYPE_BROADCAST |
+ USB_CDC_PACKET_TYPE_MULTICAST |
+ USB_CDC_PACKET_TYPE_PROMISCUOUS;
+ } else if (net->mc_count > odev->wNumberMCFilters) {
+ /* Too many to filter perfectly -- accept all multicasts. */
+ D1("%s: too many MC filters for hardware, using allmulti",
+ net->name);
+ odev->mode_flags = USB_CDC_PACKET_TYPE_ALL_MULTICAST |
+ USB_CDC_PACKET_TYPE_DIRECTED |
+ USB_CDC_PACKET_TYPE_BROADCAST |
+ USB_CDC_PACKET_TYPE_MULTICAST;
+ } else if (net->flags & IFF_ALLMULTI) {
+ /* Filter in software */
+ D1("%s: using allmulti", net->name);
+ odev->mode_flags = USB_CDC_PACKET_TYPE_ALL_MULTICAST |
+ USB_CDC_PACKET_TYPE_DIRECTED |
+ USB_CDC_PACKET_TYPE_BROADCAST |
+ USB_CDC_PACKET_TYPE_MULTICAST;
+ } else {
+ /* do multicast filtering in hardware */
+ struct dev_mc_list *mclist;
+ D1("%s: set multicast filters", net->name);
+ odev->mode_flags = USB_CDC_PACKET_TYPE_ALL_MULTICAST |
+ USB_CDC_PACKET_TYPE_DIRECTED |
+ USB_CDC_PACKET_TYPE_BROADCAST |
+ USB_CDC_PACKET_TYPE_MULTICAST;
+ buf = kmalloc(6 * net->mc_count, GFP_ATOMIC);
+ if (!buf) {
+ dev_err(&net->dev, "No memory to allocate?");
+ goto exit;
+ }
+ for (i = 0, mclist = net->mc_list; mclist && i < net->mc_count;
+ i++, mclist = mclist->next) {
+ memcpy(&mclist->dmi_addr, &buf[i * 6], 6);
+ }
+ kfree(buf);
+ }
+
+exit:
+ /* Tell the kernel to start giving frames to us again. */
+ netif_wake_queue(net);
+}
+
+/* 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 = 0;
+ unsigned short buffer_offset = 0;
+ unsigned short frame_len = 0;
+ unsigned char *tmp_rx_buf = NULL;
+ struct ethhdr *eth_head = NULL;
+
+ /* 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 = dev_alloc_skb(
+ frame_len + 2 +
+ odev->net->hard_header_len);
+ if (!odev->skb_rx_buf) {
+ /* We got no receive buffer. */
+ D1("could not allocate memory");
+ odev->rx_parse_state = WAIT_SYNC;
+ return;
+ }
+ /* Here's where it came from */
+ odev->skb_rx_buf->dev = odev->net;
+
+ /* Make some headroom: standard alignment + the
+ * ethernet header. */
+ skb_reserve(odev->skb_rx_buf,
+ 2 + odev->net->hard_header_len);
+
+ /* 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 =
+ odev->net->hard_header_len +
+ 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. */
+ /* Add fake ethernet header. */
+ eth_head = (struct ethhdr *)skb_push(odev->
+ skb_rx_buf,
+ odev->
+ net->
+ hard_header_len);
+ memcpy(eth_head, &odev->dummy_eth_head,
+ sizeof(struct ethhdr));
+
+ /* Not sure here either */
+ odev->skb_rx_buf->protocol = eth_type_trans(
+ odev->skb_rx_buf,
+ odev->net);
+ /* don't check it */
+ odev->skb_rx_buf->ip_summed =
+ CHECKSUM_UNNECESSARY;
+ /* 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->stats.rx_packets++;
+
+ /* Hmmm, wonder if we have received the IP len
+ * or the ETH len. */
+ odev->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);
+ }
+ }
+}
+
+/* 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 = NULL;
+ int result = 0;
+ int status = urb->status;
+
+ /* is al ok? (Filip: Who's Al ?) */
+ if (status) {
+ log_usb_status(status, __func__);
+ 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) {
+ u32 rest;
+ u8 crc_check[4] = { 0xDE, 0xAD, 0xBE, 0xEF };
+ rest = urb->actual_length % odev->in_endp->wMaxPacketSize;
+ if (((rest == 5) || (rest == 6))
+ && !memcmp(((u8 *) urb->transfer_buffer) +
+ urb->actual_length - 4, crc_check, 4)) {
+ urb->actual_length -= 4;
+ }
+ }
+
+ /* 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", __func__,
+ result);
+}
+
+/* Serial driver functions */
+
+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 ((!tty) || (!tty->termios) || (!serial)) {
+ printk(KERN_ERR "%s: no tty structures", __func__);
+ return;
+ }
+
+ D4("port %d", serial->minor);
+
+ /*
+ * The default requirements for this device are:
+ */
+ termios = serial->tty->termios;
+ 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_encode_baud_rate(serial->tty, 115200, 115200);
+
+ /*
+ * Force low_latency on; otherwise the pushes are scheduled;
+ * this is bad as it opens up the possibility of dropping bytes
+ * on the floor. We don't want to drop bytes on the floor. :)
+ */
+ serial->tty->low_latency = 1;
+ return;
+}
+
+/* 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) {
+ 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 */
+ tty->driver_data = serial;
+ serial->tty = tty;
+
+ /* check for port allready opened, if not set the termios */
+ serial->open_count++;
+ if (serial->open_count == 1) {
+ tty->low_latency = 1;
+ serial->flags = 0;
+ /* Force default termio settings */
+ _hso_serial_set_termios(tty, NULL);
+ 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, NULL, 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");
+
+ /* sanity check */
+ if (tty == NULL || serial == NULL) {
+ D1("(tty == NULL || tty->driver_data == 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) {
+ kref_put(&serial->parent->ref, hso_serial_ref_free);
+ serial->open_count = 0;
+ if (serial->tty) {
+ serial->tty->driver_data = NULL;
+ serial->tty = NULL;
+ }
+ if (!usb_gone)
+ hso_stop_serial_device(serial->parent);
+ }
+ if (!usb_gone)
+ usb_autopm_put_interface(serial->parent->interface);
+ mutex_unlock(&serial->parent->mutex);
+}
+
+/* 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 = 0, tx_bytes = 0;
+ unsigned long flags;
+
+ /* sanity check */
+ if (serial == NULL) {
+ printk(KERN_ERR "%s: tty or tty->driver_data 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 = 0;
+ 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);
+ spin_unlock_irqrestore(&serial->serial_lock, flags);
+
+ /* done */
+ return;
+}
+
+/* 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 = 0;
+ 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 hso_serial_tiocmget(struct tty_struct *tty, struct file *file)
+{
+ unsigned int value = 0;
+ struct hso_serial *serial = get_serial_by_tty(tty);
+ unsigned long flags;
+
+ /* sanity check */
+ if (!serial) {
+ D1("no tty structures");
+ return -EINVAL;
+ }
+
+ spin_lock_irqsave(&serial->serial_lock, flags);
+ value = ((serial->rts_state) ? TIOCM_RTS : 0) |
+ ((serial->dtr_state) ? TIOCM_DTR : 0);
+ spin_unlock_irqrestore(&serial->serial_lock, flags);
+
+ return value;
+}
+
+static int hso_serial_tiocmset(struct tty_struct *tty, struct file *file,
+ 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_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);
+}
+
+/* starts a transmit */
+static void hso_kick_transmit(struct hso_serial *serial)
+{
+ u8 *temp = NULL;
+ 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 = 0;
+ int pipe = -1;
+
+ /* 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 = hso_port_to_mux(port);
+ ctrl_req->wLength = 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", __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->interface->dev,
+ "ERROR: mux'd reads with multiple buffers "
+ "not possible\n");
+ return 0;
+ }
+ return mux_device_request(serial,
+ USB_CDC_GET_ENCAPSULATED_RESPONSE,
+ serial->parent->port_spec & HSO_PORT_MASK,
+ serial->rx_urb[0],
+ &serial->ctrl_req_rx,
+ serial->rx_data[0], serial->rx_data_length);
+}
+
+/* used for muxed serial port callback (muxed serial read) */
+static void intr_callback(struct urb *urb)
+{
+ struct hso_shared_int *shared_int = urb->context;
+ struct hso_serial *serial = NULL;
+ unsigned char *port_req = NULL;
+ int status = urb->status;
+ int i = 0;
+
+ usb_mark_last_busy(urb->dev);
+
+ /* sanity check */
+ if (!shared_int)
+ return;
+
+ /* status check */
+ if (status) {
+ log_usb_status(status, __func__);
+ return;
+ }
+ D4("\n--- Got intr callback 0x%02X ---", status);
+
+ /* what request? */
+ port_req = urb->transfer_buffer;
+ D4(" port_req = 0x%.2X\n", *port_req);
+ /* loop over all muxed ports to find the one sending this */
+ for (i = 0; i < 8; i++) {
+ /* max 8 channels on MUX */
+ if (*port_req & (1 << i)) {
+ serial = get_serial_by_shared_int_and_type(shared_int,
+ (1 << i));
+ if (serial != NULL) {
+ D1("Pending read interrupt on port %d\n", i);
+ if (!test_and_set_bit(HSO_SERIAL_FLAG_RX_SENT,
+ &serial->flags)) {
+ /* Setup and send a ctrl req read on
+ * port i */
+ hso_mux_serial_read(serial);
+ } else {
+ D1("Already pending a read on "
+ "port %d\n", i);
+ }
+ }
+ }
+ }
+ /* Resubmit interrupt urb */
+ hso_mux_submit_intr_urb(shared_int, urb->dev, GFP_ATOMIC);
+}
+
+/* called for writing to muxed serial port */
+static int hso_mux_serial_write_data(struct hso_serial *serial)
+{
+ if (NULL == serial)
+ return -EINVAL;
+
+ return mux_device_request(serial,
+ USB_CDC_SEND_ENCAPSULATED_COMMAND,
+ serial->parent->port_spec & HSO_PORT_MASK,
+ serial->tx_urb,
+ &serial->ctrl_req_tx,
+ serial->tx_data, serial->tx_data_count);
+}
+
+/* write callback for Diag and CS port */
+static void hso_std_serial_write_bulk_callback(struct urb *urb)
+{
+ struct hso_serial *serial = urb->context;
+ int status = urb->status;
+
+ /* sanity check */
+ if (!serial) {
+ D1("serial == NULL");
+ return;
+ }
+
+ spin_lock(&serial->serial_lock);
+ serial->tx_urb_used = 0;
+ spin_unlock(&serial->serial_lock);
+ if (status) {
+ log_usb_status(status, __func__);
+ return;
+ }
+ hso_put_activity(serial->parent);
+ tty_wakeup(serial->tty);
+ hso_kick_transmit(serial);
+
+ D1(" ");
+ return;
+}
+
+/* called for writing diag or CS serial port */
+static int hso_std_serial_write_data(struct hso_serial *serial)
+{
+ int count = serial->tx_data_count;
+ int result = 0;
+
+ usb_fill_bulk_urb(serial->tx_urb,
+ serial->parent->usb,
+ usb_sndbulkpipe(serial->parent->usb,
+ serial->out_endp->
+ bEndpointAddress & 0x7F),
+ serial->tx_data, serial->tx_data_count,
+ hso_std_serial_write_bulk_callback, serial);
+
+ result = usb_submit_urb(serial->tx_urb, GFP_ATOMIC);
+ if (result) {
+ dev_warn(&serial->parent->usb->dev,
+ "Failed to submit urb - res %d\n", result);
+ return result;
+ }
+
+ return count;
+}
+
+/* callback after read or write on muxed serial port */
+static void ctrl_callback(struct urb *urb)
+{
+ struct hso_serial *serial = urb->context;
+ struct usb_ctrlrequest *req = NULL;
+ int status = urb->status;
+
+ /* sanity check */
+ if (!serial)
+ return;
+
+ spin_lock(&serial->serial_lock);
+ serial->tx_urb_used = 0;
+ spin_unlock(&serial->serial_lock);
+ if (status) {
+ log_usb_status(status, __func__);
+ return;
+ }
+
+ /* what request? */
+ req = (struct usb_ctrlrequest *)(urb->setup_packet);
+ D4("\n--- Got muxed ctrl callback 0x%02X ---", status);
+ D4("Actual length of urb = %d\n", urb->actual_length);
+ DUMP1(urb->transfer_buffer, urb->actual_length);
+
+ if (req->bRequestType ==
+ (USB_DIR_IN | USB_TYPE_OPTION_VENDOR | USB_RECIP_INTERFACE)) {
+ /* response to a read command */
+ if (serial->open_count > 0) {
+ /* handle RX data the normal way */
+ put_rxbuf_data(urb, serial);
+ }
+
+ /* Re issue a read as long as we receive data. */
+ if (urb->actual_length != 0)
+ hso_mux_serial_read(serial);
+ else
+ clear_bit(HSO_SERIAL_FLAG_RX_SENT, &serial->flags);
+ } else {
+ hso_put_activity(serial->parent);
+ tty_wakeup(serial->tty);
+ /* response to a write command */
+ hso_kick_transmit(serial);
+ }
+}
+
+/* handle RX data for serial port */
+static void put_rxbuf_data(struct urb *urb, struct hso_serial *serial)
+{
+ struct tty_struct *tty = serial->tty;
+
+ /* Sanity check */
+ if (urb == NULL || serial == NULL) {
+ D1("serial = NULL");
+ return;
+ }
+
+ /* Push data to tty */
+ if (tty && urb->actual_length) {
+ D1("data to push to tty");
+ tty_insert_flip_string(tty, urb->transfer_buffer,
+ urb->actual_length);
+ tty_flip_buffer_push(tty);
+ }
+}
+
+/* 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 result = 0;
+ int status = urb->status;
+
+ /* sanity check */
+ if (!serial) {
+ D1("serial == NULL");
+ return;
+ } else if (status) {
+ log_usb_status(status, __func__);
+ 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) {
+ u32 rest;
+ u8 crc_check[4] = { 0xDE, 0xAD, 0xBE, 0xEF };
+ rest =
+ urb->actual_length %
+ serial->in_endp->wMaxPacketSize;
+ if (((rest == 5) || (rest == 6))
+ && !memcmp(((u8 *) urb->transfer_buffer) +
+ urb->actual_length - 4, crc_check, 4)) {
+ urb->actual_length -= 4;
+ }
+ }
+ /* Valid data, handle RX data */
+ put_rxbuf_data(urb, serial);
+ } else if (status == -ENOENT || status == -ECONNRESET) {
+ /* Unlinked - check for throttled port. */
+ D2("Port %d, successfully unlinked urb", serial->minor);
+ } else {
+ D2("Port %d, status = %d for read urb", serial->minor, status);
+ return;
+ }
+
+ usb_mark_last_busy(urb->dev);
+
+ /* 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",
+ __func__, result);
+ }
+}
+
+/* Base driver functions */
+
+static void hso_log_port(struct hso_device *hso_dev)
+{
+ char *port_type = NULL;
+ char port_dev[20];
+
+ switch (hso_dev->port_spec & HSO_PORT_MASK) {
+ case HSO_PORT_CONTROL:
+ port_type = "Control";
+ break;
+ case HSO_PORT_APP:
+ port_type = "Application";
+ break;
+ case HSO_PORT_GPS:
+ port_type = "GPS";
+ break;
+ case HSO_PORT_GPS_CONTROL:
+ port_type = "GPS control";
+ break;
+ case HSO_PORT_APP2:
+ port_type = "Application2";
+ break;
+ case HSO_PORT_PCSC:
+ port_type = "PCSC";
+ break;
+ case HSO_PORT_DIAG:
+ port_type = "Diagnostic";
+ break;
+ case HSO_PORT_DIAG2:
+ port_type = "Diagnostic2";
+ break;
+ case HSO_PORT_MODEM:
+ port_type = "Modem";
+ break;
+ case HSO_PORT_NETWORK:
+ port_type = "Network";
+ break;
+ default:
+ port_type = "Unknown";
+ break;
+ }
+ if ((hso_dev->port_spec & HSO_PORT_MASK) == HSO_PORT_NETWORK) {
+ sprintf(port_dev, "%s", dev2net(hso_dev)->net->name);
+ } else
+ sprintf(port_dev, "/dev/%s%d", tty_filename,
+ dev2ser(hso_dev)->minor);
+
+ dev_dbg(&hso_dev->interface->dev, "HSO: Found %s port %s\n",
+ port_type, port_dev);
+}
+
+static int hso_start_net_device(struct hso_device *hso_dev)
+{
+ int i, result = 0;
+ struct hso_net *hso_net = dev2net(hso_dev);
+
+ if (!hso_net)
+ return -ENODEV;
+
+ /* send URBs for all read buffers */
+ for (i = 0; i < MUX_BULK_RX_BUF_COUNT; i++) {
+
+ /* Prep a receive URB */
+ usb_fill_bulk_urb(hso_net->mux_bulk_rx_urb_pool[i],
+ hso_dev->usb,
+ usb_rcvbulkpipe(hso_dev->usb,
+ hso_net->in_endp->
+ bEndpointAddress & 0x7F),
+ hso_net->mux_bulk_rx_buf_pool[i],
+ MUX_BULK_RX_BUF_SIZE, read_bulk_callback,
+ hso_net);
+
+ /* Put it out there so the device can send us stuff */
+ result = usb_submit_urb(hso_net->mux_bulk_rx_urb_pool[i],
+ GFP_NOIO);
+ if (result)
+ dev_warn(&hso_dev->usb->dev,
+ "%s failed mux_bulk_rx_urb[%d] %d\n", __func__,
+ i, result);
+ }
+
+ return result;
+}
+
+static int hso_stop_net_device(struct hso_device *hso_dev)
+{
+ int i;
+ struct hso_net *hso_net = dev2net(hso_dev);
+
+ if (!hso_net)
+ return -ENODEV;
+
+ for (i = 0; i < MUX_BULK_RX_BUF_COUNT; i++) {
+ if (hso_net->mux_bulk_rx_urb_pool[i])
+ usb_kill_urb(hso_net->mux_bulk_rx_urb_pool[i]);
+
+ }
+ if (hso_net->mux_bulk_tx_urb)
+ usb_kill_urb(hso_net->mux_bulk_tx_urb);
+
+ return 0;
+}
+
+static int hso_start_serial_device(struct hso_device *hso_dev, gfp_t flags)
+{
+ int i, result = 0;
+ struct hso_serial *serial = dev2ser(hso_dev);
+
+ if (!serial)
+ return -ENODEV;
+
+ /* If it is not the MUX port fill in and submit a bulk urb (already
+ * allocated in hso_serial_start) */
+ if (!(serial->parent->port_spec & HSO_INTF_MUX)) {
+ for (i = 0; i < serial->num_rx_urbs; i++) {
+ usb_fill_bulk_urb(serial->rx_urb[i],
+ serial->parent->usb,
+ usb_rcvbulkpipe(serial->parent->usb,
+ serial->in_endp->
+ bEndpointAddress &
+ 0x7F),
+ serial->rx_data[i],
+ serial->rx_data_length,
+ hso_std_serial_read_bulk_callback,
+ serial);
+ result = usb_submit_urb(serial->rx_urb[i], flags);
+ if (result) {
+ dev_warn(&serial->parent->usb->dev,
+ "Failed to submit urb - res %d\n",
+ result);
+ break;
+ }
+ }
+ } else {
+ mutex_lock(&serial->shared_int->shared_int_lock);
+ if (!serial->shared_int->use_count) {
+ result =
+ hso_mux_submit_intr_urb(serial->shared_int,
+ hso_dev->usb, flags);
+ }
+ serial->shared_int->use_count++;
+ mutex_unlock(&serial->shared_int->shared_int_lock);
+ }
+
+ return result;
+}
+
+static int hso_stop_serial_device(struct hso_device *hso_dev)
+{
+ int i;
+ struct hso_serial *serial = dev2ser(hso_dev);
+
+ if (!serial)
+ return -ENODEV;
+
+ for (i = 0; i < serial->num_rx_urbs; i++) {
+ if (serial->rx_urb[i])
+ usb_kill_urb(serial->rx_urb[i]);
+ }
+
+ if (serial->tx_urb)
+ usb_kill_urb(serial->rx_urb[i]);
+
+ if (serial->shared_int) {
+ mutex_lock(&serial->shared_int->shared_int_lock);
+ if (serial->shared_int->use_count &&
+ (--serial->shared_int->use_count == 0)) {
+ struct urb *urb;
+
+ urb = serial->shared_int->shared_intr_urb;
+ if (urb)
+ usb_kill_urb(urb);
+ }
+ mutex_unlock(&serial->shared_int->shared_int_lock);
+ }
+
+ return 0;
+}
+
+static void hso_serial_common_free(struct hso_serial *serial)
+{
+ int i;
+
+ if (serial->parent->dev)
+ device_remove_file(serial->parent->dev, &dev_attr_hsotype);
+
+ tty_unregister_device(tty_drv, serial->minor);
+
+ for (i = 0; i < serial->num_rx_urbs; i++) {
+ /* unlink and free RX URB */
+ usb_free_urb(serial->rx_urb[i]);
+ /* free the RX buffer */
+ kfree(serial->rx_data[i]);
+ }
+
+ /* unlink and free TX URB */
+ usb_free_urb(serial->tx_urb);
+ kfree(serial->tx_data);
+}
+
+static int hso_serial_common_create(struct hso_serial *serial, int num_urbs,
+ int rx_size, int tx_size)
+{
+ struct device *dev = NULL;
+ int minor;
+ int i;
+
+ minor = get_free_serial_index();
+ if (minor < 0)
+ goto exit;
+
+ /* register our minor number */
+ serial->parent->dev = tty_register_device(tty_drv, minor,
+ &serial->parent->interface->dev);
+ dev = serial->parent->dev;
+ dev->driver_data = serial->parent;
+ i = device_create_file(dev, &dev_attr_hsotype);
+
+ /* fill in specific data for later use */
+ serial->minor = minor;
+ serial->magic = HSO_SERIAL_MAGIC;
+ spin_lock_init(&serial->serial_lock);
+ serial->num_rx_urbs = num_urbs;
+
+ /* RX, allocate urb and initialize */
+
+ /* prepare our RX buffer */
+ serial->rx_data_length = rx_size;
+ for (i = 0; i < serial->num_rx_urbs; i++) {
+ serial->rx_urb[i] = usb_alloc_urb(0, GFP_KERNEL);
+ if (!serial->rx_urb[i]) {
+ dev_err(dev, "Could not allocate urb?\n");
+ goto exit;
+ }
+ serial->rx_urb[i]->transfer_buffer = NULL;
+ serial->rx_urb[i]->transfer_buffer_length = 0;
+ serial->rx_data[i] = kzalloc(serial->rx_data_length,
+ GFP_KERNEL);
+ if (!serial->rx_data[i]) {
+ dev_err(dev, "%s - Out of memory\n", __func__);
+ goto exit;
+ }
+ }
+
+ /* TX, allocate urb and initialize */
+ serial->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
+ if (!serial->tx_urb) {
+ dev_err(dev, "Could not allocate urb?\n");
+ goto exit;
+ }
+ serial->tx_urb->transfer_buffer = NULL;
+ serial->tx_urb->transfer_buffer_length = 0;
+ /* prepare our TX buffer */
+ serial->tx_data_count = 0;
+ serial->tx_buffer_count = 0;
+ serial->tx_data_length = tx_size;
+ serial->tx_data = kzalloc(serial->tx_data_length, GFP_KERNEL);
+ if (!serial->tx_data) {
+ dev_err(dev, "%s - Out of memory", __func__);
+ goto exit;
+ }
+ serial->tx_buffer = kzalloc(serial->tx_data_length, GFP_KERNEL);
+ if (!serial->tx_buffer) {
+ dev_err(dev, "%s - Out of memory", __func__);
+ goto exit;
+ }
+
+ return 0;
+exit:
+ hso_serial_common_free(serial);
+ return -1;
+
+}
+
+/* Frees a general hso device */
+static void hso_free_device(struct hso_device *hso_dev)
+{
+ kfree(hso_dev);
+}
+
+/* Creates a general hso device */
+static struct hso_device *hso_create_device(struct usb_interface *intf,
+ int port_spec)
+{
+ struct hso_device *hso_dev;
+
+ hso_dev = kzalloc(sizeof(*hso_dev), GFP_ATOMIC);
+ if (!hso_dev)
+ return NULL;
+
+ hso_dev->port_spec = port_spec;
+ hso_dev->usb = interface_to_usbdev(intf);
+ hso_dev->interface = intf;
+ kref_init(&hso_dev->ref);
+ mutex_init(&hso_dev->mutex);
+
+ INIT_WORK(&hso_dev->async_get_intf, async_get_intf);
+ INIT_WORK(&hso_dev->async_put_intf, async_put_intf);
+
+ return hso_dev;
+}
+
+/* Removes a network device in the network device table */
+static int remove_net_device(struct hso_device *hso_dev)
+{
+ int i;
+
+ for (i = 0; i < HSO_MAX_NET_DEVICES; i++) {
+ if (network_table[i] == hso_dev) {
+ network_table[i] = NULL;
+ break;
+ }
+ }
+ if (i == HSO_MAX_NET_DEVICES)
+ return -1;
+ return 0;
+}
+
+/* Frees our network device */
+static void hso_free_net_device(struct hso_device *hso_dev)
+{
+ int i;
+ struct hso_net *hso_net = dev2net(hso_dev);
+
+ if (!hso_net)
+ return;
+
+ if (procfs)
+ remove_proc_entry(hso_net->net->name, hso_proc_dir_devices);
+
+ /* start freeing */
+ for (i = 0; i < MUX_BULK_RX_BUF_COUNT; i++) {
+ usb_free_urb(hso_net->mux_bulk_rx_urb_pool[i]);
+ kfree(hso_net->mux_bulk_rx_buf_pool[i]);
+ }
+ usb_free_urb(hso_net->mux_bulk_tx_urb);
+ kfree(hso_net->mux_bulk_tx_buf);
+
+ remove_net_device(hso_net->parent);
+
+ if (hso_net->net) {
+ unregister_netdev(hso_net->net);
+ free_netdev(hso_net->net);
+ }
+
+ hso_free_device(hso_dev);
+}
+
+/* initialize the network interface */
+static void hso_net_init(struct net_device *net)
+{
+ struct hso_net *hso_net = netdev_priv(net);
+
+ /* initialize to zero */
+ memset(hso_net, 0, sizeof(*hso_net));
+ D1("sizeof hso_net is %d", (int)sizeof(*hso_net));
+
+ /* most of the setup is done by standard function */
+ ether_setup(net);
+
+ /* fill in the other fields */
+ net->open = hso_net_open;
+ net->stop = hso_net_close;
+ net->hard_start_xmit = hso_net_start_xmit;
+ net->get_stats = hso_net_get_stats;
+ net->tx_timeout = hso_net_tx_timeout;
+ net->watchdog_timeo = HSO_NET_TX_TIMEOUT;
+ net->set_multicast_list = hso_net_set_multicast;
+ net->flags |= IFF_NOARP;
+ net->mtu = DEFAULT_MTU - 14;
+ net->tx_queue_len = 10;
+ SET_ETHTOOL_OPS(net, &ops);
+ hso_net->skb_rx_buf = NULL;
+ hso_net->rx_parse_state = WAIT_IP;
+ hso_net->wMaxSegmentSize = DEFAULT_MTU;
+ /* always use all multi, no lists of multicasts */
+ hso_net->wNumberMCFilters = 0;
+
+ /* and initialize the semaphore */
+ spin_lock_init(&hso_net->net_lock);
+}
+
+/* setting the mac-address of the newly created iface */
+static void set_ethernet_addr(struct hso_net *odev)
+{
+ unsigned char mac_addr[6];
+ unsigned char dummy_mac[6];
+ int i = 0;
+ int len = 0;
+ unsigned char buffer[13];
+
+ /* we can't fail, therefor we use a random macaddress */
+ random_ether_addr(mac_addr);
+ dummy_mac[0] = 0xFA;
+ dummy_mac[1] = mac_addr[1];
+ dummy_mac[2] = mac_addr[2];
+ dummy_mac[3] = mac_addr[3];
+ dummy_mac[4] = mac_addr[4];
+ dummy_mac[5] = mac_addr[5];
+
+ /* but we like consistency, that's why we try to use the serial number
+ * as a macaddress if available */
+ len = usb_string(odev->parent->usb,
+ odev->parent->usb->descriptor.iSerialNumber,
+ buffer, 13);
+ if (len != 12 && strcmp("Serial", buffer)) {
+ /* Fill in the mac_addr */
+ for (i = 0; i < 6; i++) {
+ mac_addr[i] = (hex2dec(buffer[2 * i]) << 4) +
+ hex2dec(buffer[2 * i + 1]);
+ }
+ mac_addr[0] &= 0xfe; /* clear multicast bit */
+ mac_addr[0] |= 0x02; /* set local assignment bit (IEEE802) */
+ } else {
+ dev_err(&odev->parent->usb->dev, "Attempting to get MAC "
+ "address failed: using random\n");
+ }
+
+ /* Now copy it over to our network device structure */
+ memcpy(odev->net->dev_addr, mac_addr, sizeof(mac_addr));
+
+ /* Create the default fake ethernet header. */
+ memcpy(odev->dummy_eth_head.h_dest, mac_addr, ETH_ALEN);
+ memcpy(odev->dummy_eth_head.h_source, dummy_mac, ETH_ALEN);
+ odev->dummy_eth_head.h_proto = htons(ETH_P_IP);
+}
+
+/* Adds a network device in the network device table */
+static int add_net_device(struct hso_device *hso_dev)
+{
+ int i;
+
+ for (i = 0; i < HSO_MAX_NET_DEVICES; i++) {
+ if (network_table[i] == NULL) {
+ network_table[i] = hso_dev;
+ break;
+ }
+ }
+ if (i == HSO_MAX_NET_DEVICES)
+ return -1;
+ return 0;
+}
+
+/* Creates our network device */
+static struct hso_device *hso_create_net_device(struct usb_interface *interface)
+{
+ int result, i;
+ struct net_device *net = NULL;
+ struct hso_net *hso_net = NULL;
+ struct hso_device *hso_dev = NULL;
+
+ hso_dev = hso_create_device(interface, HSO_INTF_MUX | HSO_PORT_NETWORK);
+ if (!hso_dev)
+ return NULL;
+
+ /* allocate our network device, then we can put in our private data */
+ /* call hso_net_init to do the basic initialization */
+ net = alloc_netdev(sizeof(struct hso_net), "hso%d", hso_net_init);
+ if (!net) {
+ dev_err(&interface->dev, "Unable to create ethernet device\n");
+ goto exit;
+ }
+
+ hso_net = netdev_priv(net);
+
+ hso_dev->port_data.dev_net = hso_net;
+ hso_net->net = net;
+ hso_net->parent = hso_dev;
+
+ hso_net->in_endp = hso_get_ep(interface, USB_ENDPOINT_XFER_BULK,
+ USB_DIR_IN);
+ if (!hso_net->in_endp) {
+ dev_err(&interface->dev, "Can't find BULK IN endpoint\n");
+ goto exit;
+ }
+ hso_net->out_endp = hso_get_ep(interface, USB_ENDPOINT_XFER_BULK,
+ USB_DIR_OUT);
+ if (!hso_net->out_endp) {
+ dev_err(&interface->dev, "Can't find BULK OUT endpoint\n");
+ goto exit;
+ }
+ SET_NETDEV_DEV(net, &interface->dev);
+
+ /* registering our net device */
+ result = register_netdev(net);
+ if (result) {
+ dev_err(&interface->dev, "Failed to register device\n");
+ goto exit;
+ }
+
+ /* start allocating */
+ for (i = 0; i < MUX_BULK_RX_BUF_COUNT; i++) {
+ hso_net->mux_bulk_rx_urb_pool[i] = usb_alloc_urb(0, GFP_KERNEL);
+ if (!hso_net->mux_bulk_rx_urb_pool[i]) {
+ dev_err(&interface->dev, "Could not allocate rx urb\n");
+ goto exit;
+ }
+ hso_net->mux_bulk_rx_buf_pool[i] = kzalloc(MUX_BULK_RX_BUF_SIZE,
+ GFP_KERNEL);
+ if (!hso_net->mux_bulk_rx_buf_pool[i]) {
+ dev_err(&interface->dev, "Could not allocate rx buf\n");
+ goto exit;
+ }
+ }
+ hso_net->mux_bulk_tx_urb = usb_alloc_urb(0, GFP_KERNEL);
+ if (!hso_net->mux_bulk_tx_urb) {
+ dev_err(&interface->dev, "Could not allocate tx urb\n");
+ goto exit;
+ }
+ hso_net->mux_bulk_tx_buf = kzalloc(MUX_BULK_TX_BUF_SIZE, GFP_KERNEL);
+ if (!hso_net->mux_bulk_tx_buf) {
+ dev_err(&interface->dev, "Could not allocate tx buf\n");
+ goto exit;
+ }
+
+ /* and don't forget the MAC address. */
+ set_ethernet_addr(hso_net);
+
+ add_net_device(hso_dev);
+
+ /* setup the proc dirs and files if needed */
+ if (procfs) {
+ if (!hso_proc_dir_devices)
+ printk(KERN_WARNING "hso: Warning, creating port info "
+ "under root\n");
+ create_proc_read_entry(hso_net->net->name, 0,
+ hso_proc_dir_devices, hso_proc_port_info,
+ hso_dev);
+ }
+
+ hso_log_port(hso_dev);
+
+ return hso_dev;
+exit:
+ hso_free_net_device(hso_dev);
+ return NULL;
+}
+
+/* Frees an AT channel ( goes for both mux and non-mux ) */
+static void hso_free_serial_device(struct hso_device *hso_dev)
+{
+ struct hso_serial *serial = dev2ser(hso_dev);
+ char device_name[20];
+
+ if (!serial)
+ return;
+ set_serial_by_index(serial->minor, NULL);
+
+ if (procfs) {
+ sprintf(device_name, "%s%d", tty_filename, serial->minor);
+ remove_proc_entry(device_name, hso_proc_dir_devices);
+ }
+
+ hso_serial_common_free(serial);
+
+ if (serial->shared_int) {
+ mutex_lock(&serial->shared_int->shared_int_lock);
+ if (--serial->shared_int->ref_count == 0)
+ hso_free_shared_int(serial->shared_int);
+ mutex_unlock(&serial->shared_int->shared_int_lock);
+ }
+ kfree(serial);
+ hso_free_device(hso_dev);
+}
+
+/* Creates a bulk AT channel */
+static struct hso_device *hso_create_bulk_serial_device(
+ struct usb_interface *interface, int port)
+{
+ struct hso_device *hso_dev = NULL;
+ struct hso_serial *serial = NULL;
+ char device_name[20];
+ int num_urbs;
+
+ hso_dev = hso_create_device(interface, port);
+ if (!hso_dev)
+ return NULL;
+
+ serial = kzalloc(sizeof(*serial), GFP_KERNEL);
+ if (!serial)
+ goto exit;
+
+ serial->parent = hso_dev;
+ hso_dev->port_data.dev_serial = serial;
+
+ if (port & HSO_PORT_MODEM)
+ num_urbs = 2;
+ else
+ num_urbs = 1;
+
+ if (hso_serial_common_create(serial, num_urbs, BULK_URB_RX_SIZE,
+ BULK_URB_TX_SIZE))
+ goto exit;
+
+ serial->in_endp = hso_get_ep(interface, USB_ENDPOINT_XFER_BULK,
+ USB_DIR_IN);
+ if (!serial->in_endp) {
+ dev_err(&interface->dev, "Failed to find BULK IN ep\n");
+ goto exit;
+ }
+
+ if (!
+ (serial->out_endp =
+ hso_get_ep(interface, USB_ENDPOINT_XFER_BULK, USB_DIR_OUT))) {
+ dev_err(&interface->dev, "Failed to find BULK IN ep\n");
+ goto exit;
+ }
+
+ serial->write_data = hso_std_serial_write_data;
+
+ /* and record this serial */
+ set_serial_by_index(serial->minor, serial);
+
+ /* setup the proc dirs and files if needed */
+ if (procfs) {
+ if (!hso_proc_dir_devices)
+ printk(KERN_WARNING "hso: Warning, creating port "
+ "info under root\n");
+ sprintf(device_name, "%s%d", tty_filename, serial->minor);
+ create_proc_read_entry(device_name, 0, hso_proc_dir_devices,
+ hso_proc_port_info, hso_dev);
+ }
+
+ hso_log_port(hso_dev);
+
+ /* done, return it */
+ return hso_dev;
+exit:
+ if (hso_dev && serial)
+ hso_serial_common_free(serial);
+ kfree(serial);
+ hso_free_device(hso_dev);
+ return NULL;
+}
+
+/* Creates a multiplexed AT channel */
+static
+struct hso_device *hso_create_mux_serial_device(struct usb_interface *interface,
+ int port,
+ struct hso_shared_int *mux)
+{
+ struct hso_device *hso_dev = NULL;
+ struct hso_serial *serial = NULL;
+ char device_name[20];
+ int port_spec = 0;
+
+ port_spec |= HSO_INTF_MUX;
+ port_spec &= ~HSO_PORT_MASK;
+
+ port_spec |= hso_mux_to_port(port);
+ if ((port_spec & HSO_PORT_MASK) == HSO_PORT_NO_PORT)
+ return NULL;
+
+ hso_dev = hso_create_device(interface, port_spec);
+ if (!hso_dev)
+ return NULL;
+
+ serial = kzalloc(sizeof(*serial), GFP_KERNEL);
+ if (!serial)
+ goto exit;
+
+ hso_dev->port_data.dev_serial = serial;
+ serial->parent = hso_dev;
+
+ if (hso_serial_common_create
+ (serial, 1, CTRL_URB_RX_SIZE, CTRL_URB_TX_SIZE))
+ goto exit;
+
+ serial->tx_data_length--;
+ serial->write_data = hso_mux_serial_write_data;
+
+ serial->shared_int = mux;
+ mutex_lock(&serial->shared_int->shared_int_lock);
+ serial->shared_int->ref_count++;
+ mutex_unlock(&serial->shared_int->shared_int_lock);
+
+ /* and record this serial */
+ set_serial_by_index(serial->minor, serial);
+
+ /* setup the proc dirs and files if needed */
+ if (procfs) {
+ if (!hso_proc_dir_devices)
+ printk(KERN_WARNING "hso: Warning, creating port info "
+ "under root\n");
+ sprintf(device_name, "%s%d", tty_filename, serial->minor);
+ create_proc_read_entry(device_name, 0, hso_proc_dir_devices,
+ hso_proc_port_info, hso_dev);
+ }
+
+ hso_log_port(hso_dev);
+
+ /* done, return it */
+ return hso_dev;
+
+exit:
+ if (serial) {
+ tty_unregister_device(tty_drv, serial->minor);
+ kfree(serial);
+ }
+ if (hso_dev)
+ hso_free_device(hso_dev);
+ return NULL;
+
+}
+
+static void hso_free_shared_int(struct hso_shared_int *mux)
+{
+ usb_free_urb(mux->shared_intr_urb);
+ kfree(mux->shared_intr_buf);
+ kfree(mux);
+}
+
+static
+struct hso_shared_int *hso_create_shared_int(struct usb_interface *interface)
+{
+ struct hso_shared_int *mux = kzalloc(sizeof(*mux), GFP_KERNEL);
+
+ if (!mux)
+ return NULL;
+
+ mux->intr_endp = hso_get_ep(interface, USB_ENDPOINT_XFER_INT,
+ USB_DIR_IN);
+ if (!mux->intr_endp) {
+ dev_err(&interface->dev, "Can't find INT IN endpoint\n");
+ goto exit;
+ }
+
+ mux->shared_intr_urb = usb_alloc_urb(0, GFP_KERNEL);
+ if (!mux->shared_intr_urb) {
+ dev_err(&interface->dev, "Could not allocate intr urb?");
+ goto exit;
+ }
+ mux->shared_intr_buf = kzalloc(mux->intr_endp->wMaxPacketSize,
+ GFP_KERNEL);
+ if (!mux->shared_intr_buf) {
+ dev_err(&interface->dev, "Could not allocate intr buf?");
+ goto exit;
+ }
+
+ mutex_init(&mux->shared_int_lock);
+
+ return mux;
+
+exit:
+ kfree(mux->shared_intr_buf);
+ usb_free_urb(mux->shared_intr_urb);
+ kfree(mux);
+ return NULL;
+}
+
+/* Gets the port spec for a certain interface */
+static int hso_get_config_data(struct usb_interface *interface)
+{
+ struct usb_device *usbdev = interface_to_usbdev(interface);
+ u8 config_data[17];
+ u32 if_num = interface->altsetting->desc.bInterfaceNumber;
+ s32 result = 0;
+
+ if (usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0),
+ 0x86, 0xC0, 0, 0, config_data, 17,
+ USB_CTRL_SET_TIMEOUT) != 0x11) {
+ return -EIO;
+ }
+
+ switch (config_data[if_num]) {
+ case 0x0:
+ result = 0;
+ break;
+ case 0x1:
+ result = HSO_PORT_DIAG;
+ break;
+ case 0x2:
+ result = HSO_PORT_GPS;
+ break;
+ case 0x3:
+ result = HSO_PORT_GPS_CONTROL;
+ break;
+ case 0x4:
+ result = HSO_PORT_APP;
+ break;
+ case 0x5:
+ result = HSO_PORT_APP2;
+ break;
+ case 0x6:
+ result = HSO_PORT_CONTROL;
+ break;
+ case 0x7:
+ result = HSO_PORT_NETWORK;
+ break;
+ case 0x8:
+ result = HSO_PORT_MODEM;
+ break;
+ case 0x9:
+ result = HSO_PORT_MSD;
+ break;
+ case 0xa:
+ result = HSO_PORT_PCSC;
+ break;
+ case 0xb:
+ result = HSO_PORT_VOICE;
+ break;
+ default:
+ result = 0;
+ }
+
+ if (result)
+ result |= HSO_INTF_BULK;
+
+ if (config_data[16] & 0x1)
+ result |= HSO_INFO_CRC_BUG;
+
+ return result;
+}
+
+static int hso_radio_toggle(void *data, enum rfkill_state state)
+{
+ struct hso_device *hso_dev = data;
+ int enabled = (state == RFKILL_STATE_ON);
+ int rv;
+
+ mutex_lock(&hso_dev->mutex);
+ if (hso_dev->usb_gone)
+ rv = 0;
+ else
+ rv = usb_control_msg(hso_dev->usb, usb_rcvctrlpipe(hso_dev->usb, 0),
+ enabled ? 0x82 : 0x81, 0x40, 0, 0, NULL, 0,
+ USB_CTRL_SET_TIMEOUT);
+ mutex_unlock(&hso_dev->mutex);
+ return rv;
+}
+
+/* called once for each interface upon device insertion */
+static int hso_probe(struct usb_interface *interface,
+ const struct usb_device_id *id)
+{
+ int mux, i, if_num, port_spec;
+ unsigned char port_mask;
+ char *rfkn;
+ struct hso_device *hso_dev = NULL;
+ struct hso_shared_int *shared_int = NULL;
+ struct hso_device *tmp_dev = NULL;
+
+ if_num = interface->altsetting->desc.bInterfaceNumber;
+
+ /* Get the interface/port specification from either driver_info or from
+ * the device itself */
+ if (id->driver_info)
+ port_spec = ((u32 *)(id->driver_info))[if_num];
+ else
+ port_spec = hso_get_config_data(interface);
+
+ if (interface->cur_altsetting->desc.bInterfaceClass != 0xFF) {
+ dev_err(&interface->dev, "Not our interface\n");
+ return -ENODEV;
+ }
+ /* Check if we need to switch to alt interfaces prior to port
+ * configuration */
+ if (interface->num_altsetting > 1)
+ usb_set_interface(interface_to_usbdev(interface), if_num, 1);
+ interface->needs_remote_wakeup = 1;
+
+ /* Allocate new hso device(s) */
+ switch (port_spec & HSO_INTF_MASK) {
+ case HSO_INTF_MUX:
+ if ((port_spec & HSO_PORT_MASK) == HSO_PORT_NETWORK) {
+ /* Create the network device */
+ if (!disable_net) {
+ hso_dev = hso_create_net_device(interface);
+ if (!hso_dev)
+ goto exit;
+ tmp_dev = hso_dev;
+ }
+ }
+
+ if (hso_get_mux_ports(interface, &port_mask))
+ /* TODO: de-allocate everything */
+ goto exit;
+
+ shared_int = hso_create_shared_int(interface);
+ if (!shared_int)
+ goto exit;
+
+ for (i = 1, mux = 0; i < 0x100; i = i << 1, mux++) {
+ if (port_mask & i) {
+ hso_dev = hso_create_mux_serial_device(
+ interface, i, shared_int);
+ if (!hso_dev)
+ goto exit;
+ }
+ }
+
+ if (tmp_dev)
+ hso_dev = tmp_dev;
+ break;
+
+ case HSO_INTF_BULK:
+ /* It's a regular bulk interface */
+ if (((port_spec & HSO_PORT_MASK) == HSO_PORT_NETWORK)
+ && !disable_net)
+ hso_dev = hso_create_net_device(interface);
+ else
+ hso_dev =
+ hso_create_bulk_serial_device(interface, port_spec);
+ if (!hso_dev)
+ goto exit;
+ break;
+ default:
+ goto exit;
+ }
+
+ hso_dev->rfkill = rfkill_allocate(&interface_to_usbdev(interface)->dev,
+ RFKILL_TYPE_WLAN);
+ if (!hso_dev->rfkill)
+ goto exit;
+ rfkn = kzalloc(20, GFP_KERNEL);
+ if (!rfkn) {
+ rfkill_free(hso_dev->rfkill);
+ goto exit;
+ }
+ snprintf(rfkn, 20, "hso-%d", if_num);
+ hso_dev->rfkill->name = rfkn;
+ hso_dev->rfkill->state = RFKILL_STATE_ON;
+ hso_dev->rfkill->data = hso_dev;
+ hso_dev->rfkill->toggle_radio = hso_radio_toggle;
+ if (rfkill_register(hso_dev->rfkill) < 0) {
+ kfree(rfkn);
+ hso_dev->rfkill->name = NULL;
+ rfkill_free(hso_dev->rfkill);
+ goto exit;
+ }
+
+ usb_driver_claim_interface(&hso_driver, interface, hso_dev);
+
+ /* save our data pointer in this device */
+ usb_set_intfdata(interface, hso_dev);
+
+ /* done */
+ return 0;
+
+exit:
+ hso_free_interface(interface);
+ return -ENODEV;
+}
+
+/* device removed, cleaning up */
+static void hso_disconnect(struct usb_interface *interface)
+{
+ struct hso_device *hso_dev = usb_get_intfdata(interface);
+
+ hso_free_interface(interface);
+
+ if (hso_dev) {
+ cancel_work_sync(&hso_dev->async_put_intf);
+ cancel_work_sync(&hso_dev->async_get_intf);
+ rfkill_unregister(hso_dev->rfkill);
+ }
+
+ /* remove reference of our private data */
+ usb_set_intfdata(interface, NULL);
+
+ usb_driver_release_interface(&hso_driver, interface);
+}
+
+static void async_get_intf(struct work_struct *data)
+{
+ struct hso_device *hso_dev =
+ container_of(data, struct hso_device, async_get_intf);
+ usb_autopm_get_interface(hso_dev->interface);
+}
+
+static void async_put_intf(struct work_struct *data)
+{
+ struct hso_device *hso_dev =
+ container_of(data, struct hso_device, async_put_intf);
+ usb_autopm_put_interface(hso_dev->interface);
+}
+
+static int hso_get_activity(struct hso_device *hso_dev)
+{
+ if (hso_dev->usb->state == USB_STATE_SUSPENDED) {
+ if (!hso_dev->is_active) {
+ hso_dev->is_active = 1;
+ schedule_work(&hso_dev->async_get_intf);
+ }
+ }
+
+ if (hso_dev->usb->state != USB_STATE_CONFIGURED)
+ return -EAGAIN;
+
+ usb_mark_last_busy(hso_dev->usb);
+
+ return 0;
+}
+
+static int hso_put_activity(struct hso_device *hso_dev)
+{
+ if (hso_dev->usb->state != USB_STATE_SUSPENDED) {
+ if (hso_dev->is_active) {
+ hso_dev->is_active = 0;
+ schedule_work(&hso_dev->async_put_intf);
+ return -EAGAIN;
+ }
+ }
+ hso_dev->is_active = 0;
+ return 0;
+}
+
+/* called by kernel when we need to suspend device */
+static int hso_suspend(struct usb_interface *iface, pm_message_t message)
+{
+ int i, result = 0;
+
+ /* Stop all serial ports */
+ for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++) {
+ if (serial_table[i] && (serial_table[i]->interface == iface)) {
+ result = hso_stop_serial_device(serial_table[i]);
+ if (result)
+ goto out;
+ }
+ }
+
+ /* Stop all network ports */
+ for (i = 0; i < HSO_MAX_NET_DEVICES; i++) {
+ if (network_table[i] &&
+ (network_table[i]->interface == iface)) {
+ result = hso_stop_net_device(network_table[i]);
+ if (result)
+ goto out;
+ }
+ }
+
+out:
+ return 0;
+}
+
+/* called by kernel when we need to resume device */
+static int hso_resume(struct usb_interface *iface)
+{
+ int i, result = 0;
+ struct hso_net *hso_net;
+
+ /* Start all serial ports */
+ for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++) {
+ if (serial_table[i] && (serial_table[i]->interface == iface)) {
+ if (dev2ser(serial_table[i])->open_count) {
+ result =
+ hso_start_serial_device(serial_table[i], GFP_NOIO);
+ hso_kick_transmit(dev2ser(serial_table[i]));
+ if (result)
+ goto out;
+ }
+ }
+ }
+
+ /* Start all network ports */
+ for (i = 0; i < HSO_MAX_NET_DEVICES; i++) {
+ if (network_table[i] &&
+ (network_table[i]->interface == iface)) {
+ hso_net = dev2net(network_table[i]);
+ /* First transmit any lingering data, then restart the
+ * device. */
+ if (hso_net->skb_tx_buf) {
+ dev_dbg(&iface->dev,
+ "Transmitting lingering data\n");
+ hso_net_start_xmit(hso_net->skb_tx_buf,
+ hso_net->net);
+ }
+ result = hso_start_net_device(network_table[i]);
+ if (result)
+ goto out;
+ }
+ }
+
+out:
+ return result;
+}
+
+static void hso_serial_ref_free(struct kref *ref)
+{
+ struct hso_device *hso_dev = container_of(ref, struct hso_device, ref);
+
+ hso_free_serial_device(hso_dev);
+}
+
+static void hso_free_interface(struct usb_interface *interface)
+{
+ struct hso_serial *hso_dev;
+ int i;
+
+ for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++) {
+ if (serial_table[i]
+ && (serial_table[i]->interface == interface)) {
+ hso_dev = dev2ser(serial_table[i]);
+ if (hso_dev->tty)
+ tty_hangup(hso_dev->tty);
+ mutex_lock(&hso_dev->parent->mutex);
+ hso_dev->parent->usb_gone = 1;
+ mutex_unlock(&hso_dev->parent->mutex);
+ kref_put(&serial_table[i]->ref, hso_serial_ref_free);
+ }
+ }
+
+ for (i = 0; i < HSO_MAX_NET_DEVICES; i++) {
+ if (network_table[i]
+ && (network_table[i]->interface == interface)) {
+ /* hso_stop_net_device doesn't stop the net queue since
+ * traffic needs to start it again when suspended */
+ netif_stop_queue(dev2net(network_table[i])->net);
+ hso_stop_net_device(network_table[i]);
+ hso_free_net_device(network_table[i]);
+ }
+ }
+}
+
+/* Helper functions */
+
+/* Get the endpoint ! */
+static struct usb_endpoint_descriptor *hso_get_ep(struct usb_interface *intf,
+ int type, int dir)
+{
+ int i;
+ struct usb_host_interface *iface = intf->cur_altsetting;
+ struct usb_endpoint_descriptor *endp = NULL;
+
+ for (i = 0; i < iface->desc.bNumEndpoints; i++) {
+ endp = &iface->endpoint[i].desc;
+ if (((endp->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == dir) &&
+ ((endp->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == type))
+ return endp;
+ }
+
+ return NULL;
+}
+
+/* Get the byte that describes which ports are enabled */
+static int hso_get_mux_ports(struct usb_interface *intf, unsigned char *ports)
+{
+ int i;
+ struct usb_host_interface *iface = intf->cur_altsetting;
+
+ if (iface->extralen == 3) {
+ *ports = iface->extra[2];
+ return 0;
+ }
+
+ for (i = 0; i < iface->desc.bNumEndpoints; i++) {
+ if (iface->endpoint[i].extralen == 3) {
+ *ports = iface->endpoint[i].extra[2];
+ return 0;
+ }
+ }
+
+ return -1;
+}
+
+/* interrupt urb needs to be submitted, used for serial read of muxed port */
+static int hso_mux_submit_intr_urb(struct hso_shared_int *shared_int,
+ struct usb_device *usb, gfp_t gfp)
+{
+ int result;
+
+ usb_fill_int_urb(shared_int->shared_intr_urb, usb,
+ usb_rcvintpipe(usb,
+ shared_int->intr_endp->bEndpointAddress & 0x7F),
+ shared_int->shared_intr_buf,
+ shared_int->intr_endp->wMaxPacketSize,
+ intr_callback, shared_int,
+ shared_int->intr_endp->bInterval);
+
+ result = usb_submit_urb(shared_int->shared_intr_urb, gfp);
+ if (result)
+ dev_warn(&usb->dev, "%s failed mux_intr_urb %d", __func__,
+ result);
+
+ return result;
+}
+
+/* operations setup of the serial interface */
+static struct tty_operations hso_serial_ops = {
+ .open = hso_serial_open,
+ .close = hso_serial_close,
+ .write = hso_serial_write,
+ .write_room = hso_serial_write_room,
+ .set_termios = hso_serial_set_termios,
+ .chars_in_buffer = hso_serial_chars_in_buffer,
+ .tiocmget = hso_serial_tiocmget,
+ .tiocmset = hso_serial_tiocmset,
+};
+
+static struct usb_driver hso_driver = {
+ .name = driver_name,
+ .probe = hso_probe,
+ .disconnect = hso_disconnect,
+ .id_table = hso_ids,
+ .suspend = hso_suspend,
+ .resume = hso_resume,
+ .supports_autosuspend = 1,
+};
+
+static int __init hso_init(void)
+{
+ int i = 0;
+ int result = 0;
+
+ /* put it in the log */
+ printk(KERN_INFO "hso: %s\n", version);
+
+ /* if procfs is enabled, initialize devices */
+ if (procfs) {
+ hso_proc_dir = proc_mkdir(driver_name, NULL);
+ if (hso_proc_dir) {
+ hso_proc_dir_devices =
+ proc_mkdir("devices", hso_proc_dir);
+ create_proc_read_entry("options", 0, hso_proc_dir,
+ hso_proc_options, NULL);
+ }
+ }
+
+ /* Initialise the serial table semaphore and table */
+ spin_lock_init(&serial_table_lock);
+ for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++)
+ serial_table[i] = NULL;
+
+ /* allocate our driver using the proper amount of supported minors */
+ tty_drv = alloc_tty_driver(HSO_SERIAL_TTY_MINORS);
+ if (!tty_drv)
+ return -ENOMEM;
+
+ /* fill in all needed values */
+ tty_drv->magic = TTY_DRIVER_MAGIC;
+ tty_drv->owner = THIS_MODULE;
+ tty_drv->driver_name = driver_name;
+ tty_drv->name = tty_filename;
+
+ /* if major number is provided as parameter, use that one */
+ if (tty_major)
+ tty_drv->major = tty_major;
+
+ tty_drv->minor_start = 0;
+ tty_drv->num = HSO_SERIAL_TTY_MINORS;
+ tty_drv->type = TTY_DRIVER_TYPE_SERIAL;
+ tty_drv->subtype = SERIAL_TYPE_NORMAL;
+ tty_drv->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
+ tty_drv->init_termios = tty_std_termios;
+ tty_drv->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
+ tty_drv->termios = hso_serial_termios;
+ tty_drv->termios_locked = hso_serial_termios_locked;
+ tty_set_operations(tty_drv, &hso_serial_ops);
+
+ /* register the tty driver */
+ result = tty_register_driver(tty_drv);
+ if (result) {
+ printk(KERN_ERR "%s - tty_register_driver failed(%d)\n",
+ __func__, result);
+ return result;
+ }
+
+ /* register this module as an usb driver */
+ result = usb_register(&hso_driver);
+ if (result) {
+ printk(KERN_ERR "Could not register hso driver? error: %d\n",
+ result);
+ /* cleanup serial interface */
+ tty_unregister_driver(tty_drv);
+ return result;
+ }
+
+ /* done */
+ return 0;
+}
+
+static void __exit hso_exit(void)
+{
+ printk(KERN_INFO "hso: unloaded\n");
+
+ tty_unregister_driver(tty_drv);
+ /* deregister the usb driver */
+ usb_deregister(&hso_driver);
+ /* if procfs is enabled, remove the entries */
+
+ if (procfs) {
+ remove_proc_entry("options", hso_proc_dir);
+ remove_proc_entry("devices", hso_proc_dir);
+ remove_proc_entry(driver_name, NULL);
+ }
+
+}
+
+/* Module definitions */
+module_init(hso_init);
+module_exit(hso_exit);
+
+MODULE_AUTHOR(MOD_AUTHOR);
+MODULE_DESCRIPTION(MOD_DESCRIPTION);
+MODULE_LICENSE(MOD_LICENSE);
+MODULE_INFO(Version, DRIVER_VERSION);
+
+/* Module parameter to allow procfs (eg: insmod hso.ko procfs=1) */
+MODULE_PARM_DESC(procfs, "Allow procfs [0 | 1]");
+module_param(procfs, int, S_IRUGO | S_IWUSR);
+
+/* change the debug level (eg: insmod hso.ko debug=0x04) */
+MODULE_PARM_DESC(debug, "Level of debug [0x01 | 0x02 | 0x04 | 0x08 | 0x10]");
+module_param(debug, int, S_IRUGO | S_IWUSR);
+
+/* set the major tty number (eg: insmod hso.ko tty_major=245) */
+MODULE_PARM_DESC(tty_major, "Set the major tty number");
+module_param(tty_major, int, S_IRUGO | S_IWUSR);
+
+/* disable network interface (eg: insmod hso.ko disable_net=1) */
+MODULE_PARM_DESC(disable_net, "Disable the network interface");
+module_param(disable_net, int, S_IRUGO | S_IWUSR);
--
To unsubscribe from this list: send the line "unsubscribe linux-usb" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [RFC] updated Patch to option HSO driver to the kernel
[not found] ` <20080417214719.GF17664-U8xfFu+wG4EAvxtiuMwx3w@public.gmane.org>
@ 2008-04-21 1:04 ` Paulius Zaleckas
2008-04-21 8:16 ` Oliver Neukum
[not found] ` <480BE815.2000409-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
2008-04-21 12:43 ` Paulius Zaleckas
1 sibling, 2 replies; 22+ messages in thread
From: Paulius Zaleckas @ 2008-04-21 1:04 UTC (permalink / raw)
To: linux-usb-u79uwXL29TY76Z2rM5mHXA; +Cc: netdev-u79uwXL29TY76Z2rM5mHXA
[-- Attachment #1: Type: text/plain, Size: 207 bytes --]
- Cleaned up unused defines and variables
- Remove broken firmware info from ethtool_ops
- Const for usb IDs table
Signed-off-by: Paulius Zaleckas <paulius.zaleckas-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
[-- Attachment #2: hso_cleanup.patch --]
[-- Type: text/x-patch, Size: 5151 bytes --]
--- linux-2.6-hso/drivers/net/usb/hso.c 2008-04-21 03:53:53.000000000 +0300
+++ linux-2.6-hso-my/drivers/net/usb/hso.c 2008-04-21 03:47:36.000000000 +0300
@@ -82,7 +82,6 @@
#define BULK_URB_RX_SIZE 4096
#define BULK_URB_TX_SIZE 8192
-#define MUX_INTR_BUF_SIZE 16
#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
@@ -91,18 +90,11 @@
/* 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_BUSY 1
-#define HSO_TERMINATE 2
#define HSO_NET_TX_TIMEOUT (HZ*10)
/* Serial port defines and structs. */
-#define HSO_THRESHOLD_THROTTLE (7*1024)
-#define HSO_THRESHOLD_UNTHROTTLE (2*1024)
-
-#define HSO_SERIAL_FLAG_THROTTLED 0
-#define HSO_SERIAL_FLAG_TX_SENT 1
-#define HSO_SERIAL_FLAG_RX_SENT 2
+#define HSO_SERIAL_FLAG_RX_SENT 0
#define HSO_SERIAL_MAGIC 0x48534f31
@@ -182,12 +174,8 @@ struct hso_net {
struct iphdr rx_ip_hdr;
struct ethhdr dummy_eth_head;
- __u16 bcdCDC;
- __u16 wMaxSegmentSize;
__u16 wNumberMCFilters;
- __u16 mode_flags;
unsigned long flags;
-
};
struct hso_serial {
@@ -210,7 +198,6 @@ struct hso_serial {
u16 tx_data_length; /* should contain allocated length */
u16 tx_data_count;
u16 tx_buffer_count;
- spinlock_t buffer_lock;
struct usb_ctrlrequest ctrl_req_tx;
struct usb_ctrlrequest ctrl_req_rx;
@@ -226,7 +213,6 @@ struct hso_serial {
struct tty_struct *tty;
int open_count;
spinlock_t serial_lock;
- void *private;
int (*write_data) (struct hso_serial *serial);
};
@@ -240,7 +226,6 @@ struct hso_device {
u32 port_spec;
u8 is_active;
- u8 suspend_disabled;
u8 usb_gone;
struct work_struct async_get_intf;
struct work_struct async_put_intf;
@@ -252,9 +237,6 @@ struct hso_device {
struct device *dev;
struct kref ref;
struct mutex mutex;
-
- /* TODO: Not sure about the ones below */
- struct proc_dir_entry *ourproc;
};
/* Type of interface */
@@ -327,8 +309,6 @@ static unsigned char hex2dec(unsigned ch
return 0;
}
-#define SIOCSETRADIO (SIOCDEVPRIVATE+4)
-
/* #define DEBUG */
#define dev2net(x) (x->port_data.dev_net)
@@ -411,7 +391,7 @@ static const s32 icon321_port_spec[] = {
.driver_info = (kernel_ulong_t)icon321_port_spec
/* list of devices we support */
-static struct usb_device_id hso_ids[] = {
+static const struct usb_device_id hso_ids[] = {
{default_port_device(0x0af0, 0x6711)},
{default_port_device(0x0af0, 0x6731)},
{default_port_device(0x0af0, 0x6751)},
@@ -610,7 +590,7 @@ static void set_serial_by_index(unsigned
spin_unlock_irqrestore(&serial_table_lock, flags);
}
-/* log a meaningfull explanation of an USB status to syslog */
+/* log a meaningfull explanation of an USB status */
static void log_usb_status(int status, const char *function)
{
char *explanation = NULL;
@@ -858,8 +838,6 @@ static void hso_get_drvinfo(struct net_d
strncpy(info->driver, driver_name, ETHTOOL_BUSINFO_LEN);
strncpy(info->version, DRIVER_VERSION, ETHTOOL_BUSINFO_LEN);
usb_make_path(odev->parent->usb, info->bus_info, sizeof info->bus_info);
- snprintf(info->fw_version, ETHTOOL_BUSINFO_LEN, "%s %x.%x", driver_name,
- ((odev->bcdCDC & 0xff00) >> 8), (odev->bcdCDC & 0x00ff));
}
static struct ethtool_ops ops = {
@@ -907,34 +885,17 @@ static void hso_net_set_multicast(struct
if (net->flags & IFF_PROMISC) {
/* Unconditionally log net taps. */
D1("%s: Promiscuous mode enabled", net->name);
- odev->mode_flags = USB_CDC_PACKET_TYPE_ALL_MULTICAST |
- USB_CDC_PACKET_TYPE_DIRECTED |
- USB_CDC_PACKET_TYPE_BROADCAST |
- USB_CDC_PACKET_TYPE_MULTICAST |
- USB_CDC_PACKET_TYPE_PROMISCUOUS;
} else if (net->mc_count > odev->wNumberMCFilters) {
/* Too many to filter perfectly -- accept all multicasts. */
D1("%s: too many MC filters for hardware, using allmulti",
net->name);
- odev->mode_flags = USB_CDC_PACKET_TYPE_ALL_MULTICAST |
- USB_CDC_PACKET_TYPE_DIRECTED |
- USB_CDC_PACKET_TYPE_BROADCAST |
- USB_CDC_PACKET_TYPE_MULTICAST;
} else if (net->flags & IFF_ALLMULTI) {
/* Filter in software */
D1("%s: using allmulti", net->name);
- odev->mode_flags = USB_CDC_PACKET_TYPE_ALL_MULTICAST |
- USB_CDC_PACKET_TYPE_DIRECTED |
- USB_CDC_PACKET_TYPE_BROADCAST |
- USB_CDC_PACKET_TYPE_MULTICAST;
} else {
/* do multicast filtering in hardware */
struct dev_mc_list *mclist;
D1("%s: set multicast filters", net->name);
- odev->mode_flags = USB_CDC_PACKET_TYPE_ALL_MULTICAST |
- USB_CDC_PACKET_TYPE_DIRECTED |
- USB_CDC_PACKET_TYPE_BROADCAST |
- USB_CDC_PACKET_TYPE_MULTICAST;
buf = kmalloc(6 * net->mc_count, GFP_ATOMIC);
if (!buf) {
dev_err(&net->dev, "No memory to allocate?");
@@ -2213,7 +2174,6 @@ static void hso_net_init(struct net_devi
SET_ETHTOOL_OPS(net, &ops);
hso_net->skb_rx_buf = NULL;
hso_net->rx_parse_state = WAIT_IP;
- hso_net->wMaxSegmentSize = DEFAULT_MTU;
/* always use all multi, no lists of multicasts */
hso_net->wNumberMCFilters = 0;
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [RFC] updated Patch to option HSO driver to the kernel
2008-04-21 1:04 ` Paulius Zaleckas
@ 2008-04-21 8:16 ` Oliver Neukum
2008-04-21 9:34 ` Paulius Zaleckas
[not found] ` <480BE815.2000409-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
1 sibling, 1 reply; 22+ messages in thread
From: Oliver Neukum @ 2008-04-21 8:16 UTC (permalink / raw)
To: Paulius Zaleckas; +Cc: netdev, linux-usb
Am Montag, 21. April 2008 03:04:21 schrieb Paulius Zaleckas:
> - odev->mode_flags = USB_CDC_PACKET_TYPE_ALL_MULTICAST |
> - USB_CDC_PACKET_TYPE_DIRECTED |
> - USB_CDC_PACKET_TYPE_BROADCAST |
> - USB_CDC_PACKET_TYPE_MULTICAST;
Hi,
before you rip out the multicast stuff, do you have an idea why it was
included in the first place? Is the device capable of operating in a
real network topology where multicast would make sense?
Regards
Oliver
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [RFC] updated Patch to option HSO driver to the kernel
2008-04-21 8:16 ` Oliver Neukum
@ 2008-04-21 9:34 ` Paulius Zaleckas
[not found] ` <480C5FAF.1050408-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
0 siblings, 1 reply; 22+ messages in thread
From: Paulius Zaleckas @ 2008-04-21 9:34 UTC (permalink / raw)
To: netdev; +Cc: linux-usb
Oliver Neukum wrote:
> Am Montag, 21. April 2008 03:04:21 schrieb Paulius Zaleckas:
>> - odev->mode_flags = USB_CDC_PACKET_TYPE_ALL_MULTICAST |
>> - USB_CDC_PACKET_TYPE_DIRECTED |
>> - USB_CDC_PACKET_TYPE_BROADCAST |
>> - USB_CDC_PACKET_TYPE_MULTICAST;
>
> Hi,
>
> before you rip out the multicast stuff, do you have an idea why it was
> included in the first place? Is the device capable of operating in a
> real network topology where multicast would make sense?
It was there from the oldest version (0.6) I have, but in the dead code
as it is now. There was also a comment:
/* FIXME AJB, work out what we need to do with multicast */
It was addressed to Andrew Bird (added to CC)
IMO it doesn't make sense to do multicasting since actually it is
point-to-point and not ethernet traffic.
Currently I am studying if it is possible to convert current pseudo
ethernet interface to point-to-point one.
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [RFC] updated Patch to option HSO driver to the kernel
[not found] ` <20080417214719.GF17664-U8xfFu+wG4EAvxtiuMwx3w@public.gmane.org>
2008-04-21 1:04 ` Paulius Zaleckas
@ 2008-04-21 12:43 ` Paulius Zaleckas
1 sibling, 0 replies; 22+ messages in thread
From: Paulius Zaleckas @ 2008-04-21 12:43 UTC (permalink / raw)
To: linux-usb-u79uwXL29TY76Z2rM5mHXA; +Cc: netdev-u79uwXL29TY76Z2rM5mHXA
Here is the crash dump when I do "modprobe -r hso". I think I had no
problems when I was using not debug version of kernel.
hso: unloaded
usbcore: deregistering interface driver hso
general protection fault: 0000 [1] SMP
CPU 1
Modules linked in: i915 drm autofs4 fuse sunrpc loop dm_multipath ipv6
parport_pc parport snd_hda_intel pcspkr i2c_i801 r8169 snd_seq_dummy
e100 i2c_core mii iTCO_wdt snd_seq_oss hso(U) usblp snd_seq_midi_event
iTCO_vendor_support rfkill snd_seq snd_seq_device snd_pcm_oss
snd_mixer_oss snd_pcm snd_timer snd_page_alloc snd_hwdep snd soundcore
button sg sr_mod cdrom dm_snapshot dm_zero dm_mirror dm_mod pata_acpi
ata_generic ata_piix libata sd_mod scsi_mod ext3 jbd mbcache uhci_hcd
ohci_hcd ehci_hcd
Pid: 2926, comm: modprobe Not tainted 2.6.24.4-64.fc8debug #1
RIP: 0010:[<ffffffff810559b6>] [<ffffffff810559b6>]
__lock_acquire+0xb6/0xce5
RSP: 0000:ffff810010497c88 EFLAGS: 00010046
RAX: 0000000000000002 RBX: 0000000000000046 RCX: 0000000000000000
RDX: 0000000000000000 RSI: 0000000000000000 RDI: 6b6b6b6b6b6b6b80
RBP: 6b6b6b6b6b6b6b68 R08: 0000000000000002 R09: 0000000000000001
R10: ffffffff81046da4 R11: 0000000000000008 R12: ffff8100105b0000
R13: ffffffff88191780 R14: 00000000ffffffff R15: 6b6b6b6b6b6b6b80
FS: 00002aaaaaac76f0(0000) GS:ffff81003f0014b0(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 000000008005003b
CR2: 00000000008ca3f0 CR3: 000000001e917000 CR4: 00000000000006a0
DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
DR3: 0000000000000000 DR6: 00000000ffff0ff0 DR7: 0000000000000400
Process modprobe (pid: 2926, threadinfo ffff810010496000, task
ffff8100105b0000)
Stack: 000000018149c2e8 0000000000000002 0000000000000000 ffffffff8149c2b8
ffff81003d8a8920 0000000000000046 6b6b6b6b6b6b6b68 ffff81003d1a6890
ffffffff88191780 00000000ffffffff 00000000ffffffff ffffffff81056a45
Call Trace:
[<ffffffff81056a45>] lock_acquire+0x5a/0x73
[<ffffffff81046da4>] __cancel_work_timer+0x51/0x1b5
[<ffffffff812865c5>] _spin_lock_irq+0x2c/0x58
[<ffffffff81046da4>] __cancel_work_timer+0x51/0x1b5
[<ffffffff8105548e>] trace_hardirqs_on+0x12e/0x151
[<ffffffff8818b317>] :hso:hso_serial_ref_free+0xc5/0xce
[<ffffffff8105548e>] trace_hardirqs_on+0x12e/0x151
[<ffffffff8818b252>] :hso:hso_serial_ref_free+0x0/0xce
[<ffffffff81131c5d>] kref_put+0x6f/0x7a
[<ffffffff8818b10b>] :hso:hso_disconnect+0x23/0x55
[<ffffffff811d128b>] usb_unbind_interface+0x5c/0xb9
[<ffffffff811b710d>] __device_release_driver+0x91/0xb3
[<ffffffff811b7653>] driver_detach+0xd3/0x114
[<ffffffff811b6be4>] bus_remove_driver+0x80/0xa3
[<ffffffff811d0c1b>] usb_deregister+0x97/0xa4
[<ffffffff8818d926>] :hso:hso_exit+0x2a/0x6a
[<ffffffff8105ef9c>] sys_delete_module+0x18c/0x1bd
[<ffffffff8100c053>] tracesys+0xd5/0xda
Code: 48 8b 6f 08 48 85 ed 0f 85 db 02 00 00 49 83 3f 00 75 03 4d
RIP [<ffffffff810559b6>] __lock_acquire+0xb6/0xce5
RSP <ffff810010497c88>
---[ end trace 8adbc80e43569c09 ]---
BUG: sleeping function called from invalid context at kernel/rwsem.c:21
in_atomic():0, irqs_disabled():1
INFO: lockdep is turned off.
irq event stamp: 5090
hardirqs last enabled at (5089): [<ffffffff810a4773>] kfree+0xe1/0xec
hardirqs last disabled at (5090): [<ffffffff812865a8>]
_spin_lock_irq+0xf/0x58
softirqs last enabled at (4848): [<ffffffff8100d0cc>]
call_softirq+0x1c/0x28
softirqs last disabled at (4835): [<ffffffff8100d0cc>]
call_softirq+0x1c/0x28
Pid: 2926, comm: modprobe Tainted: G D 2.6.24.4-64.fc8debug #1
Call Trace:
[<ffffffff8102f4ca>] __might_sleep+0xd5/0xdd
[<ffffffff81285256>] down_read+0x1e/0x6c
[<ffffffff810653bb>] acct_collect+0x42/0x18f
[<ffffffff8103ad47>] do_exit+0x21e/0x7de
[<ffffffff8100d6e6>] kernel_math_error+0x0/0x71
[<ffffffff812869ad>] error_exit+0x0/0xa9
[<ffffffff81046da4>] __cancel_work_timer+0x51/0x1b5
[<ffffffff810559b6>] __lock_acquire+0xb6/0xce5
[<ffffffff81056a45>] lock_acquire+0x5a/0x73
[<ffffffff81046da4>] __cancel_work_timer+0x51/0x1b5
[<ffffffff812865c5>] _spin_lock_irq+0x2c/0x58
[<ffffffff81046da4>] __cancel_work_timer+0x51/0x1b5
[<ffffffff8105548e>] trace_hardirqs_on+0x12e/0x151
[<ffffffff8818b317>] :hso:hso_serial_ref_free+0xc5/0xce
[<ffffffff8105548e>] trace_hardirqs_on+0x12e/0x151
[<ffffffff8818b252>] :hso:hso_serial_ref_free+0x0/0xce
[<ffffffff81131c5d>] kref_put+0x6f/0x7a
[<ffffffff8818b10b>] :hso:hso_disconnect+0x23/0x55
[<ffffffff811d128b>] usb_unbind_interface+0x5c/0xb9
[<ffffffff811b710d>] __device_release_driver+0x91/0xb3
[<ffffffff811b7653>] driver_detach+0xd3/0x114
[<ffffffff811b6be4>] bus_remove_driver+0x80/0xa3
[<ffffffff811d0c1b>] usb_deregister+0x97/0xa4
[<ffffffff8818d926>] :hso:hso_exit+0x2a/0x6a
[<ffffffff8105ef9c>] sys_delete_module+0x18c/0x1bd
[<ffffffff8100c053>] tracesys+0xd5/0xda
--
To unsubscribe from this list: send the line "unsubscribe linux-usb" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [RFC] updated Patch to option HSO driver to the kernel
[not found] ` <480BE815.2000409-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
@ 2008-04-21 15:54 ` Paulius Zaleckas
[not found] ` <480CB8C2.9090902-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
0 siblings, 1 reply; 22+ messages in thread
From: Paulius Zaleckas @ 2008-04-21 15:54 UTC (permalink / raw)
To: linux-usb-u79uwXL29TY76Z2rM5mHXA; +Cc: netdev-u79uwXL29TY76Z2rM5mHXA
[-- Attachment #1: Type: text/plain, Size: 133 bytes --]
Incremental patch.
- Remove multicasting
Signed-off-by: Paulius Zaleckas <paulius.zaleckas-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
[-- Attachment #2: hso_remove_multicast.patch --]
[-- Type: text/x-patch, Size: 2797 bytes --]
--- linux-2.6-hso-my/drivers/net/usb/hso.c.orig 2008-04-21 18:41:47.000000000 +0300
+++ linux-2.6-hso-my/drivers/net/usb/hso.c 2008-04-21 18:45:43.000000000 +0300
@@ -174,7 +174,6 @@ struct hso_net {
struct iphdr rx_ip_hdr;
struct ethhdr dummy_eth_head;
- __u16 wNumberMCFilters;
unsigned long flags;
};
@@ -870,49 +869,6 @@ static void hso_net_tx_timeout(struct ne
odev->stats.tx_errors++;
}
-/* setup the multicast filters */
-static void hso_net_set_multicast(struct net_device *net)
-{
- struct hso_net *odev = netdev_priv(net);
- int i = 0;
- __u8 *buf = NULL;
-
- /* Tell the kernel to stop sending us frames while we get this all set
- * up. */
- netif_stop_queue(net);
-
- /* Note: do not reorder, GCC is clever about common statements. */
- if (net->flags & IFF_PROMISC) {
- /* Unconditionally log net taps. */
- D1("%s: Promiscuous mode enabled", net->name);
- } else if (net->mc_count > odev->wNumberMCFilters) {
- /* Too many to filter perfectly -- accept all multicasts. */
- D1("%s: too many MC filters for hardware, using allmulti",
- net->name);
- } else if (net->flags & IFF_ALLMULTI) {
- /* Filter in software */
- D1("%s: using allmulti", net->name);
- } else {
- /* do multicast filtering in hardware */
- struct dev_mc_list *mclist;
- D1("%s: set multicast filters", net->name);
- buf = kmalloc(6 * net->mc_count, GFP_ATOMIC);
- if (!buf) {
- dev_err(&net->dev, "No memory to allocate?");
- goto exit;
- }
- for (i = 0, mclist = net->mc_list; mclist && i < net->mc_count;
- i++, mclist = mclist->next) {
- memcpy(&mclist->dmi_addr, &buf[i * 6], 6);
- }
- kfree(buf);
- }
-
-exit:
- /* Tell the kernel to start giving frames to us again. */
- netif_wake_queue(net);
-}
-
/* 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)
@@ -2071,7 +2027,6 @@ static int hso_serial_common_create(stru
exit:
hso_serial_common_free(serial);
return -1;
-
}
/* Frees a general hso device */
@@ -2167,15 +2122,12 @@ static void hso_net_init(struct net_devi
net->get_stats = hso_net_get_stats;
net->tx_timeout = hso_net_tx_timeout;
net->watchdog_timeo = HSO_NET_TX_TIMEOUT;
- net->set_multicast_list = hso_net_set_multicast;
net->flags |= IFF_NOARP;
net->mtu = DEFAULT_MTU - 14;
net->tx_queue_len = 10;
SET_ETHTOOL_OPS(net, &ops);
hso_net->skb_rx_buf = NULL;
hso_net->rx_parse_state = WAIT_IP;
- /* always use all multi, no lists of multicasts */
- hso_net->wNumberMCFilters = 0;
/* and initialize the semaphore */
spin_lock_init(&hso_net->net_lock);
@@ -3084,7 +3036,6 @@ static void __exit hso_exit(void)
remove_proc_entry("devices", hso_proc_dir);
remove_proc_entry(driver_name, NULL);
}
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [RFC] updated Patch to option HSO driver to the kernel
[not found] ` <480C5FAF.1050408-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
@ 2008-04-21 18:41 ` David Brownell
[not found] ` <20080421184157.106603602C8-ZcXrCSuhvln6VZ3dlLfH/g4gEjPzgfUyLrfjE7I9kuVHxeISYlDBzl6hYfS7NtTn@public.gmane.org>
0 siblings, 1 reply; 22+ messages in thread
From: David Brownell @ 2008-04-21 18:41 UTC (permalink / raw)
To: paulius.zaleckas-Ft0m5Q12RQ9xBelEqimL3w,
linux-usb-u79uwXL29TY76Z2rM5mHXA
Cc: netdev-u79uwXL29TY76Z2rM5mHXA
> From: Paulius Zaleckas <paulius.zaleckas-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
> Date: Mon, 21 Apr 2008 12:34:39 +0300
>
> IMO it doesn't make sense to do multicasting since actually it is
> point-to-point and not ethernet traffic.
> Currently I am studying if it is possible to convert current pseudo
> ethernet interface to point-to-point one.
For the record: when I looked at that issue with respect to USB
network connections for handheld devices, one issue seemed to be
weak support for managing (lots of) point-to-point links.
The example that sticks in my memory is that of routing. Setting
up a point to point link between a handheld and a PC required
the PC to act as an IP router. Managing lots of desktop routers
in any large configuration seemed to be a losing game ... and
one that many network administrators would refuse to play. And
that's in addition to the lack of a dynamic IP address assignment
solution for lots of point-to-point links.
The alternative was to set up the links like Ethernet, then bridge
them. That's a *much* more manageable solution, even though I still
don't know of any distro that makes bridge setup work as easily as
Windows does (sigh). Bridging properly requires the ability to handle
multicast and broadcast packets ... and once you've got that then
DHCP, zeroconf, and other automatic network configuration schemes
work easily.
QED ... that's why the "usbnet" framework doesn't try to use the
point-to-point framework, instead allows N-casting.
- Dave
--
To unsubscribe from this list: send the line "unsubscribe linux-usb" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [RFC] updated Patch to option HSO driver to the kernel
[not found] ` <480CB8C2.9090902-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
@ 2008-04-21 20:17 ` David Brownell
[not found] ` <200804211317.23971.david-b-yBeKhBN/0LDR7s880joybQ@public.gmane.org>
2008-04-22 8:33 ` Paulius Zaleckas
1 sibling, 1 reply; 22+ messages in thread
From: David Brownell @ 2008-04-21 20:17 UTC (permalink / raw)
To: Paulius Zaleckas
Cc: linux-usb-u79uwXL29TY76Z2rM5mHXA, netdev-u79uwXL29TY76Z2rM5mHXA
On Monday 21 April 2008, Paulius Zaleckas wrote:
>
> Incremental patch.
> - Remove multicasting
Is it really a good idea to remove the ability to
use DHCP over these links?
--
To unsubscribe from this list: send the line "unsubscribe linux-usb" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [RFC] updated Patch to option HSO driver to the kernel
[not found] ` <20080421184157.106603602C8-ZcXrCSuhvln6VZ3dlLfH/g4gEjPzgfUyLrfjE7I9kuVHxeISYlDBzl6hYfS7NtTn@public.gmane.org>
@ 2008-04-21 22:04 ` Paulius Zaleckas
2008-04-21 22:58 ` David Brownell
[not found] ` <480D0F5B.9010808-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
0 siblings, 2 replies; 22+ messages in thread
From: Paulius Zaleckas @ 2008-04-21 22:04 UTC (permalink / raw)
To: linux-usb-u79uwXL29TY76Z2rM5mHXA; +Cc: netdev-u79uwXL29TY76Z2rM5mHXA
David Brownell wrote:
>> From: Paulius Zaleckas <paulius.zaleckas-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
>> Date: Mon, 21 Apr 2008 12:34:39 +0300
>>
>> IMO it doesn't make sense to do multicasting since actually it is
>> point-to-point and not ethernet traffic.
>> Currently I am studying if it is possible to convert current pseudo
>> ethernet interface to point-to-point one.
>
> For the record: when I looked at that issue with respect to USB
> network connections for handheld devices, one issue seemed to be
> weak support for managing (lots of) point-to-point links.
>
> The example that sticks in my memory is that of routing. Setting
> up a point to point link between a handheld and a PC required
> the PC to act as an IP router. Managing lots of desktop routers
> in any large configuration seemed to be a losing game ... and
> one that many network administrators would refuse to play. And
> that's in addition to the lack of a dynamic IP address assignment
> solution for lots of point-to-point links.
>
> The alternative was to set up the links like Ethernet, then bridge
> them. That's a *much* more manageable solution, even though I still
> don't know of any distro that makes bridge setup work as easily as
> Windows does (sigh). Bridging properly requires the ability to handle
> multicast and broadcast packets ... and once you've got that then
> DHCP, zeroconf, and other automatic network configuration schemes
> work easily.
>
> QED ... that's why the "usbnet" framework doesn't try to use the
> point-to-point framework, instead allows N-casting.
>
> - Dave
I would agree with you, but... To make this interface work you have to
send AT command with APN and optionally with PAP/CHAP username and password.
Then you call AT command witch initiates PPP with basestation and begins
to send/receive traffic on this pseudo ethernet interface... Actually it
still needs one more AT command to get your IP and DNS addresses.
Then you do: ifconfig hso0 xxx.xxx.xxx.xxx netmask 255.255.255.255 up
And then you have to write DNS addresses (got through AT interface) to
the /etc/resolv.conf. Now you have a working internet connection!
So... I don't see any chance to do multicasting or broadcasting here...
IMO the only way to distribute this kind of connection to local network
is to do NAT'ing :( Am I wrong?
P.S. Pseudo ethernet means that it receives bare IP packet from USB device,
adds dummy ethernet header and sends it for further processing to kernel.
Paulius
--
To unsubscribe from this list: send the line "unsubscribe linux-usb" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [RFC] updated Patch to option HSO driver to the kernel
[not found] ` <200804211317.23971.david-b-yBeKhBN/0LDR7s880joybQ@public.gmane.org>
@ 2008-04-21 22:12 ` Paulius Zaleckas
0 siblings, 0 replies; 22+ messages in thread
From: Paulius Zaleckas @ 2008-04-21 22:12 UTC (permalink / raw)
To: linux-usb-u79uwXL29TY76Z2rM5mHXA; +Cc: netdev-u79uwXL29TY76Z2rM5mHXA
David Brownell wrote:
> On Monday 21 April 2008, Paulius Zaleckas wrote:
>> Incremental patch.
>> - Remove multicasting
>
> Is it really a good idea to remove the ability to
> use DHCP over these links?
IMO it is really good idea:
1. Please read my comments to your previous post.
2. This code was dead and broken anyway. If you don't believe
just look what wNumberMCFilters variable is doing there :)
Paulius
--
To unsubscribe from this list: send the line "unsubscribe linux-usb" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [RFC] updated Patch to option HSO driver to the kernel
2008-04-21 22:04 ` Paulius Zaleckas
@ 2008-04-21 22:58 ` David Brownell
[not found] ` <480D0F5B.9010808-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
1 sibling, 0 replies; 22+ messages in thread
From: David Brownell @ 2008-04-21 22:58 UTC (permalink / raw)
To: Paulius Zaleckas; +Cc: Network development list
On Monday 21 April 2008, Paulius Zaleckas wrote:
> To make this interface work you have to
> send AT command with APN and optionally with PAP/CHAP username and password.
> Then you call AT command witch initiates PPP with basestation and begins
> to send/receive traffic on this pseudo ethernet interface... Actually it
> still needs one more AT command to get your IP and DNS addresses.
> Then you do: ifconfig hso0 xxx.xxx.xxx.xxx netmask 255.255.255.255 up
> And then you have to write DNS addresses (got through AT interface) to
> the /etc/resolv.conf. Now you have a working internet connection!
Hardly a general purpose device, then ... not even the model I'm
used to seeing from a DSL or cable modem. Presumably you have some
tool that runs on Linux to set up links like that.
> So... I don't see any chance to do multicasting or broadcasting here...
Well, some folk would want IP multicast for video support, but that's
a different issue.
- Dave
> P.S. Pseudo ethernet means that it receives bare IP packet from USB device,
> adds dummy ethernet header and sends it for further processing to kerne
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [RFC] updated Patch to option HSO driver to the kernel
[not found] ` <480D0F5B.9010808-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
@ 2008-04-22 6:29 ` Filip Aben
2008-04-22 8:52 ` Oliver Neukum
1 sibling, 0 replies; 22+ messages in thread
From: Filip Aben @ 2008-04-22 6:29 UTC (permalink / raw)
To: Paulius Zaleckas
Cc: linux-usb-u79uwXL29TY76Z2rM5mHXA, netdev-u79uwXL29TY76Z2rM5mHXA
Paulius Zaleckas schreef:
> David Brownell wrote:
>>> From: Paulius Zaleckas <paulius.zaleckas-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
>>> Date: Mon, 21 Apr 2008 12:34:39 +0300
>>>
>>> IMO it doesn't make sense to do multicasting since actually it is
>>> point-to-point and not ethernet traffic.
>>> Currently I am studying if it is possible to convert current pseudo
>>> ethernet interface to point-to-point one.
>>
>> For the record: when I looked at that issue with respect to USB
>> network connections for handheld devices, one issue seemed to be
>> weak support for managing (lots of) point-to-point links.
>>
>> The example that sticks in my memory is that of routing. Setting
>> up a point to point link between a handheld and a PC required
>> the PC to act as an IP router. Managing lots of desktop routers
>> in any large configuration seemed to be a losing game ... and
>> one that many network administrators would refuse to play. And
>> that's in addition to the lack of a dynamic IP address assignment
>> solution for lots of point-to-point links.
>>
>> The alternative was to set up the links like Ethernet, then bridge
>> them. That's a *much* more manageable solution, even though I still
>> don't know of any distro that makes bridge setup work as easily as
>> Windows does (sigh). Bridging properly requires the ability to handle
>> multicast and broadcast packets ... and once you've got that then
>> DHCP, zeroconf, and other automatic network configuration schemes
>> work easily.
>>
>> QED ... that's why the "usbnet" framework doesn't try to use the
>> point-to-point framework, instead allows N-casting.
>>
>> - Dave
>
> I would agree with you, but... To make this interface work you have to
> send AT command with APN and optionally with PAP/CHAP username and
> password.
> Then you call AT command witch initiates PPP with basestation and begins
> to send/receive traffic on this pseudo ethernet interface... Actually it
> still needs one more AT command to get your IP and DNS addresses.
> Then you do: ifconfig hso0 xxx.xxx.xxx.xxx netmask 255.255.255.255 up
> And then you have to write DNS addresses (got through AT interface) to
> the /etc/resolv.conf. Now you have a working internet connection!
>
> So... I don't see any chance to do multicasting or broadcasting here...
> IMO the only way to distribute this kind of connection to local network
> is to do NAT'ing :( Am I wrong?
>
> P.S. Pseudo ethernet means that it receives bare IP packet from USB device,
> adds dummy ethernet header and sends it for further processing to kernel.
Correct. And we don't support DHCP.
Filip-
--
To unsubscribe from this list: send the line "unsubscribe linux-usb" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [RFC] updated Patch to option HSO driver to the kernel
[not found] ` <480CB8C2.9090902-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
2008-04-21 20:17 ` David Brownell
@ 2008-04-22 8:33 ` Paulius Zaleckas
[not found] ` <480DA2CA.8090705-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
1 sibling, 1 reply; 22+ messages in thread
From: Paulius Zaleckas @ 2008-04-22 8:33 UTC (permalink / raw)
To: linux-usb-u79uwXL29TY76Z2rM5mHXA; +Cc: netdev-u79uwXL29TY76Z2rM5mHXA
[-- Attachment #1: Type: text/plain, Size: 58 bytes --]
Incremental patch.
- use net_device_stats from dev->stats
[-- Attachment #2: hso_net_stats.patch --]
[-- Type: text/x-patch, Size: 2078 bytes --]
--- linux-2.6-hso-my/drivers/net/usb/hso.c.orig 2008-04-21 18:45:43.000000000 +0300
+++ linux-2.6-hso-my/drivers/net/usb/hso.c 2008-04-22 11:16:01.000000000 +0300
@@ -152,7 +152,6 @@ struct hso_shared_int {
struct hso_net {
struct hso_device *parent;
- struct net_device_stats stats;
struct net_device *net;
struct usb_endpoint_descriptor *in_endp;
@@ -712,7 +711,7 @@ static int hso_net_open(struct net_devic
return -ENODEV;
}
/* reset read counter. */
- odev->stats.rx_packets = 0;
+ odev->net->stats.rx_packets = 0;
odev->skb_tx_buf = NULL;
/* setup environment */
@@ -817,11 +816,11 @@ static int hso_net_start_xmit(struct sk_
if (result) {
dev_warn(&odev->parent->interface->dev,
"failed mux_bulk_tx_urb %d", result);
- odev->stats.tx_errors++;
+ odev->net->stats.tx_errors++;
netif_start_queue(net);
} else {
- odev->stats.tx_packets++;
- odev->stats.tx_bytes += skb->len;
+ odev->net->stats.tx_packets++;
+ odev->net->stats.tx_bytes += skb->len;
/* And tell the kernel when the last transmit started. */
net->trans_start = jiffies;
}
@@ -846,7 +845,7 @@ static struct ethtool_ops ops = {
static struct net_device_stats *hso_net_get_stats(struct net_device *net)
{
- return &((struct hso_net *)netdev_priv(net))->stats;
+ return &net->stats;
}
/* called when a packet did not ack after watchdogtimeout */
@@ -866,7 +865,7 @@ static void hso_net_tx_timeout(struct ne
usb_unlink_urb(odev->mux_bulk_tx_urb);
/* Update statistics */
- odev->stats.tx_errors++;
+ odev->net->stats.tx_errors++;
}
/* make a real packet from the received USB buffer */
@@ -991,11 +990,11 @@ static void packetizeRx(struct hso_net *
odev->skb_rx_buf = NULL;
/* update out statistics */
- odev->stats.rx_packets++;
+ odev->net->stats.rx_packets++;
/* Hmmm, wonder if we have received the IP len
* or the ETH len. */
- odev->stats.rx_bytes += odev->rx_buf_size;
+ odev->net->stats.rx_bytes += odev->rx_buf_size;
odev->rx_buf_size = 0;
odev->rx_buf_missing = sizeof(struct iphdr);
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [RFC] updated Patch to option HSO driver to the kernel
[not found] ` <480D0F5B.9010808-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
2008-04-22 6:29 ` Filip Aben
@ 2008-04-22 8:52 ` Oliver Neukum
1 sibling, 0 replies; 22+ messages in thread
From: Oliver Neukum @ 2008-04-22 8:52 UTC (permalink / raw)
To: Paulius Zaleckas
Cc: netdev-u79uwXL29TY76Z2rM5mHXA, linux-usb-u79uwXL29TY76Z2rM5mHXA
Am Dienstag, 22. April 2008 00:04:11 schrieb Paulius Zaleckas:
> I would agree with you, but... To make this interface work you have to
> send AT command with APN and optionally with PAP/CHAP username and password.
> Then you call AT command witch initiates PPP with basestation and begins
> to send/receive traffic on this pseudo ethernet interface... Actually it
> still needs one more AT command to get your IP and DNS addresses.
> Then you do: ifconfig hso0 xxx.xxx.xxx.xxx netmask 255.255.255.255 up
> And then you have to write DNS addresses (got through AT interface) to
> the /etc/resolv.conf. Now you have a working internet connection!
>
> So... I don't see any chance to do multicasting or broadcasting here...
> IMO the only way to distribute this kind of connection to local network
> is to do NAT'ing :( Am I wrong?
But what in this setup would prevent the other end of the connection
from sending packets to a multicast address down the link? If that
can happen, the questions remains, can the device filter these packets
in hardware?
Regards
Oliver
--
To unsubscribe from this list: send the line "unsubscribe linux-usb" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [RFC] updated Patch to option HSO driver to the kernel
[not found] ` <480DA2CA.8090705-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
@ 2008-04-22 13:50 ` Paulius Zaleckas
[not found] ` <480DED38.3080900-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
0 siblings, 1 reply; 22+ messages in thread
From: Paulius Zaleckas @ 2008-04-22 13:50 UTC (permalink / raw)
To: linux-usb-u79uwXL29TY76Z2rM5mHXA; +Cc: netdev-u79uwXL29TY76Z2rM5mHXA
[-- Attachment #1: Type: text/plain, Size: 279 bytes --]
Incremental patch.
- remove not needed variable initializations
- remove hso_net_get_stats, because by default identical
internal_stats function from net/core/dev.c is used.
- remove not needed memset(hso_net, 0, sizeof(*hso_net)),
because memory is allocated with kzalloc
[-- Attachment #2: hso_not_needed.patch --]
[-- Type: text/x-patch, Size: 10328 bytes --]
--- linux-2.6-hso-my/drivers/net/usb/hso.c.orig 2008-04-22 11:16:01.000000000 +0300
+++ linux-2.6-hso-my/drivers/net/usb/hso.c 2008-04-22 16:37:31.000000000 +0300
@@ -547,7 +547,7 @@ static struct hso_serial *get_serial_by_
static struct hso_serial *get_serial_by_index(unsigned index)
{
- struct hso_serial *serial = NULL;
+ struct hso_serial *serial;
unsigned long flags;
if (!serial_table[index])
@@ -561,7 +561,7 @@ static struct hso_serial *get_serial_by_
static int get_free_serial_index(void)
{
- int index = 0;
+ int index;
unsigned long flags;
spin_lock_irqsave(&serial_table_lock, flags);
@@ -591,7 +591,7 @@ static void set_serial_by_index(unsigned
/* log a meaningfull explanation of an USB status */
static void log_usb_status(int status, const char *function)
{
- char *explanation = NULL;
+ char *explanation;
switch (status) {
case -ENODEV:
@@ -630,10 +630,9 @@ static void log_usb_status(int status, c
static int hso_proc_options(char *buf, char **start, off_t offset, int count,
int *eof, void *data)
{
- int len = 0;
+ int len;
/* get the module parameters */
- len +=
- snprintf(buf + len, count - len, "Version: %s\n", DRIVER_VERSION);
+ len = snprintf(buf, count, "Version: %s\n", DRIVER_VERSION);
len += snprintf(buf + len, count - len, "debug: 0x%02x\n", debug);
len += snprintf(buf + len, count - len, "procfs: 0x%02x\n", procfs);
len +=
@@ -647,9 +646,9 @@ static int hso_proc_options(char *buf, c
static int hso_proc_port_info(char *buf, char **start, off_t offset, int count,
int *eof, void *data)
{
- int len = 0;
+ int len;
struct hso_device *hso_dev = (struct hso_device *)data;
- char *port_name = NULL;
+ char *port_name;
D1("count: %d", count);
@@ -689,7 +688,7 @@ static int hso_proc_port_info(char *buf,
break;
}
- len += snprintf(buf + len, count - len, "%s\n", port_name);
+ len = snprintf(buf, count, "%s\n", port_name);
/* return the device id to the user, for use in scripts for autopm */
len +=
@@ -782,7 +781,7 @@ static void write_bulk_callback(struct u
static int hso_net_start_xmit(struct sk_buff *skb, struct net_device *net)
{
struct hso_net *odev = netdev_priv(net);
- int result = 0;
+ int result;
/* Tell the kernel, "No more frames 'til we are done with this one." */
netif_stop_queue(net);
@@ -843,11 +842,6 @@ static struct ethtool_ops ops = {
.get_link = ethtool_op_get_link
};
-static struct net_device_stats *hso_net_get_stats(struct net_device *net)
-{
- return &net->stats;
-}
-
/* called when a packet did not ack after watchdogtimeout */
static void hso_net_tx_timeout(struct net_device *net)
{
@@ -872,11 +866,11 @@ static void hso_net_tx_timeout(struct ne
static void packetizeRx(struct hso_net *odev, unsigned char *ip_pkt,
unsigned int count, unsigned char is_eop)
{
- unsigned short temp_bytes = 0;
+ unsigned short temp_bytes;
unsigned short buffer_offset = 0;
- unsigned short frame_len = 0;
- unsigned char *tmp_rx_buf = NULL;
- struct ethhdr *eth_head = NULL;
+ unsigned short frame_len;
+ unsigned char *tmp_rx_buf;
+ struct ethhdr *eth_head;
/* log if needed */
D1("Rx %d bytes", count);
@@ -1027,8 +1021,8 @@ static void packetizeRx(struct hso_net *
static void read_bulk_callback(struct urb *urb)
{
struct hso_net *odev = urb->context;
- struct net_device *net = NULL;
- int result = 0;
+ struct net_device *net;
+ int result;
int status = urb->status;
/* is al ok? (Filip: Who's Al ?) */
@@ -1248,7 +1242,7 @@ static int hso_serial_write(struct tty_s
int count)
{
struct hso_serial *serial = get_serial_by_tty(tty);
- int space = 0, tx_bytes = 0;
+ int space, tx_bytes;
unsigned long flags;
/* sanity check */
@@ -1281,7 +1275,7 @@ out:
static int hso_serial_write_room(struct tty_struct *tty)
{
struct hso_serial *serial = get_serial_by_tty(tty);
- int room = 0;
+ int room;
unsigned long flags;
spin_lock_irqsave(&serial->serial_lock, flags);
@@ -1316,7 +1310,7 @@ static void hso_serial_set_termios(struc
static int hso_serial_chars_in_buffer(struct tty_struct *tty)
{
struct hso_serial *serial = get_serial_by_tty(tty);
- int chars = 0;
+ int chars;
unsigned long flags;
/* sanity check */
@@ -1332,7 +1326,7 @@ static int hso_serial_chars_in_buffer(st
static int hso_serial_tiocmget(struct tty_struct *tty, struct file *file)
{
- unsigned int value = 0;
+ unsigned int value;
struct hso_serial *serial = get_serial_by_tty(tty);
unsigned long flags;
@@ -1392,7 +1386,7 @@ static int hso_serial_tiocmset(struct tt
/* starts a transmit */
static void hso_kick_transmit(struct hso_serial *serial)
{
- u8 *temp = NULL;
+ u8 *temp;
unsigned long flags;
int res;
@@ -1430,8 +1424,8 @@ static int mux_device_request(struct hso
struct usb_ctrlrequest *ctrl_req,
u8 *ctrl_urb_data, u32 size)
{
- int result = 0;
- int pipe = -1;
+ int result;
+ int pipe;
/* Sanity check */
if (!serial || !ctrl_urb || !ctrl_req) {
@@ -1512,10 +1506,10 @@ static int hso_mux_serial_read(struct hs
static void intr_callback(struct urb *urb)
{
struct hso_shared_int *shared_int = urb->context;
- struct hso_serial *serial = NULL;
- unsigned char *port_req = NULL;
+ struct hso_serial *serial;
+ unsigned char *port_req;
int status = urb->status;
- int i = 0;
+ int i;
usb_mark_last_busy(urb->dev);
@@ -1602,7 +1596,7 @@ static void hso_std_serial_write_bulk_ca
static int hso_std_serial_write_data(struct hso_serial *serial)
{
int count = serial->tx_data_count;
- int result = 0;
+ int result;
usb_fill_bulk_urb(serial->tx_urb,
serial->parent->usb,
@@ -1626,7 +1620,7 @@ static int hso_std_serial_write_data(str
static void ctrl_callback(struct urb *urb)
{
struct hso_serial *serial = urb->context;
- struct usb_ctrlrequest *req = NULL;
+ struct usb_ctrlrequest *req;
int status = urb->status;
/* sanity check */
@@ -1692,7 +1686,7 @@ static void put_rxbuf_data(struct urb *u
static void hso_std_serial_read_bulk_callback(struct urb *urb)
{
struct hso_serial *serial = urb->context;
- int result = 0;
+ int result;
int status = urb->status;
/* sanity check */
@@ -1758,7 +1752,7 @@ static void hso_std_serial_read_bulk_cal
static void hso_log_port(struct hso_device *hso_dev)
{
- char *port_type = NULL;
+ char *port_type;
char port_dev[20];
switch (hso_dev->port_spec & HSO_PORT_MASK) {
@@ -1958,7 +1952,7 @@ static void hso_serial_common_free(struc
static int hso_serial_common_create(struct hso_serial *serial, int num_urbs,
int rx_size, int tx_size)
{
- struct device *dev = NULL;
+ struct device *dev;
int minor;
int i;
@@ -2107,8 +2101,6 @@ static void hso_net_init(struct net_devi
{
struct hso_net *hso_net = netdev_priv(net);
- /* initialize to zero */
- memset(hso_net, 0, sizeof(*hso_net));
D1("sizeof hso_net is %d", (int)sizeof(*hso_net));
/* most of the setup is done by standard function */
@@ -2118,7 +2110,6 @@ static void hso_net_init(struct net_devi
net->open = hso_net_open;
net->stop = hso_net_close;
net->hard_start_xmit = hso_net_start_xmit;
- net->get_stats = hso_net_get_stats;
net->tx_timeout = hso_net_tx_timeout;
net->watchdog_timeo = HSO_NET_TX_TIMEOUT;
net->flags |= IFF_NOARP;
@@ -2137,8 +2128,7 @@ static void set_ethernet_addr(struct hso
{
unsigned char mac_addr[6];
unsigned char dummy_mac[6];
- int i = 0;
- int len = 0;
+ int i, len;
unsigned char buffer[13];
/* we can't fail, therefor we use a random macaddress */
@@ -2197,9 +2187,9 @@ static int add_net_device(struct hso_dev
static struct hso_device *hso_create_net_device(struct usb_interface *interface)
{
int result, i;
- struct net_device *net = NULL;
- struct hso_net *hso_net = NULL;
- struct hso_device *hso_dev = NULL;
+ struct net_device *net;
+ struct hso_net *hso_net;
+ struct hso_device *hso_dev;
hso_dev = hso_create_device(interface, HSO_INTF_MUX | HSO_PORT_NETWORK);
if (!hso_dev)
@@ -2319,8 +2309,8 @@ static void hso_free_serial_device(struc
static struct hso_device *hso_create_bulk_serial_device(
struct usb_interface *interface, int port)
{
- struct hso_device *hso_dev = NULL;
- struct hso_serial *serial = NULL;
+ struct hso_device *hso_dev;
+ struct hso_serial *serial;
char device_name[20];
int num_urbs;
@@ -2391,12 +2381,12 @@ struct hso_device *hso_create_mux_serial
int port,
struct hso_shared_int *mux)
{
- struct hso_device *hso_dev = NULL;
- struct hso_serial *serial = NULL;
+ struct hso_device *hso_dev;
+ struct hso_serial *serial;
char device_name[20];
- int port_spec = 0;
+ int port_spec;
- port_spec |= HSO_INTF_MUX;
+ port_spec = HSO_INTF_MUX;
port_spec &= ~HSO_PORT_MASK;
port_spec |= hso_mux_to_port(port);
@@ -2506,7 +2496,7 @@ static int hso_get_config_data(struct us
struct usb_device *usbdev = interface_to_usbdev(interface);
u8 config_data[17];
u32 if_num = interface->altsetting->desc.bInterfaceNumber;
- s32 result = 0;
+ s32 result;
if (usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0),
0x86, 0xC0, 0, 0, config_data, 17,
@@ -2588,8 +2578,8 @@ static int hso_probe(struct usb_interfac
int mux, i, if_num, port_spec;
unsigned char port_mask;
char *rfkn;
- struct hso_device *hso_dev = NULL;
- struct hso_shared_int *shared_int = NULL;
+ struct hso_device *hso_dev;
+ struct hso_shared_int *shared_int;
struct hso_device *tmp_dev = NULL;
if_num = interface->altsetting->desc.bInterfaceNumber;
@@ -2760,7 +2750,7 @@ static int hso_put_activity(struct hso_d
/* called by kernel when we need to suspend device */
static int hso_suspend(struct usb_interface *iface, pm_message_t message)
{
- int i, result = 0;
+ int i, result;
/* Stop all serial ports */
for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++) {
@@ -2872,7 +2862,7 @@ static struct usb_endpoint_descriptor *h
{
int i;
struct usb_host_interface *iface = intf->cur_altsetting;
- struct usb_endpoint_descriptor *endp = NULL;
+ struct usb_endpoint_descriptor *endp;
for (i = 0; i < iface->desc.bNumEndpoints; i++) {
endp = &iface->endpoint[i].desc;
@@ -2951,8 +2941,8 @@ static struct usb_driver hso_driver = {
static int __init hso_init(void)
{
- int i = 0;
- int result = 0;
+ int i;
+ int result;
/* put it in the log */
printk(KERN_INFO "hso: %s\n", version);
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [RFC] updated Patch to option HSO driver to the kernel
[not found] ` <480DED38.3080900-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
@ 2008-04-23 13:40 ` Paulius Zaleckas
[not found] ` <480F3C41.10908-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
0 siblings, 1 reply; 22+ messages in thread
From: Paulius Zaleckas @ 2008-04-23 13:40 UTC (permalink / raw)
To: linux-usb-u79uwXL29TY76Z2rM5mHXA; +Cc: netdev-u79uwXL29TY76Z2rM5mHXA
[-- Attachment #1: Type: text/plain, Size: 280 bytes --]
Incremental patch.
- converted network interface from ethernet to PtP
- some includes cleanup
- fixed false gcc warning about using uninitialized
variable. Introduced by previous patch.
Signed-of-by: Paulius Zaleckas <paulius.zaleckas-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
[-- Attachment #2: hso_not_eth.patch --]
[-- Type: text/x-patch, Size: 6553 bytes --]
--- linux-2.6-hso-my/drivers/net/usb/hso.c.orig 2008-04-22 16:37:31.000000000 +0300
+++ linux-2.6-hso-my/drivers/net/usb/hso.c 2008-04-23 16:24:30.000000000 +0300
@@ -47,8 +47,6 @@
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/netdevice.h>
-#include <linux/inetdevice.h>
-#include <linux/etherdevice.h>
#include <linux/module.h>
#include <linux/ethtool.h>
#include <linux/usb.h>
@@ -171,7 +169,6 @@ struct hso_net {
unsigned short rx_buf_size;
unsigned short rx_buf_missing;
struct iphdr rx_ip_hdr;
- struct ethhdr dummy_eth_head;
unsigned long flags;
};
@@ -294,19 +291,6 @@ static int hso_get_activity(struct hso_d
/* Helping functions */
/*****************************************************************************/
-/* convert a character representing a hex value to a number */
-static unsigned char hex2dec(unsigned char digit)
-{
- if ((digit >= '0') && (digit <= '9'))
- return (digit - '0');
- /* Map all characters to 0-15 */
- if ((digit >= 'a') && (digit <= 'z'))
- return (digit - 'a' + 10) % 16;
- if ((digit >= 'A') && (digit <= 'Z'))
- return (digit - 'A' + 10) % 16;
- return 0;
-}
-
/* #define DEBUG */
#define dev2net(x) (x->port_data.dev_net)
@@ -790,8 +774,6 @@ static int hso_net_start_xmit(struct sk_
return 0;
}
- /* fetch the packet */
- skb_pull(skb, ETH_HLEN);
/* log if asked */
DUMP1(skb->data, skb->len);
/* Copy it from kernel memory to OUR memory */
@@ -870,7 +852,6 @@ static void packetizeRx(struct hso_net *
unsigned short buffer_offset = 0;
unsigned short frame_len;
unsigned char *tmp_rx_buf;
- struct ethhdr *eth_head;
/* log if needed */
D1("Rx %d bytes", count);
@@ -909,9 +890,7 @@ static void packetizeRx(struct hso_net *
continue;
}
/* Allocate an sk_buff */
- odev->skb_rx_buf = dev_alloc_skb(
- frame_len + 2 +
- odev->net->hard_header_len);
+ odev->skb_rx_buf = dev_alloc_skb(frame_len);
if (!odev->skb_rx_buf) {
/* We got no receive buffer. */
D1("could not allocate memory");
@@ -921,11 +900,6 @@ static void packetizeRx(struct hso_net *
/* Here's where it came from */
odev->skb_rx_buf->dev = odev->net;
- /* Make some headroom: standard alignment + the
- * ethernet header. */
- skb_reserve(odev->skb_rx_buf,
- 2 + odev->net->hard_header_len);
-
/* Copy what we got so far. make room for iphdr
* after tail. */
tmp_rx_buf =
@@ -935,9 +909,7 @@ static void packetizeRx(struct hso_net *
sizeof(struct iphdr));
/* ETH_HLEN */
- odev->rx_buf_size =
- odev->net->hard_header_len +
- sizeof(struct iphdr);
+ odev->rx_buf_size = sizeof(struct iphdr);
/* Filip actually use .tot_len */
odev->rx_buf_missing =
@@ -962,22 +934,15 @@ static void packetizeRx(struct hso_net *
odev->rx_buf_size += temp_bytes;
if (!odev->rx_buf_missing) {
/* Packet is complete. Inject into stack. */
- /* Add fake ethernet header. */
- eth_head = (struct ethhdr *)skb_push(odev->
- skb_rx_buf,
- odev->
- net->
- hard_header_len);
- memcpy(eth_head, &odev->dummy_eth_head,
- sizeof(struct ethhdr));
-
- /* Not sure here either */
- odev->skb_rx_buf->protocol = eth_type_trans(
- odev->skb_rx_buf,
- odev->net);
+ /* We have IP packet here */
+ odev->skb_rx_buf->protocol =
+ __constant_htons(ETH_P_IP);
/* don't check it */
odev->skb_rx_buf->ip_summed =
CHECKSUM_UNNECESSARY;
+
+ skb_reset_mac_header(odev->skb_rx_buf);
+
/* Ship it off to the kernel */
netif_rx(odev->skb_rx_buf);
/* No longer our buffer. */
@@ -986,8 +951,6 @@ static void packetizeRx(struct hso_net *
/* update out statistics */
odev->net->stats.rx_packets++;
- /* Hmmm, wonder if we have received the IP len
- * or the ETH len. */
odev->net->stats.rx_bytes += odev->rx_buf_size;
odev->rx_buf_size = 0;
@@ -2103,70 +2066,22 @@ static void hso_net_init(struct net_devi
D1("sizeof hso_net is %d", (int)sizeof(*hso_net));
- /* most of the setup is done by standard function */
- ether_setup(net);
-
/* fill in the other fields */
net->open = hso_net_open;
net->stop = hso_net_close;
net->hard_start_xmit = hso_net_start_xmit;
net->tx_timeout = hso_net_tx_timeout;
net->watchdog_timeo = HSO_NET_TX_TIMEOUT;
- net->flags |= IFF_NOARP;
+ net->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
+ net->type = ARPHRD_NONE;
net->mtu = DEFAULT_MTU - 14;
net->tx_queue_len = 10;
SET_ETHTOOL_OPS(net, &ops);
- hso_net->skb_rx_buf = NULL;
- hso_net->rx_parse_state = WAIT_IP;
/* and initialize the semaphore */
spin_lock_init(&hso_net->net_lock);
}
-/* setting the mac-address of the newly created iface */
-static void set_ethernet_addr(struct hso_net *odev)
-{
- unsigned char mac_addr[6];
- unsigned char dummy_mac[6];
- int i, len;
- unsigned char buffer[13];
-
- /* we can't fail, therefor we use a random macaddress */
- random_ether_addr(mac_addr);
- dummy_mac[0] = 0xFA;
- dummy_mac[1] = mac_addr[1];
- dummy_mac[2] = mac_addr[2];
- dummy_mac[3] = mac_addr[3];
- dummy_mac[4] = mac_addr[4];
- dummy_mac[5] = mac_addr[5];
-
- /* but we like consistency, that's why we try to use the serial number
- * as a macaddress if available */
- len = usb_string(odev->parent->usb,
- odev->parent->usb->descriptor.iSerialNumber,
- buffer, 13);
- if (len != 12 && strcmp("Serial", buffer)) {
- /* Fill in the mac_addr */
- for (i = 0; i < 6; i++) {
- mac_addr[i] = (hex2dec(buffer[2 * i]) << 4) +
- hex2dec(buffer[2 * i + 1]);
- }
- mac_addr[0] &= 0xfe; /* clear multicast bit */
- mac_addr[0] |= 0x02; /* set local assignment bit (IEEE802) */
- } else {
- dev_err(&odev->parent->usb->dev, "Attempting to get MAC "
- "address failed: using random\n");
- }
-
- /* Now copy it over to our network device structure */
- memcpy(odev->net->dev_addr, mac_addr, sizeof(mac_addr));
-
- /* Create the default fake ethernet header. */
- memcpy(odev->dummy_eth_head.h_dest, mac_addr, ETH_ALEN);
- memcpy(odev->dummy_eth_head.h_source, dummy_mac, ETH_ALEN);
- odev->dummy_eth_head.h_proto = htons(ETH_P_IP);
-}
-
/* Adds a network device in the network device table */
static int add_net_device(struct hso_device *hso_dev)
{
@@ -2255,9 +2170,6 @@ static struct hso_device *hso_create_net
goto exit;
}
- /* and don't forget the MAC address. */
- set_ethernet_addr(hso_net);
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [RFC] updated Patch to option HSO driver to the kernel
[not found] ` <480F3C41.10908-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
@ 2008-04-25 12:31 ` Paulius Zaleckas
2008-04-25 13:03 ` Oliver Neukum
[not found] ` <4811CF33.8040007-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
0 siblings, 2 replies; 22+ messages in thread
From: Paulius Zaleckas @ 2008-04-25 12:31 UTC (permalink / raw)
To: linux-usb-u79uwXL29TY76Z2rM5mHXA; +Cc: netdev-u79uwXL29TY76Z2rM5mHXA
[-- Attachment #1: Type: text/plain, Size: 407 bytes --]
Incremental patch.
- don't reset rx_packets stats when telling device "up".
TODO:
- figure out what should be MTU value. Currently it is set
to 1500-14. I guess that 14 here means eth header size, but
this has no logical explanation...
- do we really need ethtool support? It always reports that
link is up... The only useful information is driver name,
version and USB path... Is it worth it?
[-- Attachment #2: hso_reset_rx.patch --]
[-- Type: text/x-patch, Size: 411 bytes --]
--- linux-2.6-hso-my/drivers/net/usb/hso.c.orig 2008-04-23 16:24:30.000000000 +0300
+++ linux-2.6-hso-my/drivers/net/usb/hso.c 2008-04-25 15:12:48.000000000 +0300
@@ -693,8 +693,7 @@ static int hso_net_open(struct net_devic
dev_err(&net->dev, "No net device !\n");
return -ENODEV;
}
- /* reset read counter. */
- odev->net->stats.rx_packets = 0;
+
odev->skb_tx_buf = NULL;
/* setup environment */
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [RFC] updated Patch to option HSO driver to the kernel
2008-04-25 12:31 ` Paulius Zaleckas
@ 2008-04-25 13:03 ` Oliver Neukum
[not found] ` <200804251503.31240.oliver-GvhC2dPhHPQdnm+yROfE0A@public.gmane.org>
[not found] ` <4811CF33.8040007-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
1 sibling, 1 reply; 22+ messages in thread
From: Oliver Neukum @ 2008-04-25 13:03 UTC (permalink / raw)
To: Paulius Zaleckas; +Cc: linux-usb, netdev
Am Freitag, 25. April 2008 14:31:47 schrieb Paulius Zaleckas:
> - do we really need ethtool support? It always reports that
> link is up... The only useful information is driver name,
> version and USB path... Is it worth it?
Yes. NetworkManager does strange things to devices without ethtool
support. NetworkManager is important.
Regards
Oliver
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [RFC] updated Patch to option HSO driver to the kernel
[not found] ` <4811CF33.8040007-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
@ 2008-04-25 13:19 ` Paulius Zaleckas
[not found] ` <4811DA4F.30209-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
0 siblings, 1 reply; 22+ messages in thread
From: Paulius Zaleckas @ 2008-04-25 13:19 UTC (permalink / raw)
To: linux-usb-u79uwXL29TY76Z2rM5mHXA; +Cc: netdev-u79uwXL29TY76Z2rM5mHXA
[-- Attachment #1: Type: text/plain, Size: 50 bytes --]
Incremental patch.
- simplify net stats even more
[-- Attachment #2: hso_stats_simplify.patch --]
[-- Type: text/x-patch, Size: 910 bytes --]
--- linux-2.6-hso-my/drivers/net/usb/hso.c.orig 2008-04-25 15:12:48.000000000 +0300
+++ linux-2.6-hso-my/drivers/net/usb/hso.c 2008-04-25 16:13:41.000000000 +0300
@@ -796,11 +796,11 @@ static int hso_net_start_xmit(struct sk_
if (result) {
dev_warn(&odev->parent->interface->dev,
"failed mux_bulk_tx_urb %d", result);
- odev->net->stats.tx_errors++;
+ net->stats.tx_errors++;
netif_start_queue(net);
} else {
- odev->net->stats.tx_packets++;
- odev->net->stats.tx_bytes += skb->len;
+ net->stats.tx_packets++;
+ net->stats.tx_bytes += skb->len;
/* And tell the kernel when the last transmit started. */
net->trans_start = jiffies;
}
@@ -840,7 +840,7 @@ static void hso_net_tx_timeout(struct ne
usb_unlink_urb(odev->mux_bulk_tx_urb);
/* Update statistics */
- odev->net->stats.tx_errors++;
+ net->stats.tx_errors++;
}
/* make a real packet from the received USB buffer */
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [RFC] updated Patch to option HSO driver to the kernel
[not found] ` <200804251503.31240.oliver-GvhC2dPhHPQdnm+yROfE0A@public.gmane.org>
@ 2008-04-25 16:09 ` Christoph Hellwig
0 siblings, 0 replies; 22+ messages in thread
From: Christoph Hellwig @ 2008-04-25 16:09 UTC (permalink / raw)
To: Oliver Neukum
Cc: Paulius Zaleckas, linux-usb-u79uwXL29TY76Z2rM5mHXA,
netdev-u79uwXL29TY76Z2rM5mHXA
On Fri, Apr 25, 2008 at 03:03:30PM +0200, Oliver Neukum wrote:
> Am Freitag, 25. April 2008 14:31:47 schrieb Paulius Zaleckas:
> > - do we really need ethtool support? It always reports that
> > ?? ??link is up... The only useful information is driver name,
> > ?? ??version and USB path... Is it worth it?
>
> Yes. NetworkManager does strange things to devices without ethtool
> support. NetworkManager is important.
So we hack around broken userspace in the kernel now? What about using
your energy to fix up NetworkManager (yes, I know it's crap code, but
life is hard sometimes)
--
To unsubscribe from this list: send the line "unsubscribe linux-usb" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [RFC] updated Patch to option HSO driver to the kernel
[not found] ` <4811DA4F.30209-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
@ 2008-04-28 10:53 ` Paulius Zaleckas
[not found] ` <4815AC9D.7080009-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
0 siblings, 1 reply; 22+ messages in thread
From: Paulius Zaleckas @ 2008-04-28 10:53 UTC (permalink / raw)
To: linux-usb-u79uwXL29TY76Z2rM5mHXA; +Cc: netdev-u79uwXL29TY76Z2rM5mHXA
[-- Attachment #1: Type: text/plain, Size: 483 bytes --]
Incremental patch.
- fix bug with freeing locked mutex:
> =========================
> [ BUG: held lock freed! ]
> -------------------------
> modprobe/3829 is freeing memory ffff81002acb5948-ffff81002acb5a07, with
> a lock still held there!
> (&mux->shared_int_lock){--..}, at: [<ffffffff88303234>]
> hso_serial_ref_free+0x7a/0xce [hso]
> 1 lock held by modprobe/3829:
> #0: (&mux->shared_int_lock){--..}, at: [<ffffffff88303234>]
> hso_serial_ref_free+0x7a/0xce [hso]
[-- Attachment #2: hso_shared_int_free.patch --]
[-- Type: text/x-patch, Size: 730 bytes --]
--- linux-2.6-hso-my/drivers/net/usb/hso.c.orig 2008-04-25 16:13:41.000000000 +0300
+++ linux-2.6-hso-my/drivers/net/usb/hso.c 2008-04-28 12:34:23.000000000 +0300
@@ -2210,7 +2210,8 @@ static void hso_free_serial_device(struc
mutex_lock(&serial->shared_int->shared_int_lock);
if (--serial->shared_int->ref_count == 0)
hso_free_shared_int(serial->shared_int);
- mutex_unlock(&serial->shared_int->shared_int_lock);
+ else
+ mutex_unlock(&serial->shared_int->shared_int_lock);
}
kfree(serial);
hso_free_device(hso_dev);
@@ -2360,6 +2361,7 @@ static void hso_free_shared_int(struct h
{
usb_free_urb(mux->shared_intr_urb);
kfree(mux->shared_intr_buf);
+ mutex_unlock(&mux->shared_int_lock);
kfree(mux);
}
^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [RFC] updated Patch to option HSO driver to the kernel
[not found] ` <4815AC9D.7080009-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
@ 2008-04-28 15:37 ` Paulius Zaleckas
0 siblings, 0 replies; 22+ messages in thread
From: Paulius Zaleckas @ 2008-04-28 15:37 UTC (permalink / raw)
To: linux-usb-u79uwXL29TY76Z2rM5mHXA; +Cc: netdev-u79uwXL29TY76Z2rM5mHXA
[-- Attachment #1: Type: text/plain, Size: 245 bytes --]
Incremental patch.
- Oliver patch for rfkill crash (introduced rfkill/mem leak)
- Create rfkill only for network device (fixed rfkill/mem leak)
- Make driver work even if rfkill initialization fails
Greg: What do you think about unified patch?
[-- Attachment #2: hso_rfkill_network.patch --]
[-- Type: text/x-patch, Size: 4640 bytes --]
--- linux-2.6-hso-my/drivers/net/usb/hso.c.orig 2008-04-28 12:34:23.000000000 +0300
+++ linux-2.6-hso-my/drivers/net/usb/hso.c 2008-04-28 18:02:23.000000000 +0300
@@ -151,6 +151,7 @@ struct hso_shared_int {
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;
@@ -227,7 +228,6 @@ struct hso_device {
struct usb_device *usb;
struct usb_interface *interface;
- struct rfkill *rfkill;
struct device *dev;
struct kref ref;
@@ -2097,6 +2097,58 @@ static int add_net_device(struct hso_dev
return 0;
}
+static int hso_radio_toggle(void *data, enum rfkill_state state)
+{
+ struct hso_device *hso_dev = data;
+ int enabled = (state == RFKILL_STATE_ON);
+ int rv;
+
+ mutex_lock(&hso_dev->mutex);
+ if (hso_dev->usb_gone)
+ rv = 0;
+ else
+ rv = usb_control_msg(hso_dev->usb, usb_rcvctrlpipe(hso_dev->usb, 0),
+ enabled ? 0x82 : 0x81, 0x40, 0, 0, NULL, 0,
+ USB_CTRL_SET_TIMEOUT);
+ mutex_unlock(&hso_dev->mutex);
+ return rv;
+}
+
+/* Creates and sets up everything for rfkill */
+static void hso_create_rfkill(struct hso_device *hso_dev,
+ struct usb_interface *interface)
+{
+ struct hso_net *hso_net = dev2net(hso_dev);
+ struct device *dev = hso_dev->dev;
+ char *rfkn;
+
+ hso_net->rfkill = rfkill_allocate(&interface_to_usbdev(interface)->dev,
+ RFKILL_TYPE_WLAN);
+ if (!hso_net->rfkill) {
+ dev_err(dev, "%s - Out of memory", __func__);
+ return;
+ }
+ rfkn = kzalloc(20, GFP_KERNEL);
+ if (!rfkn) {
+ rfkill_free(hso_net->rfkill);
+ dev_err(dev, "%s - Out of memory", __func__);
+ return;
+ }
+ snprintf(rfkn, 20, "hso-%d",
+ interface->altsetting->desc.bInterfaceNumber);
+ hso_net->rfkill->name = rfkn;
+ hso_net->rfkill->state = RFKILL_STATE_ON;
+ hso_net->rfkill->data = hso_dev;
+ hso_net->rfkill->toggle_radio = hso_radio_toggle;
+ if (rfkill_register(hso_net->rfkill) < 0) {
+ kfree(rfkn);
+ hso_net->rfkill->name = NULL;
+ rfkill_free(hso_net->rfkill);
+ dev_err(dev, "%s - Failed to register rfkill", __func__);
+ return;
+ }
+}
+
/* Creates our network device */
static struct hso_device *hso_create_net_device(struct usb_interface *interface)
{
@@ -2183,6 +2235,8 @@ static struct hso_device *hso_create_net
hso_log_port(hso_dev);
+ hso_create_rfkill(hso_dev, interface);
+
return hso_dev;
exit:
hso_free_net_device(hso_dev);
@@ -2467,30 +2521,12 @@ static int hso_get_config_data(struct us
return result;
}
-static int hso_radio_toggle(void *data, enum rfkill_state state)
-{
- struct hso_device *hso_dev = data;
- int enabled = (state == RFKILL_STATE_ON);
- int rv;
-
- mutex_lock(&hso_dev->mutex);
- if (hso_dev->usb_gone)
- rv = 0;
- else
- rv = usb_control_msg(hso_dev->usb, usb_rcvctrlpipe(hso_dev->usb, 0),
- enabled ? 0x82 : 0x81, 0x40, 0, 0, NULL, 0,
- USB_CTRL_SET_TIMEOUT);
- mutex_unlock(&hso_dev->mutex);
- return rv;
-}
-
/* called once for each interface upon device insertion */
static int hso_probe(struct usb_interface *interface,
const struct usb_device_id *id)
{
int mux, i, if_num, port_spec;
unsigned char port_mask;
- char *rfkn;
struct hso_device *hso_dev = NULL;
struct hso_shared_int *shared_int;
struct hso_device *tmp_dev = NULL;
@@ -2563,27 +2599,6 @@ static int hso_probe(struct usb_interfac
goto exit;
}
- hso_dev->rfkill = rfkill_allocate(&interface_to_usbdev(interface)->dev,
- RFKILL_TYPE_WLAN);
- if (!hso_dev->rfkill)
- goto exit;
- rfkn = kzalloc(20, GFP_KERNEL);
- if (!rfkn) {
- rfkill_free(hso_dev->rfkill);
- goto exit;
- }
- snprintf(rfkn, 20, "hso-%d", if_num);
- hso_dev->rfkill->name = rfkn;
- hso_dev->rfkill->state = RFKILL_STATE_ON;
- hso_dev->rfkill->data = hso_dev;
- hso_dev->rfkill->toggle_radio = hso_radio_toggle;
- if (rfkill_register(hso_dev->rfkill) < 0) {
- kfree(rfkn);
- hso_dev->rfkill->name = NULL;
- rfkill_free(hso_dev->rfkill);
- goto exit;
- }
-
usb_driver_claim_interface(&hso_driver, interface, hso_dev);
/* save our data pointer in this device */
@@ -2591,7 +2606,6 @@ static int hso_probe(struct usb_interfac
/* done */
return 0;
-
exit:
hso_free_interface(interface);
return -ENODEV;
@@ -2600,16 +2614,8 @@ exit:
/* device removed, cleaning up */
static void hso_disconnect(struct usb_interface *interface)
{
- struct hso_device *hso_dev = usb_get_intfdata(interface);
-
hso_free_interface(interface);
- if (hso_dev) {
- cancel_work_sync(&hso_dev->async_put_intf);
- cancel_work_sync(&hso_dev->async_get_intf);
- rfkill_unregister(hso_dev->rfkill);
- }
^ permalink raw reply [flat|nested] 22+ messages in thread
end of thread, other threads:[~2008-04-28 15:37 UTC | newest]
Thread overview: 22+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2008-04-17 21:47 [RFC] updated Patch to option HSO driver to the kernel Greg KH
[not found] ` <20080417214719.GF17664-U8xfFu+wG4EAvxtiuMwx3w@public.gmane.org>
2008-04-21 1:04 ` Paulius Zaleckas
2008-04-21 8:16 ` Oliver Neukum
2008-04-21 9:34 ` Paulius Zaleckas
[not found] ` <480C5FAF.1050408-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
2008-04-21 18:41 ` David Brownell
[not found] ` <20080421184157.106603602C8-ZcXrCSuhvln6VZ3dlLfH/g4gEjPzgfUyLrfjE7I9kuVHxeISYlDBzl6hYfS7NtTn@public.gmane.org>
2008-04-21 22:04 ` Paulius Zaleckas
2008-04-21 22:58 ` David Brownell
[not found] ` <480D0F5B.9010808-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
2008-04-22 6:29 ` Filip Aben
2008-04-22 8:52 ` Oliver Neukum
[not found] ` <480BE815.2000409-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
2008-04-21 15:54 ` Paulius Zaleckas
[not found] ` <480CB8C2.9090902-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
2008-04-21 20:17 ` David Brownell
[not found] ` <200804211317.23971.david-b-yBeKhBN/0LDR7s880joybQ@public.gmane.org>
2008-04-21 22:12 ` Paulius Zaleckas
2008-04-22 8:33 ` Paulius Zaleckas
[not found] ` <480DA2CA.8090705-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
2008-04-22 13:50 ` Paulius Zaleckas
[not found] ` <480DED38.3080900-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
2008-04-23 13:40 ` Paulius Zaleckas
[not found] ` <480F3C41.10908-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
2008-04-25 12:31 ` Paulius Zaleckas
2008-04-25 13:03 ` Oliver Neukum
[not found] ` <200804251503.31240.oliver-GvhC2dPhHPQdnm+yROfE0A@public.gmane.org>
2008-04-25 16:09 ` Christoph Hellwig
[not found] ` <4811CF33.8040007-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
2008-04-25 13:19 ` Paulius Zaleckas
[not found] ` <4811DA4F.30209-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
2008-04-28 10:53 ` Paulius Zaleckas
[not found] ` <4815AC9D.7080009-Ft0m5Q12RQ9xBelEqimL3w@public.gmane.org>
2008-04-28 15:37 ` Paulius Zaleckas
2008-04-21 12:43 ` Paulius Zaleckas
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).