net/usb/hso.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /******************************************************************************
0003  *
0004  * Driver for Option High Speed Mobile Devices.
0005  *
0006  *  Copyright (C) 2008 Option International
0007  *                     Filip Aben <f.aben@option.com>
0008  *                     Denis Joseph Barrow <d.barow@option.com>
0009  *                     Jan Dumon <j.dumon@option.com>
0010  *  Copyright (C) 2007 Andrew Bird (Sphere Systems Ltd)
0011  *              <ajb@spheresystems.co.uk>
0012  *  Copyright (C) 2008 Greg Kroah-Hartman <gregkh@suse.de>
0013  *  Copyright (C) 2008 Novell, Inc.
0014  *
0015  *****************************************************************************/
0016
0017 /******************************************************************************
0018  *
0019  * Description of the device:
0020  *
0021  * Interface 0: Contains the IP network interface on the bulk end points.
0022  *      The multiplexed serial ports are using the interrupt and
0023  *      control endpoints.
0024  *      Interrupt contains a bitmap telling which multiplexed
0025  *      serialport needs servicing.
0026  *
0027  * Interface 1: Diagnostics port, uses bulk only, do not submit urbs until the
0028  *      port is opened, as this have a huge impact on the network port
0029  *      throughput.
0030  *
0031  * Interface 2: Standard modem interface - circuit switched interface, this
0032  *      can be used to make a standard ppp connection however it
0033  *              should not be used in conjunction with the IP network interface
0034  *              enabled for USB performance reasons i.e. if using this set
0035  *              ideally disable_net=1.
0036  *
0037  *****************************************************************************/
0038
0039 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0040
0041 #include <linux/sched/signal.h>
0042 #include <linux/slab.h>
0043 #include <linux/init.h>
0044 #include <linux/delay.h>
0045 #include <linux/netdevice.h>
0046 #include <linux/module.h>
0047 #include <linux/ethtool.h>
0048 #include <linux/usb.h>
0049 #include <linux/tty.h>
0050 #include <linux/tty_driver.h>
0051 #include <linux/tty_flip.h>
0052 #include <linux/kmod.h>
0053 #include <linux/rfkill.h>
0054 #include <linux/ip.h>
0055 #include <linux/uaccess.h>
0056 #include <linux/usb/cdc.h>
0057 #include <net/arp.h>
0058 #include <asm/byteorder.h>
0059 #include <linux/serial_core.h>
0060 #include <linux/serial.h>
0061
0062
0063 #define MOD_AUTHOR          "Option Wireless"
0064 #define MOD_DESCRIPTION         "USB High Speed Option driver"
0065
0066 #define HSO_MAX_NET_DEVICES     10
0067 #define HSO__MAX_MTU            2048
0068 #define DEFAULT_MTU         1500
0069 #define DEFAULT_MRU         1500
0070
0071 #define CTRL_URB_RX_SIZE        1024
0072 #define CTRL_URB_TX_SIZE        64
0073
0074 #define BULK_URB_RX_SIZE        4096
0075 #define BULK_URB_TX_SIZE        8192
0076
0077 #define MUX_BULK_RX_BUF_SIZE        HSO__MAX_MTU
0078 #define MUX_BULK_TX_BUF_SIZE        HSO__MAX_MTU
0079 #define MUX_BULK_RX_BUF_COUNT       4
0080 #define USB_TYPE_OPTION_VENDOR      0x20
0081
0082 /* These definitions are used with the struct hso_net flags element */
0083 /* - use *_bit operations on it. (bit indices not values.) */
0084 #define HSO_NET_RUNNING         0
0085
0086 #define HSO_NET_TX_TIMEOUT      (HZ*10)
0087
0088 #define HSO_SERIAL_MAGIC        0x48534f31
0089
0090 /* Number of ttys to handle */
0091 #define HSO_SERIAL_TTY_MINORS       256
0092
0093 #define MAX_RX_URBS         2
0094
0095 /*****************************************************************************/
0096 /* Debugging functions                                                       */
0097 /*****************************************************************************/
0098 #define hso_dbg(lvl, fmt, ...)                      \
0099 do {                                    \
0100     if ((lvl) & debug)                      \
0101         pr_info("[%d:%s] " fmt,                 \
0102             __LINE__, __func__, ##__VA_ARGS__);     \
0103 } while (0)
0104
0105 /*****************************************************************************/
0106 /* Enumerators                                                               */
0107 /*****************************************************************************/
0108 enum pkt_parse_state {
0109     WAIT_IP,
0110     WAIT_DATA,
0111     WAIT_SYNC
0112 };
0113
0114 /*****************************************************************************/
0115 /* Structs                                                                   */
0116 /*****************************************************************************/
0117
0118 struct hso_shared_int {
0119     struct usb_endpoint_descriptor *intr_endp;
0120     void *shared_intr_buf;
0121     struct urb *shared_intr_urb;
0122     struct usb_device *usb;
0123     int use_count;
0124     int ref_count;
0125     struct mutex shared_int_lock;
0126 };
0127
0128 struct hso_net {
0129     struct hso_device *parent;
0130     struct net_device *net;
0131     struct rfkill *rfkill;
0132     char name[24];
0133
0134     struct usb_endpoint_descriptor *in_endp;
0135     struct usb_endpoint_descriptor *out_endp;
0136
0137     struct urb *mux_bulk_rx_urb_pool[MUX_BULK_RX_BUF_COUNT];
0138     struct urb *mux_bulk_tx_urb;
0139     void *mux_bulk_rx_buf_pool[MUX_BULK_RX_BUF_COUNT];
0140     void *mux_bulk_tx_buf;
0141
0142     struct sk_buff *skb_rx_buf;
0143     struct sk_buff *skb_tx_buf;
0144
0145     enum pkt_parse_state rx_parse_state;
0146     spinlock_t net_lock;
0147
0148     unsigned short rx_buf_size;
0149     unsigned short rx_buf_missing;
0150     struct iphdr rx_ip_hdr;
0151
0152     unsigned long flags;
0153 };
0154
0155 enum rx_ctrl_state{
0156     RX_IDLE,
0157     RX_SENT,
0158     RX_PENDING
0159 };
0160
0161 #define BM_REQUEST_TYPE (0xa1)
0162 #define B_NOTIFICATION  (0x20)
0163 #define W_VALUE         (0x0)
0164 #define W_LENGTH        (0x2)
0165
0166 #define B_OVERRUN       (0x1<<6)
0167 #define B_PARITY        (0x1<<5)
0168 #define B_FRAMING       (0x1<<4)
0169 #define B_RING_SIGNAL   (0x1<<3)
0170 #define B_BREAK         (0x1<<2)
0171 #define B_TX_CARRIER    (0x1<<1)
0172 #define B_RX_CARRIER    (0x1<<0)
0173
0174 struct hso_serial_state_notification {
0175     u8 bmRequestType;
0176     u8 bNotification;
0177     u16 wValue;
0178     u16 wIndex;
0179     u16 wLength;
0180     u16 UART_state_bitmap;
0181 } __packed;
0182
0183 struct hso_tiocmget {
0184     struct mutex mutex;
0185     wait_queue_head_t waitq;
0186     int    intr_completed;
0187     struct usb_endpoint_descriptor *endp;
0188     struct urb *urb;
0189     struct hso_serial_state_notification *serial_state_notification;
0190     u16    prev_UART_state_bitmap;
0191     struct uart_icount icount;
0192 };
0193
0194
0195 struct hso_serial {
0196     struct hso_device *parent;
0197     int magic;
0198     u8 minor;
0199
0200     struct hso_shared_int *shared_int;
0201
0202     /* rx/tx urb could be either a bulk urb or a control urb depending
0203        on which serial port it is used on. */
0204     struct urb *rx_urb[MAX_RX_URBS];
0205     u8 num_rx_urbs;
0206     u8 *rx_data[MAX_RX_URBS];
0207     u16 rx_data_length; /* should contain allocated length */
0208
0209     struct urb *tx_urb;
0210     u8 *tx_data;
0211     u8 *tx_buffer;
0212     u16 tx_data_length; /* should contain allocated length */
0213     u16 tx_data_count;
0214     u16 tx_buffer_count;
0215     struct usb_ctrlrequest ctrl_req_tx;
0216     struct usb_ctrlrequest ctrl_req_rx;
0217
0218     struct usb_endpoint_descriptor *in_endp;
0219     struct usb_endpoint_descriptor *out_endp;
0220
0221     enum rx_ctrl_state rx_state;
0222     u8 rts_state;
0223     u8 dtr_state;
0224     unsigned tx_urb_used:1;
0225
0226     struct tty_port port;
0227     /* from usb_serial_port */
0228     spinlock_t serial_lock;
0229
0230     int (*write_data) (struct hso_serial *serial);
0231     struct hso_tiocmget  *tiocmget;
0232     /* Hacks required to get flow control
0233      * working on the serial receive buffers
0234      * so as not to drop characters on the floor.
0235      */
0236     int  curr_rx_urb_idx;
0237     u8   rx_urb_filled[MAX_RX_URBS];
0238     struct tasklet_struct unthrottle_tasklet;
0239 };
0240
0241 struct hso_device {
0242     union {
0243         struct hso_serial *dev_serial;
0244         struct hso_net *dev_net;
0245     } port_data;
0246
0247     u32 port_spec;
0248
0249     u8 is_active;
0250     u8 usb_gone;
0251     struct work_struct async_get_intf;
0252     struct work_struct async_put_intf;
0253
0254     struct usb_device *usb;
0255     struct usb_interface *interface;
0256
0257     struct device *dev;
0258     struct kref ref;
0259     struct mutex mutex;
0260 };
0261
0262 /* Type of interface */
0263 #define HSO_INTF_MASK       0xFF00
0264 #define HSO_INTF_MUX        0x0100
0265 #define HSO_INTF_BULK       0x0200
0266
0267 /* Type of port */
0268 #define HSO_PORT_MASK       0xFF
0269 #define HSO_PORT_NO_PORT    0x0
0270 #define HSO_PORT_CONTROL    0x1
0271 #define HSO_PORT_APP        0x2
0272 #define HSO_PORT_GPS        0x3
0273 #define HSO_PORT_PCSC       0x4
0274 #define HSO_PORT_APP2       0x5
0275 #define HSO_PORT_GPS_CONTROL    0x6
0276 #define HSO_PORT_MSD        0x7
0277 #define HSO_PORT_VOICE      0x8
0278 #define HSO_PORT_DIAG2      0x9
0279 #define HSO_PORT_DIAG       0x10
0280 #define HSO_PORT_MODEM      0x11
0281 #define HSO_PORT_NETWORK    0x12
0282
0283 /* Additional device info */
0284 #define HSO_INFO_MASK       0xFF000000
0285 #define HSO_INFO_CRC_BUG    0x01000000
0286
0287 /*****************************************************************************/
0288 /* Prototypes                                                                */
0289 /*****************************************************************************/
0290 /* Serial driver functions */
0291 static int hso_serial_tiocmset(struct tty_struct *tty,
0292                    unsigned int set, unsigned int clear);
0293 static void ctrl_callback(struct urb *urb);
0294 static int put_rxbuf_data(struct urb *urb, struct hso_serial *serial);
0295 static void hso_kick_transmit(struct hso_serial *serial);
0296 /* Helper functions */
0297 static int hso_mux_submit_intr_urb(struct hso_shared_int *mux_int,
0298                    struct usb_device *usb, gfp_t gfp);
0299 static void handle_usb_error(int status, const char *function,
0300                  struct hso_device *hso_dev);
0301 static struct usb_endpoint_descriptor *hso_get_ep(struct usb_interface *intf,
0302                           int type, int dir);
0303 static int hso_get_mux_ports(struct usb_interface *intf, unsigned char *ports);
0304 static void hso_free_interface(struct usb_interface *intf);
0305 static int hso_start_serial_device(struct hso_device *hso_dev, gfp_t flags);
0306 static int hso_stop_serial_device(struct hso_device *hso_dev);
0307 static int hso_start_net_device(struct hso_device *hso_dev);
0308 static void hso_free_shared_int(struct hso_shared_int *shared_int);
0309 static int hso_stop_net_device(struct hso_device *hso_dev);
0310 static void hso_serial_ref_free(struct kref *ref);
0311 static void hso_std_serial_read_bulk_callback(struct urb *urb);
0312 static int hso_mux_serial_read(struct hso_serial *serial);
0313 static void async_get_intf(struct work_struct *data);
0314 static void async_put_intf(struct work_struct *data);
0315 static int hso_put_activity(struct hso_device *hso_dev);
0316 static int hso_get_activity(struct hso_device *hso_dev);
0317 static void tiocmget_intr_callback(struct urb *urb);
0318 /*****************************************************************************/
0319 /* Helping functions                                                         */
0320 /*****************************************************************************/
0321
0322 /* #define DEBUG */
0323
0324 static inline struct hso_net *dev2net(struct hso_device *hso_dev)
0325 {
0326     return hso_dev->port_data.dev_net;
0327 }
0328
0329 static inline struct hso_serial *dev2ser(struct hso_device *hso_dev)
0330 {
0331     return hso_dev->port_data.dev_serial;
0332 }
0333
0334 /* Debugging functions */
0335 #ifdef DEBUG
0336 static void dbg_dump(int line_count, const char *func_name, unsigned char *buf,
0337              unsigned int len)
0338 {
0339     static char name[255];
0340
0341     sprintf(name, "hso[%d:%s]", line_count, func_name);
0342     print_hex_dump_bytes(name, DUMP_PREFIX_NONE, buf, len);
0343 }
0344
0345 #define DUMP(buf_, len_)    \
0346     dbg_dump(__LINE__, __func__, (unsigned char *)buf_, len_)
0347
0348 #define DUMP1(buf_, len_)           \
0349     do {                    \
0350         if (0x01 & debug)       \
0351             DUMP(buf_, len_);   \
0352     } while (0)
0353 #else
0354 #define DUMP(buf_, len_)
0355 #define DUMP1(buf_, len_)
0356 #endif
0357
0358 /* module parameters */
0359 static int debug;
0360 static int tty_major;
0361 static int disable_net;
0362
0363 /* driver info */
0364 static const char driver_name[] = "hso";
0365 static const char tty_filename[] = "ttyHS";
0366 static const char *version = __FILE__ ": " MOD_AUTHOR;
0367 /* the usb driver itself (registered in hso_init) */
0368 static struct usb_driver hso_driver;
0369 /* serial structures */
0370 static struct tty_driver *tty_drv;
0371 static struct hso_device *serial_table[HSO_SERIAL_TTY_MINORS];
0372 static struct hso_device *network_table[HSO_MAX_NET_DEVICES];
0373 static DEFINE_SPINLOCK(serial_table_lock);
0374
0375 static const s32 default_port_spec[] = {
0376     HSO_INTF_MUX | HSO_PORT_NETWORK,
0377     HSO_INTF_BULK | HSO_PORT_DIAG,
0378     HSO_INTF_BULK | HSO_PORT_MODEM,
0379     0
0380 };
0381
0382 static const s32 icon321_port_spec[] = {
0383     HSO_INTF_MUX | HSO_PORT_NETWORK,
0384     HSO_INTF_BULK | HSO_PORT_DIAG2,
0385     HSO_INTF_BULK | HSO_PORT_MODEM,
0386     HSO_INTF_BULK | HSO_PORT_DIAG,
0387     0
0388 };
0389
0390 #define default_port_device(vendor, product)    \
0391     USB_DEVICE(vendor, product),    \
0392         .driver_info = (kernel_ulong_t)default_port_spec
0393
0394 #define icon321_port_device(vendor, product)    \
0395     USB_DEVICE(vendor, product),    \
0396         .driver_info = (kernel_ulong_t)icon321_port_spec
0397
0398 /* list of devices we support */
0399 static const struct usb_device_id hso_ids[] = {
0400     {default_port_device(0x0af0, 0x6711)},
0401     {default_port_device(0x0af0, 0x6731)},
0402     {default_port_device(0x0af0, 0x6751)},
0403     {default_port_device(0x0af0, 0x6771)},
0404     {default_port_device(0x0af0, 0x6791)},
0405     {default_port_device(0x0af0, 0x6811)},
0406     {default_port_device(0x0af0, 0x6911)},
0407     {default_port_device(0x0af0, 0x6951)},
0408     {default_port_device(0x0af0, 0x6971)},
0409     {default_port_device(0x0af0, 0x7011)},
0410     {default_port_device(0x0af0, 0x7031)},
0411     {default_port_device(0x0af0, 0x7051)},
0412     {default_port_device(0x0af0, 0x7071)},
0413     {default_port_device(0x0af0, 0x7111)},
0414     {default_port_device(0x0af0, 0x7211)},
0415     {default_port_device(0x0af0, 0x7251)},
0416     {default_port_device(0x0af0, 0x7271)},
0417     {default_port_device(0x0af0, 0x7311)},
0418     {default_port_device(0x0af0, 0xc031)},  /* Icon-Edge */
0419     {icon321_port_device(0x0af0, 0xd013)},  /* Module HSxPA */
0420     {icon321_port_device(0x0af0, 0xd031)},  /* Icon-321 */
0421     {icon321_port_device(0x0af0, 0xd033)},  /* Icon-322 */
0422     {USB_DEVICE(0x0af0, 0x7301)},       /* GE40x */
0423     {USB_DEVICE(0x0af0, 0x7361)},       /* GE40x */
0424     {USB_DEVICE(0x0af0, 0x7381)},       /* GE40x */
0425     {USB_DEVICE(0x0af0, 0x7401)},       /* GI 0401 */
0426     {USB_DEVICE(0x0af0, 0x7501)},       /* GTM 382 */
0427     {USB_DEVICE(0x0af0, 0x7601)},       /* GE40x */
0428     {USB_DEVICE(0x0af0, 0x7701)},
0429     {USB_DEVICE(0x0af0, 0x7706)},
0430     {USB_DEVICE(0x0af0, 0x7801)},
0431     {USB_DEVICE(0x0af0, 0x7901)},
0432     {USB_DEVICE(0x0af0, 0x7A01)},
0433     {USB_DEVICE(0x0af0, 0x7A05)},
0434     {USB_DEVICE(0x0af0, 0x8200)},
0435     {USB_DEVICE(0x0af0, 0x8201)},
0436     {USB_DEVICE(0x0af0, 0x8300)},
0437     {USB_DEVICE(0x0af0, 0x8302)},
0438     {USB_DEVICE(0x0af0, 0x8304)},
0439     {USB_DEVICE(0x0af0, 0x8400)},
0440     {USB_DEVICE(0x0af0, 0x8600)},
0441     {USB_DEVICE(0x0af0, 0x8800)},
0442     {USB_DEVICE(0x0af0, 0x8900)},
0443     {USB_DEVICE(0x0af0, 0x9000)},
0444     {USB_DEVICE(0x0af0, 0x9200)},       /* Option GTM671WFS */
0445     {USB_DEVICE(0x0af0, 0xd035)},
0446     {USB_DEVICE(0x0af0, 0xd055)},
0447     {USB_DEVICE(0x0af0, 0xd155)},
0448     {USB_DEVICE(0x0af0, 0xd255)},
0449     {USB_DEVICE(0x0af0, 0xd057)},
0450     {USB_DEVICE(0x0af0, 0xd157)},
0451     {USB_DEVICE(0x0af0, 0xd257)},
0452     {USB_DEVICE(0x0af0, 0xd357)},
0453     {USB_DEVICE(0x0af0, 0xd058)},
0454     {USB_DEVICE(0x0af0, 0xc100)},
0455     {}
0456 };
0457 MODULE_DEVICE_TABLE(usb, hso_ids);
0458
0459 /* Sysfs attribute */
0460 static ssize_t hsotype_show(struct device *dev,
0461                 struct device_attribute *attr, char *buf)
0462 {
0463     struct hso_device *hso_dev = dev_get_drvdata(dev);
0464     char *port_name;
0465
0466     if (!hso_dev)
0467         return 0;
0468
0469     switch (hso_dev->port_spec & HSO_PORT_MASK) {
0470     case HSO_PORT_CONTROL:
0471         port_name = "Control";
0472         break;
0473     case HSO_PORT_APP:
0474         port_name = "Application";
0475         break;
0476     case HSO_PORT_APP2:
0477         port_name = "Application2";
0478         break;
0479     case HSO_PORT_GPS:
0480         port_name = "GPS";
0481         break;
0482     case HSO_PORT_GPS_CONTROL:
0483         port_name = "GPS Control";
0484         break;
0485     case HSO_PORT_PCSC:
0486         port_name = "PCSC";
0487         break;
0488     case HSO_PORT_DIAG:
0489         port_name = "Diagnostic";
0490         break;
0491     case HSO_PORT_DIAG2:
0492         port_name = "Diagnostic2";
0493         break;
0494     case HSO_PORT_MODEM:
0495         port_name = "Modem";
0496         break;
0497     case HSO_PORT_NETWORK:
0498         port_name = "Network";
0499         break;
0500     default:
0501         port_name = "Unknown";
0502         break;
0503     }
0504
0505     return sprintf(buf, "%s\n", port_name);
0506 }
0507 static DEVICE_ATTR_RO(hsotype);
0508
0509 static struct attribute *hso_serial_dev_attrs[] = {
0510     &dev_attr_hsotype.attr,
0511     NULL
0512 };
0513
0514 ATTRIBUTE_GROUPS(hso_serial_dev);
0515
0516 static int hso_urb_to_index(struct hso_serial *serial, struct urb *urb)
0517 {
0518     int idx;
0519
0520     for (idx = 0; idx < serial->num_rx_urbs; idx++)
0521         if (serial->rx_urb[idx] == urb)
0522             return idx;
0523     dev_err(serial->parent->dev, "hso_urb_to_index failed\n");
0524     return -1;
0525 }
0526
0527 /* converts mux value to a port spec value */
0528 static u32 hso_mux_to_port(int mux)
0529 {
0530     u32 result;
0531
0532     switch (mux) {
0533     case 0x1:
0534         result = HSO_PORT_CONTROL;
0535         break;
0536     case 0x2:
0537         result = HSO_PORT_APP;
0538         break;
0539     case 0x4:
0540         result = HSO_PORT_PCSC;
0541         break;
0542     case 0x8:
0543         result = HSO_PORT_GPS;
0544         break;
0545     case 0x10:
0546         result = HSO_PORT_APP2;
0547         break;
0548     default:
0549         result = HSO_PORT_NO_PORT;
0550     }
0551     return result;
0552 }
0553
0554 /* converts port spec value to a mux value */
0555 static u32 hso_port_to_mux(int port)
0556 {
0557     u32 result;
0558
0559     switch (port & HSO_PORT_MASK) {
0560     case HSO_PORT_CONTROL:
0561         result = 0x0;
0562         break;
0563     case HSO_PORT_APP:
0564         result = 0x1;
0565         break;
0566     case HSO_PORT_PCSC:
0567         result = 0x2;
0568         break;
0569     case HSO_PORT_GPS:
0570         result = 0x3;
0571         break;
0572     case HSO_PORT_APP2:
0573         result = 0x4;
0574         break;
0575     default:
0576         result = 0x0;
0577     }
0578     return result;
0579 }
0580
0581 static struct hso_serial *get_serial_by_shared_int_and_type(
0582                     struct hso_shared_int *shared_int,
0583                     int mux)
0584 {
0585     int i, port;
0586
0587     port = hso_mux_to_port(mux);
0588
0589     for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++) {
0590         if (serial_table[i] &&
0591             (dev2ser(serial_table[i])->shared_int == shared_int) &&
0592             ((serial_table[i]->port_spec & HSO_PORT_MASK) == port)) {
0593             return dev2ser(serial_table[i]);
0594         }
0595     }
0596
0597     return NULL;
0598 }
0599
0600 static struct hso_serial *get_serial_by_index(unsigned index)
0601 {
0602     struct hso_serial *serial = NULL;
0603     unsigned long flags;
0604
0605     spin_lock_irqsave(&serial_table_lock, flags);
0606     if (serial_table[index])
0607         serial = dev2ser(serial_table[index]);
0608     spin_unlock_irqrestore(&serial_table_lock, flags);
0609
0610     return serial;
0611 }
0612
0613 static int obtain_minor(struct hso_serial *serial)
0614 {
0615     int index;
0616     unsigned long flags;
0617
0618     spin_lock_irqsave(&serial_table_lock, flags);
0619     for (index = 0; index < HSO_SERIAL_TTY_MINORS; index++) {
0620         if (serial_table[index] == NULL) {
0621             serial_table[index] = serial->parent;
0622             serial->minor = index;
0623             spin_unlock_irqrestore(&serial_table_lock, flags);
0624             return 0;
0625         }
0626     }
0627     spin_unlock_irqrestore(&serial_table_lock, flags);
0628
0629     pr_err("%s: no free serial devices in table\n", __func__);
0630     return -1;
0631 }
0632
0633 static void release_minor(struct hso_serial *serial)
0634 {
0635     unsigned long flags;
0636
0637     spin_lock_irqsave(&serial_table_lock, flags);
0638     serial_table[serial->minor] = NULL;
0639     spin_unlock_irqrestore(&serial_table_lock, flags);
0640 }
0641
0642 static void handle_usb_error(int status, const char *function,
0643                  struct hso_device *hso_dev)
0644 {
0645     char *explanation;
0646
0647     switch (status) {
0648     case -ENODEV:
0649         explanation = "no device";
0650         break;
0651     case -ENOENT:
0652         explanation = "endpoint not enabled";
0653         break;
0654     case -EPIPE:
0655         explanation = "endpoint stalled";
0656         break;
0657     case -ENOSPC:
0658         explanation = "not enough bandwidth";
0659         break;
0660     case -ESHUTDOWN:
0661         explanation = "device disabled";
0662         break;
0663     case -EHOSTUNREACH:
0664         explanation = "device suspended";
0665         break;
0666     case -EINVAL:
0667     case -EAGAIN:
0668     case -EFBIG:
0669     case -EMSGSIZE:
0670         explanation = "internal error";
0671         break;
0672     case -EILSEQ:
0673     case -EPROTO:
0674     case -ETIME:
0675     case -ETIMEDOUT:
0676         explanation = "protocol error";
0677         if (hso_dev)
0678             usb_queue_reset_device(hso_dev->interface);
0679         break;
0680     default:
0681         explanation = "unknown status";
0682         break;
0683     }
0684
0685     /* log a meaningful explanation of an USB status */
0686     hso_dbg(0x1, "%s: received USB status - %s (%d)\n",
0687         function, explanation, status);
0688 }
0689
0690 /* Network interface functions */
0691
0692 /* called when net interface is brought up by ifconfig */
0693 static int hso_net_open(struct net_device *net)
0694 {
0695     struct hso_net *odev = netdev_priv(net);
0696     unsigned long flags = 0;
0697
0698     if (!odev) {
0699         dev_err(&net->dev, "No net device !\n");
0700         return -ENODEV;
0701     }
0702
0703     odev->skb_tx_buf = NULL;
0704
0705     /* setup environment */
0706     spin_lock_irqsave(&odev->net_lock, flags);
0707     odev->rx_parse_state = WAIT_IP;
0708     odev->rx_buf_size = 0;
0709     odev->rx_buf_missing = sizeof(struct iphdr);
0710     spin_unlock_irqrestore(&odev->net_lock, flags);
0711
0712     /* We are up and running. */
0713     set_bit(HSO_NET_RUNNING, &odev->flags);
0714     hso_start_net_device(odev->parent);
0715
0716     /* Tell the kernel we are ready to start receiving from it */
0717     netif_start_queue(net);
0718
0719     return 0;
0720 }
0721
0722 /* called when interface is brought down by ifconfig */
0723 static int hso_net_close(struct net_device *net)
0724 {
0725     struct hso_net *odev = netdev_priv(net);
0726
0727     /* we don't need the queue anymore */
0728     netif_stop_queue(net);
0729     /* no longer running */
0730     clear_bit(HSO_NET_RUNNING, &odev->flags);
0731
0732     hso_stop_net_device(odev->parent);
0733
0734     /* done */
0735     return 0;
0736 }
0737
0738 /* USB tells is xmit done, we should start the netqueue again */
0739 static void write_bulk_callback(struct urb *urb)
0740 {
0741     struct hso_net *odev = urb->context;
0742     int status = urb->status;
0743
0744     /* Sanity check */
0745     if (!odev || !test_bit(HSO_NET_RUNNING, &odev->flags)) {
0746         dev_err(&urb->dev->dev, "%s: device not running\n", __func__);
0747         return;
0748     }
0749
0750     /* Do we still have a valid kernel network device? */
0751     if (!netif_device_present(odev->net)) {
0752         dev_err(&urb->dev->dev, "%s: net device not present\n",
0753             __func__);
0754         return;
0755     }
0756
0757     /* log status, but don't act on it, we don't need to resubmit anything
0758      * anyhow */
0759     if (status)
0760         handle_usb_error(status, __func__, odev->parent);
0761
0762     hso_put_activity(odev->parent);
0763
0764     /* Tell the network interface we are ready for another frame */
0765     netif_wake_queue(odev->net);
0766 }
0767
0768 /* called by kernel when we need to transmit a packet */
0769 static netdev_tx_t hso_net_start_xmit(struct sk_buff *skb,
0770                         struct net_device *net)
0771 {
0772     struct hso_net *odev = netdev_priv(net);
0773     int result;
0774
0775     /* Tell the kernel, "No more frames 'til we are done with this one." */
0776     netif_stop_queue(net);
0777     if (hso_get_activity(odev->parent) == -EAGAIN) {
0778         odev->skb_tx_buf = skb;
0779         return NETDEV_TX_OK;
0780     }
0781
0782     /* log if asked */
0783     DUMP1(skb->data, skb->len);
0784     /* Copy it from kernel memory to OUR memory */
0785     memcpy(odev->mux_bulk_tx_buf, skb->data, skb->len);
0786     hso_dbg(0x1, "len: %d/%d\n", skb->len, MUX_BULK_TX_BUF_SIZE);
0787
0788     /* Fill in the URB for shipping it out. */
0789     usb_fill_bulk_urb(odev->mux_bulk_tx_urb,
0790               odev->parent->usb,
0791               usb_sndbulkpipe(odev->parent->usb,
0792                       odev->out_endp->
0793                       bEndpointAddress & 0x7F),
0794               odev->mux_bulk_tx_buf, skb->len, write_bulk_callback,
0795               odev);
0796
0797     /* Deal with the Zero Length packet problem, I hope */
0798     odev->mux_bulk_tx_urb->transfer_flags |= URB_ZERO_PACKET;
0799
0800     /* Send the URB on its merry way. */
0801     result = usb_submit_urb(odev->mux_bulk_tx_urb, GFP_ATOMIC);
0802     if (result) {
0803         dev_warn(&odev->parent->interface->dev,
0804             "failed mux_bulk_tx_urb %d\n", result);
0805         net->stats.tx_errors++;
0806         netif_start_queue(net);
0807     } else {
0808         net->stats.tx_packets++;
0809         net->stats.tx_bytes += skb->len;
0810     }
0811     dev_kfree_skb(skb);
0812     /* we're done */
0813     return NETDEV_TX_OK;
0814 }
0815
0816 static const struct ethtool_ops ops = {
0817     .get_link = ethtool_op_get_link
0818 };
0819
0820 /* called when a packet did not ack after watchdogtimeout */
0821 static void hso_net_tx_timeout(struct net_device *net, unsigned int txqueue)
0822 {
0823     struct hso_net *odev = netdev_priv(net);
0824
0825     if (!odev)
0826         return;
0827
0828     /* Tell syslog we are hosed. */
0829     dev_warn(&net->dev, "Tx timed out.\n");
0830
0831     /* Tear the waiting frame off the list */
0832     if (odev->mux_bulk_tx_urb)
0833         usb_unlink_urb(odev->mux_bulk_tx_urb);
0834
0835     /* Update statistics */
0836     net->stats.tx_errors++;
0837 }
0838
0839 /* make a real packet from the received USB buffer */
0840 static void packetizeRx(struct hso_net *odev, unsigned char *ip_pkt,
0841             unsigned int count, unsigned char is_eop)
0842 {
0843     unsigned short temp_bytes;
0844     unsigned short buffer_offset = 0;
0845     unsigned short frame_len;
0846
0847     /* log if needed */
0848     hso_dbg(0x1, "Rx %d bytes\n", count);
0849     DUMP(ip_pkt, min(128, (int)count));
0850
0851     while (count) {
0852         switch (odev->rx_parse_state) {
0853         case WAIT_IP:
0854             /* waiting for IP header. */
0855             /* wanted bytes - size of ip header */
0856             temp_bytes =
0857                 (count <
0858                  odev->rx_buf_missing) ? count : odev->
0859                 rx_buf_missing;
0860
0861             memcpy(((unsigned char *)(&odev->rx_ip_hdr)) +
0862                    odev->rx_buf_size, ip_pkt + buffer_offset,
0863                    temp_bytes);
0864
0865             odev->rx_buf_size += temp_bytes;
0866             buffer_offset += temp_bytes;
0867             odev->rx_buf_missing -= temp_bytes;
0868             count -= temp_bytes;
0869
0870             if (!odev->rx_buf_missing) {
0871                 /* header is complete allocate an sk_buffer and
0872                  * continue to WAIT_DATA */
0873                 frame_len = ntohs(odev->rx_ip_hdr.tot_len);
0874
0875                 if ((frame_len > DEFAULT_MRU) ||
0876                     (frame_len < sizeof(struct iphdr))) {
0877                     dev_err(&odev->net->dev,
0878                         "Invalid frame (%d) length\n",
0879                         frame_len);
0880                     odev->rx_parse_state = WAIT_SYNC;
0881                     continue;
0882                 }
0883                 /* Allocate an sk_buff */
0884                 odev->skb_rx_buf = netdev_alloc_skb(odev->net,
0885                                     frame_len);
0886                 if (!odev->skb_rx_buf) {
0887                     /* We got no receive buffer. */
0888                     hso_dbg(0x1, "could not allocate memory\n");
0889                     odev->rx_parse_state = WAIT_SYNC;
0890                     continue;
0891                 }
0892
0893                 /* Copy what we got so far. make room for iphdr
0894                  * after tail. */
0895                 skb_put_data(odev->skb_rx_buf,
0896                          (char *)&(odev->rx_ip_hdr),
0897                          sizeof(struct iphdr));
0898
0899                 /* ETH_HLEN */
0900                 odev->rx_buf_size = sizeof(struct iphdr);
0901
0902                 /* Filip actually use .tot_len */
0903                 odev->rx_buf_missing =
0904                     frame_len - sizeof(struct iphdr);
0905                 odev->rx_parse_state = WAIT_DATA;
0906             }
0907             break;
0908
0909         case WAIT_DATA:
0910             temp_bytes = (count < odev->rx_buf_missing)
0911                     ? count : odev->rx_buf_missing;
0912
0913             /* Copy the rest of the bytes that are left in the
0914              * buffer into the waiting sk_buf. */
0915             /* Make room for temp_bytes after tail. */
0916             skb_put_data(odev->skb_rx_buf,
0917                      ip_pkt + buffer_offset,
0918                      temp_bytes);
0919
0920             odev->rx_buf_missing -= temp_bytes;
0921             count -= temp_bytes;
0922             buffer_offset += temp_bytes;
0923             odev->rx_buf_size += temp_bytes;
0924             if (!odev->rx_buf_missing) {
0925                 /* Packet is complete. Inject into stack. */
0926                 /* We have IP packet here */
0927                 odev->skb_rx_buf->protocol = cpu_to_be16(ETH_P_IP);
0928                 skb_reset_mac_header(odev->skb_rx_buf);
0929
0930                 /* Ship it off to the kernel */
0931                 netif_rx(odev->skb_rx_buf);
0932                 /* No longer our buffer. */
0933                 odev->skb_rx_buf = NULL;
0934
0935                 /* update out statistics */
0936                 odev->net->stats.rx_packets++;
0937
0938                 odev->net->stats.rx_bytes += odev->rx_buf_size;
0939
0940                 odev->rx_buf_size = 0;
0941                 odev->rx_buf_missing = sizeof(struct iphdr);
0942                 odev->rx_parse_state = WAIT_IP;
0943             }
0944             break;
0945
0946         case WAIT_SYNC:
0947             hso_dbg(0x1, " W_S\n");
0948             count = 0;
0949             break;
0950         default:
0951             hso_dbg(0x1, "\n");
0952             count--;
0953             break;
0954         }
0955     }
0956
0957     /* Recovery mechanism for WAIT_SYNC state. */
0958     if (is_eop) {
0959         if (odev->rx_parse_state == WAIT_SYNC) {
0960             odev->rx_parse_state = WAIT_IP;
0961             odev->rx_buf_size = 0;
0962             odev->rx_buf_missing = sizeof(struct iphdr);
0963         }
0964     }
0965 }
0966
0967 static void fix_crc_bug(struct urb *urb, __le16 max_packet_size)
0968 {
0969     static const u8 crc_check[4] = { 0xDE, 0xAD, 0xBE, 0xEF };
0970     u32 rest = urb->actual_length % le16_to_cpu(max_packet_size);
0971
0972     if (((rest == 5) || (rest == 6)) &&
0973         !memcmp(((u8 *)urb->transfer_buffer) + urb->actual_length - 4,
0974             crc_check, 4)) {
0975         urb->actual_length -= 4;
0976     }
0977 }
0978
0979 /* Moving data from usb to kernel (in interrupt state) */
0980 static void read_bulk_callback(struct urb *urb)
0981 {
0982     struct hso_net *odev = urb->context;
0983     struct net_device *net;
0984     int result;
0985     unsigned long flags;
0986     int status = urb->status;
0987
0988     /* is al ok?  (Filip: Who's Al ?) */
0989     if (status) {
0990         handle_usb_error(status, __func__, odev->parent);
0991         return;
0992     }
0993
0994     /* Sanity check */
0995     if (!odev || !test_bit(HSO_NET_RUNNING, &odev->flags)) {
0996         hso_dbg(0x1, "BULK IN callback but driver is not active!\n");
0997         return;
0998     }
0999     usb_mark_last_busy(urb->dev);
1000
1001     net = odev->net;
1002
1003     if (!netif_device_present(net)) {
1004         /* Somebody killed our network interface... */
1005         return;
1006     }
1007
1008     if (odev->parent->port_spec & HSO_INFO_CRC_BUG)
1009         fix_crc_bug(urb, odev->in_endp->wMaxPacketSize);
1010
1011     /* do we even have a packet? */
1012     if (urb->actual_length) {
1013         /* Handle the IP stream, add header and push it onto network
1014          * stack if the packet is complete. */
1015         spin_lock_irqsave(&odev->net_lock, flags);
1016         packetizeRx(odev, urb->transfer_buffer, urb->actual_length,
1017                 (urb->transfer_buffer_length >
1018                  urb->actual_length) ? 1 : 0);
1019         spin_unlock_irqrestore(&odev->net_lock, flags);
1020     }
1021
1022     /* We are done with this URB, resubmit it. Prep the USB to wait for
1023      * another frame. Reuse same as received. */
1024     usb_fill_bulk_urb(urb,
1025               odev->parent->usb,
1026               usb_rcvbulkpipe(odev->parent->usb,
1027                       odev->in_endp->
1028                       bEndpointAddress & 0x7F),
1029               urb->transfer_buffer, MUX_BULK_RX_BUF_SIZE,
1030               read_bulk_callback, odev);
1031
1032     /* Give this to the USB subsystem so it can tell us when more data
1033      * arrives. */
1034     result = usb_submit_urb(urb, GFP_ATOMIC);
1035     if (result)
1036         dev_warn(&odev->parent->interface->dev,
1037              "%s failed submit mux_bulk_rx_urb %d\n", __func__,
1038              result);
1039 }
1040
1041 /* Serial driver functions */
1042
1043 static void hso_init_termios(struct ktermios *termios)
1044 {
1045     /*
1046      * The default requirements for this device are:
1047      */
1048     termios->c_iflag &=
1049         ~(IGNBRK    /* disable ignore break */
1050         | BRKINT    /* disable break causes interrupt */
1051         | PARMRK    /* disable mark parity errors */
1052         | ISTRIP    /* disable clear high bit of input characters */
1053         | INLCR     /* disable translate NL to CR */
1054         | IGNCR     /* disable ignore CR */
1055         | ICRNL     /* disable translate CR to NL */
1056         | IXON);    /* disable enable XON/XOFF flow control */
1057
1058     /* disable postprocess output characters */
1059     termios->c_oflag &= ~OPOST;
1060
1061     termios->c_lflag &=
1062         ~(ECHO      /* disable echo input characters */
1063         | ECHONL    /* disable echo new line */
1064         | ICANON    /* disable erase, kill, werase, and rprnt
1065                    special characters */
1066         | ISIG      /* disable interrupt, quit, and suspend special
1067                    characters */
1068         | IEXTEN);  /* disable non-POSIX special characters */
1069
1070     termios->c_cflag &=
1071         ~(CSIZE     /* no size */
1072         | PARENB    /* disable parity bit */
1073         | CBAUD     /* clear current baud rate */
1074         | CBAUDEX); /* clear current buad rate */
1075
1076     termios->c_cflag |= CS8;    /* character size 8 bits */
1077
1078     /* baud rate 115200 */
1079     tty_termios_encode_baud_rate(termios, 115200, 115200);
1080 }
1081
1082 static void _hso_serial_set_termios(struct tty_struct *tty)
1083 {
1084     struct hso_serial *serial = tty->driver_data;
1085
1086     if (!serial) {
1087         pr_err("%s: no tty structures", __func__);
1088         return;
1089     }
1090
1091     hso_dbg(0x8, "port %d\n", serial->minor);
1092
1093     /*
1094      *  Fix up unsupported bits
1095      */
1096     tty->termios.c_iflag &= ~IXON; /* disable enable XON/XOFF flow control */
1097
1098     tty->termios.c_cflag &=
1099         ~(CSIZE     /* no size */
1100         | PARENB    /* disable parity bit */
1101         | CBAUD     /* clear current baud rate */
1102         | CBAUDEX); /* clear current buad rate */
1103
1104     tty->termios.c_cflag |= CS8;    /* character size 8 bits */
1105
1106     /* baud rate 115200 */
1107     tty_encode_baud_rate(tty, 115200, 115200);
1108 }
1109
1110 static void hso_resubmit_rx_bulk_urb(struct hso_serial *serial, struct urb *urb)
1111 {
1112     int result;
1113     /* We are done with this URB, resubmit it. Prep the USB to wait for
1114      * another frame */
1115     usb_fill_bulk_urb(urb, serial->parent->usb,
1116               usb_rcvbulkpipe(serial->parent->usb,
1117                       serial->in_endp->
1118                       bEndpointAddress & 0x7F),
1119               urb->transfer_buffer, serial->rx_data_length,
1120               hso_std_serial_read_bulk_callback, serial);
1121     /* Give this to the USB subsystem so it can tell us when more data
1122      * arrives. */
1123     result = usb_submit_urb(urb, GFP_ATOMIC);
1124     if (result) {
1125         dev_err(&urb->dev->dev, "%s failed submit serial rx_urb %d\n",
1126             __func__, result);
1127     }
1128 }
1129
1130
1131
1132
1133 static void put_rxbuf_data_and_resubmit_bulk_urb(struct hso_serial *serial)
1134 {
1135     int count;
1136     struct urb *curr_urb;
1137
1138     while (serial->rx_urb_filled[serial->curr_rx_urb_idx]) {
1139         curr_urb = serial->rx_urb[serial->curr_rx_urb_idx];
1140         count = put_rxbuf_data(curr_urb, serial);
1141         if (count == -1)
1142             return;
1143         if (count == 0) {
1144             serial->curr_rx_urb_idx++;
1145             if (serial->curr_rx_urb_idx >= serial->num_rx_urbs)
1146                 serial->curr_rx_urb_idx = 0;
1147             hso_resubmit_rx_bulk_urb(serial, curr_urb);
1148         }
1149     }
1150 }
1151
1152 static void put_rxbuf_data_and_resubmit_ctrl_urb(struct hso_serial *serial)
1153 {
1154     int count = 0;
1155     struct urb *urb;
1156
1157     urb = serial->rx_urb[0];
1158     if (serial->port.count > 0) {
1159         count = put_rxbuf_data(urb, serial);
1160         if (count == -1)
1161             return;
1162     }
1163     /* Re issue a read as long as we receive data. */
1164
1165     if (count == 0 && ((urb->actual_length != 0) ||
1166                (serial->rx_state == RX_PENDING))) {
1167         serial->rx_state = RX_SENT;
1168         hso_mux_serial_read(serial);
1169     } else
1170         serial->rx_state = RX_IDLE;
1171 }
1172
1173
1174 /* read callback for Diag and CS port */
1175 static void hso_std_serial_read_bulk_callback(struct urb *urb)
1176 {
1177     struct hso_serial *serial = urb->context;
1178     int status = urb->status;
1179     unsigned long flags;
1180
1181     hso_dbg(0x8, "--- Got serial_read_bulk callback %02x ---\n", status);
1182
1183     /* sanity check */
1184     if (!serial) {
1185         hso_dbg(0x1, "serial == NULL\n");
1186         return;
1187     }
1188     if (status) {
1189         handle_usb_error(status, __func__, serial->parent);
1190         return;
1191     }
1192
1193     hso_dbg(0x1, "Actual length = %d\n", urb->actual_length);
1194     DUMP1(urb->transfer_buffer, urb->actual_length);
1195
1196     /* Anyone listening? */
1197     if (serial->port.count == 0)
1198         return;
1199
1200     if (serial->parent->port_spec & HSO_INFO_CRC_BUG)
1201         fix_crc_bug(urb, serial->in_endp->wMaxPacketSize);
1202     /* Valid data, handle RX data */
1203     spin_lock_irqsave(&serial->serial_lock, flags);
1204     serial->rx_urb_filled[hso_urb_to_index(serial, urb)] = 1;
1205     put_rxbuf_data_and_resubmit_bulk_urb(serial);
1206     spin_unlock_irqrestore(&serial->serial_lock, flags);
1207 }
1208
1209 /*
1210  * This needs to be a tasklet otherwise we will
1211  * end up recursively calling this function.
1212  */
1213 static void hso_unthrottle_tasklet(struct tasklet_struct *t)
1214 {
1215     struct hso_serial *serial = from_tasklet(serial, t,
1216                          unthrottle_tasklet);
1217     unsigned long flags;
1218
1219     spin_lock_irqsave(&serial->serial_lock, flags);
1220     if ((serial->parent->port_spec & HSO_INTF_MUX))
1221         put_rxbuf_data_and_resubmit_ctrl_urb(serial);
1222     else
1223         put_rxbuf_data_and_resubmit_bulk_urb(serial);
1224     spin_unlock_irqrestore(&serial->serial_lock, flags);
1225 }
1226
1227 static  void hso_unthrottle(struct tty_struct *tty)
1228 {
1229     struct hso_serial *serial = tty->driver_data;
1230
1231     tasklet_hi_schedule(&serial->unthrottle_tasklet);
1232 }
1233
1234 /* open the requested serial port */
1235 static int hso_serial_open(struct tty_struct *tty, struct file *filp)
1236 {
1237     struct hso_serial *serial = get_serial_by_index(tty->index);
1238     int result;
1239
1240     /* sanity check */
1241     if (serial == NULL || serial->magic != HSO_SERIAL_MAGIC) {
1242         WARN_ON(1);
1243         tty->driver_data = NULL;
1244         hso_dbg(0x1, "Failed to open port\n");
1245         return -ENODEV;
1246     }
1247
1248     mutex_lock(&serial->parent->mutex);
1249     result = usb_autopm_get_interface(serial->parent->interface);
1250     if (result < 0)
1251         goto err_out;
1252
1253     hso_dbg(0x1, "Opening %d\n", serial->minor);
1254
1255     /* setup */
1256     tty->driver_data = serial;
1257     tty_port_tty_set(&serial->port, tty);
1258
1259     /* check for port already opened, if not set the termios */
1260     serial->port.count++;
1261     if (serial->port.count == 1) {
1262         serial->rx_state = RX_IDLE;
1263         /* Force default termio settings */
1264         _hso_serial_set_termios(tty);
1265         tasklet_setup(&serial->unthrottle_tasklet,
1266                   hso_unthrottle_tasklet);
1267         result = hso_start_serial_device(serial->parent, GFP_KERNEL);
1268         if (result) {
1269             hso_stop_serial_device(serial->parent);
1270             serial->port.count--;
1271         } else {
1272             kref_get(&serial->parent->ref);
1273         }
1274     } else {
1275         hso_dbg(0x1, "Port was already open\n");
1276     }
1277
1278     usb_autopm_put_interface(serial->parent->interface);
1279
1280     /* done */
1281     if (result)
1282         hso_serial_tiocmset(tty, TIOCM_RTS | TIOCM_DTR, 0);
1283 err_out:
1284     mutex_unlock(&serial->parent->mutex);
1285     return result;
1286 }
1287
1288 /* close the requested serial port */
1289 static void hso_serial_close(struct tty_struct *tty, struct file *filp)
1290 {
1291     struct hso_serial *serial = tty->driver_data;
1292     u8 usb_gone;
1293
1294     hso_dbg(0x1, "Closing serial port\n");
1295
1296     /* Open failed, no close cleanup required */
1297     if (serial == NULL)
1298         return;
1299
1300     mutex_lock(&serial->parent->mutex);
1301     usb_gone = serial->parent->usb_gone;
1302
1303     if (!usb_gone)
1304         usb_autopm_get_interface(serial->parent->interface);
1305
1306     /* reset the rts and dtr */
1307     /* do the actual close */
1308     serial->port.count--;
1309
1310     if (serial->port.count <= 0) {
1311         serial->port.count = 0;
1312         tty_port_tty_set(&serial->port, NULL);
1313         if (!usb_gone)
1314             hso_stop_serial_device(serial->parent);
1315         tasklet_kill(&serial->unthrottle_tasklet);
1316     }
1317
1318     if (!usb_gone)
1319         usb_autopm_put_interface(serial->parent->interface);
1320
1321     mutex_unlock(&serial->parent->mutex);
1322 }
1323
1324 /* close the requested serial port */
1325 static int hso_serial_write(struct tty_struct *tty, const unsigned char *buf,
1326                 int count)
1327 {
1328     struct hso_serial *serial = tty->driver_data;
1329     int space, tx_bytes;
1330     unsigned long flags;
1331
1332     /* sanity check */
1333     if (serial == NULL) {
1334         pr_err("%s: serial is NULL\n", __func__);
1335         return -ENODEV;
1336     }
1337
1338     spin_lock_irqsave(&serial->serial_lock, flags);
1339
1340     space = serial->tx_data_length - serial->tx_buffer_count;
1341     tx_bytes = (count < space) ? count : space;
1342
1343     if (!tx_bytes)
1344         goto out;
1345
1346     memcpy(serial->tx_buffer + serial->tx_buffer_count, buf, tx_bytes);
1347     serial->tx_buffer_count += tx_bytes;
1348
1349 out:
1350     spin_unlock_irqrestore(&serial->serial_lock, flags);
1351
1352     hso_kick_transmit(serial);
1353     /* done */
1354     return tx_bytes;
1355 }
1356
1357 /* how much room is there for writing */
1358 static unsigned int hso_serial_write_room(struct tty_struct *tty)
1359 {
1360     struct hso_serial *serial = tty->driver_data;
1361     unsigned int room;
1362     unsigned long flags;
1363
1364     spin_lock_irqsave(&serial->serial_lock, flags);
1365     room = serial->tx_data_length - serial->tx_buffer_count;
1366     spin_unlock_irqrestore(&serial->serial_lock, flags);
1367
1368     /* return free room */
1369     return room;
1370 }
1371
1372 static void hso_serial_cleanup(struct tty_struct *tty)
1373 {
1374     struct hso_serial *serial = tty->driver_data;
1375
1376     if (!serial)
1377         return;
1378
1379     kref_put(&serial->parent->ref, hso_serial_ref_free);
1380 }
1381
1382 /* setup the term */
1383 static void hso_serial_set_termios(struct tty_struct *tty, struct ktermios *old)
1384 {
1385     struct hso_serial *serial = tty->driver_data;
1386     unsigned long flags;
1387
1388     if (old)
1389         hso_dbg(0x16, "Termios called with: cflags new[%u] - old[%u]\n",
1390             (unsigned int)tty->termios.c_cflag,
1391             (unsigned int)old->c_cflag);
1392
1393     /* the actual setup */
1394     spin_lock_irqsave(&serial->serial_lock, flags);
1395     if (serial->port.count)
1396         _hso_serial_set_termios(tty);
1397     else
1398         tty->termios = *old;
1399     spin_unlock_irqrestore(&serial->serial_lock, flags);
1400
1401     /* done */
1402 }
1403
1404 /* how many characters in the buffer */
1405 static unsigned int hso_serial_chars_in_buffer(struct tty_struct *tty)
1406 {
1407     struct hso_serial *serial = tty->driver_data;
1408     unsigned long flags;
1409     unsigned int chars;
1410
1411     /* sanity check */
1412     if (serial == NULL)
1413         return 0;
1414
1415     spin_lock_irqsave(&serial->serial_lock, flags);
1416     chars = serial->tx_buffer_count;
1417     spin_unlock_irqrestore(&serial->serial_lock, flags);
1418
1419     return chars;
1420 }
1421 static int tiocmget_submit_urb(struct hso_serial *serial,
1422                    struct hso_tiocmget *tiocmget,
1423                    struct usb_device *usb)
1424 {
1425     int result;
1426
1427     if (serial->parent->usb_gone)
1428         return -ENODEV;
1429     usb_fill_int_urb(tiocmget->urb, usb,
1430              usb_rcvintpipe(usb,
1431                     tiocmget->endp->
1432                     bEndpointAddress & 0x7F),
1433              tiocmget->serial_state_notification,
1434              sizeof(struct hso_serial_state_notification),
1435              tiocmget_intr_callback, serial,
1436              tiocmget->endp->bInterval);
1437     result = usb_submit_urb(tiocmget->urb, GFP_ATOMIC);
1438     if (result) {
1439         dev_warn(&usb->dev, "%s usb_submit_urb failed %d\n", __func__,
1440              result);
1441     }
1442     return result;
1443
1444 }
1445
1446 static void tiocmget_intr_callback(struct urb *urb)
1447 {
1448     struct hso_serial *serial = urb->context;
1449     struct hso_tiocmget *tiocmget;
1450     int status = urb->status;
1451     u16 UART_state_bitmap, prev_UART_state_bitmap;
1452     struct uart_icount *icount;
1453     struct hso_serial_state_notification *serial_state_notification;
1454     struct usb_device *usb;
1455     struct usb_interface *interface;
1456     int if_num;
1457
1458     /* Sanity checks */
1459     if (!serial)
1460         return;
1461     if (status) {
1462         handle_usb_error(status, __func__, serial->parent);
1463         return;
1464     }
1465
1466     /* tiocmget is only supported on HSO_PORT_MODEM */
1467     tiocmget = serial->tiocmget;
1468     if (!tiocmget)
1469         return;
1470     BUG_ON((serial->parent->port_spec & HSO_PORT_MASK) != HSO_PORT_MODEM);
1471
1472     usb = serial->parent->usb;
1473     interface = serial->parent->interface;
1474
1475     if_num = interface->cur_altsetting->desc.bInterfaceNumber;
1476
1477     /* wIndex should be the USB interface number of the port to which the
1478      * notification applies, which should always be the Modem port.
1479      */
1480     serial_state_notification = tiocmget->serial_state_notification;
1481     if (serial_state_notification->bmRequestType != BM_REQUEST_TYPE ||
1482         serial_state_notification->bNotification != B_NOTIFICATION ||
1483         le16_to_cpu(serial_state_notification->wValue) != W_VALUE ||
1484         le16_to_cpu(serial_state_notification->wIndex) != if_num ||
1485         le16_to_cpu(serial_state_notification->wLength) != W_LENGTH) {
1486         dev_warn(&usb->dev,
1487              "hso received invalid serial state notification\n");
1488         DUMP(serial_state_notification,
1489              sizeof(struct hso_serial_state_notification));
1490     } else {
1491         unsigned long flags;
1492
1493         UART_state_bitmap = le16_to_cpu(serial_state_notification->
1494                         UART_state_bitmap);
1495         prev_UART_state_bitmap = tiocmget->prev_UART_state_bitmap;
1496         icount = &tiocmget->icount;
1497         spin_lock_irqsave(&serial->serial_lock, flags);
1498         if ((UART_state_bitmap & B_OVERRUN) !=
1499            (prev_UART_state_bitmap & B_OVERRUN))
1500             icount->parity++;
1501         if ((UART_state_bitmap & B_PARITY) !=
1502            (prev_UART_state_bitmap & B_PARITY))
1503             icount->parity++;
1504         if ((UART_state_bitmap & B_FRAMING) !=
1505            (prev_UART_state_bitmap & B_FRAMING))
1506             icount->frame++;
1507         if ((UART_state_bitmap & B_RING_SIGNAL) &&
1508            !(prev_UART_state_bitmap & B_RING_SIGNAL))
1509             icount->rng++;
1510         if ((UART_state_bitmap & B_BREAK) !=
1511            (prev_UART_state_bitmap & B_BREAK))
1512             icount->brk++;
1513         if ((UART_state_bitmap & B_TX_CARRIER) !=
1514            (prev_UART_state_bitmap & B_TX_CARRIER))
1515             icount->dsr++;
1516         if ((UART_state_bitmap & B_RX_CARRIER) !=
1517            (prev_UART_state_bitmap & B_RX_CARRIER))
1518             icount->dcd++;
1519         tiocmget->prev_UART_state_bitmap = UART_state_bitmap;
1520         spin_unlock_irqrestore(&serial->serial_lock, flags);
1521         tiocmget->intr_completed = 1;
1522         wake_up_interruptible(&tiocmget->waitq);
1523     }
1524     memset(serial_state_notification, 0,
1525            sizeof(struct hso_serial_state_notification));
1526     tiocmget_submit_urb(serial,
1527                 tiocmget,
1528                 serial->parent->usb);
1529 }
1530
1531 /*
1532  * next few functions largely stolen from drivers/serial/serial_core.c
1533  */
1534 /* Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
1535  * - mask passed in arg for lines of interest
1536  *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
1537  * Caller should use TIOCGICOUNT to see which one it was
1538  */
1539 static int
1540 hso_wait_modem_status(struct hso_serial *serial, unsigned long arg)
1541 {
1542     DECLARE_WAITQUEUE(wait, current);
1543     struct uart_icount cprev, cnow;
1544     struct hso_tiocmget  *tiocmget;
1545     int ret;
1546
1547     tiocmget = serial->tiocmget;
1548     if (!tiocmget)
1549         return -ENOENT;
1550     /*
1551      * note the counters on entry
1552      */
1553     spin_lock_irq(&serial->serial_lock);
1554     memcpy(&cprev, &tiocmget->icount, sizeof(struct uart_icount));
1555     spin_unlock_irq(&serial->serial_lock);
1556     add_wait_queue(&tiocmget->waitq, &wait);
1557     for (;;) {
1558         spin_lock_irq(&serial->serial_lock);
1559         memcpy(&cnow, &tiocmget->icount, sizeof(struct uart_icount));
1560         spin_unlock_irq(&serial->serial_lock);
1561         set_current_state(TASK_INTERRUPTIBLE);
1562         if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
1563             ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
1564             ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd))) {
1565             ret = 0;
1566             break;
1567         }
1568         schedule();
1569         /* see if a signal did it */
1570         if (signal_pending(current)) {
1571             ret = -ERESTARTSYS;
1572             break;
1573         }
1574         cprev = cnow;
1575     }
1576     __set_current_state(TASK_RUNNING);
1577     remove_wait_queue(&tiocmget->waitq, &wait);
1578
1579     return ret;
1580 }
1581
1582 /*
1583  * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
1584  * Return: write counters to the user passed counter struct
1585  * NB: both 1->0 and 0->1 transitions are counted except for
1586  *     RI where only 0->1 is counted.
1587  */
1588 static int hso_get_count(struct tty_struct *tty,
1589           struct serial_icounter_struct *icount)
1590 {
1591     struct uart_icount cnow;
1592     struct hso_serial *serial = tty->driver_data;
1593     struct hso_tiocmget  *tiocmget = serial->tiocmget;
1594
1595     memset(icount, 0, sizeof(struct serial_icounter_struct));
1596
1597     if (!tiocmget)
1598          return -ENOENT;
1599     spin_lock_irq(&serial->serial_lock);
1600     memcpy(&cnow, &tiocmget->icount, sizeof(struct uart_icount));
1601     spin_unlock_irq(&serial->serial_lock);
1602
1603     icount->cts         = cnow.cts;
1604     icount->dsr         = cnow.dsr;
1605     icount->rng         = cnow.rng;
1606     icount->dcd         = cnow.dcd;
1607     icount->rx          = cnow.rx;
1608     icount->tx          = cnow.tx;
1609     icount->frame       = cnow.frame;
1610     icount->overrun     = cnow.overrun;
1611     icount->parity      = cnow.parity;
1612     icount->brk         = cnow.brk;
1613     icount->buf_overrun = cnow.buf_overrun;
1614
1615     return 0;
1616 }
1617
1618
1619 static int hso_serial_tiocmget(struct tty_struct *tty)
1620 {
1621     int retval;
1622     struct hso_serial *serial = tty->driver_data;
1623     struct hso_tiocmget  *tiocmget;
1624     u16 UART_state_bitmap;
1625
1626     /* sanity check */
1627     if (!serial) {
1628         hso_dbg(0x1, "no tty structures\n");
1629         return -EINVAL;
1630     }
1631     spin_lock_irq(&serial->serial_lock);
1632     retval = ((serial->rts_state) ? TIOCM_RTS : 0) |
1633         ((serial->dtr_state) ? TIOCM_DTR : 0);
1634     tiocmget = serial->tiocmget;
1635     if (tiocmget) {
1636
1637         UART_state_bitmap = le16_to_cpu(
1638             tiocmget->prev_UART_state_bitmap);
1639         if (UART_state_bitmap & B_RING_SIGNAL)
1640             retval |=  TIOCM_RNG;
1641         if (UART_state_bitmap & B_RX_CARRIER)
1642             retval |=  TIOCM_CD;
1643         if (UART_state_bitmap & B_TX_CARRIER)
1644             retval |=  TIOCM_DSR;
1645     }
1646     spin_unlock_irq(&serial->serial_lock);
1647     return retval;
1648 }
1649
1650 static int hso_serial_tiocmset(struct tty_struct *tty,
1651                    unsigned int set, unsigned int clear)
1652 {
1653     int val = 0;
1654     unsigned long flags;
1655     int if_num;
1656     struct hso_serial *serial = tty->driver_data;
1657     struct usb_interface *interface;
1658
1659     /* sanity check */
1660     if (!serial) {
1661         hso_dbg(0x1, "no tty structures\n");
1662         return -EINVAL;
1663     }
1664
1665     if ((serial->parent->port_spec & HSO_PORT_MASK) != HSO_PORT_MODEM)
1666         return -EINVAL;
1667
1668     interface = serial->parent->interface;
1669     if_num = interface->cur_altsetting->desc.bInterfaceNumber;
1670
1671     spin_lock_irqsave(&serial->serial_lock, flags);
1672     if (set & TIOCM_RTS)
1673         serial->rts_state = 1;
1674     if (set & TIOCM_DTR)
1675         serial->dtr_state = 1;
1676
1677     if (clear & TIOCM_RTS)
1678         serial->rts_state = 0;
1679     if (clear & TIOCM_DTR)
1680         serial->dtr_state = 0;
1681
1682     if (serial->dtr_state)
1683         val |= 0x01;
1684     if (serial->rts_state)
1685         val |= 0x02;
1686
1687     spin_unlock_irqrestore(&serial->serial_lock, flags);
1688
1689     return usb_control_msg(serial->parent->usb,
1690                    usb_sndctrlpipe(serial->parent->usb, 0), 0x22,
1691                    0x21, val, if_num, NULL, 0,
1692                    USB_CTRL_SET_TIMEOUT);
1693 }
1694
1695 static int hso_serial_ioctl(struct tty_struct *tty,
1696                 unsigned int cmd, unsigned long arg)
1697 {
1698     struct hso_serial *serial = tty->driver_data;
1699     int ret = 0;
1700     hso_dbg(0x8, "IOCTL cmd: %d, arg: %ld\n", cmd, arg);
1701
1702     if (!serial)
1703         return -ENODEV;
1704     switch (cmd) {
1705     case TIOCMIWAIT:
1706         ret = hso_wait_modem_status(serial, arg);
1707         break;
1708     default:
1709         ret = -ENOIOCTLCMD;
1710         break;
1711     }
1712     return ret;
1713 }
1714
1715
1716 /* starts a transmit */
1717 static void hso_kick_transmit(struct hso_serial *serial)
1718 {
1719     unsigned long flags;
1720     int res;
1721
1722     spin_lock_irqsave(&serial->serial_lock, flags);
1723     if (!serial->tx_buffer_count)
1724         goto out;
1725
1726     if (serial->tx_urb_used)
1727         goto out;
1728
1729     /* Wakeup USB interface if necessary */
1730     if (hso_get_activity(serial->parent) == -EAGAIN)
1731         goto out;
1732
1733     /* Switch pointers around to avoid memcpy */
1734     swap(serial->tx_buffer, serial->tx_data);
1735     serial->tx_data_count = serial->tx_buffer_count;
1736     serial->tx_buffer_count = 0;
1737
1738     /* If serial->tx_data is set, it means we switched buffers */
1739     if (serial->tx_data && serial->write_data) {
1740         res = serial->write_data(serial);
1741         if (res >= 0)
1742             serial->tx_urb_used = 1;
1743     }
1744 out:
1745     spin_unlock_irqrestore(&serial->serial_lock, flags);
1746 }
1747
1748 /* make a request (for reading and writing data to muxed serial port) */
1749 static int mux_device_request(struct hso_serial *serial, u8 type, u16 port,
1750                   struct urb *ctrl_urb,
1751                   struct usb_ctrlrequest *ctrl_req,
1752                   u8 *ctrl_urb_data, u32 size)
1753 {
1754     int result;
1755     int pipe;
1756
1757     /* Sanity check */
1758     if (!serial || !ctrl_urb || !ctrl_req) {
1759         pr_err("%s: Wrong arguments\n", __func__);
1760         return -EINVAL;
1761     }
1762
1763     /* initialize */
1764     ctrl_req->wValue = 0;
1765     ctrl_req->wIndex = cpu_to_le16(hso_port_to_mux(port));
1766     ctrl_req->wLength = cpu_to_le16(size);
1767
1768     if (type == USB_CDC_GET_ENCAPSULATED_RESPONSE) {
1769         /* Reading command */
1770         ctrl_req->bRequestType = USB_DIR_IN |
1771                      USB_TYPE_OPTION_VENDOR |
1772                      USB_RECIP_INTERFACE;
1773         ctrl_req->bRequest = USB_CDC_GET_ENCAPSULATED_RESPONSE;
1774         pipe = usb_rcvctrlpipe(serial->parent->usb, 0);
1775     } else {
1776         /* Writing command */
1777         ctrl_req->bRequestType = USB_DIR_OUT |
1778                      USB_TYPE_OPTION_VENDOR |
1779                      USB_RECIP_INTERFACE;
1780         ctrl_req->bRequest = USB_CDC_SEND_ENCAPSULATED_COMMAND;
1781         pipe = usb_sndctrlpipe(serial->parent->usb, 0);
1782     }
1783     /* syslog */
1784     hso_dbg(0x2, "%s command (%02x) len: %d, port: %d\n",
1785         type == USB_CDC_GET_ENCAPSULATED_RESPONSE ? "Read" : "Write",
1786         ctrl_req->bRequestType, ctrl_req->wLength, port);
1787
1788     /* Load ctrl urb */
1789     ctrl_urb->transfer_flags = 0;
1790     usb_fill_control_urb(ctrl_urb,
1791                  serial->parent->usb,
1792                  pipe,
1793                  (u8 *) ctrl_req,
1794                  ctrl_urb_data, size, ctrl_callback, serial);
1795     /* Send it on merry way */
1796     result = usb_submit_urb(ctrl_urb, GFP_ATOMIC);
1797     if (result) {
1798         dev_err(&ctrl_urb->dev->dev,
1799             "%s failed submit ctrl_urb %d type %d\n", __func__,
1800             result, type);
1801         return result;
1802     }
1803
1804     /* done */
1805     return size;
1806 }
1807
1808 /* called by intr_callback when read occurs */
1809 static int hso_mux_serial_read(struct hso_serial *serial)
1810 {
1811     if (!serial)
1812         return -EINVAL;
1813
1814     /* clean data */
1815     memset(serial->rx_data[0], 0, CTRL_URB_RX_SIZE);
1816     /* make the request */
1817
1818     if (serial->num_rx_urbs != 1) {
1819         dev_err(&serial->parent->interface->dev,
1820             "ERROR: mux'd reads with multiple buffers "
1821             "not possible\n");
1822         return 0;
1823     }
1824     return mux_device_request(serial,
1825                   USB_CDC_GET_ENCAPSULATED_RESPONSE,
1826                   serial->parent->port_spec & HSO_PORT_MASK,
1827                   serial->rx_urb[0],
1828                   &serial->ctrl_req_rx,
1829                   serial->rx_data[0], serial->rx_data_length);
1830 }
1831
1832 /* used for muxed serial port callback (muxed serial read) */
1833 static void intr_callback(struct urb *urb)
1834 {
1835     struct hso_shared_int *shared_int = urb->context;
1836     struct hso_serial *serial;
1837     unsigned char *port_req;
1838     int status = urb->status;
1839     unsigned long flags;
1840     int i;
1841
1842     usb_mark_last_busy(urb->dev);
1843
1844     /* sanity check */
1845     if (!shared_int)
1846         return;
1847
1848     /* status check */
1849     if (status) {
1850         handle_usb_error(status, __func__, NULL);
1851         return;
1852     }
1853     hso_dbg(0x8, "--- Got intr callback 0x%02X ---\n", status);
1854
1855     /* what request? */
1856     port_req = urb->transfer_buffer;
1857     hso_dbg(0x8, "port_req = 0x%.2X\n", *port_req);
1858     /* loop over all muxed ports to find the one sending this */
1859     for (i = 0; i < 8; i++) {
1860         /* max 8 channels on MUX */
1861         if (*port_req & (1 << i)) {
1862             serial = get_serial_by_shared_int_and_type(shared_int,
1863                                    (1 << i));
1864             if (serial != NULL) {
1865                 hso_dbg(0x1, "Pending read interrupt on port %d\n",
1866                     i);
1867                 spin_lock_irqsave(&serial->serial_lock, flags);
1868                 if (serial->rx_state == RX_IDLE &&
1869                     serial->port.count > 0) {
1870                     /* Setup and send a ctrl req read on
1871                      * port i */
1872                     if (!serial->rx_urb_filled[0]) {
1873                         serial->rx_state = RX_SENT;
1874                         hso_mux_serial_read(serial);
1875                     } else
1876                         serial->rx_state = RX_PENDING;
1877                 } else {
1878                     hso_dbg(0x1, "Already a read pending on port %d or port not open\n",
1879                         i);
1880                 }
1881                 spin_unlock_irqrestore(&serial->serial_lock,
1882                                flags);
1883             }
1884         }
1885     }
1886     /* Resubmit interrupt urb */
1887     hso_mux_submit_intr_urb(shared_int, urb->dev, GFP_ATOMIC);
1888 }
1889
1890 /* called for writing to muxed serial port */
1891 static int hso_mux_serial_write_data(struct hso_serial *serial)
1892 {
1893     if (NULL == serial)
1894         return -EINVAL;
1895
1896     return mux_device_request(serial,
1897                   USB_CDC_SEND_ENCAPSULATED_COMMAND,
1898                   serial->parent->port_spec & HSO_PORT_MASK,
1899                   serial->tx_urb,
1900                   &serial->ctrl_req_tx,
1901                   serial->tx_data, serial->tx_data_count);
1902 }
1903
1904 /* write callback for Diag and CS port */
1905 static void hso_std_serial_write_bulk_callback(struct urb *urb)
1906 {
1907     struct hso_serial *serial = urb->context;
1908     int status = urb->status;
1909     unsigned long flags;
1910
1911     /* sanity check */
1912     if (!serial) {
1913         hso_dbg(0x1, "serial == NULL\n");
1914         return;
1915     }
1916
1917     spin_lock_irqsave(&serial->serial_lock, flags);
1918     serial->tx_urb_used = 0;
1919     spin_unlock_irqrestore(&serial->serial_lock, flags);
1920     if (status) {
1921         handle_usb_error(status, __func__, serial->parent);
1922         return;
1923     }
1924     hso_put_activity(serial->parent);
1925     tty_port_tty_wakeup(&serial->port);
1926     hso_kick_transmit(serial);
1927
1928     hso_dbg(0x1, "\n");
1929 }
1930
1931 /* called for writing diag or CS serial port */
1932 static int hso_std_serial_write_data(struct hso_serial *serial)
1933 {
1934     int count = serial->tx_data_count;
1935     int result;
1936
1937     usb_fill_bulk_urb(serial->tx_urb,
1938               serial->parent->usb,
1939               usb_sndbulkpipe(serial->parent->usb,
1940                       serial->out_endp->
1941                       bEndpointAddress & 0x7F),
1942               serial->tx_data, serial->tx_data_count,
1943               hso_std_serial_write_bulk_callback, serial);
1944
1945     result = usb_submit_urb(serial->tx_urb, GFP_ATOMIC);
1946     if (result) {
1947         dev_warn(&serial->parent->usb->dev,
1948              "Failed to submit urb - res %d\n", result);
1949         return result;
1950     }
1951
1952     return count;
1953 }
1954
1955 /* callback after read or write on muxed serial port */
1956 static void ctrl_callback(struct urb *urb)
1957 {
1958     struct hso_serial *serial = urb->context;
1959     struct usb_ctrlrequest *req;
1960     int status = urb->status;
1961     unsigned long flags;
1962
1963     /* sanity check */
1964     if (!serial)
1965         return;
1966
1967     spin_lock_irqsave(&serial->serial_lock, flags);
1968     serial->tx_urb_used = 0;
1969     spin_unlock_irqrestore(&serial->serial_lock, flags);
1970     if (status) {
1971         handle_usb_error(status, __func__, serial->parent);
1972         return;
1973     }
1974
1975     /* what request? */
1976     req = (struct usb_ctrlrequest *)(urb->setup_packet);
1977     hso_dbg(0x8, "--- Got muxed ctrl callback 0x%02X ---\n", status);
1978     hso_dbg(0x8, "Actual length of urb = %d\n", urb->actual_length);
1979     DUMP1(urb->transfer_buffer, urb->actual_length);
1980
1981     if (req->bRequestType ==
1982         (USB_DIR_IN | USB_TYPE_OPTION_VENDOR | USB_RECIP_INTERFACE)) {
1983         /* response to a read command */
1984         serial->rx_urb_filled[0] = 1;
1985         spin_lock_irqsave(&serial->serial_lock, flags);
1986         put_rxbuf_data_and_resubmit_ctrl_urb(serial);
1987         spin_unlock_irqrestore(&serial->serial_lock, flags);
1988     } else {
1989         hso_put_activity(serial->parent);
1990         tty_port_tty_wakeup(&serial->port);
1991         /* response to a write command */
1992         hso_kick_transmit(serial);
1993     }
1994 }
1995
1996 /* handle RX data for serial port */
1997 static int put_rxbuf_data(struct urb *urb, struct hso_serial *serial)
1998 {
1999     struct tty_struct *tty;
2000     int count;
2001
2002     /* Sanity check */
2003     if (urb == NULL || serial == NULL) {
2004         hso_dbg(0x1, "serial = NULL\n");
2005         return -2;
2006     }
2007
2008     tty = tty_port_tty_get(&serial->port);
2009
2010     if (tty && tty_throttled(tty)) {
2011         tty_kref_put(tty);
2012         return -1;
2013     }
2014
2015     /* Push data to tty */
2016     hso_dbg(0x1, "data to push to tty\n");
2017     count = tty_buffer_request_room(&serial->port, urb->actual_length);
2018     if (count >= urb->actual_length) {
2019         tty_insert_flip_string(&serial->port, urb->transfer_buffer,
2020                        urb->actual_length);
2021         tty_flip_buffer_push(&serial->port);
2022     } else {
2023         dev_warn(&serial->parent->usb->dev,
2024              "dropping data, %d bytes lost\n", urb->actual_length);
2025     }
2026
2027     tty_kref_put(tty);
2028
2029     serial->rx_urb_filled[hso_urb_to_index(serial, urb)] = 0;
2030
2031     return 0;
2032 }
2033
2034
2035 /* Base driver functions */
2036
2037 static void hso_log_port(struct hso_device *hso_dev)
2038 {
2039     char *port_type;
2040     char port_dev[20];
2041
2042     switch (hso_dev->port_spec & HSO_PORT_MASK) {
2043     case HSO_PORT_CONTROL:
2044         port_type = "Control";
2045         break;
2046     case HSO_PORT_APP:
2047         port_type = "Application";
2048         break;
2049     case HSO_PORT_GPS:
2050         port_type = "GPS";
2051         break;
2052     case HSO_PORT_GPS_CONTROL:
2053         port_type = "GPS control";
2054         break;
2055     case HSO_PORT_APP2:
2056         port_type = "Application2";
2057         break;
2058     case HSO_PORT_PCSC:
2059         port_type = "PCSC";
2060         break;
2061     case HSO_PORT_DIAG:
2062         port_type = "Diagnostic";
2063         break;
2064     case HSO_PORT_DIAG2:
2065         port_type = "Diagnostic2";
2066         break;
2067     case HSO_PORT_MODEM:
2068         port_type = "Modem";
2069         break;
2070     case HSO_PORT_NETWORK:
2071         port_type = "Network";
2072         break;
2073     default:
2074         port_type = "Unknown";
2075         break;
2076     }
2077     if ((hso_dev->port_spec & HSO_PORT_MASK) == HSO_PORT_NETWORK) {
2078         sprintf(port_dev, "%s", dev2net(hso_dev)->net->name);
2079     } else
2080         sprintf(port_dev, "/dev/%s%d", tty_filename,
2081             dev2ser(hso_dev)->minor);
2082
2083     dev_dbg(&hso_dev->interface->dev, "HSO: Found %s port %s\n",
2084         port_type, port_dev);
2085 }
2086
2087 static int hso_start_net_device(struct hso_device *hso_dev)
2088 {
2089     int i, result = 0;
2090     struct hso_net *hso_net = dev2net(hso_dev);
2091
2092     if (!hso_net)
2093         return -ENODEV;
2094
2095     /* send URBs for all read buffers */
2096     for (i = 0; i < MUX_BULK_RX_BUF_COUNT; i++) {
2097
2098         /* Prep a receive URB */
2099         usb_fill_bulk_urb(hso_net->mux_bulk_rx_urb_pool[i],
2100                   hso_dev->usb,
2101                   usb_rcvbulkpipe(hso_dev->usb,
2102                           hso_net->in_endp->
2103                           bEndpointAddress & 0x7F),
2104                   hso_net->mux_bulk_rx_buf_pool[i],
2105                   MUX_BULK_RX_BUF_SIZE, read_bulk_callback,
2106                   hso_net);
2107
2108         /* Put it out there so the device can send us stuff */
2109         result = usb_submit_urb(hso_net->mux_bulk_rx_urb_pool[i],
2110                     GFP_NOIO);
2111         if (result)
2112             dev_warn(&hso_dev->usb->dev,
2113                 "%s failed mux_bulk_rx_urb[%d] %d\n", __func__,
2114                 i, result);
2115     }
2116
2117     return result;
2118 }
2119
2120 static int hso_stop_net_device(struct hso_device *hso_dev)
2121 {
2122     int i;
2123     struct hso_net *hso_net = dev2net(hso_dev);
2124
2125     if (!hso_net)
2126         return -ENODEV;
2127
2128     for (i = 0; i < MUX_BULK_RX_BUF_COUNT; i++) {
2129         if (hso_net->mux_bulk_rx_urb_pool[i])
2130             usb_kill_urb(hso_net->mux_bulk_rx_urb_pool[i]);
2131
2132     }
2133     if (hso_net->mux_bulk_tx_urb)
2134         usb_kill_urb(hso_net->mux_bulk_tx_urb);
2135
2136     return 0;
2137 }
2138
2139 static int hso_start_serial_device(struct hso_device *hso_dev, gfp_t flags)
2140 {
2141     int i, result = 0;
2142     struct hso_serial *serial = dev2ser(hso_dev);
2143
2144     if (!serial)
2145         return -ENODEV;
2146
2147     /* If it is not the MUX port fill in and submit a bulk urb (already
2148      * allocated in hso_serial_start) */
2149     if (!(serial->parent->port_spec & HSO_INTF_MUX)) {
2150         for (i = 0; i < serial->num_rx_urbs; i++) {
2151             usb_fill_bulk_urb(serial->rx_urb[i],
2152                       serial->parent->usb,
2153                       usb_rcvbulkpipe(serial->parent->usb,
2154                               serial->in_endp->
2155                               bEndpointAddress &
2156                               0x7F),
2157                       serial->rx_data[i],
2158                       serial->rx_data_length,
2159                       hso_std_serial_read_bulk_callback,
2160                       serial);
2161             result = usb_submit_urb(serial->rx_urb[i], flags);
2162             if (result) {
2163                 dev_warn(&serial->parent->usb->dev,
2164                      "Failed to submit urb - res %d\n",
2165                      result);
2166                 break;
2167             }
2168         }
2169     } else {
2170         mutex_lock(&serial->shared_int->shared_int_lock);
2171         if (!serial->shared_int->use_count) {
2172             result =
2173                 hso_mux_submit_intr_urb(serial->shared_int,
2174                             hso_dev->usb, flags);
2175         }
2176         serial->shared_int->use_count++;
2177         mutex_unlock(&serial->shared_int->shared_int_lock);
2178     }
2179     if (serial->tiocmget)
2180         tiocmget_submit_urb(serial,
2181                     serial->tiocmget,
2182                     serial->parent->usb);
2183     return result;
2184 }
2185
2186 static int hso_stop_serial_device(struct hso_device *hso_dev)
2187 {
2188     int i;
2189     struct hso_serial *serial = dev2ser(hso_dev);
2190     struct hso_tiocmget  *tiocmget;
2191
2192     if (!serial)
2193         return -ENODEV;
2194
2195     for (i = 0; i < serial->num_rx_urbs; i++) {
2196         if (serial->rx_urb[i]) {
2197             usb_kill_urb(serial->rx_urb[i]);
2198             serial->rx_urb_filled[i] = 0;
2199         }
2200     }
2201     serial->curr_rx_urb_idx = 0;
2202
2203     if (serial->tx_urb)
2204         usb_kill_urb(serial->tx_urb);
2205
2206     if (serial->shared_int) {
2207         mutex_lock(&serial->shared_int->shared_int_lock);
2208         if (serial->shared_int->use_count &&
2209             (--serial->shared_int->use_count == 0)) {
2210             struct urb *urb;
2211
2212             urb = serial->shared_int->shared_intr_urb;
2213             if (urb)
2214                 usb_kill_urb(urb);
2215         }
2216         mutex_unlock(&serial->shared_int->shared_int_lock);
2217     }
2218     tiocmget = serial->tiocmget;
2219     if (tiocmget) {
2220         wake_up_interruptible(&tiocmget->waitq);
2221         usb_kill_urb(tiocmget->urb);
2222     }
2223
2224     return 0;
2225 }
2226
2227 static void hso_serial_tty_unregister(struct hso_serial *serial)
2228 {
2229     tty_unregister_device(tty_drv, serial->minor);
2230     release_minor(serial);
2231 }
2232
2233 static void hso_serial_common_free(struct hso_serial *serial)
2234 {
2235     int i;
2236
2237     for (i = 0; i < serial->num_rx_urbs; i++) {
2238         /* unlink and free RX URB */
2239         usb_free_urb(serial->rx_urb[i]);
2240         /* free the RX buffer */
2241         kfree(serial->rx_data[i]);
2242     }
2243
2244     /* unlink and free TX URB */
2245     usb_free_urb(serial->tx_urb);
2246     kfree(serial->tx_buffer);
2247     kfree(serial->tx_data);
2248     tty_port_destroy(&serial->port);
2249 }
2250
2251 static int hso_serial_common_create(struct hso_serial *serial, int num_urbs,
2252                     int rx_size, int tx_size)
2253 {
2254     int i;
2255
2256     tty_port_init(&serial->port);
2257
2258     if (obtain_minor(serial))
2259         goto exit2;
2260
2261     /* register our minor number */
2262     serial->parent->dev = tty_port_register_device_attr(&serial->port,
2263             tty_drv, serial->minor, &serial->parent->interface->dev,
2264             serial->parent, hso_serial_dev_groups);
2265     if (IS_ERR(serial->parent->dev)) {
2266         release_minor(serial);
2267         goto exit2;
2268     }
2269
2270     serial->magic = HSO_SERIAL_MAGIC;
2271     spin_lock_init(&serial->serial_lock);
2272     serial->num_rx_urbs = num_urbs;
2273
2274     /* RX, allocate urb and initialize */
2275
2276     /* prepare our RX buffer */
2277     serial->rx_data_length = rx_size;
2278     for (i = 0; i < serial->num_rx_urbs; i++) {
2279         serial->rx_urb[i] = usb_alloc_urb(0, GFP_KERNEL);
2280         if (!serial->rx_urb[i])
2281             goto exit;
2282         serial->rx_urb[i]->transfer_buffer = NULL;
2283         serial->rx_urb[i]->transfer_buffer_length = 0;
2284         serial->rx_data[i] = kzalloc(serial->rx_data_length,
2285                          GFP_KERNEL);
2286         if (!serial->rx_data[i])
2287             goto exit;
2288     }
2289
2290     /* TX, allocate urb and initialize */
2291     serial->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
2292     if (!serial->tx_urb)
2293         goto exit;
2294     serial->tx_urb->transfer_buffer = NULL;
2295     serial->tx_urb->transfer_buffer_length = 0;
2296     /* prepare our TX buffer */
2297     serial->tx_data_count = 0;
2298     serial->tx_buffer_count = 0;
2299     serial->tx_data_length = tx_size;
2300     serial->tx_data = kzalloc(serial->tx_data_length, GFP_KERNEL);
2301     if (!serial->tx_data)
2302         goto exit;
2303
2304     serial->tx_buffer = kzalloc(serial->tx_data_length, GFP_KERNEL);
2305     if (!serial->tx_buffer)
2306         goto exit;
2307
2308     return 0;
2309 exit:
2310     hso_serial_tty_unregister(serial);
2311 exit2:
2312     hso_serial_common_free(serial);
2313     return -1;
2314 }
2315
2316 /* Creates a general hso device */
2317 static struct hso_device *hso_create_device(struct usb_interface *intf,
2318                         int port_spec)
2319 {
2320     struct hso_device *hso_dev;
2321
2322     hso_dev = kzalloc(sizeof(*hso_dev), GFP_KERNEL);
2323     if (!hso_dev)
2324         return NULL;
2325
2326     hso_dev->port_spec = port_spec;
2327     hso_dev->usb = interface_to_usbdev(intf);
2328     hso_dev->interface = intf;
2329     kref_init(&hso_dev->ref);
2330     mutex_init(&hso_dev->mutex);
2331
2332     INIT_WORK(&hso_dev->async_get_intf, async_get_intf);
2333     INIT_WORK(&hso_dev->async_put_intf, async_put_intf);
2334
2335     return hso_dev;
2336 }
2337
2338 /* Removes a network device in the network device table */
2339 static int remove_net_device(struct hso_device *hso_dev)
2340 {
2341     int i;
2342
2343     for (i = 0; i < HSO_MAX_NET_DEVICES; i++) {
2344         if (network_table[i] == hso_dev) {
2345             network_table[i] = NULL;
2346             break;
2347         }
2348     }
2349     if (i == HSO_MAX_NET_DEVICES)
2350         return -1;
2351     return 0;
2352 }
2353
2354 /* Frees our network device */
2355 static void hso_free_net_device(struct hso_device *hso_dev)
2356 {
2357     int i;
2358     struct hso_net *hso_net = dev2net(hso_dev);
2359
2360     if (!hso_net)
2361         return;
2362
2363     remove_net_device(hso_net->parent);
2364
2365     if (hso_net->net)
2366         unregister_netdev(hso_net->net);
2367
2368     /* start freeing */
2369     for (i = 0; i < MUX_BULK_RX_BUF_COUNT; i++) {
2370         usb_free_urb(hso_net->mux_bulk_rx_urb_pool[i]);
2371         kfree(hso_net->mux_bulk_rx_buf_pool[i]);
2372         hso_net->mux_bulk_rx_buf_pool[i] = NULL;
2373     }
2374     usb_free_urb(hso_net->mux_bulk_tx_urb);
2375     kfree(hso_net->mux_bulk_tx_buf);
2376     hso_net->mux_bulk_tx_buf = NULL;
2377
2378     if (hso_net->net)
2379         free_netdev(hso_net->net);
2380
2381     kfree(hso_dev);
2382 }
2383
2384 static const struct net_device_ops hso_netdev_ops = {
2385     .ndo_open   = hso_net_open,
2386     .ndo_stop   = hso_net_close,
2387     .ndo_start_xmit = hso_net_start_xmit,
2388     .ndo_tx_timeout = hso_net_tx_timeout,
2389 };
2390
2391 /* initialize the network interface */
2392 static void hso_net_init(struct net_device *net)
2393 {
2394     struct hso_net *hso_net = netdev_priv(net);
2395
2396     hso_dbg(0x1, "sizeof hso_net is %zu\n", sizeof(*hso_net));
2397
2398     /* fill in the other fields */
2399     net->netdev_ops = &hso_netdev_ops;
2400     net->watchdog_timeo = HSO_NET_TX_TIMEOUT;
2401     net->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
2402     net->type = ARPHRD_NONE;
2403     net->mtu = DEFAULT_MTU - 14;
2404     net->tx_queue_len = 10;
2405     net->ethtool_ops = &ops;
2406
2407     /* and initialize the semaphore */
2408     spin_lock_init(&hso_net->net_lock);
2409 }
2410
2411 /* Adds a network device in the network device table */
2412 static int add_net_device(struct hso_device *hso_dev)
2413 {
2414     int i;
2415
2416     for (i = 0; i < HSO_MAX_NET_DEVICES; i++) {
2417         if (network_table[i] == NULL) {
2418             network_table[i] = hso_dev;
2419             break;
2420         }
2421     }
2422     if (i == HSO_MAX_NET_DEVICES)
2423         return -1;
2424     return 0;
2425 }
2426
2427 static int hso_rfkill_set_block(void *data, bool blocked)
2428 {
2429     struct hso_device *hso_dev = data;
2430     int enabled = !blocked;
2431     int rv;
2432
2433     mutex_lock(&hso_dev->mutex);
2434     if (hso_dev->usb_gone)
2435         rv = 0;
2436     else
2437         rv = usb_control_msg(hso_dev->usb, usb_sndctrlpipe(hso_dev->usb, 0),
2438                        enabled ? 0x82 : 0x81, 0x40, 0, 0, NULL, 0,
2439                        USB_CTRL_SET_TIMEOUT);
2440     mutex_unlock(&hso_dev->mutex);
2441     return rv;
2442 }
2443
2444 static const struct rfkill_ops hso_rfkill_ops = {
2445     .set_block = hso_rfkill_set_block,
2446 };
2447
2448 /* Creates and sets up everything for rfkill */
2449 static void hso_create_rfkill(struct hso_device *hso_dev,
2450                  struct usb_interface *interface)
2451 {
2452     struct hso_net *hso_net = dev2net(hso_dev);
2453     struct device *dev = &hso_net->net->dev;
2454     static u32 rfkill_counter;
2455
2456     snprintf(hso_net->name, sizeof(hso_net->name), "hso-%d",
2457          rfkill_counter++);
2458
2459     hso_net->rfkill = rfkill_alloc(hso_net->name,
2460                        &interface_to_usbdev(interface)->dev,
2461                        RFKILL_TYPE_WWAN,
2462                        &hso_rfkill_ops, hso_dev);
2463     if (!hso_net->rfkill)
2464         return;
2465
2466     if (rfkill_register(hso_net->rfkill) < 0) {
2467         rfkill_destroy(hso_net->rfkill);
2468         hso_net->rfkill = NULL;
2469         dev_err(dev, "%s - Failed to register rfkill\n", __func__);
2470         return;
2471     }
2472 }
2473
2474 static struct device_type hso_type = {
2475     .name   = "wwan",
2476 };
2477
2478 /* Creates our network device */
2479 static struct hso_device *hso_create_net_device(struct usb_interface *interface,
2480                         int port_spec)
2481 {
2482     int result, i;
2483     struct net_device *net;
2484     struct hso_net *hso_net;
2485     struct hso_device *hso_dev;
2486
2487     hso_dev = hso_create_device(interface, port_spec);
2488     if (!hso_dev)
2489         return NULL;
2490
2491     /* allocate our network device, then we can put in our private data */
2492     /* call hso_net_init to do the basic initialization */
2493     net = alloc_netdev(sizeof(struct hso_net), "hso%d", NET_NAME_UNKNOWN,
2494                hso_net_init);
2495     if (!net) {
2496         dev_err(&interface->dev, "Unable to create ethernet device\n");
2497         goto err_hso_dev;
2498     }
2499
2500     hso_net = netdev_priv(net);
2501
2502     hso_dev->port_data.dev_net = hso_net;
2503     hso_net->net = net;
2504     hso_net->parent = hso_dev;
2505
2506     hso_net->in_endp = hso_get_ep(interface, USB_ENDPOINT_XFER_BULK,
2507                       USB_DIR_IN);
2508     if (!hso_net->in_endp) {
2509         dev_err(&interface->dev, "Can't find BULK IN endpoint\n");
2510         goto err_net;
2511     }
2512     hso_net->out_endp = hso_get_ep(interface, USB_ENDPOINT_XFER_BULK,
2513                        USB_DIR_OUT);
2514     if (!hso_net->out_endp) {
2515         dev_err(&interface->dev, "Can't find BULK OUT endpoint\n");
2516         goto err_net;
2517     }
2518     SET_NETDEV_DEV(net, &interface->dev);
2519     SET_NETDEV_DEVTYPE(net, &hso_type);
2520
2521     /* start allocating */
2522     for (i = 0; i < MUX_BULK_RX_BUF_COUNT; i++) {
2523         hso_net->mux_bulk_rx_urb_pool[i] = usb_alloc_urb(0, GFP_KERNEL);
2524         if (!hso_net->mux_bulk_rx_urb_pool[i])
2525             goto err_mux_bulk_rx;
2526         hso_net->mux_bulk_rx_buf_pool[i] = kzalloc(MUX_BULK_RX_BUF_SIZE,
2527                                GFP_KERNEL);
2528         if (!hso_net->mux_bulk_rx_buf_pool[i])
2529             goto err_mux_bulk_rx;
2530     }
2531     hso_net->mux_bulk_tx_urb = usb_alloc_urb(0, GFP_KERNEL);
2532     if (!hso_net->mux_bulk_tx_urb)
2533         goto err_mux_bulk_rx;
2534     hso_net->mux_bulk_tx_buf = kzalloc(MUX_BULK_TX_BUF_SIZE, GFP_KERNEL);
2535     if (!hso_net->mux_bulk_tx_buf)
2536         goto err_free_tx_urb;
2537
2538     result = add_net_device(hso_dev);
2539     if (result) {
2540         dev_err(&interface->dev, "Failed to add net device\n");
2541         goto err_free_tx_buf;
2542     }
2543
2544     /* registering our net device */
2545     result = register_netdev(net);
2546     if (result) {
2547         dev_err(&interface->dev, "Failed to register device\n");
2548         goto err_rmv_ndev;
2549     }
2550
2551     hso_log_port(hso_dev);
2552
2553     hso_create_rfkill(hso_dev, interface);
2554
2555     return hso_dev;
2556
2557 err_rmv_ndev:
2558     remove_net_device(hso_dev);
2559 err_free_tx_buf:
2560     kfree(hso_net->mux_bulk_tx_buf);
2561 err_free_tx_urb:
2562     usb_free_urb(hso_net->mux_bulk_tx_urb);
2563 err_mux_bulk_rx:
2564     for (i = 0; i < MUX_BULK_RX_BUF_COUNT; i++) {
2565         usb_free_urb(hso_net->mux_bulk_rx_urb_pool[i]);
2566         kfree(hso_net->mux_bulk_rx_buf_pool[i]);
2567     }
2568 err_net:
2569     free_netdev(net);
2570 err_hso_dev:
2571     kfree(hso_dev);
2572     return NULL;
2573 }
2574
2575 static void hso_free_tiomget(struct hso_serial *serial)
2576 {
2577     struct hso_tiocmget *tiocmget;
2578     if (!serial)
2579         return;
2580     tiocmget = serial->tiocmget;
2581     if (tiocmget) {
2582         usb_free_urb(tiocmget->urb);
2583         tiocmget->urb = NULL;
2584         serial->tiocmget = NULL;
2585         kfree(tiocmget->serial_state_notification);
2586         tiocmget->serial_state_notification = NULL;
2587         kfree(tiocmget);
2588     }
2589 }
2590
2591 /* Frees an AT channel ( goes for both mux and non-mux ) */
2592 static void hso_free_serial_device(struct hso_device *hso_dev)
2593 {
2594     struct hso_serial *serial = dev2ser(hso_dev);
2595
2596     if (!serial)
2597         return;
2598
2599     hso_serial_common_free(serial);
2600
2601     if (serial->shared_int) {
2602         mutex_lock(&serial->shared_int->shared_int_lock);
2603         if (--serial->shared_int->ref_count == 0)
2604             hso_free_shared_int(serial->shared_int);
2605         else
2606             mutex_unlock(&serial->shared_int->shared_int_lock);
2607     }
2608     hso_free_tiomget(serial);
2609     kfree(serial);
2610     kfree(hso_dev);
2611 }
2612
2613 /* Creates a bulk AT channel */
2614 static struct hso_device *hso_create_bulk_serial_device(
2615             struct usb_interface *interface, int port)
2616 {
2617     struct hso_device *hso_dev;
2618     struct hso_serial *serial;
2619     int num_urbs;
2620     struct hso_tiocmget *tiocmget;
2621
2622     hso_dev = hso_create_device(interface, port);
2623     if (!hso_dev)
2624         return NULL;
2625
2626     serial = kzalloc(sizeof(*serial), GFP_KERNEL);
2627     if (!serial)
2628         goto exit;
2629
2630     serial->parent = hso_dev;
2631     hso_dev->port_data.dev_serial = serial;
2632
2633     if ((port & HSO_PORT_MASK) == HSO_PORT_MODEM) {
2634         num_urbs = 2;
2635         serial->tiocmget = kzalloc(sizeof(struct hso_tiocmget),
2636                        GFP_KERNEL);
2637         if (!serial->tiocmget)
2638             goto exit;
2639         serial->tiocmget->serial_state_notification
2640             = kzalloc(sizeof(struct hso_serial_state_notification),
2641                        GFP_KERNEL);
2642         if (!serial->tiocmget->serial_state_notification)
2643             goto exit;
2644         tiocmget = serial->tiocmget;
2645         tiocmget->endp = hso_get_ep(interface,
2646                         USB_ENDPOINT_XFER_INT,
2647                         USB_DIR_IN);
2648         if (!tiocmget->endp) {
2649             dev_err(&interface->dev, "Failed to find INT IN ep\n");
2650             goto exit;
2651         }
2652
2653         tiocmget->urb = usb_alloc_urb(0, GFP_KERNEL);
2654         if (!tiocmget->urb)
2655             goto exit;
2656
2657         mutex_init(&tiocmget->mutex);
2658         init_waitqueue_head(&tiocmget->waitq);
2659     } else {
2660         num_urbs = 1;
2661     }
2662
2663     if (hso_serial_common_create(serial, num_urbs, BULK_URB_RX_SIZE,
2664                      BULK_URB_TX_SIZE))
2665         goto exit;
2666
2667     serial->in_endp = hso_get_ep(interface, USB_ENDPOINT_XFER_BULK,
2668                      USB_DIR_IN);
2669     if (!serial->in_endp) {
2670         dev_err(&interface->dev, "Failed to find BULK IN ep\n");
2671         goto exit2;
2672     }
2673
2674     if (!
2675         (serial->out_endp =
2676          hso_get_ep(interface, USB_ENDPOINT_XFER_BULK, USB_DIR_OUT))) {
2677         dev_err(&interface->dev, "Failed to find BULK OUT ep\n");
2678         goto exit2;
2679     }
2680
2681     serial->write_data = hso_std_serial_write_data;
2682
2683     /* setup the proc dirs and files if needed */
2684     hso_log_port(hso_dev);
2685
2686     /* done, return it */
2687     return hso_dev;
2688
2689 exit2:
2690     hso_serial_tty_unregister(serial);
2691     hso_serial_common_free(serial);
2692 exit:
2693     hso_free_tiomget(serial);
2694     kfree(serial);
2695     kfree(hso_dev);
2696     return NULL;
2697 }
2698
2699 /* Creates a multiplexed AT channel */
2700 static
2701 struct hso_device *hso_create_mux_serial_device(struct usb_interface *interface,
2702                         int port,
2703                         struct hso_shared_int *mux)
2704 {
2705     struct hso_device *hso_dev;
2706     struct hso_serial *serial;
2707     int port_spec;
2708
2709     port_spec = HSO_INTF_MUX;
2710     port_spec &= ~HSO_PORT_MASK;
2711
2712     port_spec |= hso_mux_to_port(port);
2713     if ((port_spec & HSO_PORT_MASK) == HSO_PORT_NO_PORT)
2714         return NULL;
2715
2716     hso_dev = hso_create_device(interface, port_spec);
2717     if (!hso_dev)
2718         return NULL;
2719
2720     serial = kzalloc(sizeof(*serial), GFP_KERNEL);
2721     if (!serial)
2722         goto err_free_dev;
2723
2724     hso_dev->port_data.dev_serial = serial;
2725     serial->parent = hso_dev;
2726
2727     if (hso_serial_common_create
2728         (serial, 1, CTRL_URB_RX_SIZE, CTRL_URB_TX_SIZE))
2729         goto err_free_serial;
2730
2731     serial->tx_data_length--;
2732     serial->write_data = hso_mux_serial_write_data;
2733
2734     serial->shared_int = mux;
2735     mutex_lock(&serial->shared_int->shared_int_lock);
2736     serial->shared_int->ref_count++;
2737     mutex_unlock(&serial->shared_int->shared_int_lock);
2738
2739     /* setup the proc dirs and files if needed */
2740     hso_log_port(hso_dev);
2741
2742     /* done, return it */
2743     return hso_dev;
2744
2745 err_free_serial:
2746     kfree(serial);
2747 err_free_dev:
2748     kfree(hso_dev);
2749     return NULL;
2750
2751 }
2752
2753 static void hso_free_shared_int(struct hso_shared_int *mux)
2754 {
2755     usb_free_urb(mux->shared_intr_urb);
2756     kfree(mux->shared_intr_buf);
2757     mutex_unlock(&mux->shared_int_lock);
2758     kfree(mux);
2759 }
2760
2761 static
2762 struct hso_shared_int *hso_create_shared_int(struct usb_interface *interface)
2763 {
2764     struct hso_shared_int *mux = kzalloc(sizeof(*mux), GFP_KERNEL);
2765
2766     if (!mux)
2767         return NULL;
2768
2769     mux->intr_endp = hso_get_ep(interface, USB_ENDPOINT_XFER_INT,
2770                     USB_DIR_IN);
2771     if (!mux->intr_endp) {
2772         dev_err(&interface->dev, "Can't find INT IN endpoint\n");
2773         goto exit;
2774     }
2775
2776     mux->shared_intr_urb = usb_alloc_urb(0, GFP_KERNEL);
2777     if (!mux->shared_intr_urb)
2778         goto exit;
2779     mux->shared_intr_buf =
2780         kzalloc(le16_to_cpu(mux->intr_endp->wMaxPacketSize),
2781             GFP_KERNEL);
2782     if (!mux->shared_intr_buf)
2783         goto exit;
2784
2785     mutex_init(&mux->shared_int_lock);
2786
2787     return mux;
2788
2789 exit:
2790     kfree(mux->shared_intr_buf);
2791     usb_free_urb(mux->shared_intr_urb);
2792     kfree(mux);
2793     return NULL;
2794 }
2795
2796 /* Gets the port spec for a certain interface */
2797 static int hso_get_config_data(struct usb_interface *interface)
2798 {
2799     struct usb_device *usbdev = interface_to_usbdev(interface);
2800     u8 *config_data = kmalloc(17, GFP_KERNEL);
2801     u32 if_num = interface->cur_altsetting->desc.bInterfaceNumber;
2802     s32 result;
2803
2804     if (!config_data)
2805         return -ENOMEM;
2806     if (usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0),
2807                 0x86, 0xC0, 0, 0, config_data, 17,
2808                 USB_CTRL_SET_TIMEOUT) != 0x11) {
2809         kfree(config_data);
2810         return -EIO;
2811     }
2812
2813     /* check if we have a valid interface */
2814     if (if_num > 16) {
2815         kfree(config_data);
2816         return -EINVAL;
2817     }
2818
2819     switch (config_data[if_num]) {
2820     case 0x0:
2821         result = 0;
2822         break;
2823     case 0x1:
2824         result = HSO_PORT_DIAG;
2825         break;
2826     case 0x2:
2827         result = HSO_PORT_GPS;
2828         break;
2829     case 0x3:
2830         result = HSO_PORT_GPS_CONTROL;
2831         break;
2832     case 0x4:
2833         result = HSO_PORT_APP;
2834         break;
2835     case 0x5:
2836         result = HSO_PORT_APP2;
2837         break;
2838     case 0x6:
2839         result = HSO_PORT_CONTROL;
2840         break;
2841     case 0x7:
2842         result = HSO_PORT_NETWORK;
2843         break;
2844     case 0x8:
2845         result = HSO_PORT_MODEM;
2846         break;
2847     case 0x9:
2848         result = HSO_PORT_MSD;
2849         break;
2850     case 0xa:
2851         result = HSO_PORT_PCSC;
2852         break;
2853     case 0xb:
2854         result = HSO_PORT_VOICE;
2855         break;
2856     default:
2857         result = 0;
2858     }
2859
2860     if (result)
2861         result |= HSO_INTF_BULK;
2862
2863     if (config_data[16] & 0x1)
2864         result |= HSO_INFO_CRC_BUG;
2865
2866     kfree(config_data);
2867     return result;
2868 }
2869
2870 /* called once for each interface upon device insertion */
2871 static int hso_probe(struct usb_interface *interface,
2872              const struct usb_device_id *id)
2873 {
2874     int mux, i, if_num, port_spec;
2875     unsigned char port_mask;
2876     struct hso_device *hso_dev = NULL;
2877     struct hso_shared_int *shared_int;
2878     struct hso_device *tmp_dev = NULL;
2879
2880     if (interface->cur_altsetting->desc.bInterfaceClass != 0xFF) {
2881         dev_err(&interface->dev, "Not our interface\n");
2882         return -ENODEV;
2883     }
2884
2885     if_num = interface->cur_altsetting->desc.bInterfaceNumber;
2886
2887     /* Get the interface/port specification from either driver_info or from
2888      * the device itself */
2889     if (id->driver_info) {
2890         /* if_num is controlled by the device, driver_info is a 0 terminated
2891          * array. Make sure, the access is in bounds! */
2892         for (i = 0; i <= if_num; ++i)
2893             if (((u32 *)(id->driver_info))[i] == 0)
2894                 goto exit;
2895         port_spec = ((u32 *)(id->driver_info))[if_num];
2896     } else {
2897         port_spec = hso_get_config_data(interface);
2898         if (port_spec < 0)
2899             goto exit;
2900     }
2901
2902     /* Check if we need to switch to alt interfaces prior to port
2903      * configuration */
2904     if (interface->num_altsetting > 1)
2905         usb_set_interface(interface_to_usbdev(interface), if_num, 1);
2906     interface->needs_remote_wakeup = 1;
2907
2908     /* Allocate new hso device(s) */
2909     switch (port_spec & HSO_INTF_MASK) {
2910     case HSO_INTF_MUX:
2911         if ((port_spec & HSO_PORT_MASK) == HSO_PORT_NETWORK) {
2912             /* Create the network device */
2913             if (!disable_net) {
2914                 hso_dev = hso_create_net_device(interface,
2915                                 port_spec);
2916                 if (!hso_dev)
2917                     goto exit;
2918                 tmp_dev = hso_dev;
2919             }
2920         }
2921
2922         if (hso_get_mux_ports(interface, &port_mask))
2923             /* TODO: de-allocate everything */
2924             goto exit;
2925
2926         shared_int = hso_create_shared_int(interface);
2927         if (!shared_int)
2928             goto exit;
2929
2930         for (i = 1, mux = 0; i < 0x100; i = i << 1, mux++) {
2931             if (port_mask & i) {
2932                 hso_dev = hso_create_mux_serial_device(
2933                         interface, i, shared_int);
2934                 if (!hso_dev)
2935                     goto exit;
2936             }
2937         }
2938
2939         if (tmp_dev)
2940             hso_dev = tmp_dev;
2941         break;
2942
2943     case HSO_INTF_BULK:
2944         /* It's a regular bulk interface */
2945         if ((port_spec & HSO_PORT_MASK) == HSO_PORT_NETWORK) {
2946             if (!disable_net)
2947                 hso_dev =
2948                     hso_create_net_device(interface, port_spec);
2949         } else {
2950             hso_dev =
2951                 hso_create_bulk_serial_device(interface, port_spec);
2952         }
2953         if (!hso_dev)
2954             goto exit;
2955         break;
2956     default:
2957         goto exit;
2958     }
2959
2960     /* save our data pointer in this device */
2961     usb_set_intfdata(interface, hso_dev);
2962
2963     /* done */
2964     return 0;
2965 exit:
2966     hso_free_interface(interface);
2967     return -ENODEV;
2968 }
2969
2970 /* device removed, cleaning up */
2971 static void hso_disconnect(struct usb_interface *interface)
2972 {
2973     hso_free_interface(interface);
2974
2975     /* remove reference of our private data */
2976     usb_set_intfdata(interface, NULL);
2977 }
2978
2979 static void async_get_intf(struct work_struct *data)
2980 {
2981     struct hso_device *hso_dev =
2982         container_of(data, struct hso_device, async_get_intf);
2983     usb_autopm_get_interface(hso_dev->interface);
2984 }
2985
2986 static void async_put_intf(struct work_struct *data)
2987 {
2988     struct hso_device *hso_dev =
2989         container_of(data, struct hso_device, async_put_intf);
2990     usb_autopm_put_interface(hso_dev->interface);
2991 }
2992
2993 static int hso_get_activity(struct hso_device *hso_dev)
2994 {
2995     if (hso_dev->usb->state == USB_STATE_SUSPENDED) {
2996         if (!hso_dev->is_active) {
2997             hso_dev->is_active = 1;
2998             schedule_work(&hso_dev->async_get_intf);
2999         }
3000     }
3001
3002     if (hso_dev->usb->state != USB_STATE_CONFIGURED)
3003         return -EAGAIN;
3004
3005     usb_mark_last_busy(hso_dev->usb);
3006
3007     return 0;
3008 }
3009
3010 static int hso_put_activity(struct hso_device *hso_dev)
3011 {
3012     if (hso_dev->usb->state != USB_STATE_SUSPENDED) {
3013         if (hso_dev->is_active) {
3014             hso_dev->is_active = 0;
3015             schedule_work(&hso_dev->async_put_intf);
3016             return -EAGAIN;
3017         }
3018     }
3019     hso_dev->is_active = 0;
3020     return 0;
3021 }
3022
3023 /* called by kernel when we need to suspend device */
3024 static int hso_suspend(struct usb_interface *iface, pm_message_t message)
3025 {
3026     int i, result;
3027
3028     /* Stop all serial ports */
3029     for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++) {
3030         if (serial_table[i] && (serial_table[i]->interface == iface)) {
3031             result = hso_stop_serial_device(serial_table[i]);
3032             if (result)
3033                 goto out;
3034         }
3035     }
3036
3037     /* Stop all network ports */
3038     for (i = 0; i < HSO_MAX_NET_DEVICES; i++) {
3039         if (network_table[i] &&
3040             (network_table[i]->interface == iface)) {
3041             result = hso_stop_net_device(network_table[i]);
3042             if (result)
3043                 goto out;
3044         }
3045     }
3046
3047 out:
3048     return 0;
3049 }
3050
3051 /* called by kernel when we need to resume device */
3052 static int hso_resume(struct usb_interface *iface)
3053 {
3054     int i, result = 0;
3055     struct hso_net *hso_net;
3056
3057     /* Start all serial ports */
3058     for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++) {
3059         if (serial_table[i] && (serial_table[i]->interface == iface)) {
3060             if (dev2ser(serial_table[i])->port.count) {
3061                 result =
3062                     hso_start_serial_device(serial_table[i], GFP_NOIO);
3063                 hso_kick_transmit(dev2ser(serial_table[i]));
3064                 if (result)
3065                     goto out;
3066             }
3067         }
3068     }
3069
3070     /* Start all network ports */
3071     for (i = 0; i < HSO_MAX_NET_DEVICES; i++) {
3072         if (network_table[i] &&
3073             (network_table[i]->interface == iface)) {
3074             hso_net = dev2net(network_table[i]);
3075             if (hso_net->flags & IFF_UP) {
3076                 /* First transmit any lingering data,
3077                    then restart the device. */
3078                 if (hso_net->skb_tx_buf) {
3079                     dev_dbg(&iface->dev,
3080                         "Transmitting"
3081                         " lingering data\n");
3082                     hso_net_start_xmit(hso_net->skb_tx_buf,
3083                                hso_net->net);
3084                     hso_net->skb_tx_buf = NULL;
3085                 }
3086                 result = hso_start_net_device(network_table[i]);
3087                 if (result)
3088                     goto out;
3089             }
3090         }
3091     }
3092
3093 out:
3094     return result;
3095 }
3096
3097 static void hso_serial_ref_free(struct kref *ref)
3098 {
3099     struct hso_device *hso_dev = container_of(ref, struct hso_device, ref);
3100
3101     hso_free_serial_device(hso_dev);
3102 }
3103
3104 static void hso_free_interface(struct usb_interface *interface)
3105 {
3106     struct hso_serial *serial;
3107     int i;
3108
3109     for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++) {
3110         if (serial_table[i] &&
3111             (serial_table[i]->interface == interface)) {
3112             serial = dev2ser(serial_table[i]);
3113             tty_port_tty_hangup(&serial->port, false);
3114             mutex_lock(&serial->parent->mutex);
3115             serial->parent->usb_gone = 1;
3116             mutex_unlock(&serial->parent->mutex);
3117             cancel_work_sync(&serial_table[i]->async_put_intf);
3118             cancel_work_sync(&serial_table[i]->async_get_intf);
3119             hso_serial_tty_unregister(serial);
3120             kref_put(&serial->parent->ref, hso_serial_ref_free);
3121         }
3122     }
3123
3124     for (i = 0; i < HSO_MAX_NET_DEVICES; i++) {
3125         if (network_table[i] &&
3126             (network_table[i]->interface == interface)) {
3127             struct rfkill *rfk = dev2net(network_table[i])->rfkill;
3128             /* hso_stop_net_device doesn't stop the net queue since
3129              * traffic needs to start it again when suspended */
3130             netif_stop_queue(dev2net(network_table[i])->net);
3131             hso_stop_net_device(network_table[i]);
3132             cancel_work_sync(&network_table[i]->async_put_intf);
3133             cancel_work_sync(&network_table[i]->async_get_intf);
3134             if (rfk) {
3135                 rfkill_unregister(rfk);
3136                 rfkill_destroy(rfk);
3137             }
3138             hso_free_net_device(network_table[i]);
3139         }
3140     }
3141 }
3142
3143 /* Helper functions */
3144
3145 /* Get the endpoint ! */
3146 static struct usb_endpoint_descriptor *hso_get_ep(struct usb_interface *intf,
3147                           int type, int dir)
3148 {
3149     int i;
3150     struct usb_host_interface *iface = intf->cur_altsetting;
3151     struct usb_endpoint_descriptor *endp;
3152
3153     for (i = 0; i < iface->desc.bNumEndpoints; i++) {
3154         endp = &iface->endpoint[i].desc;
3155         if (((endp->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == dir) &&
3156             (usb_endpoint_type(endp) == type))
3157             return endp;
3158     }
3159
3160     return NULL;
3161 }
3162
3163 /* Get the byte that describes which ports are enabled */
3164 static int hso_get_mux_ports(struct usb_interface *intf, unsigned char *ports)
3165 {
3166     int i;
3167     struct usb_host_interface *iface = intf->cur_altsetting;
3168
3169     if (iface->extralen == 3) {
3170         *ports = iface->extra[2];
3171         return 0;
3172     }
3173
3174     for (i = 0; i < iface->desc.bNumEndpoints; i++) {
3175         if (iface->endpoint[i].extralen == 3) {
3176             *ports = iface->endpoint[i].extra[2];
3177             return 0;
3178         }
3179     }
3180
3181     return -1;
3182 }
3183
3184 /* interrupt urb needs to be submitted, used for serial read of muxed port */
3185 static int hso_mux_submit_intr_urb(struct hso_shared_int *shared_int,
3186                    struct usb_device *usb, gfp_t gfp)
3187 {
3188     int result;
3189
3190     usb_fill_int_urb(shared_int->shared_intr_urb, usb,
3191              usb_rcvintpipe(usb,
3192                 shared_int->intr_endp->bEndpointAddress & 0x7F),
3193              shared_int->shared_intr_buf,
3194              1,
3195              intr_callback, shared_int,
3196              shared_int->intr_endp->bInterval);
3197
3198     result = usb_submit_urb(shared_int->shared_intr_urb, gfp);
3199     if (result)
3200         dev_warn(&usb->dev, "%s failed mux_intr_urb %d\n", __func__,
3201             result);
3202
3203     return result;
3204 }
3205
3206 /* operations setup of the serial interface */
3207 static const struct tty_operations hso_serial_ops = {
3208     .open = hso_serial_open,
3209     .close = hso_serial_close,
3210     .write = hso_serial_write,
3211     .write_room = hso_serial_write_room,
3212     .cleanup = hso_serial_cleanup,
3213     .ioctl = hso_serial_ioctl,
3214     .set_termios = hso_serial_set_termios,
3215     .chars_in_buffer = hso_serial_chars_in_buffer,
3216     .tiocmget = hso_serial_tiocmget,
3217     .tiocmset = hso_serial_tiocmset,
3218     .get_icount = hso_get_count,
3219     .unthrottle = hso_unthrottle
3220 };
3221
3222 static struct usb_driver hso_driver = {
3223     .name = driver_name,
3224     .probe = hso_probe,
3225     .disconnect = hso_disconnect,
3226     .id_table = hso_ids,
3227     .suspend = hso_suspend,
3228     .resume = hso_resume,
3229     .reset_resume = hso_resume,
3230     .supports_autosuspend = 1,
3231     .disable_hub_initiated_lpm = 1,
3232 };
3233
3234 static int __init hso_init(void)
3235 {
3236     int i;
3237     int result;
3238
3239     /* put it in the log */
3240     pr_info("%s\n", version);
3241
3242     /* Initialise the serial table semaphore and table */
3243     for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++)
3244         serial_table[i] = NULL;
3245
3246     /* allocate our driver using the proper amount of supported minors */
3247     tty_drv = tty_alloc_driver(HSO_SERIAL_TTY_MINORS, TTY_DRIVER_REAL_RAW |
3248             TTY_DRIVER_DYNAMIC_DEV);
3249     if (IS_ERR(tty_drv))
3250         return PTR_ERR(tty_drv);
3251
3252     /* fill in all needed values */
3253     tty_drv->driver_name = driver_name;
3254     tty_drv->name = tty_filename;
3255
3256     /* if major number is provided as parameter, use that one */
3257     if (tty_major)
3258         tty_drv->major = tty_major;
3259
3260     tty_drv->minor_start = 0;
3261     tty_drv->type = TTY_DRIVER_TYPE_SERIAL;
3262     tty_drv->subtype = SERIAL_TYPE_NORMAL;
3263     tty_drv->init_termios = tty_std_termios;
3264     hso_init_termios(&tty_drv->init_termios);
3265     tty_set_operations(tty_drv, &hso_serial_ops);
3266
3267     /* register the tty driver */
3268     result = tty_register_driver(tty_drv);
3269     if (result) {
3270         pr_err("%s - tty_register_driver failed(%d)\n",
3271                __func__, result);
3272         goto err_free_tty;
3273     }
3274
3275     /* register this module as an usb driver */
3276     result = usb_register(&hso_driver);
3277     if (result) {
3278         pr_err("Could not register hso driver - error: %d\n", result);
3279         goto err_unreg_tty;
3280     }
3281
3282     /* done */
3283     return 0;
3284 err_unreg_tty:
3285     tty_unregister_driver(tty_drv);
3286 err_free_tty:
3287     tty_driver_kref_put(tty_drv);
3288     return result;
3289 }
3290
3291 static void __exit hso_exit(void)
3292 {
3293     pr_info("unloaded\n");
3294
3295     tty_unregister_driver(tty_drv);
3296     /* deregister the usb driver */
3297     usb_deregister(&hso_driver);
3298     tty_driver_kref_put(tty_drv);
3299 }
3300
3301 /* Module definitions */
3302 module_init(hso_init);
3303 module_exit(hso_exit);
3304
3305 MODULE_AUTHOR(MOD_AUTHOR);
3306 MODULE_DESCRIPTION(MOD_DESCRIPTION);
3307 MODULE_LICENSE("GPL");
3308
3309 /* change the debug level (eg: insmod hso.ko debug=0x04) */
3310 MODULE_PARM_DESC(debug, "debug level mask [0x01 | 0x02 | 0x04 | 0x08 | 0x10]");
3311 module_param(debug, int, 0644);
3312
3313 /* set the major tty number (eg: insmod hso.ko tty_major=245) */
3314 MODULE_PARM_DESC(tty_major, "Set the major tty number");
3315 module_param(tty_major, int, 0644);
3316
3317 /* disable network interface (eg: insmod hso.ko disable_net=1) */
3318 MODULE_PARM_DESC(disable_net, "Disable the network interface");
3319 module_param(disable_net, int, 0644);