diff -urN b/drivers/net/wan/hso/CHANGELOG a/drivers/net/wan/hso/CHANGELOG --- b/drivers/net/wan/hso/CHANGELOG 1970-01-01 03:00:00.000000000 +0300 +++ a/drivers/net/wan/hso/CHANGELOG 2008-09-19 13:43:10.000000000 +0400 @@ -0,0 +1,145 @@ +v1.6 Denis Joseph Barrow + Put MOD_INFO back to show if CONFIG_HSO_AUTOPM & CONFIG_HSO_DEBUG + is set or not removed warning about disabling CONFIG_HSO_AUTOPM if + the kernel version is too old, also fixed some sloppyness found + by Peter Henn. + + Fixed compile bug which left reset_resume method + defined for kernels prior to 2.6.22 where it didn't exist. +v1.5 Denis Joseph Barrow + Updated README + + Applied Adrian Bunks hso_create_bulk_serial_device(): + fix of a double free patch from the linux-usb mailing list. + + Made usb_drivers reset_resume function point to + hso_resume this fixes problems when the network + interface is left idle for a few minutes. + Possibly reset_resume should initialise hardware + more but this works in the common case. + + Added check for IFF_UP in hso_resume this should + eliminate -EINVAL (-22) errors caused from + urb's being submitted twice once by hso_resume + & once in hso_net_open if suspend/resume USB power saving + mode is enabled. + + Added s setpwr.sh script so that USB power saving mode can + be switched on or off quickly in the driver without having + to walk through sysfs. + + Removed usb_driver_claim_interface & usb_driver_release_interface + calls as they were deemed by Paulius Zaleckas on the + linux usb mailing list to be unneccessary. + + Improved hso_connect.sh script to make it automatically + detect the application port. + Improved hso_connect.sh so that it automatically finds + the application port. + + Removed usb_driver_claim_interface & usb_driver_release_interface + calls as they were deemed by Paulius Zaleckas on the + linux usb mailing list to be unneccessary. + +v1.5-rc1 Denis Joseph Barrow + Took updates upto 2.6.27-rc5, + A new structure hso_mutex_table had to be declared statically + & used as as hso_device mutex_lock(&serial->parent->mutex) etc + is freed in hso_serial_open & hso_serial_close by kref_put while + the mutex is still in use. + This is a substantial change but should make the driver much stabler. + Patch to stop loss of characters on the hso modems, + this patch throttles & unthrottles the modem by + not putting out urbs until the tty/line discipline layer + has enough space for newly received packets. + serial ports. This is required for firmware diagnostics + being done at Option. + +v2.6.27-rc3 Denis Joseph Barrow + Taking code directly from 2.6.27-rc3 will be using + the official linux kernel version as a basis for + our future releases & porting our bugfixes onto this. + + Denis Joseph Barrow + Fixed a problem found by a firmware engineer, the + program basically in hso_std_serial_write_bulk_callback was being + not sanity checking serial->tty was not NULL before calling tty_wakeup + this resulted in a race condition where urbs after + serial->tty was shut down. maybe more needs to be done here. + + Moved kref_put in hso_serial_close as refcnt was incorrectly + going to zero when serial->open_count went to zero + which was not consistent with hso_serial_open. + A similar patch was posted to the linux usb mailing list. + + +1.4 Denis Joseph Barrow + Fixed dev_kfree_skb happening too many times when hso_start_net_device + is called from hso_resume. This manifests itself as a crash after a + kernel message saying that the hso driver is transmitting lingering data + + Renamed hso driver printk macros to have a prefix HSO_ this + was needed as the kernel also defines a macro called WARN in 2.6.27-rc1 + which hso.h also defined. + + Fixed a tty line stuff needed to compile for 2.6.27-rc1 + + Made calls to hso_mux_submit_intr_urb use GFP_ATOMIC in their + allocations like the 2.6.27-rc1 driver this prevents the kernel + trying to sleep while in interrupt. +1.3 Peter Henn + - correct USB interface initialisation for ICON322 + - correct some compile warnings +1.2 Filip Aben + - Added frame length lower boundary checking + - Catch failed opens and unwanted closes. + - Set DTR/RTS at open() + - Add hso_tiocmset() locking + - Use usb_unlink_urb() when in_interrupt. + - Removed 'Suspend' modinfo and replace with more general 'Flags' which should contain all compiler defines. + +1.1 Filip Aben + - Added SIOCSETSUSPEND ioctl for serial ports: Enables or disables selective suspend if supported by kernel. + - Added SIOCSETRADIO ioctl for serial ports: Enabled or disables the radio. + - Icon401 support + - Added sysfs support + - Added GE40x, GTM382 devices + - Fixed APP2 port support + - Fixed crash when closing active port +1.0 Filip Aben + - Fixed Interrupt endpoint bug for HS speed devices ( Icon321 ) + - Major overhaul of devices structure and way of working. Should be a bit cleaner now. +0.9 Sven Duytschaever + - added suspend, resume, autosuspend and autoresume + - minor restructuring of the code + - Icon031 enumeration fix + - added DTR and RTS handling + Filip Aben + - Added IP downlink recovery + - Fixed rescheduling while atomic crash. + - Changed serial writing mechanism + - Added port types to our per-device 'ttys' proc entry. + - Added multi-rx-urbs for modem downlink + - Replaced semaphore by safer spinlock + - Merged in Stefano Klinke's Icon031 patch +0.8 Peter Henn + - Add device id for some new cards + - Fix for 2.6.18 & 2.6.19 compilation ( courtesy of Pharscape forum user joke_dst ) +0.7 Filip Aben + - Added 2.6.12+ compatability +0.6 Marco Himmer ( Option ) + - Send REZERO UNIT command to switch from UMS to 3G device + - Move packed out of struct to avoid compiler warning +0.5 Filip Aben ( Option ) + - Removed internal project names from comments + - Removed dependency on Modem port which is not always there + - Added USB id's for other compatible Option devices +0.4 Andrew Bird (Sphere Systems Ltd) + Initial support for Circuit Switched interface - no H/W handshaking +0.3 Andrew Bird (Sphere Systems Ltd) + Multiple device support, startup & shutdown cleanups +0.2 Andrew Bird (Sphere Systems Ltd) + Initial port to 2.6, target 2.6.21/22 +0.1 Option International + 2.4 driver + diff -urN b/drivers/net/wan/hso/connect.sh a/drivers/net/wan/hso/connect.sh --- b/drivers/net/wan/hso/connect.sh 1970-01-01 03:00:00.000000000 +0300 +++ a/drivers/net/wan/hso/connect.sh 2008-09-19 13:43:10.000000000 +0400 @@ -0,0 +1,88 @@ +#!/bin/sh + +export APN="internet.eplus.de" +export USR="eplus" +export PAS="gprs" +export PIN="0000" +#export APN="web.vodafone.de" +#export USR="" +#export PAS="" + + + +DEVICE=/dev/ttyHS0 + +TMPFIL=/tmp/connect.$$ + +up() { + echo connecting + + stty 19200 -tostop + + rm -f $TMPFIL + ( + /usr/sbin/chat -E -s -V -f dial.cht <$DEVICE > $DEVICE + ) 2>&1 |tee $TMPFIL + echo " "n inet + echo connected + echo " " + PIP="`grep '^_OWANDATA' $TMPFIL | cut -d, -f2`" + NS1="`grep '^_OWANDATA' $TMPFIL | cut -d, -f4`" + NS2="`grep '^_OWANDATA' $TMPFIL | cut -d, -f5`" + + #ifconfig hso0 $PIP netmask 255.255.255.255 up + + ORT="`route | grep default | awk '{printf $8}'`" # find the old default route and replace it + #route delete default dev $ORT + echo "add route" + #route add default dev hso0 + #mv -f /etc/resolv.conf /tmp/resolv.conf.tmp + + echo "set nameserver" + ( # update the DNS + echo "nameserver $NS1" + echo "nameserver $NS2" + ) > /etc/resolv.conf + + rm -f $TMPFIL + +} + +down() { + echo disconnecting + + /usr/sbin/chat -V -f stop.cht <$DEVICE >$DEVICE + ifconfig hso0 down + echo "reset nameserver" + mv -f /tmp/resolv.conf.tmp /etc/resolv.conf +} + +init() { + echo init + + /usr/sbin/chat -E -s -V -f init.cht <$DEVICE >$DEVICE +} + +usage() { + echo Usage: $0 \(up\|down\|restart\|init\) +} + +case "$1" in + up) + up + ;; + down) + down + ;; + restart) + down + up + ;; + init) + init + ;; + *) + usage + ;; +esac + diff -urN b/drivers/net/wan/hso/dial.cht a/drivers/net/wan/hso/dial.cht --- b/drivers/net/wan/hso/dial.cht 1970-01-01 03:00:00.000000000 +0300 +++ a/drivers/net/wan/hso/dial.cht 2008-09-19 13:43:10.000000000 +0400 @@ -0,0 +1,7 @@ +ABORT ERROR +TIMEOUT 10 +"" ATZ +OK "AT_OWANCALL=1,1,0^m" +OK "\d\d\d\d\d\d\d\dAT_OWANDATA=1^m" +OK "" + diff -urN b/drivers/net/wan/hso/hso.c a/drivers/net/wan/hso/hso.c --- b/drivers/net/wan/hso/hso.c 1970-01-01 03:00:00.000000000 +0300 +++ a/drivers/net/wan/hso/hso.c 2008-09-22 12:14:09.000000000 +0400 @@ -0,0 +1,3371 @@ +/****************************************************************************** + * + * Driver for Option High Speed Mobile Devices. + * + * Copyright (C) 2008 Option International + * Copyright (C) 2007 Andrew Bird (Sphere Systems Ltd) + * + * Copyright (C) 2008 Greg Kroah-Hartman + * Copyright (C) 2008 Novell, Inc. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, + * USA + * + * + *****************************************************************************/ + +/****************************************************************************** + * + * Description of the device: + * + * Interface 0: Contains the IP network interface on the bulk end points. + * The multiplexed serial ports are using the interrupt and + * control endpoints. + * Interrupt contains a bitmap telling which multiplexed + * serialport needs servicing. + * + * Interface 1: Diagnostics port, uses bulk only, do not submit urbs until the + * port is opened, as this have a huge impact on the network port + * throughput. + * + * Interface 2: Standard modem interface - circuit switched interface, should + * not be used. + * + *****************************************************************************/ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#define HAVE_RFKILL (defined(CONFIG_RFKILL) || defined(CONFIG_RFKILL_MODULE)) +#if (HAVE_RFKILL) +#include +#endif +#include +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) +#include +#else +#include +#endif +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) +#include +#else +#include +#endif +#include +#include + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 15)) +#include +#define MUTEX mutex +#else +#include +#define MUTEX semaphore +#define mutex_init(sem) sema_init(sem, 1) +#define mutex_lock(sem) down(sem) +#define mutex_unlock(sem) up(sem) +#endif /* ( LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 15) ) */ + +#define NETDEV_HAVE_DEV (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 19)) +#if NETDEV_HAVE_DEV +#define netdev_err(net, format, arg...) dev_err(&net->dev, format, ## arg) +#define netdev_warn(net, format, arg...) dev_warn(&net->dev, format, ## arg) +#else +#define netdev_err(net, format, arg...) printk(KERN_ERR "%s" format ,\ + (char *)(&net->name), ## arg) +#define netdev_warn(net, format, arg...) printk(KERN_WARNING "%s" format ,\ + (char *)(&net->name), ## arg) +#endif +#ifdef CONFIG_HSO_AUTOPM +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)) +#warning "CONFIG_HSO_AUTOPM set for kernel version < 2.6.19," \ + "it's not supported by the kernel I'm undeffing it." +#undef CONFIG_HSO_AUTOPM +#endif +#endif +#define HAVE_RESET_RESUME (defined(CONFIG_HSO_AUTOPM) &&\ + (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 22))) + +#if (!HAVE_RFKILL) +#define SIOCSETRADIO (SIOCDEVPRIVATE+4) +#endif + +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 22)) +static inline void skb_reset_mac_header(struct sk_buff *skb) +{ + skb->mac.raw = skb->data; +} +#endif +#ifdef CONFIG_HSO_AUTOPM +#define sCONFIG_HSO_AUTOPM "CONFIG_HSO_AUTOPM " +#else +#define sCONFIG_HSO_AUTOPM "" +#endif +#ifdef CONFIG_HSO_DEBUG +#define sCONFIG_HSO_DEBUG "CONFIG_HSO_DEBUG " +#else +#define sCONFIG_HSO_DEBUG "" +#endif + + +#define DRIVER_VERSION "1.6-Option" +#define MOD_AUTHOR "Option Wireless" +#define MOD_DESCRIPTION "USB High Speed Option driver" +#define MOD_LICENSE "GPL" + +#define HSO_MAX_NET_DEVICES 10 +#define HSO_MAX_MTU 2048 +#define DEFAULT_MTU 1500 +#define DEFAULT_MRU 1500 + +#define CTRL_URB_RX_SIZE 1024 +#define CTRL_URB_TX_SIZE 64 + +#define BULK_URB_RX_SIZE 4096 +#define BULK_URB_TX_SIZE 8192 + +#define MUX_BULK_RX_BUF_SIZE HSO_MAX_MTU +#define MUX_BULK_TX_BUF_SIZE HSO_MAX_MTU +#define MUX_BULK_RX_BUF_COUNT 4 +#define USB_TYPE_OPTION_VENDOR 0x20 + +/* These definitions are used with the struct hso_net flags element */ +/* - use *_bit operations on it. (bit indices not values.) */ +#define HSO_NET_RUNNING 0 + +#define HSO_NET_TX_TIMEOUT (HZ*10) + +#define HSO_SERIAL_MAGIC 0x48534f31 + +/* Number of ttys to handle */ +#define HSO_SERIAL_TTY_MINORS 256 + +#define MAX_RX_URBS 2 + + + + + +/*****************************************************************************/ +/* kernel dependent declarations */ +/*****************************************************************************/ +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)) + +#define TERMIOS termios +#define GFP_T int +#define CALLBACK_ARGS struct urb *urb, struct pt_regs *regs + +#else /* (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)) */ + +#define TERMIOS ktermios +#define GFP_T gfp_t +#define CALLBACK_ARGS struct urb *urb + +#endif /* (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)) */ + +static inline struct hso_serial *get_serial_by_tty(struct tty_struct *tty) +{ + if (tty) + return tty->driver_data; + return NULL; +} +/*****************************************************************************/ +/* Debugging functions */ +/*****************************************************************************/ +#define D__(lvl_, fmt, arg...) \ + do { \ + printk(lvl_ "[%d:%s]: " fmt "\n", \ + __LINE__, __func__, ## arg); \ + } while (0) + +#define D_(lvl, args...) \ + do { \ + if (lvl & debug) \ + D__(KERN_INFO, args); \ + } while (0) + +#define D1(args...) D_(0x01, ##args) +#define D2(args...) D_(0x02, ##args) +#define D3(args...) D_(0x04, ##args) +#define D4(args...) D_(0x08, ##args) +#define D5(args...) D_(0x10, ##args) + +/*****************************************************************************/ +/* Enumerators */ +/*****************************************************************************/ +enum pkt_parse_state { + WAIT_IP, + WAIT_DATA, + WAIT_SYNC +}; + +/*****************************************************************************/ +/* Structs */ +/*****************************************************************************/ + +struct hso_shared_int { + struct usb_endpoint_descriptor *intr_endp; + void *shared_intr_buf; + struct urb *shared_intr_urb; + struct usb_device *usb; + int use_count; + int ref_count; + struct MUTEX shared_int_lock; +}; + +#define NETDEVICE_HAS_STATS (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 22)) +struct hso_net { + struct hso_device *parent; +#if (!NETDEVICE_HAS_STATS) + struct net_device_stats stats; +#endif + struct net_device *net; +#if HAVE_RFKILL + struct rfkill *rfkill; +#endif + struct usb_endpoint_descriptor *in_endp; + struct usb_endpoint_descriptor *out_endp; + + struct urb *mux_bulk_rx_urb_pool[MUX_BULK_RX_BUF_COUNT]; + struct urb *mux_bulk_tx_urb; + void *mux_bulk_rx_buf_pool[MUX_BULK_RX_BUF_COUNT]; + void *mux_bulk_tx_buf; + + struct sk_buff *skb_rx_buf; + struct sk_buff *skb_tx_buf; + + enum pkt_parse_state rx_parse_state; + spinlock_t net_lock; + + unsigned short rx_buf_size; + unsigned short rx_buf_missing; + struct iphdr rx_ip_hdr; + + unsigned long flags; +}; +#if NETDEVICE_HAS_STATS +#define STATS(net) ((net)->stats) +#else +#define STATS(net) (((struct hso_net *)netdev_priv(net))->stats) +#endif + +#define HAVE_TTY_INSERT_FLIP_STRING \ +(LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 16)) + +#define HAVE_LDISC_OPS (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 16)) + +enum rx_ctrl_state{ + RX_IDLE, + RX_SENT, + RX_PENDING +}; + + +struct hso_serial { + struct hso_device *parent; + int magic; + u8 minor; + + struct hso_shared_int *shared_int; + + /* rx/tx urb could be either a bulk urb or a control urb depending + on which serial port it is used on. */ + struct urb *rx_urb[MAX_RX_URBS]; + u8 num_rx_urbs; + u8 *rx_data[MAX_RX_URBS]; + u16 rx_data_length; /* should contain allocated length */ + + struct urb *tx_urb; + u8 *tx_data; + u8 *tx_buffer; + u16 tx_data_length; /* should contain allocated length */ + u16 tx_data_count; + u16 tx_buffer_count; + struct usb_ctrlrequest ctrl_req_tx; + struct usb_ctrlrequest ctrl_req_rx; + + struct usb_endpoint_descriptor *in_endp; + struct usb_endpoint_descriptor *out_endp; + + enum rx_ctrl_state rx_state; + u8 rts_state; + u8 dtr_state; + unsigned tx_urb_used:1; + + /* from usb_serial_port */ + struct tty_struct *tty; + int open_count; + spinlock_t serial_lock; + + int (*write_data) (struct hso_serial *serial); + /* Hacks required to get flow control + * working on the serial receive buffers + * so as not to drop characters on the floor. + */ + int curr_rx_urb_idx; + u16 curr_rx_urb_offset; + u8 rx_urb_filled[MAX_RX_URBS]; + struct tasklet_struct unthrottle_tasklet; + struct work_struct retry_unthrottle_workqueue; +}; + +struct hso_mutex_t { + struct MUTEX mutex; + u8 allocated; +}; + +struct hso_device { + union { + struct hso_serial *dev_serial; + struct hso_net *dev_net; + } port_data; + + u32 port_spec; + + + u8 usb_gone; +#ifdef CONFIG_HSO_AUTOPM + u8 is_active; + struct work_struct async_get_intf; + struct work_struct async_put_intf; +#endif + struct usb_device *usb; + struct usb_interface *interface; + + struct device *dev; + struct kref ref; + struct hso_mutex_t *mutex; +}; + + +/* Type of interface */ +#define HSO_INTF_MASK 0xFF00 +#define HSO_INTF_MUX 0x0100 +#define HSO_INTF_BULK 0x0200 + +/* Type of port */ +#define HSO_PORT_MASK 0xFF +#define HSO_PORT_NO_PORT 0x0 +#define HSO_PORT_CONTROL 0x1 +#define HSO_PORT_APP 0x2 +#define HSO_PORT_GPS 0x3 +#define HSO_PORT_PCSC 0x4 +#define HSO_PORT_APP2 0x5 +#define HSO_PORT_GPS_CONTROL 0x6 +#define HSO_PORT_MSD 0x7 +#define HSO_PORT_VOICE 0x8 +#define HSO_PORT_DIAG2 0x9 +#define HSO_PORT_DIAG 0x10 +#define HSO_PORT_MODEM 0x11 +#define HSO_PORT_NETWORK 0x12 + +/* Additional device info */ +#define HSO_INFO_MASK 0xFF000000 +#define HSO_INFO_CRC_BUG 0x01000000 + +/*****************************************************************************/ +/* Prototypes */ +/*****************************************************************************/ +/* Serial driver functions */ +static int hso_serial_tiocmset(struct tty_struct *tty, struct file *file, + unsigned int set, unsigned int clear); +static void ctrl_callback(CALLBACK_ARGS); +static int put_rxbuf_data(struct urb *urb, struct hso_serial *serial); +static void hso_kick_transmit(struct hso_serial *serial); +/* Helper functions */ +static int hso_mux_submit_intr_urb(struct hso_shared_int *mux_int, + struct usb_device *usb, GFP_T gfp); +static void 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 hso_std_serial_read_bulk_callback(CALLBACK_ARGS); +static int hso_mux_serial_read(struct hso_serial *serial); +#ifdef CONFIG_HSO_AUTOPM +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); +#endif +/*****************************************************************************/ +/* Helping functions */ +/*****************************************************************************/ + +static inline struct hso_net *dev2net(struct hso_device *hso_dev) +{ + return hso_dev->port_data.dev_net; +} + +static inline struct hso_serial *dev2ser(struct hso_device *hso_dev) +{ + return hso_dev->port_data.dev_serial; +} + +/* Debugging functions */ +#ifdef CONFIG_HSO_DEBUG +static void dbg_dump(int line_count, const char *func_name, unsigned char *buf, + unsigned int len) +{ + static char name[255]; + + sprintf(name, "hso[%d:%s]", line_count, func_name); + print_hex_dump_bytes(name, DUMP_PREFIX_NONE, buf, len); +} + +#define DUMP(buf_, len_) \ + dbg_dump(__LINE__, __func__, buf_, len_) + +#define DUMP1(buf_, len_) \ + do { \ + if (0x01 & debug) \ + DUMP(buf_, len_); \ + } while (0) +#else +#define DUMP(buf_, len_) +#define DUMP1(buf_, len_) +#endif + +/* module parameters */ +static int debug; +static int tty_major; +static int disable_net; + +/* driver info */ +static const char driver_name[] = "hso"; +static const char tty_filename[] = "ttyHS"; +static const char *version = __FILE__ ": " DRIVER_VERSION " " MOD_AUTHOR; +/* the usb driver itself (registered in hso_init) */ +static struct usb_driver hso_driver; +/* serial structures */ +static struct tty_driver *tty_drv; +static struct hso_device *serial_table[HSO_SERIAL_TTY_MINORS]; +static struct hso_device *network_table[HSO_MAX_NET_DEVICES]; +static spinlock_t serial_table_lock; +static struct TERMIOS *hso_serial_termios[HSO_SERIAL_TTY_MINORS]; +static struct TERMIOS *hso_serial_termios_locked[HSO_SERIAL_TTY_MINORS]; + +/* hso_mutex_table has to be declared statically as hso_device + * is freed in hso_serial_open & hso_serial_close while + * the mutex is still in use. + */ +#define HSO_NUM_MUTEXES (HSO_SERIAL_TTY_MINORS+HSO_MAX_NET_DEVICES) +static struct hso_mutex_t hso_mutex_table[HSO_NUM_MUTEXES]; +static spinlock_t hso_mutex_lock; + +static const s32 default_port_spec[] = { + HSO_INTF_MUX | HSO_PORT_NETWORK, + HSO_INTF_BULK | HSO_PORT_DIAG, + HSO_INTF_BULK | HSO_PORT_MODEM, + 0 +}; + +static const s32 icon321_port_spec[] = { + HSO_INTF_MUX | HSO_PORT_NETWORK, + HSO_INTF_BULK | HSO_PORT_DIAG2, + HSO_INTF_BULK | HSO_PORT_MODEM, + HSO_INTF_BULK | HSO_PORT_DIAG, + 0 +}; + +#define default_port_device(vendor, product) \ + USB_DEVICE(vendor, product), \ + .driver_info = (kernel_ulong_t)default_port_spec + +#define icon321_port_device(vendor, product) \ + USB_DEVICE(vendor, product), \ + .driver_info = (kernel_ulong_t)icon321_port_spec + +/* list of devices we support */ +static const struct usb_device_id hso_ids[] = { + {default_port_device(0x0af0, 0x6711)}, + {default_port_device(0x0af0, 0x6731)}, + {default_port_device(0x0af0, 0x6751)}, + {default_port_device(0x0af0, 0x6771)}, + {default_port_device(0x0af0, 0x6791)}, + {default_port_device(0x0af0, 0x6811)}, + {default_port_device(0x0af0, 0x6911)}, + {default_port_device(0x0af0, 0x6951)}, + {default_port_device(0x0af0, 0x6971)}, + {default_port_device(0x0af0, 0x7011)}, + {default_port_device(0x0af0, 0x7031)}, + {default_port_device(0x0af0, 0x7051)}, + {default_port_device(0x0af0, 0x7071)}, + {default_port_device(0x0af0, 0x7111)}, + {default_port_device(0x0af0, 0x7211)}, + {default_port_device(0x0af0, 0x7251)}, + {default_port_device(0x0af0, 0x7271)}, + {default_port_device(0x0af0, 0x7311)}, + {default_port_device(0x0af0, 0xc031)}, /* Icon-Edge */ + {icon321_port_device(0x0af0, 0xd013)}, /* Module HSxPA */ + {icon321_port_device(0x0af0, 0xd031)}, /* Icon-321 */ + {icon321_port_device(0x0af0, 0xd033)}, /* Icon-322 */ + {USB_DEVICE(0x0af0, 0x7301)}, /* GE40x */ + {USB_DEVICE(0x0af0, 0x7361)}, /* GE40x */ + {USB_DEVICE(0x0af0, 0x7401)}, /* GI 0401 */ + {USB_DEVICE(0x0af0, 0x7501)}, /* GTM 382 */ + {USB_DEVICE(0x0af0, 0x7601)}, /* GE40x */ + {} +}; +MODULE_DEVICE_TABLE(usb, hso_ids); + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 19)) +/* 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); +#endif + +static int hso_urb_to_index(struct hso_serial *serial, struct urb *urb) +{ + int idx; + + for (idx = 0; idx < serial->num_rx_urbs; idx++) + if (serial->rx_urb[idx] == urb) + return idx; + dev_err(serial->parent->dev, "hso_urb_to_index failed\n"); + return -1; +} + +/* converts mux value to a port spec value */ +static u32 hso_mux_to_port(int mux) +{ + u32 result; + + switch (mux) { + case 0x1: + result = HSO_PORT_CONTROL; + break; + case 0x2: + result = HSO_PORT_APP; + break; + case 0x4: + result = HSO_PORT_PCSC; + break; + case 0x8: + result = HSO_PORT_GPS; + break; + case 0x10: + result = HSO_PORT_APP2; + break; + default: + result = HSO_PORT_NO_PORT; + } + return result; +} + +/* converts port spec value to a mux value */ +static u32 hso_port_to_mux(int port) +{ + u32 result; + + switch (port & HSO_PORT_MASK) { + case HSO_PORT_CONTROL: + result = 0x0; + break; + case HSO_PORT_APP: + result = 0x1; + break; + case HSO_PORT_PCSC: + result = 0x2; + break; + case HSO_PORT_GPS: + result = 0x3; + break; + case HSO_PORT_APP2: + result = 0x4; + break; + default: + result = 0x0; + } + return result; +} + +static struct hso_serial *get_serial_by_shared_int_and_type( + struct hso_shared_int *shared_int, + int mux) +{ + int i, port; + + port = hso_mux_to_port(mux); + + for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++) { + if (serial_table[i] + && (dev2ser(serial_table[i])->shared_int == shared_int) + && ((serial_table[i]->port_spec & HSO_PORT_MASK) == port)) { + return dev2ser(serial_table[i]); + } + } + + return NULL; +} + +static struct hso_serial *get_serial_by_index(unsigned index) +{ + struct hso_serial *serial = NULL; + unsigned long flags; + + spin_lock_irqsave(&serial_table_lock, flags); + if (serial_table[index]) + serial = dev2ser(serial_table[index]); + spin_unlock_irqrestore(&serial_table_lock, flags); + + return serial; +} + +static int get_free_serial_index(void) +{ + int index; + unsigned long flags; + + spin_lock_irqsave(&serial_table_lock, flags); + for (index = 0; index < HSO_SERIAL_TTY_MINORS; index++) { + if (serial_table[index] == NULL) { + spin_unlock_irqrestore(&serial_table_lock, flags); + return index; + } + } + spin_unlock_irqrestore(&serial_table_lock, flags); + + printk(KERN_ERR "%s: no free serial devices in table\n", __func__); + return -1; +} + +static void set_serial_by_index(unsigned index, struct hso_serial *serial) +{ + unsigned long flags; + spin_lock_irqsave(&serial_table_lock, flags); + if (serial) + serial_table[index] = serial->parent; + else + serial_table[index] = NULL; + spin_unlock_irqrestore(&serial_table_lock, flags); +} + + +static struct hso_mutex_t *hso_get_free_mutex(void) +{ + int index; + struct hso_mutex_t *curr_hso_mutex; + + spin_lock(&hso_mutex_lock); + for (index = 0; index < HSO_NUM_MUTEXES; index++) { + curr_hso_mutex = &hso_mutex_table[index]; + if (!curr_hso_mutex->allocated) { + curr_hso_mutex->allocated = 1; + spin_unlock(&hso_mutex_lock); + return curr_hso_mutex; + } + } + printk(KERN_ERR "BUG %s: no free hso_mutexs devices in table\n", + __func__); + spin_unlock(&hso_mutex_lock); + return NULL; +} + +static void hso_free_mutex(struct hso_mutex_t *mutex) +{ + spin_lock(&hso_mutex_lock); + mutex->allocated = 0; + spin_unlock(&hso_mutex_lock); +} + +/* log a meaningful explanation of an USB status */ +static void log_usb_status(int status, const char *function) +{ + char *explanation; + + switch (status) { + case -ENODEV: + explanation = "no device"; + break; + case -ENOENT: + explanation = "endpoint not enabled"; + break; + case -EPIPE: + explanation = "endpoint stalled"; + break; + case -ENOSPC: + explanation = "not enough bandwidth"; + break; + case -ESHUTDOWN: + explanation = "device disabled"; + break; + case -EHOSTUNREACH: + explanation = "device suspended"; + break; + case -EINVAL: + case -EAGAIN: + case -EFBIG: + case -EMSGSIZE: + explanation = "internal error"; + break; + default: + explanation = "unknown status"; + break; + } + D1("%s: received USB status - %s (%d)", function, explanation, status); +} + +/* Network interface functions */ + +/* called when net interface is brought up by ifconfig */ +static int hso_net_open(struct net_device *net) +{ + struct hso_net *odev = netdev_priv(net); + unsigned long flags = 0; + + if (!odev) { + netdev_err(net, "No net device !\n"); + return -ENODEV; + } + + odev->skb_tx_buf = NULL; + + /* setup environment */ + spin_lock_irqsave(&odev->net_lock, flags); + odev->rx_parse_state = WAIT_IP; + odev->rx_buf_size = 0; + odev->rx_buf_missing = sizeof(struct iphdr); + spin_unlock_irqrestore(&odev->net_lock, flags); + + 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(CALLBACK_ARGS) +{ + 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__); +#ifdef CONFIG_HSO_AUTOPM + hso_put_activity(odev->parent); +#endif + /* 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; + + /* Tell the kernel, "No more frames 'til we are done with this one." */ + netif_stop_queue(net); +#ifdef CONFIG_HSO_AUTOPM + if (hso_get_activity(odev->parent) == -EAGAIN) { + odev->skb_tx_buf = skb; + return 0; + } +#endif + /* log if asked */ + DUMP1(skb->data, skb->len); + /* Copy it from kernel memory to OUR memory */ + memcpy(odev->mux_bulk_tx_buf, skb->data, skb->len); + D1("len: %d/%d", skb->len, MUX_BULK_TX_BUF_SIZE); + + /* Fill in the URB for shipping it out. */ + usb_fill_bulk_urb(odev->mux_bulk_tx_urb, + odev->parent->usb, + usb_sndbulkpipe(odev->parent->usb, + odev->out_endp-> + bEndpointAddress & 0x7F), + odev->mux_bulk_tx_buf, skb->len, write_bulk_callback, + odev); + + /* Deal with the Zero Length packet problem, I hope */ + odev->mux_bulk_tx_urb->transfer_flags |= URB_ZERO_PACKET; + + /* Send the URB on its merry way. */ + result = usb_submit_urb(odev->mux_bulk_tx_urb, GFP_ATOMIC); + if (result) { + dev_warn(&odev->parent->interface->dev, + "failed mux_bulk_tx_urb %d\n", result); + STATS(net).tx_errors++; + netif_start_queue(net); + } else { + STATS(net).tx_packets++; + STATS(net).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); +} + +static struct ethtool_ops ops = { + .get_drvinfo = hso_get_drvinfo, + .get_link = ethtool_op_get_link +}; + +/*============================================================================= + * function: hso_net_ioctl + * purpose: + *============================================================================= + */ +static int hso_net_ioctl(struct net_device *net, struct ifreq *rq, int cmd) +{ + struct hso_net *odev = netdev_priv(net); + u32 usercmd = 0; + char tmp[40]; + + + switch (cmd) { + case SIOCDEVPRIVATE + 1: /* Chose this one because */ + /* SIOCDEVPRIVATE used somewhere else in this code. */ + /* return the number of sent bytes */ + D5("Transmitted: %lu", STATS(net).tx_bytes); + rq->ifr_ifru.ifru_ivalue = STATS(net).tx_bytes; + return 0; + case SIOCETHTOOL: + /* net specific */ + if (copy_from_user(&usercmd, rq->ifr_data, sizeof(usercmd))) + return -EFAULT; + switch (usercmd) { + case ETHTOOL_GDRVINFO: { + /* get driver info */ + struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO }; + strncpy(info.driver, driver_name, ETHTOOL_BUSINFO_LEN); + strncpy(info.version, DRIVER_VERSION, + ETHTOOL_BUSINFO_LEN); + sprintf(tmp, "usb%d:%d", + odev->parent->usb->bus->busnum, + odev->parent->usb->devnum); + strncpy(info.bus_info, tmp, ETHTOOL_BUSINFO_LEN); + sprintf(tmp, "%s ", driver_name); + strncpy(info.fw_version, tmp, ETHTOOL_BUSINFO_LEN); + if (copy_to_user(rq->ifr_data, &info, sizeof(info))) + return -EFAULT; + return 0; + } + case ETHTOOL_GLINK: { + /* get link status */ + struct ethtool_value edata = { ETHTOOL_GLINK }; + edata.data = netif_carrier_ok(net); + if (copy_to_user(rq->ifr_data, &edata, sizeof(edata))) + return -EFAULT; + return 0; + } + default: { + netdev_warn(net, "Got unsupported ioctl: %x\n", + usercmd); + return -EOPNOTSUPP; + /* the ethtool user space tool */ + /*relies on this */ + } + } + default: + return -ENOTTY; /* per ioctl man page */ + } +} + +/*============================================================================= + * function: hso_net_get_stats + * purpose: + *============================================================================= + */ +#if (!NETDEVICE_HAS_STATS) +static struct net_device_stats *hso_net_get_stats(struct net_device *net) +{ + + + return &((struct hso_net *) netdev_priv(net))->stats; +} +#endif + +/* 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. */ + netdev_warn(net, "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 */ + STATS(net).tx_errors++; +} + +/* make a real packet from the received USB buffer */ +static void packetizeRx(struct hso_net *odev, unsigned char *ip_pkt, + unsigned int count, unsigned char is_eop) +{ + unsigned short temp_bytes; + unsigned short buffer_offset = 0; + unsigned short frame_len; + unsigned char *tmp_rx_buf; + + /* log if needed */ + D1("Rx %d bytes", count); + DUMP(ip_pkt, min(128, (int)count)); + + while (count) { + switch (odev->rx_parse_state) { + case WAIT_IP: + /* waiting for IP header. */ + /* wanted bytes - size of ip header */ + temp_bytes = + (count < + odev->rx_buf_missing) ? count : odev-> + rx_buf_missing; + + memcpy(((unsigned char *)(&odev->rx_ip_hdr)) + + odev->rx_buf_size, ip_pkt + buffer_offset, + temp_bytes); + + odev->rx_buf_size += temp_bytes; + buffer_offset += temp_bytes; + odev->rx_buf_missing -= temp_bytes; + count -= temp_bytes; + + if (!odev->rx_buf_missing) { + /* header is complete allocate an sk_buffer and + * continue to WAIT_DATA */ + frame_len = ntohs(odev->rx_ip_hdr.tot_len); + + if ((frame_len > DEFAULT_MRU) || + (frame_len < sizeof(struct iphdr))) { + netdev_err(odev->net, + "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); + 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; + + /* Copy what we got so far. make room for iphdr + * after tail. */ + tmp_rx_buf = + skb_put(odev->skb_rx_buf, + sizeof(struct iphdr)); + memcpy(tmp_rx_buf, (char *)&(odev->rx_ip_hdr), + sizeof(struct iphdr)); + + /* ETH_HLEN */ + odev->rx_buf_size = sizeof(struct iphdr); + + /* Filip actually use .tot_len */ + odev->rx_buf_missing = + frame_len - sizeof(struct iphdr); + odev->rx_parse_state = WAIT_DATA; + } + break; + + case WAIT_DATA: + temp_bytes = (count < odev->rx_buf_missing) + ? count : odev->rx_buf_missing; + + /* Copy the rest of the bytes that are left in the + * buffer into the waiting sk_buf. */ + /* Make room for temp_bytes after tail. */ + tmp_rx_buf = skb_put(odev->skb_rx_buf, temp_bytes); + memcpy(tmp_rx_buf, ip_pkt + buffer_offset, temp_bytes); + + odev->rx_buf_missing -= temp_bytes; + count -= temp_bytes; + buffer_offset += temp_bytes; + odev->rx_buf_size += temp_bytes; + if (!odev->rx_buf_missing) { + /* Packet is complete. Inject into stack. */ + /* We have IP packet here */ + odev->skb_rx_buf->protocol = + __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. */ + odev->skb_rx_buf = NULL; + + /* update out statistics */ + STATS(odev->net).rx_packets++; + + STATS(odev->net).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(CALLBACK_ARGS) +{ + struct hso_net *odev = urb->context; + struct net_device *net; + int result; + int status = urb->status; + + /* is al ok? (Filip: Who's Al ?) */ + if (status) { + 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; + } +#ifdef CONFIG_HSO_AUTOPM + usb_mark_last_busy(urb->dev); +#endif + 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\n", __func__, + result); +} + +/* Serial driver functions */ + +static void _hso_serial_set_termios(struct tty_struct *tty, + struct TERMIOS *old) +{ + struct hso_serial *serial = get_serial_by_tty(tty); + struct TERMIOS *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 = 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 */ +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 26)) + /* baud rate 115200 */ + tty_encode_baud_rate(serial->tty, 115200, 115200); +#endif + /* + * 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; +#if (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 26)) + serial->tty->termios->c_cflag |= B115200; /* baud rate 115200 */ + serial->tty->ldisc.set_termios(serial->tty, NULL); +#endif + return; +} + +static void hso_resubmit_rx_bulk_urb(struct hso_serial *serial, struct urb *urb) +{ + int result; +#ifdef CONFIG_HSO_AUTOPM + usb_mark_last_busy(urb->dev); +#endif + /* We are done with this URB, resubmit it. Prep the USB to wait for + * another frame */ + usb_fill_bulk_urb(urb, serial->parent->usb, + usb_rcvbulkpipe(serial->parent->usb, + serial->in_endp-> + bEndpointAddress & 0x7F), + urb->transfer_buffer, serial->rx_data_length, + hso_std_serial_read_bulk_callback, serial); + /* Give this to the USB subsystem so it can tell us when more data + * arrives. */ + result = usb_submit_urb(urb, GFP_ATOMIC); + if (result) { + dev_err(&urb->dev->dev, "%s failed submit serial rx_urb %d\n", + __func__, result); + } +} + + + + +static void put_rxbuf_data_and_resubmit_bulk_urb(struct hso_serial *serial) +{ + int count; + struct urb *curr_urb; + + while (serial->rx_urb_filled[serial->curr_rx_urb_idx]) { + curr_urb = serial->rx_urb[serial->curr_rx_urb_idx]; + count = put_rxbuf_data(curr_urb, serial); + if (count == -1) + return; + if (count == 0) { + serial->curr_rx_urb_idx++; + if (serial->curr_rx_urb_idx >= serial->num_rx_urbs) + serial->curr_rx_urb_idx = 0; + hso_resubmit_rx_bulk_urb(serial, curr_urb); + } + } +} + +static void put_rxbuf_data_and_resubmit_ctrl_urb(struct hso_serial *serial) +{ + int count = 0; + struct urb *urb; + + urb = serial->rx_urb[0]; + if (serial->open_count > 0) { + count = put_rxbuf_data(urb, serial); + if (count == -1) + return; + } + /* Re issue a read as long as we receive data. */ + + if (count == 0 && ((urb->actual_length != 0) || + (serial->rx_state == RX_PENDING))) { + serial->rx_state = RX_SENT; + hso_mux_serial_read(serial); + } else + serial->rx_state = RX_IDLE; +} + + +/* read callback for Diag and CS port */ +static void hso_std_serial_read_bulk_callback(CALLBACK_ARGS) +{ + struct hso_serial *serial = urb->context; + 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 */ + spin_lock(&serial->serial_lock); + serial->rx_urb_filled[hso_urb_to_index(serial, urb)] = 1; + put_rxbuf_data_and_resubmit_bulk_urb(serial); + spin_unlock(&serial->serial_lock); + } else if (status == -ENOENT || status == -ECONNRESET) { + /* Unlinked - check for throttled port. */ + D2("Port %d, successfully unlinked urb", serial->minor); + spin_lock(&serial->serial_lock); + serial->rx_urb_filled[hso_urb_to_index(serial, urb)] = 0; + hso_resubmit_rx_bulk_urb(serial, urb); + spin_unlock(&serial->serial_lock); + } else { + D2("Port %d, status = %d for read urb", serial->minor, status); + return; + } +} + +/* + * This needs to be a tasklet otherwise we will + * end up recursively calling this function. + */ +void hso_unthrottle_tasklet(struct hso_serial *serial) +{ + unsigned long flags; + + spin_lock_irqsave(&serial->serial_lock, flags); + if ((serial->parent->port_spec & HSO_INTF_MUX)) + put_rxbuf_data_and_resubmit_ctrl_urb(serial); + else + put_rxbuf_data_and_resubmit_bulk_urb(serial); + spin_unlock_irqrestore(&serial->serial_lock, flags); +} + +static void hso_unthrottle(struct tty_struct *tty) +{ + struct hso_serial *serial = get_serial_by_tty(tty); + + tasklet_hi_schedule(&serial->unthrottle_tasklet); +} + +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 19)) +void hso_unthrottle_workfunc(struct work_struct *work) +{ + struct hso_serial *serial = + container_of(work, struct hso_serial, + retry_unthrottle_workqueue); + hso_unthrottle_tasklet(serial); +} +#endif + +/* 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 result1 = 0, result2 = 0; + struct MUTEX *hso_mutex = NULL; + int refcnt = 1; + + /* sanity check */ + if (serial == NULL || serial->magic != HSO_SERIAL_MAGIC) { + tty->driver_data = NULL; + D1("Failed to open port"); + return -ENODEV; + } + hso_mutex = &serial->parent->mutex->mutex; + mutex_lock(hso_mutex); +#ifdef CONFIG_HSO_AUTOPM + result1 = usb_autopm_get_interface(serial->parent->interface); + if (result1 < 0) + goto err_out; +#endif + D1("Opening %d", serial->minor); + kref_get(&serial->parent->ref); + + /* setup */ + tty->driver_data = serial; + serial->tty = tty; + + /* check for port already opened, if not set the termios */ + serial->open_count++; + if (serial->open_count == 1) { + tty->low_latency = 1; + serial->rx_state = RX_IDLE; + /* Force default termio settings */ + _hso_serial_set_termios(tty, NULL); + tasklet_init(&serial->unthrottle_tasklet, + (void (*)(unsigned long))hso_unthrottle_tasklet, + (unsigned long)serial); +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 19)) + INIT_WORK(&serial->retry_unthrottle_workqueue, + hso_unthrottle_workfunc); +#else + INIT_WORK(&serial->retry_unthrottle_workqueue, + (void (*)(void *))hso_unthrottle_tasklet, + serial); +#endif + result2 = hso_start_serial_device(serial->parent, GFP_KERNEL); + if (result2) { + hso_stop_serial_device(serial->parent); + serial->open_count--; + } + } else { + D1("Port was already open"); + } + +#ifdef CONFIG_HSO_AUTOPM + usb_autopm_put_interface(serial->parent->interface); +#endif + /* done */ + if (result1) + hso_serial_tiocmset(tty, NULL, TIOCM_RTS | TIOCM_DTR, 0); +#ifdef CONFIG_HSO_AUTOPM +err_out: +#endif + if (result2) + refcnt = kref_put(&serial->parent->ref, hso_serial_ref_free); + mutex_unlock(hso_mutex); + if (refcnt == 0) + hso_free_mutex(container_of(hso_mutex, + struct hso_mutex_t, mutex)); + return result1 == 0 ? result2 : result1; +} + +/* 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; + struct MUTEX *hso_mutex; + int refcnt; + + D1("Closing serial port"); + hso_mutex = &serial->parent->mutex->mutex; + mutex_lock(hso_mutex); + usb_gone = serial->parent->usb_gone; +#ifdef CONFIG_HSO_AUTOPM + if (!usb_gone) + usb_autopm_get_interface(serial->parent->interface); +#endif + /* reset the rts and dtr */ + /* do the actual close */ + serial->open_count--; + if (serial->open_count <= 0) { + serial->open_count = 0; + if (serial->tty) { + serial->tty->driver_data = NULL; + serial->tty = NULL; + } + if (!usb_gone) + hso_stop_serial_device(serial->parent); + tasklet_kill(&serial->unthrottle_tasklet); +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 21)) + cancel_work_sync(&serial->retry_unthrottle_workqueue); +#else + flush_scheduled_work(); +#endif + } +#ifdef CONFIG_HSO_AUTOPM + if (!usb_gone) + usb_autopm_put_interface(serial->parent->interface); +#endif + refcnt = kref_put(&serial->parent->ref, hso_serial_ref_free); + mutex_unlock(hso_mutex); + if (refcnt == 0) + hso_free_mutex(container_of(hso_mutex, + struct hso_mutex_t, 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, tx_bytes; + unsigned long flags; + + /* sanity check */ + if (serial == NULL) { + printk(KERN_ERR "%s: serial is NULL\n", __func__); + return -ENODEV; + } + + spin_lock_irqsave(&serial->serial_lock, flags); + + space = serial->tx_data_length - serial->tx_buffer_count; + tx_bytes = (count < space) ? count : space; + + if (!tx_bytes) + goto out; + + memcpy(serial->tx_buffer + serial->tx_buffer_count, buf, tx_bytes); + serial->tx_buffer_count += tx_bytes; + +out: + spin_unlock_irqrestore(&serial->serial_lock, flags); + + hso_kick_transmit(serial); + /* done */ + return tx_bytes; +} + +/* how much room is there for writing */ +static int hso_serial_write_room(struct tty_struct *tty) +{ + struct hso_serial *serial = get_serial_by_tty(tty); + int room; + unsigned long flags; + + spin_lock_irqsave(&serial->serial_lock, flags); + room = serial->tx_data_length - serial->tx_buffer_count; + spin_unlock_irqrestore(&serial->serial_lock, flags); + + /* return free room */ + return room; +} + +/* setup the term */ +static void hso_serial_set_termios(struct tty_struct *tty, struct TERMIOS *old) +{ + struct hso_serial *serial = get_serial_by_tty(tty); + unsigned long flags; + + if (old) + D5("Termios called with: cflags new[%d] - old[%d]", + tty->termios->c_cflag, old->c_cflag); + + /* the actual setup */ + spin_lock_irqsave(&serial->serial_lock, flags); + if (serial->open_count) + _hso_serial_set_termios(tty, old); + else + tty->termios = old; + spin_unlock_irqrestore(&serial->serial_lock, flags); + + /* done */ + 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; + 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; + 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); +} + +/*============================================================================= + * function: hso_set_radio + * purpose: Toggles radioon or off ( used by ioctl ) + *============================================================================= + */ +#if (!HAVE_RFKILL) +static int hso_set_radio(struct hso_device *hso_dev, int enabled) +{ + if (!hso_dev) + return -ENODEV; + return usb_control_msg( hso_dev->usb, + usb_rcvctrlpipe(hso_dev->usb, 0), + enabled ? 0x82 : 0x81, + 0x40, 0, 0, NULL, 0, + USB_CTRL_SET_TIMEOUT); +} +#endif + +/*============================================================================= + * function: hso_serial_ioctl + * purpose: ioctl not supported + *============================================================================= + */ +#if (!HAVE_RFKILL) +static int hso_serial_ioctl(struct tty_struct *tty, struct file *file, + unsigned int cmd, unsigned long arg) +{ + struct hso_serial *serial = get_serial_by_tty(tty); + int ret = 0; + D4("IOCTL cmd: %d, arg: %ld", cmd, arg); + + if (!serial) + return -ENODEV; + switch (cmd) { + case SIOCSETRADIO: + if (arg) + hso_set_radio(serial->parent, 1); + else + hso_set_radio(serial->parent, 0); + ret = 0; + break; + default: + ret = -ENOIOCTLCMD; + break; + } + return ret; +} +#endif + +/* starts a transmit */ +static void hso_kick_transmit(struct hso_serial *serial) +{ + u8 *temp; + unsigned long flags; + int res; + + spin_lock_irqsave(&serial->serial_lock, flags); + if (!serial->tx_buffer_count) + goto out; + + if (serial->tx_urb_used) + goto out; +#ifdef CONFIG_HSO_AUTOPM + /* Wakeup USB interface if necessary */ + if (hso_get_activity(serial->parent) == -EAGAIN) + goto out; +#endif + /* Switch pointers around to avoid memcpy */ + temp = serial->tx_buffer; + serial->tx_buffer = serial->tx_data; + serial->tx_data = temp; + serial->tx_data_count = serial->tx_buffer_count; + serial->tx_buffer_count = 0; + + /* If temp is set, it means we switched buffers */ + if (temp && serial->write_data) { + res = serial->write_data(serial); + if (res >= 0) + serial->tx_urb_used = 1; + } +out: + spin_unlock_irqrestore(&serial->serial_lock, flags); +} + +/* make a request (for reading and writing data to muxed serial port) */ +static int mux_device_request(struct hso_serial *serial, u8 type, u16 port, + struct urb *ctrl_urb, + struct usb_ctrlrequest *ctrl_req, + u8 *ctrl_urb_data, u32 size) +{ + int result; + int pipe; + + /* Sanity check */ + if (!serial || !ctrl_urb || !ctrl_req) { + printk(KERN_ERR "%s: Wrong arguments\n", __func__); + return -EINVAL; + } + + /* initialize */ + ctrl_req->wValue = 0; + ctrl_req->wIndex = 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\n", __func__, + result, type); + return result; + } + + /* done */ + return size; +} + +/* called by intr_callback when read occurs */ +static int hso_mux_serial_read(struct hso_serial *serial) +{ + if (!serial) + return -EINVAL; + + /* clean data */ + memset(serial->rx_data[0], 0, CTRL_URB_RX_SIZE); + /* make the request */ + + if (serial->num_rx_urbs != 1) { + dev_err(&serial->parent->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(CALLBACK_ARGS) +{ + struct hso_shared_int *shared_int = urb->context; + struct hso_serial *serial; + unsigned char *port_req; + int status = urb->status; + int i; +#ifdef HSO_CONFIG_AUTOPM + usb_mark_last_busy(urb->dev); +#endif + /* 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); + spin_lock(&serial->serial_lock); + if (serial->rx_state == RX_IDLE) { + /* Setup and send a ctrl req read on + * port i */ + if (!serial->rx_urb_filled[0]) { + serial->rx_state = RX_SENT; + hso_mux_serial_read(serial); + } else + serial->rx_state = RX_PENDING; + } else { + D1("Already pending a read on " + "port %d\n", i); + } + spin_unlock(&serial->serial_lock); + } + } + } + /* 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(CALLBACK_ARGS) +{ + 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; + } +#ifdef CONFIG_HSO_AUTOPM + hso_put_activity(serial->parent); +#endif + if (serial->tty) + 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; + + 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(CALLBACK_ARGS) +{ + struct hso_serial *serial = urb->context; + struct usb_ctrlrequest *req; + 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)) { + serial->rx_urb_filled[0] = 1; + spin_lock(&serial->serial_lock); + put_rxbuf_data_and_resubmit_ctrl_urb(serial); + spin_unlock(&serial->serial_lock); + } else { +#ifdef CONFIG_HSO_AUTOPM + hso_put_activity(serial->parent); +#endif + if (serial->tty) + tty_wakeup(serial->tty); + /* response to a write command */ + hso_kick_transmit(serial); + } +} + +/* handle RX data for serial port */ +static int put_rxbuf_data(struct urb *urb, struct hso_serial *serial) +{ + struct tty_struct *tty = serial->tty; + int write_length_remaining = 0; +#if (HAVE_TTY_INSERT_FLIP_STRING) + int curr_write_len; +#else + int i; + unsigned char *data; +#endif + /* Sanity check */ + if (urb == NULL || serial == NULL) { + D1("serial = NULL"); + return -2; + } + + /* Push data to tty */ + if (tty) { + write_length_remaining = urb->actual_length - + serial->curr_rx_urb_offset; + D1("data to push to tty"); +#if (HAVE_TTY_INSERT_FLIP_STRING) + while (write_length_remaining) { + if (test_bit(TTY_THROTTLED, &tty->flags)) + return -1; + curr_write_len = tty_insert_flip_string + (tty, urb->transfer_buffer + + serial->curr_rx_urb_offset, + write_length_remaining); + serial->curr_rx_urb_offset += curr_write_len; + write_length_remaining -= curr_write_len; + tty_flip_buffer_push(tty); + } +#else + i = 0; + data = urb->transfer_buffer; + for (i = 0; i < write_length_remaining; ++i) { + if (test_bit(TTY_THROTTLED, &tty->flags)) + return -1; + if (tty->flip.count >= TTY_FLIPBUF_SIZE) + tty_flip_buffer_push(tty); + tty_insert_flip_char(tty, *(char *) + ((long)urb->transfer_buffer + + (long)serial->curr_rx_urb_offset), + 0); + serial->curr_rx_urb_offset++; + } + tty_flip_buffer_push(tty); +#endif + } + if (write_length_remaining == 0) { + serial->curr_rx_urb_offset = 0; + serial->rx_urb_filled[hso_urb_to_index(serial, urb)] = 0; + } + return write_length_remaining; +} + + + +/* Base driver functions */ + +static void hso_log_port(struct hso_device *hso_dev) +{ + char *port_type; + 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]); + serial->rx_urb_filled[i] = 0; + } + } + serial->curr_rx_urb_idx = 0; + serial->curr_rx_urb_offset = 0; + + if (serial->tx_urb) + usb_kill_urb(serial->tx_urb); + + 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 (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 19)) + if (serial->parent->dev) + device_remove_file(serial->parent->dev, &dev_attr_hsotype); +#endif + 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; + int minor; + int i; + + minor = get_free_serial_index(); + if (minor < 0) + goto exit; + + /* register our minor number */ +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 19)) + serial->parent->dev = tty_register_device(tty_drv, minor, + &serial->parent-> + interface->dev); + dev = serial->parent->dev; + if (dev) { + dev->driver_data = serial->parent; + if (device_create_file(dev, &dev_attr_hsotype)) + printk(KERN_WARNING"Could not create ttyHS? in sysfs"); + } +#else + tty_register_device(tty_drv, minor, &serial->parent->interface->dev); + dev = serial->parent->dev; +#endif + /* 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\n", __func__); + goto exit; + } + serial->tx_buffer = kzalloc(serial->tx_data_length, GFP_KERNEL); + if (!serial->tx_buffer) { + dev_err(dev, "%s - Out of memory\n", __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); + hso_dev->mutex = hso_get_free_mutex(); + if (!hso_dev->mutex) { + kfree(hso_dev); + return NULL; + } + mutex_init(&hso_dev->mutex->mutex); +#ifdef CONFIG_HSO_AUTOPM +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 19)) + INIT_WORK(&hso_dev->async_get_intf, async_get_intf); + INIT_WORK(&hso_dev->async_put_intf, async_put_intf); +#else + INIT_WORK(&hso_dev->async_get_intf, async_get_intf + , &hso_dev->async_get_intf); + INIT_WORK(&hso_dev->async_put_intf, async_put_intf + , &hso_dev->async_put_intf); +#endif +#endif + 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; + + /* 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_mutex(hso_dev->mutex); + 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); + + D1("sizeof hso_net is %d", (int)sizeof(*hso_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->do_ioctl = hso_net_ioctl; +#if (!NETDEVICE_HAS_STATS) + net->get_stats = hso_net_get_stats; +#endif + net->tx_timeout = hso_net_tx_timeout; + net->watchdog_timeo = HSO_NET_TX_TIMEOUT; + 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); + + /* and initialize the semaphore */ + spin_lock_init(&hso_net->net_lock); +} + +/* 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; +} + +#if HAVE_RFKILL +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->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->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\n", __func__); + return; + } + rfkn = kzalloc(20, GFP_KERNEL); + if (!rfkn) { + rfkill_free(hso_net->rfkill); + dev_err(dev, "%s - Out of memory\n", __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\n", __func__); + return; + } +} +#endif + +/* Creates our network device */ +static struct hso_device *hso_create_net_device(struct usb_interface *interface) +{ + int result, i; + 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) + 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; + } +#if NETDEV_HAVE_DEV + SET_NETDEV_DEV(net, &interface->dev); +#endif + /* 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; + } + + add_net_device(hso_dev); + + hso_log_port(hso_dev); +#if HAVE_RFKILL + hso_create_rfkill(hso_dev, interface); +#endif + 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); + + if (!serial) + return; + set_serial_by_index(serial->minor, NULL); + + 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); + else + 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; + struct hso_serial *serial; + 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 exit2; + } + + 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 exit2; + } + + 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 */ + hso_log_port(hso_dev); + + /* done, return it */ + return hso_dev; +exit2: + hso_serial_common_free(serial); +exit: + 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; + struct hso_serial *serial; + int port_spec; + + 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 */ + 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); + mutex_unlock(&mux->shared_int_lock); + 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?\n"); + 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?\n"); + 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; + + 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; +} + +/* 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; + struct hso_device *hso_dev = NULL; + struct hso_shared_int *shared_int; + 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); +#ifdef CONFIG_HSO_AUTOPM + interface->needs_remote_wakeup = 1; +#endif + /* 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; + } + + /* 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) +{ + hso_free_interface(interface); + + /* remove reference of our private data */ + usb_set_intfdata(interface, NULL); +} + +#ifdef CONFIG_HSO_AUTOPM +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; + + /* 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]); + if (hso_net->flags & IFF_UP) { + /* 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); + hso_net->skb_tx_buf = NULL; + } + result = hso_start_net_device(network_table[i]); + if (result) + goto out; + } + } + } + +out: + return result; +} +#endif /* CONFIG_HSO_AUTOPM */ +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; + struct MUTEX *hso_mutex = NULL; + int refcnt = 1; + + 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); + hso_mutex = &hso_dev->parent->mutex->mutex; + mutex_lock(hso_mutex); + hso_dev->parent->usb_gone = 1; + refcnt = kref_put(&serial_table[i]->ref, + hso_serial_ref_free); + mutex_unlock(hso_mutex); + } + } + + for (i = 0; i < HSO_MAX_NET_DEVICES; i++) { + if (network_table[i] + && (network_table[i]->interface == interface)) { +#if HAVE_RFKILL + struct rfkill *rfk = dev2net(network_table[i])->rfkill; +#endif + /* 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]); +#ifdef CONFIG_HSO_AUTOPM +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 21)) + cancel_work_sync(&network_table[i]->async_put_intf); + cancel_work_sync(&network_table[i]->async_get_intf); +#else + flush_scheduled_work(); +#endif +#endif +#if HAVE_RFKILL + if(rfk) + rfkill_unregister(rfk); +#endif + hso_free_net_device(network_table[i]); + } + } + if (refcnt == 0) + hso_free_mutex(container_of(hso_mutex, + struct hso_mutex_t, mutex)); +} + +/* 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; + + 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\n", __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, +#if (!HAVE_RFKILL) + .ioctl = hso_serial_ioctl, +#endif + .set_termios = hso_serial_set_termios, + .chars_in_buffer = hso_serial_chars_in_buffer, + .tiocmget = hso_serial_tiocmget, + .tiocmset = hso_serial_tiocmset, + .unthrottle = hso_unthrottle +}; + +static struct usb_driver hso_driver = { + .name = driver_name, + .probe = hso_probe, + .disconnect = hso_disconnect, + .id_table = hso_ids, +#ifdef CONFIG_HSO_AUTOPM + .suspend = hso_suspend, + .resume = hso_resume, +#if HAVE_RESET_RESUME + .reset_resume = hso_resume, +#endif + .supports_autosuspend = 1, +#endif +}; + +static int __init hso_init(void) +{ + int i; + int result; + + /* put it in the log */ + printk(KERN_INFO "hso: %s\n", version); + + /* Initialise the serial table semaphore and table */ + spin_lock_init(&serial_table_lock); + spin_lock_init(&hso_mutex_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; +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18)) + tty_drv->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS; +#else + tty_drv->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; +#endif + 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); +} + +/* 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); + +/* 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); +MODULE_INFO(Flags, sCONFIG_HSO_AUTOPM sCONFIG_HSO_DEBUG); diff -urN b/drivers/net/wan/hso/hso_connect.sh a/drivers/net/wan/hso/hso_connect.sh --- b/drivers/net/wan/hso/hso_connect.sh 1970-01-01 03:00:00.000000000 +0300 +++ a/drivers/net/wan/hso/hso_connect.sh 2008-09-19 13:43:10.000000000 +0400 @@ -0,0 +1,243 @@ +#!/bin/sh + +################################################################################################# +# Script: hso_connect.sh +# Purpose:Bring the interface up and down, send the needed AT commands to connect +################################################################################################# + +# checking for root +USERID=`id -u` +if [ "$USERID" != "0" ] +then + echo "Need root permissions to run this script" + exit +fi + +# always start with checking if a connection data file has been supplied +CONNECTIONFILE="conninfo.ini" +if [ -z "$2" ] +then + if [ ! -f $CONNECTIONFILE ] + then + echo "# this file contains the connection information for your subscription" >> $CONNECTIONFILE + echo "APN=internet.proximus.be" >> $CONNECTIONFILE + echo "# USER=" >> $CONNECTIONFILE + echo "# PASS=" >> $CONNECTIONFILE + echo "# PIN=" >> $CONNECTIONFILE + fi +else + if [ -f $2 ] + then + CONNECTIONFILE=$2 + else + echo "Supplied file $2 does not exist" + exit 1 + fi +fi +TTYS=`find /sys/class/tty -name "ttyHS*"` +APP_PORT="" +for i in $TTYS; do + if [ `grep Application $i/hsotype` ] + then + APP_PORT=$i + break + fi +done +DEVICE=/dev/`echo $APP_PORT | cut -d/ -f5` +echo Using $DEVICE application port. +NETDEV=hso0 +TMPFIL=/tmp/connect.$$ +OUTPUTFILE=/tmp/output.$$ +SCRIPTFILE=/tmp/scriptfile.$$ + +################################################################################################# +# METHOD: Connect +# PURPOSE:Connect to the specified APN with the specified user and pass and get the ip +# set the IP to the interface +################################################################################################# +Connect() +{ + echo "Initializing..." + + #============================================================ + # get the APN, USER, PASS and PIN out of the connection file + #============================================================ + APN=`grep '^APN=' $CONNECTIONFILE | cut -d= -f2` + USER=`grep '^USER=' $CONNECTIONFILE | cut -d= -f2` + PASS=`grep '^PASS=' $CONNECTIONFILE | cut -d= -f2` + PIN=`grep '^PIN=' $CONNECTIONFILE | cut -d= -f2` + if [ -z "$APN" ] + then + echo "Please provide an APN (eg web.pro.be)" + exit + fi + + #============================================================ + # send the PIN, APN, USER and PASS + #============================================================ + rm -f $SCRIPTFILE + echo "ABORT ERROR" > $SCRIPTFILE + echo "TIMEOUT 10" >> $SCRIPTFILE + echo "\"\" ATZ" >> $SCRIPTFILE + if [ -n "$PIN" ] + then + echo "OK \"AT+CPIN=\\\"$PIN\\\"^m\"" >> $SCRIPTFILE + fi + echo "OK \"AT+COPS=0^m\"" >> $SCRIPTFILE + echo "OK \"\d\d\d\d\d\d\dAT+COPS=?^m\"" >> $SCRIPTFILE + echo "OK \"AT+CGDCONT=1,,\\\"$APN\\\"^m\"" >> $SCRIPTFILE + if [ -n "$USER" -a -n "$PASS" ] + then + echo "OK \"AT\$QCPDPP=1,1,\\\"$PASS\\\",\\\"$USER\\\"^m\"" >> $SCRIPTFILE + fi + echo "OK \"\"" >> $SCRIPTFILE + + #============================================================ + # run the script + #============================================================ + echo "Trying $APN ..." + rm -f $OUTPUTFILE + ( /usr/sbin/chat -E -s -V -f $SCRIPTFILE <$DEVICE >$DEVICE ) 2> $OUTPUTFILE + ISERROR="`grep '^ERROR' $OUTPUTFILE`" + if [ -n "$ISERROR" ] + then + echo "Failed to initialize connection" + cat $OUTPUTFILE + echo " " + rm -f $OUTPUTFILE + exit + fi + ISERROR="`grep '^+CME' $OUTPUTFILE`" + if [ -n "$ISERROR" ] + then + echo "Failed to initialize connection" + cat $OUTPUTFILE + echo " " + rm -f $OUTPUTFILE + exit + fi + rm -f $SCRIPTFILE + sleep 2 + + #============================================================ + # now actually connect + #============================================================ + echo "Connecting..." + stty 19200 -tostop + + # make the call script + echo "ABORT ERROR" > $SCRIPTFILE + echo "TIMEOUT 10" >> $SCRIPTFILE + echo "\"\" ATZ" >> $SCRIPTFILE + echo "OK \"AT_OWANCALL=1,1,0^m\"" >> $SCRIPTFILE + echo "OK \"\d\d\d\d\dAT_OWANDATA=1^m\"" >> $SCRIPTFILE + echo "OK \"\"" >> $SCRIPTFILE + + PIP="" + COUNTER="" + while [ -z "$PIP" -a "$COUNTER" != "-----" ] + do + echo "trying$COUNTER" + sleep 2 + rm -f $OUTPUTFILE + ( /usr/sbin/chat -E -s -V -f $SCRIPTFILE <$DEVICE > $DEVICE ) 2> $OUTPUTFILE + ISERROR=`grep '^ERROR' $OUTPUTFILE` + if [ -z "$ISERROR" ] + then + PIP="`grep '^_OWANDATA' $OUTPUTFILE | cut -d, -f2`" + NS1="`grep '^_OWANDATA' $OUTPUTFILE | cut -d, -f4`" + NS2="`grep '^_OWANDATA' $OUTPUTFILE | cut -d, -f5`" + fi + + COUNTER="${COUNTER}-" + done + + echo Connected + + #============================================================ + # always check the IP address + #============================================================ + if [ -z "$PIP" ] + then + echo "We did not get an IP address from the provider, bailing ..." + cat $OUTPUTFILE + rm -f $OUTPUTFILE + exit + fi + rm -f $OUTPUTFILE + + #============================================================ + # setting network settings + #============================================================ + echo "Setting IP address to $PIP" + ifconfig $NETDEV $PIP netmask 255.255.255.255 up + echo "Adding route" + route add default dev $NETDEV + mv -f /etc/resolv.conf /tmp/resolv.conf.hso + echo "Setting nameserver" + echo "nameserver $NS1" > $OUTPUTFILE + echo "nameserver $NS2" >> $OUTPUTFILE + mv $OUTPUTFILE /etc/resolv.conf + + echo "Done." +} + +################################################################################################# +# METHOD: Disconnect +# PURPOSE:disconnect from the providers network +################################################################################################# +Disconnect() +{ + echo "Bringing interface down..." + ifconfig $NETDEV down + + echo "Disconnecting..." + + # make the disconnect script + rm -f $SCRIPTFILE + echo "TIMEOUT 10" >> $SCRIPTFILE + echo "ABORT ERROR" >> $SCRIPTFILE + echo "\"\" ATZ" >> $SCRIPTFILE + echo "OK \"AT_OWANCALL=1,0,0^m\"" >> $SCRIPTFILE + echo "OK \"\"" >> $SCRIPTFILE + + #============================================================ + # run the script + #============================================================ + /usr/sbin/chat -V -f $SCRIPTFILE <$DEVICE >$DEVICE 2> /dev/null + if [ -f /tmp/resolv.conf.hso ] + then + echo "Reset nameserver..." + mv -f /tmp/resolv.conf.hso /etc/resolv.conf + fi + echo "Done." +} + +################################################################################################# +# METHOD: usage +# PURPOSE: +################################################################################################# +usage() +{ + echo Usage: $0 \(up\|down\|restart\) +} + +################################################################################################# +# Choose your action +################################################################################################# +case "$1" in + up) + Connect + ;; + down) + Disconnect + ;; + restart) + Disconnect + Connect + ;; + *) + usage + ;; +esac + diff -urN b/drivers/net/wan/hso/init.cht a/drivers/net/wan/hso/init.cht --- b/drivers/net/wan/hso/init.cht 1970-01-01 03:00:00.000000000 +0300 +++ a/drivers/net/wan/hso/init.cht 2008-09-19 13:43:10.000000000 +0400 @@ -0,0 +1,9 @@ +ABORT ERROR +TIMEOUT 10 +"" ATZ +OK "AT+CPIN=\"$PIN\"^m" +OK "AT+COPS=0^m" +OK "\d\d\d\d\d\d\dAT+COPS=?^m" +OK "AT+CGDCONT=1,,\"$APN\"^m" +OK "AT\$QCPDPP=1,1,\"$PAS\",\"$USR\"^m" +OK "" diff -urN b/drivers/net/wan/hso/Makefile a/drivers/net/wan/hso/Makefile --- b/drivers/net/wan/hso/Makefile 1970-01-01 03:00:00.000000000 +0300 +++ a/drivers/net/wan/hso/Makefile 2008-09-19 13:43:10.000000000 +0400 @@ -0,0 +1,137 @@ +# +# Makefile for the Linux WWAN device drivers. +# +# NOTE: This make file can serve as both an external Makefile (launched +# directly by the user), or as the sub-dir Makefile used by the kernel +# build system. + +# If CONFIG_HSO isn't set, we'll assume the user has never configured +# their kernel to include this module and set up some defaults. +# +# NOTE: If you have previously added the HSO project to your kernel +# and configured it for inclusion, these settings will be +# overridden by your kernel configuration. +ifndef CONFIG_HSO +EXTERNAL_BUILD=y +CONFIG_HSO=m +CONFIG_HSO_DEBUG=n +ifeq ($(CONFIG_USB_SUSPEND),y) +CONFIG_HSO_AUTOPM=y +endif +endif + + +ifeq ($(CONFIG_HSO_DEBUG),y) + EXTRA_CFLAGS += -g -Wa,-adhlms=$@.lst +endif + +ifdef KBUILD_EXTMOD + EXTRA_CFLAGS += -I$(KBUILD_EXTMOD) +endif + + +list-m := +list-$(CONFIG_HSO) += hso +obj-$(CONFIG_HSO) += hso.o + +# +# Begin dual Makefile mode here. First we provide support for when we +# are being invoked by the kernel build system +# +ifneq ($(KERNELRELEASE),) + +EXTRA_CFLAGS += -DCONFIG_PM + +ifeq ($(EXTERNAL_BUILD),y) +ifeq ($(CONFIG_HSO_DEBUG),y) +EXTRA_CFLAGS += -DCONFIG_HSO_DEBUG +endif +ifeq ($(CONFIG_HSO_AUTOPM),y) +EXTRA_CFLAGS += -DCONFIG_HSO_AUTOPM +endif +endif + +else +# Here we begin the portion that is executed if the user invoked this Makefile +# directly. + +# KSRC should be set to the path to your sources +KVER := $(shell uname -r) +KSRC := /lib/modules/$(KVER)/build +INSTALLDIR:=/lib/modules/$(KVER)/kernel/drivers/net/wwan/ + +# KSRC_OUTPUT should be overridden if you are using a 2.6 kernel that +# has it's output sent elsewhere via KBUILD_OUTPUT= or O= +KSRC_OUTPUT := $(KSRC) + +PWD=$(shell pwd) + +VERFILE := $(KSRC_OUTPUT)/include/linux/version.h +KERNELRELEASE := $(shell \ + if [ -r $(VERFILE) ]; then \ + (cat $(VERFILE); echo UTS_RELEASE) | \ + $(CC) -I$(KSRC_OUTPUT) $(CFLAGS) -E - | \ + tail -n 1 | \ + xargs echo; \ + else \ + uname -r; \ + fi) + +MODPATH := $(DESTDIR)/lib/modules/$(KERNELRELEASE) + +all: modules + +clean: + $(RM) -f *.mod.* *.mod *.o *.ko .*.o.cmd .*.ko.cmd *.flags .lst + $(RM) -f *.lst Module*.symvers modules.order *~ + $(RM) -rf $(PWD)/tmp conninfo.ini + $(RM) -rf .tmp_versions + +distclean: clean + rm -f tags TAGS + +TMP=$(PWD)/tmp +MODVERDIR=$(TMP)/.tmp_versions + +modules: + mkdir -p $(MODVERDIR) +ifdef ($(KSRC_OUTPUT)/.tmp_versions) + -cp $(KSRC_OUTPUT)/.tmp_versions/*.mod $(MODVERDIR) +endif +ifeq ($(KSRC),$(KSRC_OUTPUT)) # We're not outputting elsewhere +ifdef ($(KSRC)/.tmp_versions) + -cp $(KSRC)/.tmp_versions/*.mod $(MODVERDIR) +endif + $(MAKE) -C $(KSRC) M=$(PWD) MODVERDIR=$(MODVERDIR) modules +else # We've got a kernel with seperate output, copy the config, and use O= + mkdir -p $(TMP) + cp $(KSRC_OUTPUT)/.config $(TMP) + $(MAKE) -C $(KSRC) M=$(PWD) MODVERDIR=$(MODVERDIR)) O=$(PWD)/tmp modules +endif + +install: modules + modprobe -r hso || true + install -d $(INSTALLDIR) + install -m 644 -c $(addsuffix .ko,$(list-m)) $(INSTALLDIR) + /sbin/depmod -a ${KVER} + +uninstall: + rm -rf $(addprefix $(INSTALLDIR),$(addsuffix .ko,$(list-m))) + /sbin/depmod -a ${KVER} + +endif # End of internal build + +.PHONY: TAGS tags + +RCS_FIND_IGNORE := \( -name SCCS -o -name BitKeeper -o -name .svn -o -name CVS \) -prune -o +define all-sources + ( find . $(RCS_FIND_IGNORE) -name '*.[chS]' -print ) +endef + +TAGS: + $(all-sources) | etags - +tags: + $(RM) -f $@ + CTAGSF=`ctags --version | grep -i exuberant >/dev/null && echo "-I __initdata,__exitdata,EXPORT_SYMBOL,EXPORT_SYMBOL_NOVERS"`; \ + $(all-sources) | xargs ctags $$CTAGSF -a + diff -urN b/drivers/net/wan/hso/README a/drivers/net/wan/hso/README --- b/drivers/net/wan/hso/README 1970-01-01 03:00:00.000000000 +0300 +++ a/drivers/net/wan/hso/README 2008-09-19 13:43:10.000000000 +0400 @@ -0,0 +1,104 @@ +Readme for HSO driver v1.5 and older +==================================== + +Contents: +--------- +1) Using the driver for a ppp connection +2) Using the driver as a network interface +3) Dynamic suspend/resume implementation + + +1) Using the driver for a ppp connection +======================================== + +The biggest problem in setting up a PPP connection is knowing on which port to set up pppd. +When the driver is loaded and the device inserted, there are 2 ways to know the correct port: + +Points 1 & 2 are obselete since v1.3 of the driver they are left in just for completeness. +1. Check syslog for an entry which says 'Found Modem port '. Then use to set up your ppp session. +2. Check /proc/hso/devices. In that directory there is an entry for each port. When you do a 'cat' on each entry it will +show you the type of port. + In case of a modem port it will say 'Modem' on the first line. +3. The hso_connect.sh script distributed with this package shows how to find the application port +used to send AT commands to start the network port in versions 1.3 of the driver & afterwords, +the snippet of the bash script that does this is... +TTYS=`find /sys/class/tty -name "ttyHS*"` +APP_PORT="" +for i in $TTYS; do + if [ `grep Application $i/hsotype` ] + then + APP_PORT=$i + break + fi +done +DEVICE=/dev/`echo $APP_PORT | cut -d/ -f5` +echo Using $DEVICE application port. + + + +2) Using the driver as a network interface +========================================== + +You can use the hso_connect.sh script provided to set up a call on the network interface. +However they're far from failsafe and should only serve as a guide towards +the connection setup. +I'll briefly details the steps required to manually activate such a network interface connection: + +The points presented below on how to start the network interface is pretty obselete use +this as a rough guide & read the hso_connect.sh use the script as a more accurate guide... +1) Open an AT port, preferrably the Control port. /dev/ttyHS0 serves as a pretty wild guess as a Control port. +If not sure, use the advice in previous section but replace 'Modem' with 'Control'. +2) Make sure your PIN code and APN are set correctly ( AT+CPIN=xxxx for PIN code and AT+CGDCONT=1,,"" ). +3) Make sure the card is registered on the network. Entering AT+COPS? should display the network you're currently registered on. +4) Now you need to activate your connection. So issue AT_OWANCALL=1,1,1. This will return OK immediately. +However this doesn't mean your data call is already active. It means the call succeeded and the call is -being- set up. +When the call is ready, you'll get an unsolicited response in the form of '_OWANCALL: 1,X', where X can 0,1,2,3. +0 = Disconnected, 1 = Connected, 2 = In setup, 3 = Call setup failed. If everything goes right, you should see '_OWANCALL: 1,1'. +Note on the unsolicited response: the unsolicited response is enabled by the last parameter of AT_OWANCALL. If you set that +parameter to 0 ( AT_OWANCALL=1,1,0 ), you will never see the unsolicited response, so you will need to query the call status +with AT_OWANCALL? + +5) If that went well and your data call is active, you can issue AT_OWANDATA?. This will return the IP settings you can use to +configure the hso0 interface. +The settings which will be returned are : _OWANDATA: 1, , , , , , , + +To disconnect the call simply issue AT_OWANCALL=1,0,1 on an AT port. + +NOTE: In most commands entered above, the first parameter is your context-id ( '1' here ) . In theory you can define multiple +context id's, but in practice they're of little use. Just make sure you use the same id across the AT commands or your context +might not be defined properly. + + +3) Dynamic suspend/resume implementation +======================================== + +This driver has dynamic suspend/resume implemented using the autopm interface provided from kernel 2.6.22. When CONFIG_USB_SUSPEND +was enabled in your kernel and the device supports remote wakeup, you can use this functionality. +By default it is disabled due to its experimental status, you can enable it by setting the module parameter 'enable_autopm' to 1. +You can do this when you insmod the module (eg insmod hso.ko enable_autopm=1) or you can change the default in modules.conf. +The autosuspend is implemented in the USB core, and is not enabled by default since no devices support it in the time this is written. You can enable this by changing the appropriate values in the files within the /sys/bus/usb/devices/.../power/ directory +(where the "..." is the device id). +The relevant files in that directory are: +- wakeup: this should contain the word "enabled" if the device supports remote wakeup, if it doesn't the autosuspend will be disabled. +- level: there are 3 modes: + - "on": the device is always on, autosuspend is disabled + - "suspend": the device is suspended, but can be woken up by remote wakeup + - "auto": autosuspend is enabled + You can set this mode by echo-ing the word to that file, + eg to enable autosuspend do: 'echo "auto" > /sys/bus/usb/devices/.../power/level' (where "..." is the device id) +- autosuspend: the number of seconds before autosuspend is triggered after the last time the device was busy. If set to -1, autosuspend is disabled. + If you enable autosuspend, it is strongly recommended to not put a value lower than 5 in this file. + You can set this delay by echo-ing the word to that file, + eg to set autosuspend to kick in after 10 seconds do: 'echo "10" > /sys/bus/usb/devices/.../power/autosuspend' (where "..." is the device id) + +Before version 1.3 of the driver autosuspend used be done as follows... +When trying to script it so that the autosuspend is enabled, you will need the usb device id, this however can change values, that is why an entry is created in the /proc filesystem where you can easily fetch that id. Assuming you only have 1 data card, there will be a ttyHS0 device, and the proc file will be: /proc/hso/devices/ttyHS0, and in that file a value "USB bus id:" will tell you which device. +eg: if you want to add autosuspend after 5 seconds in your script, do something like this ( as root ) : + echo 5 > /sys/bus/usb/devices/`grep USB /proc/hso/devices/ttyHS0 | awk '{print $4}'`/power/autosuspend +Since version 1.5 +The setpwr.sh script now roughly finds the place where to set switch on or off autosuspend by +finding a idVendor code of 0af0 which is Option, i.e. it only works for an Option modem & only if only +one Option modem is connected. +setpwr.sh auto swiches on autosuspend, setpwr.sh on switches off autosuspend. +The autosuspend variable in the same directory as setpwr.sh uses sets the time in seconds before autosuspend +becomes activated. \ В конце файла нет новой строки diff -urN b/drivers/net/wan/hso/setpwr.sh a/drivers/net/wan/hso/setpwr.sh --- b/drivers/net/wan/hso/setpwr.sh 1970-01-01 03:00:00.000000000 +0300 +++ a/drivers/net/wan/hso/setpwr.sh 2008-09-19 13:43:10.000000000 +0400 @@ -0,0 +1,12 @@ +#!/bin/bash +# This script can be used to quickly switch on usb suspend +# power saving mode on the Option modem in sysfs +# +# checking for root +USERID=`id -u` +if [ "$USERID" != "0" ] +then + echo "Need root permissions to run this script" + exit +fi +echo $1 >`find /sys -name idVendor | xargs -n 1 grep -H af0 | sed "s/idVendor:0af0/power\/level/"` \ В конце файла нет новой строки diff -urN b/drivers/net/wan/hso/stop.cht a/drivers/net/wan/hso/stop.cht --- b/drivers/net/wan/hso/stop.cht 1970-01-01 03:00:00.000000000 +0300 +++ a/drivers/net/wan/hso/stop.cht 2008-09-19 13:43:10.000000000 +0400 @@ -0,0 +1,7 @@ +TIMEOUT 10 +"" ATZ +OK "AT_OWANCALL=1,0,0^m" +TIMEOUT 1 +ERROR "" +OK "" + diff -urN b/drivers/net/wan/Kconfig a/drivers/net/wan/Kconfig --- b/drivers/net/wan/Kconfig 2008-11-10 21:50:34.000000000 +0300 +++ a/drivers/net/wan/Kconfig 2008-12-17 19:10:49.000000000 +0300 @@ -22,6 +22,13 @@ if WAN +# +config HSO + tristate "HSO driver for Option modems" + depends on USB && m && INET + help + Driver for Option 3G modems + # There is no way to detect a comtrol sv11 - force it modular for now. config HOSTESS_SV11 tristate "Comtrol Hostess SV-11 support" diff -urN b/drivers/net/wan/Makefile a/drivers/net/wan/Makefile --- b/drivers/net/wan/Makefile 2008-11-10 21:50:34.000000000 +0300 +++ a/drivers/net/wan/Makefile 2008-12-17 19:06:52.000000000 +0300 @@ -9,6 +9,7 @@ cyclomx-$(CONFIG_CYCLOMX_X25) += cycx_x25.o cyclomx-objs := $(cyclomx-y) +obj-$(CONFIG_HSO) += /hso obj-$(CONFIG_HDLC) += hdlc.o obj-$(CONFIG_HDLC_RAW) += hdlc_raw.o obj-$(CONFIG_HDLC_RAW_ETH) += hdlc_raw_eth.o