3304 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/******************************************************************************3 *4 * Driver for Option High Speed Mobile Devices.5 *6 * Copyright (C) 2008 Option International7 * Filip Aben <f.aben@option.com>8 * Denis Joseph Barrow <d.barow@option.com>9 * Jan Dumon <j.dumon@option.com>10 * Copyright (C) 2007 Andrew Bird (Sphere Systems Ltd)11 * <ajb@spheresystems.co.uk>12 * Copyright (C) 2008 Greg Kroah-Hartman <gregkh@suse.de>13 * Copyright (C) 2008 Novell, Inc.14 *15 *****************************************************************************/16 17/******************************************************************************18 *19 * Description of the device:20 *21 * Interface 0: Contains the IP network interface on the bulk end points.22 * The multiplexed serial ports are using the interrupt and23 * control endpoints.24 * Interrupt contains a bitmap telling which multiplexed25 * serialport needs servicing.26 *27 * Interface 1: Diagnostics port, uses bulk only, do not submit urbs until the28 * port is opened, as this have a huge impact on the network port29 * throughput.30 *31 * Interface 2: Standard modem interface - circuit switched interface, this32 * can be used to make a standard ppp connection however it33 * should not be used in conjunction with the IP network interface34 * enabled for USB performance reasons i.e. if using this set35 * ideally disable_net=1.36 *37 *****************************************************************************/38 39#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt40 41#include <linux/sched/signal.h>42#include <linux/slab.h>43#include <linux/init.h>44#include <linux/delay.h>45#include <linux/netdevice.h>46#include <linux/module.h>47#include <linux/ethtool.h>48#include <linux/usb.h>49#include <linux/tty.h>50#include <linux/tty_driver.h>51#include <linux/tty_flip.h>52#include <linux/kmod.h>53#include <linux/rfkill.h>54#include <linux/ip.h>55#include <linux/uaccess.h>56#include <linux/usb/cdc.h>57#include <net/arp.h>58#include <asm/byteorder.h>59#include <linux/serial_core.h>60#include <linux/serial.h>61 62 63#define MOD_AUTHOR "Option Wireless"64#define MOD_DESCRIPTION "USB High Speed Option driver"65 66#define HSO_MAX_NET_DEVICES 1067#define HSO__MAX_MTU 204868#define DEFAULT_MTU 150069#define DEFAULT_MRU 150070 71#define CTRL_URB_RX_SIZE 102472#define CTRL_URB_TX_SIZE 6473 74#define BULK_URB_RX_SIZE 409675#define BULK_URB_TX_SIZE 819276 77#define MUX_BULK_RX_BUF_SIZE HSO__MAX_MTU78#define MUX_BULK_TX_BUF_SIZE HSO__MAX_MTU79#define MUX_BULK_RX_BUF_COUNT 480#define USB_TYPE_OPTION_VENDOR 0x2081 82/* These definitions are used with the struct hso_net flags element */83/* - use *_bit operations on it. (bit indices not values.) */84#define HSO_NET_RUNNING 085 86#define HSO_NET_TX_TIMEOUT (HZ*10)87 88#define HSO_SERIAL_MAGIC 0x48534f3189 90/* Number of ttys to handle */91#define HSO_SERIAL_TTY_MINORS 25692 93#define MAX_RX_URBS 294 95/*****************************************************************************/96/* Debugging functions */97/*****************************************************************************/98#define hso_dbg(lvl, fmt, ...) \99do { \100 if ((lvl) & debug) \101 pr_info("[%d:%s] " fmt, \102 __LINE__, __func__, ##__VA_ARGS__); \103} while (0)104 105/*****************************************************************************/106/* Enumerators */107/*****************************************************************************/108enum pkt_parse_state {109 WAIT_IP,110 WAIT_DATA,111 WAIT_SYNC112};113 114/*****************************************************************************/115/* Structs */116/*****************************************************************************/117 118struct hso_shared_int {119 struct usb_endpoint_descriptor *intr_endp;120 void *shared_intr_buf;121 struct urb *shared_intr_urb;122 struct usb_device *usb;123 int use_count;124 int ref_count;125 struct mutex shared_int_lock;126};127 128struct hso_net {129 struct hso_device *parent;130 struct net_device *net;131 struct rfkill *rfkill;132 char name[24];133 134 struct usb_endpoint_descriptor *in_endp;135 struct usb_endpoint_descriptor *out_endp;136 137 struct urb *mux_bulk_rx_urb_pool[MUX_BULK_RX_BUF_COUNT];138 struct urb *mux_bulk_tx_urb;139 void *mux_bulk_rx_buf_pool[MUX_BULK_RX_BUF_COUNT];140 void *mux_bulk_tx_buf;141 142 struct sk_buff *skb_rx_buf;143 struct sk_buff *skb_tx_buf;144 145 enum pkt_parse_state rx_parse_state;146 spinlock_t net_lock;147 148 unsigned short rx_buf_size;149 unsigned short rx_buf_missing;150 struct iphdr rx_ip_hdr;151 152 unsigned long flags;153};154 155enum rx_ctrl_state{156 RX_IDLE,157 RX_SENT,158 RX_PENDING159};160 161#define BM_REQUEST_TYPE (0xa1)162#define B_NOTIFICATION (0x20)163#define W_VALUE (0x0)164#define W_LENGTH (0x2)165 166#define B_OVERRUN (0x1<<6)167#define B_PARITY (0x1<<5)168#define B_FRAMING (0x1<<4)169#define B_RING_SIGNAL (0x1<<3)170#define B_BREAK (0x1<<2)171#define B_TX_CARRIER (0x1<<1)172#define B_RX_CARRIER (0x1<<0)173 174struct hso_serial_state_notification {175 u8 bmRequestType;176 u8 bNotification;177 u16 wValue;178 u16 wIndex;179 u16 wLength;180 u16 UART_state_bitmap;181} __packed;182 183struct hso_tiocmget {184 struct mutex mutex;185 wait_queue_head_t waitq;186 int intr_completed;187 struct usb_endpoint_descriptor *endp;188 struct urb *urb;189 struct hso_serial_state_notification *serial_state_notification;190 u16 prev_UART_state_bitmap;191 struct uart_icount icount;192};193 194 195struct hso_serial {196 struct hso_device *parent;197 int magic;198 u8 minor;199 200 struct hso_shared_int *shared_int;201 202 /* rx/tx urb could be either a bulk urb or a control urb depending203 on which serial port it is used on. */204 struct urb *rx_urb[MAX_RX_URBS];205 u8 num_rx_urbs;206 u8 *rx_data[MAX_RX_URBS];207 u16 rx_data_length; /* should contain allocated length */208 209 struct urb *tx_urb;210 u8 *tx_data;211 u8 *tx_buffer;212 u16 tx_data_length; /* should contain allocated length */213 u16 tx_data_count;214 u16 tx_buffer_count;215 struct usb_ctrlrequest ctrl_req_tx;216 struct usb_ctrlrequest ctrl_req_rx;217 218 struct usb_endpoint_descriptor *in_endp;219 struct usb_endpoint_descriptor *out_endp;220 221 enum rx_ctrl_state rx_state;222 u8 rts_state;223 u8 dtr_state;224 unsigned tx_urb_used:1;225 226 struct tty_port port;227 /* from usb_serial_port */228 spinlock_t serial_lock;229 230 int (*write_data) (struct hso_serial *serial);231 struct hso_tiocmget *tiocmget;232 /* Hacks required to get flow control233 * working on the serial receive buffers234 * so as not to drop characters on the floor.235 */236 int curr_rx_urb_idx;237 u8 rx_urb_filled[MAX_RX_URBS];238 struct tasklet_struct unthrottle_tasklet;239};240 241struct hso_device {242 union {243 struct hso_serial *dev_serial;244 struct hso_net *dev_net;245 } port_data;246 247 u32 port_spec;248 249 u8 is_active;250 u8 usb_gone;251 struct work_struct async_get_intf;252 struct work_struct async_put_intf;253 254 struct usb_device *usb;255 struct usb_interface *interface;256 257 struct device *dev;258 struct kref ref;259 struct mutex mutex;260};261 262/* Type of interface */263#define HSO_INTF_MASK 0xFF00264#define HSO_INTF_MUX 0x0100265#define HSO_INTF_BULK 0x0200266 267/* Type of port */268#define HSO_PORT_MASK 0xFF269#define HSO_PORT_NO_PORT 0x0270#define HSO_PORT_CONTROL 0x1271#define HSO_PORT_APP 0x2272#define HSO_PORT_GPS 0x3273#define HSO_PORT_PCSC 0x4274#define HSO_PORT_APP2 0x5275#define HSO_PORT_GPS_CONTROL 0x6276#define HSO_PORT_MSD 0x7277#define HSO_PORT_VOICE 0x8278#define HSO_PORT_DIAG2 0x9279#define HSO_PORT_DIAG 0x10280#define HSO_PORT_MODEM 0x11281#define HSO_PORT_NETWORK 0x12282 283/* Additional device info */284#define HSO_INFO_MASK 0xFF000000285#define HSO_INFO_CRC_BUG 0x01000000286 287/*****************************************************************************/288/* Prototypes */289/*****************************************************************************/290/* Serial driver functions */291static int hso_serial_tiocmset(struct tty_struct *tty,292 unsigned int set, unsigned int clear);293static void ctrl_callback(struct urb *urb);294static int put_rxbuf_data(struct urb *urb, struct hso_serial *serial);295static void hso_kick_transmit(struct hso_serial *serial);296/* Helper functions */297static int hso_mux_submit_intr_urb(struct hso_shared_int *mux_int,298 struct usb_device *usb, gfp_t gfp);299static void handle_usb_error(int status, const char *function,300 struct hso_device *hso_dev);301static struct usb_endpoint_descriptor *hso_get_ep(struct usb_interface *intf,302 int type, int dir);303static int hso_get_mux_ports(struct usb_interface *intf, unsigned char *ports);304static void hso_free_interface(struct usb_interface *intf);305static int hso_start_serial_device(struct hso_device *hso_dev, gfp_t flags);306static int hso_stop_serial_device(struct hso_device *hso_dev);307static int hso_start_net_device(struct hso_device *hso_dev);308static void hso_free_shared_int(struct hso_shared_int *shared_int);309static int hso_stop_net_device(struct hso_device *hso_dev);310static void hso_serial_ref_free(struct kref *ref);311static void hso_std_serial_read_bulk_callback(struct urb *urb);312static int hso_mux_serial_read(struct hso_serial *serial);313static void async_get_intf(struct work_struct *data);314static void async_put_intf(struct work_struct *data);315static int hso_put_activity(struct hso_device *hso_dev);316static int hso_get_activity(struct hso_device *hso_dev);317static void tiocmget_intr_callback(struct urb *urb);318/*****************************************************************************/319/* Helping functions */320/*****************************************************************************/321 322/* #define DEBUG */323 324static inline struct hso_net *dev2net(struct hso_device *hso_dev)325{326 return hso_dev->port_data.dev_net;327}328 329static inline struct hso_serial *dev2ser(struct hso_device *hso_dev)330{331 return hso_dev->port_data.dev_serial;332}333 334/* Debugging functions */335#ifdef DEBUG336static void dbg_dump(int line_count, const char *func_name, unsigned char *buf,337 unsigned int len)338{339 static char name[255];340 341 sprintf(name, "hso[%d:%s]", line_count, func_name);342 print_hex_dump_bytes(name, DUMP_PREFIX_NONE, buf, len);343}344 345#define DUMP(buf_, len_) \346 dbg_dump(__LINE__, __func__, (unsigned char *)buf_, len_)347 348#define DUMP1(buf_, len_) \349 do { \350 if (0x01 & debug) \351 DUMP(buf_, len_); \352 } while (0)353#else354#define DUMP(buf_, len_)355#define DUMP1(buf_, len_)356#endif357 358/* module parameters */359static int debug;360static int tty_major;361static int disable_net;362 363/* driver info */364static const char driver_name[] = "hso";365static const char tty_filename[] = "ttyHS";366/* the usb driver itself (registered in hso_init) */367static struct usb_driver hso_driver;368/* serial structures */369static struct tty_driver *tty_drv;370static struct hso_device *serial_table[HSO_SERIAL_TTY_MINORS];371static struct hso_device *network_table[HSO_MAX_NET_DEVICES];372static DEFINE_SPINLOCK(serial_table_lock);373 374static const s32 default_port_spec[] = {375 HSO_INTF_MUX | HSO_PORT_NETWORK,376 HSO_INTF_BULK | HSO_PORT_DIAG,377 HSO_INTF_BULK | HSO_PORT_MODEM,378 0379};380 381static const s32 icon321_port_spec[] = {382 HSO_INTF_MUX | HSO_PORT_NETWORK,383 HSO_INTF_BULK | HSO_PORT_DIAG2,384 HSO_INTF_BULK | HSO_PORT_MODEM,385 HSO_INTF_BULK | HSO_PORT_DIAG,386 0387};388 389#define default_port_device(vendor, product) \390 USB_DEVICE(vendor, product), \391 .driver_info = (kernel_ulong_t)default_port_spec392 393#define icon321_port_device(vendor, product) \394 USB_DEVICE(vendor, product), \395 .driver_info = (kernel_ulong_t)icon321_port_spec396 397/* list of devices we support */398static const struct usb_device_id hso_ids[] = {399 {default_port_device(0x0af0, 0x6711)},400 {default_port_device(0x0af0, 0x6731)},401 {default_port_device(0x0af0, 0x6751)},402 {default_port_device(0x0af0, 0x6771)},403 {default_port_device(0x0af0, 0x6791)},404 {default_port_device(0x0af0, 0x6811)},405 {default_port_device(0x0af0, 0x6911)},406 {default_port_device(0x0af0, 0x6951)},407 {default_port_device(0x0af0, 0x6971)},408 {default_port_device(0x0af0, 0x7011)},409 {default_port_device(0x0af0, 0x7031)},410 {default_port_device(0x0af0, 0x7051)},411 {default_port_device(0x0af0, 0x7071)},412 {default_port_device(0x0af0, 0x7111)},413 {default_port_device(0x0af0, 0x7211)},414 {default_port_device(0x0af0, 0x7251)},415 {default_port_device(0x0af0, 0x7271)},416 {default_port_device(0x0af0, 0x7311)},417 {default_port_device(0x0af0, 0xc031)}, /* Icon-Edge */418 {icon321_port_device(0x0af0, 0xd013)}, /* Module HSxPA */419 {icon321_port_device(0x0af0, 0xd031)}, /* Icon-321 */420 {icon321_port_device(0x0af0, 0xd033)}, /* Icon-322 */421 {USB_DEVICE(0x0af0, 0x7301)}, /* GE40x */422 {USB_DEVICE(0x0af0, 0x7361)}, /* GE40x */423 {USB_DEVICE(0x0af0, 0x7381)}, /* GE40x */424 {USB_DEVICE(0x0af0, 0x7401)}, /* GI 0401 */425 {USB_DEVICE(0x0af0, 0x7501)}, /* GTM 382 */426 {USB_DEVICE(0x0af0, 0x7601)}, /* GE40x */427 {USB_DEVICE(0x0af0, 0x7701)},428 {USB_DEVICE(0x0af0, 0x7706)},429 {USB_DEVICE(0x0af0, 0x7801)},430 {USB_DEVICE(0x0af0, 0x7901)},431 {USB_DEVICE(0x0af0, 0x7A01)},432 {USB_DEVICE(0x0af0, 0x7A05)},433 {USB_DEVICE(0x0af0, 0x8200)},434 {USB_DEVICE(0x0af0, 0x8201)},435 {USB_DEVICE(0x0af0, 0x8300)},436 {USB_DEVICE(0x0af0, 0x8302)},437 {USB_DEVICE(0x0af0, 0x8304)},438 {USB_DEVICE(0x0af0, 0x8400)},439 {USB_DEVICE(0x0af0, 0x8600)},440 {USB_DEVICE(0x0af0, 0x8800)},441 {USB_DEVICE(0x0af0, 0x8900)},442 {USB_DEVICE(0x0af0, 0x9000)},443 {USB_DEVICE(0x0af0, 0x9200)}, /* Option GTM671WFS */444 {USB_DEVICE(0x0af0, 0xd035)},445 {USB_DEVICE(0x0af0, 0xd055)},446 {USB_DEVICE(0x0af0, 0xd155)},447 {USB_DEVICE(0x0af0, 0xd255)},448 {USB_DEVICE(0x0af0, 0xd057)},449 {USB_DEVICE(0x0af0, 0xd157)},450 {USB_DEVICE(0x0af0, 0xd257)},451 {USB_DEVICE(0x0af0, 0xd357)},452 {USB_DEVICE(0x0af0, 0xd058)},453 {USB_DEVICE(0x0af0, 0xc100)},454 {}455};456MODULE_DEVICE_TABLE(usb, hso_ids);457 458/* Sysfs attribute */459static ssize_t hsotype_show(struct device *dev,460 struct device_attribute *attr, char *buf)461{462 struct hso_device *hso_dev = dev_get_drvdata(dev);463 char *port_name;464 465 if (!hso_dev)466 return 0;467 468 switch (hso_dev->port_spec & HSO_PORT_MASK) {469 case HSO_PORT_CONTROL:470 port_name = "Control";471 break;472 case HSO_PORT_APP:473 port_name = "Application";474 break;475 case HSO_PORT_APP2:476 port_name = "Application2";477 break;478 case HSO_PORT_GPS:479 port_name = "GPS";480 break;481 case HSO_PORT_GPS_CONTROL:482 port_name = "GPS Control";483 break;484 case HSO_PORT_PCSC:485 port_name = "PCSC";486 break;487 case HSO_PORT_DIAG:488 port_name = "Diagnostic";489 break;490 case HSO_PORT_DIAG2:491 port_name = "Diagnostic2";492 break;493 case HSO_PORT_MODEM:494 port_name = "Modem";495 break;496 case HSO_PORT_NETWORK:497 port_name = "Network";498 break;499 default:500 port_name = "Unknown";501 break;502 }503 504 return sprintf(buf, "%s\n", port_name);505}506static DEVICE_ATTR_RO(hsotype);507 508static struct attribute *hso_serial_dev_attrs[] = {509 &dev_attr_hsotype.attr,510 NULL511};512 513ATTRIBUTE_GROUPS(hso_serial_dev);514 515static int hso_urb_to_index(struct hso_serial *serial, struct urb *urb)516{517 int idx;518 519 for (idx = 0; idx < serial->num_rx_urbs; idx++)520 if (serial->rx_urb[idx] == urb)521 return idx;522 dev_err(serial->parent->dev, "hso_urb_to_index failed\n");523 return -1;524}525 526/* converts mux value to a port spec value */527static u32 hso_mux_to_port(int mux)528{529 u32 result;530 531 switch (mux) {532 case 0x1:533 result = HSO_PORT_CONTROL;534 break;535 case 0x2:536 result = HSO_PORT_APP;537 break;538 case 0x4:539 result = HSO_PORT_PCSC;540 break;541 case 0x8:542 result = HSO_PORT_GPS;543 break;544 case 0x10:545 result = HSO_PORT_APP2;546 break;547 default:548 result = HSO_PORT_NO_PORT;549 }550 return result;551}552 553/* converts port spec value to a mux value */554static u32 hso_port_to_mux(int port)555{556 u32 result;557 558 switch (port & HSO_PORT_MASK) {559 case HSO_PORT_CONTROL:560 result = 0x0;561 break;562 case HSO_PORT_APP:563 result = 0x1;564 break;565 case HSO_PORT_PCSC:566 result = 0x2;567 break;568 case HSO_PORT_GPS:569 result = 0x3;570 break;571 case HSO_PORT_APP2:572 result = 0x4;573 break;574 default:575 result = 0x0;576 }577 return result;578}579 580static struct hso_serial *get_serial_by_shared_int_and_type(581 struct hso_shared_int *shared_int,582 int mux)583{584 int i, port;585 586 port = hso_mux_to_port(mux);587 588 for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++) {589 if (serial_table[i] &&590 (dev2ser(serial_table[i])->shared_int == shared_int) &&591 ((serial_table[i]->port_spec & HSO_PORT_MASK) == port)) {592 return dev2ser(serial_table[i]);593 }594 }595 596 return NULL;597}598 599static struct hso_serial *get_serial_by_index(unsigned index)600{601 struct hso_serial *serial = NULL;602 unsigned long flags;603 604 spin_lock_irqsave(&serial_table_lock, flags);605 if (serial_table[index])606 serial = dev2ser(serial_table[index]);607 spin_unlock_irqrestore(&serial_table_lock, flags);608 609 return serial;610}611 612static int obtain_minor(struct hso_serial *serial)613{614 int index;615 unsigned long flags;616 617 spin_lock_irqsave(&serial_table_lock, flags);618 for (index = 0; index < HSO_SERIAL_TTY_MINORS; index++) {619 if (serial_table[index] == NULL) {620 serial_table[index] = serial->parent;621 serial->minor = index;622 spin_unlock_irqrestore(&serial_table_lock, flags);623 return 0;624 }625 }626 spin_unlock_irqrestore(&serial_table_lock, flags);627 628 pr_err("%s: no free serial devices in table\n", __func__);629 return -1;630}631 632static void release_minor(struct hso_serial *serial)633{634 unsigned long flags;635 636 spin_lock_irqsave(&serial_table_lock, flags);637 serial_table[serial->minor] = NULL;638 spin_unlock_irqrestore(&serial_table_lock, flags);639}640 641static void handle_usb_error(int status, const char *function,642 struct hso_device *hso_dev)643{644 char *explanation;645 646 switch (status) {647 case -ENODEV:648 explanation = "no device";649 break;650 case -ENOENT:651 explanation = "endpoint not enabled";652 break;653 case -EPIPE:654 explanation = "endpoint stalled";655 break;656 case -ENOSPC:657 explanation = "not enough bandwidth";658 break;659 case -ESHUTDOWN:660 explanation = "device disabled";661 break;662 case -EHOSTUNREACH:663 explanation = "device suspended";664 break;665 case -EINVAL:666 case -EAGAIN:667 case -EFBIG:668 case -EMSGSIZE:669 explanation = "internal error";670 break;671 case -EILSEQ:672 case -EPROTO:673 case -ETIME:674 case -ETIMEDOUT:675 explanation = "protocol error";676 if (hso_dev)677 usb_queue_reset_device(hso_dev->interface);678 break;679 default:680 explanation = "unknown status";681 break;682 }683 684 /* log a meaningful explanation of an USB status */685 hso_dbg(0x1, "%s: received USB status - %s (%d)\n",686 function, explanation, status);687}688 689/* Network interface functions */690 691/* called when net interface is brought up by ifconfig */692static int hso_net_open(struct net_device *net)693{694 struct hso_net *odev = netdev_priv(net);695 unsigned long flags = 0;696 697 if (!odev) {698 dev_err(&net->dev, "No net device !\n");699 return -ENODEV;700 }701 702 odev->skb_tx_buf = NULL;703 704 /* setup environment */705 spin_lock_irqsave(&odev->net_lock, flags);706 odev->rx_parse_state = WAIT_IP;707 odev->rx_buf_size = 0;708 odev->rx_buf_missing = sizeof(struct iphdr);709 spin_unlock_irqrestore(&odev->net_lock, flags);710 711 /* We are up and running. */712 set_bit(HSO_NET_RUNNING, &odev->flags);713 hso_start_net_device(odev->parent);714 715 /* Tell the kernel we are ready to start receiving from it */716 netif_start_queue(net);717 718 return 0;719}720 721/* called when interface is brought down by ifconfig */722static int hso_net_close(struct net_device *net)723{724 struct hso_net *odev = netdev_priv(net);725 726 /* we don't need the queue anymore */727 netif_stop_queue(net);728 /* no longer running */729 clear_bit(HSO_NET_RUNNING, &odev->flags);730 731 hso_stop_net_device(odev->parent);732 733 /* done */734 return 0;735}736 737/* USB tells is xmit done, we should start the netqueue again */738static void write_bulk_callback(struct urb *urb)739{740 struct hso_net *odev = urb->context;741 int status = urb->status;742 743 /* Sanity check */744 if (!odev || !test_bit(HSO_NET_RUNNING, &odev->flags)) {745 dev_err(&urb->dev->dev, "%s: device not running\n", __func__);746 return;747 }748 749 /* Do we still have a valid kernel network device? */750 if (!netif_device_present(odev->net)) {751 dev_err(&urb->dev->dev, "%s: net device not present\n",752 __func__);753 return;754 }755 756 /* log status, but don't act on it, we don't need to resubmit anything757 * anyhow */758 if (status)759 handle_usb_error(status, __func__, odev->parent);760 761 hso_put_activity(odev->parent);762 763 /* Tell the network interface we are ready for another frame */764 netif_wake_queue(odev->net);765}766 767/* called by kernel when we need to transmit a packet */768static netdev_tx_t hso_net_start_xmit(struct sk_buff *skb,769 struct net_device *net)770{771 struct hso_net *odev = netdev_priv(net);772 int result;773 774 /* Tell the kernel, "No more frames 'til we are done with this one." */775 netif_stop_queue(net);776 if (hso_get_activity(odev->parent) == -EAGAIN) {777 odev->skb_tx_buf = skb;778 return NETDEV_TX_OK;779 }780 781 /* log if asked */782 DUMP1(skb->data, skb->len);783 /* Copy it from kernel memory to OUR memory */784 memcpy(odev->mux_bulk_tx_buf, skb->data, skb->len);785 hso_dbg(0x1, "len: %d/%d\n", skb->len, MUX_BULK_TX_BUF_SIZE);786 787 /* Fill in the URB for shipping it out. */788 usb_fill_bulk_urb(odev->mux_bulk_tx_urb,789 odev->parent->usb,790 usb_sndbulkpipe(odev->parent->usb,791 odev->out_endp->792 bEndpointAddress & 0x7F),793 odev->mux_bulk_tx_buf, skb->len, write_bulk_callback,794 odev);795 796 /* Deal with the Zero Length packet problem, I hope */797 odev->mux_bulk_tx_urb->transfer_flags |= URB_ZERO_PACKET;798 799 /* Send the URB on its merry way. */800 result = usb_submit_urb(odev->mux_bulk_tx_urb, GFP_ATOMIC);801 if (result) {802 dev_warn(&odev->parent->interface->dev,803 "failed mux_bulk_tx_urb %d\n", result);804 net->stats.tx_errors++;805 netif_start_queue(net);806 } else {807 net->stats.tx_packets++;808 net->stats.tx_bytes += skb->len;809 }810 dev_kfree_skb(skb);811 /* we're done */812 return NETDEV_TX_OK;813}814 815static const struct ethtool_ops ops = {816 .get_link = ethtool_op_get_link817};818 819/* called when a packet did not ack after watchdogtimeout */820static void hso_net_tx_timeout(struct net_device *net, unsigned int txqueue)821{822 struct hso_net *odev = netdev_priv(net);823 824 if (!odev)825 return;826 827 /* Tell syslog we are hosed. */828 dev_warn(&net->dev, "Tx timed out.\n");829 830 /* Tear the waiting frame off the list */831 if (odev->mux_bulk_tx_urb)832 usb_unlink_urb(odev->mux_bulk_tx_urb);833 834 /* Update statistics */835 net->stats.tx_errors++;836}837 838/* make a real packet from the received USB buffer */839static void packetizeRx(struct hso_net *odev, unsigned char *ip_pkt,840 unsigned int count, unsigned char is_eop)841{842 unsigned short temp_bytes;843 unsigned short buffer_offset = 0;844 unsigned short frame_len;845 846 /* log if needed */847 hso_dbg(0x1, "Rx %d bytes\n", count);848 DUMP(ip_pkt, min(128, (int)count));849 850 while (count) {851 switch (odev->rx_parse_state) {852 case WAIT_IP:853 /* waiting for IP header. */854 /* wanted bytes - size of ip header */855 temp_bytes =856 (count <857 odev->rx_buf_missing) ? count : odev->858 rx_buf_missing;859 860 memcpy(((unsigned char *)(&odev->rx_ip_hdr)) +861 odev->rx_buf_size, ip_pkt + buffer_offset,862 temp_bytes);863 864 odev->rx_buf_size += temp_bytes;865 buffer_offset += temp_bytes;866 odev->rx_buf_missing -= temp_bytes;867 count -= temp_bytes;868 869 if (!odev->rx_buf_missing) {870 /* header is complete allocate an sk_buffer and871 * continue to WAIT_DATA */872 frame_len = ntohs(odev->rx_ip_hdr.tot_len);873 874 if ((frame_len > DEFAULT_MRU) ||875 (frame_len < sizeof(struct iphdr))) {876 dev_err(&odev->net->dev,877 "Invalid frame (%d) length\n",878 frame_len);879 odev->rx_parse_state = WAIT_SYNC;880 continue;881 }882 /* Allocate an sk_buff */883 odev->skb_rx_buf = netdev_alloc_skb(odev->net,884 frame_len);885 if (!odev->skb_rx_buf) {886 /* We got no receive buffer. */887 hso_dbg(0x1, "could not allocate memory\n");888 odev->rx_parse_state = WAIT_SYNC;889 continue;890 }891 892 /* Copy what we got so far. make room for iphdr893 * after tail. */894 skb_put_data(odev->skb_rx_buf,895 (char *)&(odev->rx_ip_hdr),896 sizeof(struct iphdr));897 898 /* ETH_HLEN */899 odev->rx_buf_size = sizeof(struct iphdr);900 901 /* Filip actually use .tot_len */902 odev->rx_buf_missing =903 frame_len - sizeof(struct iphdr);904 odev->rx_parse_state = WAIT_DATA;905 }906 break;907 908 case WAIT_DATA:909 temp_bytes = (count < odev->rx_buf_missing)910 ? count : odev->rx_buf_missing;911 912 /* Copy the rest of the bytes that are left in the913 * buffer into the waiting sk_buf. */914 /* Make room for temp_bytes after tail. */915 skb_put_data(odev->skb_rx_buf,916 ip_pkt + buffer_offset,917 temp_bytes);918 919 odev->rx_buf_missing -= temp_bytes;920 count -= temp_bytes;921 buffer_offset += temp_bytes;922 odev->rx_buf_size += temp_bytes;923 if (!odev->rx_buf_missing) {924 /* Packet is complete. Inject into stack. */925 /* We have IP packet here */926 odev->skb_rx_buf->protocol = cpu_to_be16(ETH_P_IP);927 skb_reset_mac_header(odev->skb_rx_buf);928 929 /* Ship it off to the kernel */930 netif_rx(odev->skb_rx_buf);931 /* No longer our buffer. */932 odev->skb_rx_buf = NULL;933 934 /* update out statistics */935 odev->net->stats.rx_packets++;936 937 odev->net->stats.rx_bytes += odev->rx_buf_size;938 939 odev->rx_buf_size = 0;940 odev->rx_buf_missing = sizeof(struct iphdr);941 odev->rx_parse_state = WAIT_IP;942 }943 break;944 945 case WAIT_SYNC:946 hso_dbg(0x1, " W_S\n");947 count = 0;948 break;949 default:950 hso_dbg(0x1, "\n");951 count--;952 break;953 }954 }955 956 /* Recovery mechanism for WAIT_SYNC state. */957 if (is_eop) {958 if (odev->rx_parse_state == WAIT_SYNC) {959 odev->rx_parse_state = WAIT_IP;960 odev->rx_buf_size = 0;961 odev->rx_buf_missing = sizeof(struct iphdr);962 }963 }964}965 966static void fix_crc_bug(struct urb *urb, __le16 max_packet_size)967{968 static const u8 crc_check[4] = { 0xDE, 0xAD, 0xBE, 0xEF };969 u32 rest = urb->actual_length % le16_to_cpu(max_packet_size);970 971 if (((rest == 5) || (rest == 6)) &&972 !memcmp(((u8 *)urb->transfer_buffer) + urb->actual_length - 4,973 crc_check, 4)) {974 urb->actual_length -= 4;975 }976}977 978/* Moving data from usb to kernel (in interrupt state) */979static void read_bulk_callback(struct urb *urb)980{981 struct hso_net *odev = urb->context;982 struct net_device *net;983 int result;984 unsigned long flags;985 int status = urb->status;986 987 /* is al ok? (Filip: Who's Al ?) */988 if (status) {989 handle_usb_error(status, __func__, odev->parent);990 return;991 }992 993 /* Sanity check */994 if (!odev || !test_bit(HSO_NET_RUNNING, &odev->flags)) {995 hso_dbg(0x1, "BULK IN callback but driver is not active!\n");996 return;997 }998 usb_mark_last_busy(urb->dev);999 1000 net = odev->net;1001 1002 if (!netif_device_present(net)) {1003 /* Somebody killed our network interface... */1004 return;1005 }1006 1007 if (odev->parent->port_spec & HSO_INFO_CRC_BUG)1008 fix_crc_bug(urb, odev->in_endp->wMaxPacketSize);1009 1010 /* do we even have a packet? */1011 if (urb->actual_length) {1012 /* Handle the IP stream, add header and push it onto network1013 * stack if the packet is complete. */1014 spin_lock_irqsave(&odev->net_lock, flags);1015 packetizeRx(odev, urb->transfer_buffer, urb->actual_length,1016 (urb->transfer_buffer_length >1017 urb->actual_length) ? 1 : 0);1018 spin_unlock_irqrestore(&odev->net_lock, flags);1019 }1020 1021 /* We are done with this URB, resubmit it. Prep the USB to wait for1022 * another frame. Reuse same as received. */1023 usb_fill_bulk_urb(urb,1024 odev->parent->usb,1025 usb_rcvbulkpipe(odev->parent->usb,1026 odev->in_endp->1027 bEndpointAddress & 0x7F),1028 urb->transfer_buffer, MUX_BULK_RX_BUF_SIZE,1029 read_bulk_callback, odev);1030 1031 /* Give this to the USB subsystem so it can tell us when more data1032 * arrives. */1033 result = usb_submit_urb(urb, GFP_ATOMIC);1034 if (result)1035 dev_warn(&odev->parent->interface->dev,1036 "%s failed submit mux_bulk_rx_urb %d\n", __func__,1037 result);1038}1039 1040/* Serial driver functions */1041 1042static void hso_init_termios(struct ktermios *termios)1043{1044 /*1045 * The default requirements for this device are:1046 */1047 termios->c_iflag &=1048 ~(IGNBRK /* disable ignore break */1049 | BRKINT /* disable break causes interrupt */1050 | PARMRK /* disable mark parity errors */1051 | ISTRIP /* disable clear high bit of input characters */1052 | INLCR /* disable translate NL to CR */1053 | IGNCR /* disable ignore CR */1054 | ICRNL /* disable translate CR to NL */1055 | IXON); /* disable enable XON/XOFF flow control */1056 1057 /* disable postprocess output characters */1058 termios->c_oflag &= ~OPOST;1059 1060 termios->c_lflag &=1061 ~(ECHO /* disable echo input characters */1062 | ECHONL /* disable echo new line */1063 | ICANON /* disable erase, kill, werase, and rprnt1064 special characters */1065 | ISIG /* disable interrupt, quit, and suspend special1066 characters */1067 | IEXTEN); /* disable non-POSIX special characters */1068 1069 termios->c_cflag &=1070 ~(CSIZE /* no size */1071 | PARENB /* disable parity bit */1072 | CBAUD /* clear current baud rate */1073 | CBAUDEX); /* clear current buad rate */1074 1075 termios->c_cflag |= CS8; /* character size 8 bits */1076 1077 /* baud rate 115200 */1078 tty_termios_encode_baud_rate(termios, 115200, 115200);1079}1080 1081static void _hso_serial_set_termios(struct tty_struct *tty)1082{1083 struct hso_serial *serial = tty->driver_data;1084 1085 if (!serial) {1086 pr_err("%s: no tty structures", __func__);1087 return;1088 }1089 1090 hso_dbg(0x8, "port %d\n", serial->minor);1091 1092 /*1093 * Fix up unsupported bits1094 */1095 tty->termios.c_iflag &= ~IXON; /* disable enable XON/XOFF flow control */1096 1097 tty->termios.c_cflag &=1098 ~(CSIZE /* no size */1099 | PARENB /* disable parity bit */1100 | CBAUD /* clear current baud rate */1101 | CBAUDEX); /* clear current buad rate */1102 1103 tty->termios.c_cflag |= CS8; /* character size 8 bits */1104 1105 /* baud rate 115200 */1106 tty_encode_baud_rate(tty, 115200, 115200);1107}1108 1109static void hso_resubmit_rx_bulk_urb(struct hso_serial *serial, struct urb *urb)1110{1111 int result;1112 /* We are done with this URB, resubmit it. Prep the USB to wait for1113 * another frame */1114 usb_fill_bulk_urb(urb, serial->parent->usb,1115 usb_rcvbulkpipe(serial->parent->usb,1116 serial->in_endp->1117 bEndpointAddress & 0x7F),1118 urb->transfer_buffer, serial->rx_data_length,1119 hso_std_serial_read_bulk_callback, serial);1120 /* Give this to the USB subsystem so it can tell us when more data1121 * arrives. */1122 result = usb_submit_urb(urb, GFP_ATOMIC);1123 if (result) {1124 dev_err(&urb->dev->dev, "%s failed submit serial rx_urb %d\n",1125 __func__, result);1126 }1127}1128 1129 1130 1131 1132static void put_rxbuf_data_and_resubmit_bulk_urb(struct hso_serial *serial)1133{1134 int count;1135 struct urb *curr_urb;1136 1137 while (serial->rx_urb_filled[serial->curr_rx_urb_idx]) {1138 curr_urb = serial->rx_urb[serial->curr_rx_urb_idx];1139 count = put_rxbuf_data(curr_urb, serial);1140 if (count == -1)1141 return;1142 if (count == 0) {1143 serial->curr_rx_urb_idx++;1144 if (serial->curr_rx_urb_idx >= serial->num_rx_urbs)1145 serial->curr_rx_urb_idx = 0;1146 hso_resubmit_rx_bulk_urb(serial, curr_urb);1147 }1148 }1149}1150 1151static void put_rxbuf_data_and_resubmit_ctrl_urb(struct hso_serial *serial)1152{1153 int count = 0;1154 struct urb *urb;1155 1156 urb = serial->rx_urb[0];1157 if (serial->port.count > 0) {1158 count = put_rxbuf_data(urb, serial);1159 if (count == -1)1160 return;1161 }1162 /* Re issue a read as long as we receive data. */1163 1164 if (count == 0 && ((urb->actual_length != 0) ||1165 (serial->rx_state == RX_PENDING))) {1166 serial->rx_state = RX_SENT;1167 hso_mux_serial_read(serial);1168 } else1169 serial->rx_state = RX_IDLE;1170}1171 1172 1173/* read callback for Diag and CS port */1174static void hso_std_serial_read_bulk_callback(struct urb *urb)1175{1176 struct hso_serial *serial = urb->context;1177 int status = urb->status;1178 unsigned long flags;1179 1180 hso_dbg(0x8, "--- Got serial_read_bulk callback %02x ---\n", status);1181 1182 /* sanity check */1183 if (!serial) {1184 hso_dbg(0x1, "serial == NULL\n");1185 return;1186 }1187 if (status) {1188 handle_usb_error(status, __func__, serial->parent);1189 return;1190 }1191 1192 hso_dbg(0x1, "Actual length = %d\n", urb->actual_length);1193 DUMP1(urb->transfer_buffer, urb->actual_length);1194 1195 /* Anyone listening? */1196 if (serial->port.count == 0)1197 return;1198 1199 if (serial->parent->port_spec & HSO_INFO_CRC_BUG)1200 fix_crc_bug(urb, serial->in_endp->wMaxPacketSize);1201 /* Valid data, handle RX data */1202 spin_lock_irqsave(&serial->serial_lock, flags);1203 serial->rx_urb_filled[hso_urb_to_index(serial, urb)] = 1;1204 put_rxbuf_data_and_resubmit_bulk_urb(serial);1205 spin_unlock_irqrestore(&serial->serial_lock, flags);1206}1207 1208/*1209 * This needs to be a tasklet otherwise we will1210 * end up recursively calling this function.1211 */1212static void hso_unthrottle_tasklet(struct tasklet_struct *t)1213{1214 struct hso_serial *serial = from_tasklet(serial, t,1215 unthrottle_tasklet);1216 unsigned long flags;1217 1218 spin_lock_irqsave(&serial->serial_lock, flags);1219 if ((serial->parent->port_spec & HSO_INTF_MUX))1220 put_rxbuf_data_and_resubmit_ctrl_urb(serial);1221 else1222 put_rxbuf_data_and_resubmit_bulk_urb(serial);1223 spin_unlock_irqrestore(&serial->serial_lock, flags);1224}1225 1226static void hso_unthrottle(struct tty_struct *tty)1227{1228 struct hso_serial *serial = tty->driver_data;1229 1230 tasklet_hi_schedule(&serial->unthrottle_tasklet);1231}1232 1233/* open the requested serial port */1234static int hso_serial_open(struct tty_struct *tty, struct file *filp)1235{1236 struct hso_serial *serial = get_serial_by_index(tty->index);1237 int result;1238 1239 /* sanity check */1240 if (serial == NULL || serial->magic != HSO_SERIAL_MAGIC) {1241 WARN_ON(1);1242 tty->driver_data = NULL;1243 hso_dbg(0x1, "Failed to open port\n");1244 return -ENODEV;1245 }1246 1247 mutex_lock(&serial->parent->mutex);1248 result = usb_autopm_get_interface(serial->parent->interface);1249 if (result < 0)1250 goto err_out;1251 1252 hso_dbg(0x1, "Opening %d\n", serial->minor);1253 1254 /* setup */1255 tty->driver_data = serial;1256 tty_port_tty_set(&serial->port, tty);1257 1258 /* check for port already opened, if not set the termios */1259 serial->port.count++;1260 if (serial->port.count == 1) {1261 serial->rx_state = RX_IDLE;1262 /* Force default termio settings */1263 _hso_serial_set_termios(tty);1264 tasklet_setup(&serial->unthrottle_tasklet,1265 hso_unthrottle_tasklet);1266 result = hso_start_serial_device(serial->parent, GFP_KERNEL);1267 if (result) {1268 hso_stop_serial_device(serial->parent);1269 serial->port.count--;1270 } else {1271 kref_get(&serial->parent->ref);1272 }1273 } else {1274 hso_dbg(0x1, "Port was already open\n");1275 }1276 1277 usb_autopm_put_interface(serial->parent->interface);1278 1279 /* done */1280 if (result)1281 hso_serial_tiocmset(tty, TIOCM_RTS | TIOCM_DTR, 0);1282err_out:1283 mutex_unlock(&serial->parent->mutex);1284 return result;1285}1286 1287/* close the requested serial port */1288static void hso_serial_close(struct tty_struct *tty, struct file *filp)1289{1290 struct hso_serial *serial = tty->driver_data;1291 u8 usb_gone;1292 1293 hso_dbg(0x1, "Closing serial port\n");1294 1295 /* Open failed, no close cleanup required */1296 if (serial == NULL)1297 return;1298 1299 mutex_lock(&serial->parent->mutex);1300 usb_gone = serial->parent->usb_gone;1301 1302 if (!usb_gone)1303 usb_autopm_get_interface(serial->parent->interface);1304 1305 /* reset the rts and dtr */1306 /* do the actual close */1307 serial->port.count--;1308 1309 if (serial->port.count <= 0) {1310 serial->port.count = 0;1311 tty_port_tty_set(&serial->port, NULL);1312 if (!usb_gone)1313 hso_stop_serial_device(serial->parent);1314 tasklet_kill(&serial->unthrottle_tasklet);1315 }1316 1317 if (!usb_gone)1318 usb_autopm_put_interface(serial->parent->interface);1319 1320 mutex_unlock(&serial->parent->mutex);1321}1322 1323/* close the requested serial port */1324static ssize_t hso_serial_write(struct tty_struct *tty, const u8 *buf,1325 size_t count)1326{1327 struct hso_serial *serial = tty->driver_data;1328 unsigned long flags;1329 1330 /* sanity check */1331 if (serial == NULL) {1332 pr_err("%s: serial is NULL\n", __func__);1333 return -ENODEV;1334 }1335 1336 spin_lock_irqsave(&serial->serial_lock, flags);1337 1338 count = min_t(size_t, serial->tx_data_length - serial->tx_buffer_count,1339 count);1340 memcpy(serial->tx_buffer + serial->tx_buffer_count, buf, count);1341 serial->tx_buffer_count += count;1342 1343 spin_unlock_irqrestore(&serial->serial_lock, flags);1344 1345 hso_kick_transmit(serial);1346 /* done */1347 return count;1348}1349 1350/* how much room is there for writing */1351static unsigned int hso_serial_write_room(struct tty_struct *tty)1352{1353 struct hso_serial *serial = tty->driver_data;1354 unsigned int room;1355 unsigned long flags;1356 1357 spin_lock_irqsave(&serial->serial_lock, flags);1358 room = serial->tx_data_length - serial->tx_buffer_count;1359 spin_unlock_irqrestore(&serial->serial_lock, flags);1360 1361 /* return free room */1362 return room;1363}1364 1365static void hso_serial_cleanup(struct tty_struct *tty)1366{1367 struct hso_serial *serial = tty->driver_data;1368 1369 if (!serial)1370 return;1371 1372 kref_put(&serial->parent->ref, hso_serial_ref_free);1373}1374 1375/* setup the term */1376static void hso_serial_set_termios(struct tty_struct *tty,1377 const struct ktermios *old)1378{1379 struct hso_serial *serial = tty->driver_data;1380 unsigned long flags;1381 1382 if (old)1383 hso_dbg(0x16, "Termios called with: cflags new[%u] - old[%u]\n",1384 (unsigned int)tty->termios.c_cflag,1385 (unsigned int)old->c_cflag);1386 1387 /* the actual setup */1388 spin_lock_irqsave(&serial->serial_lock, flags);1389 if (serial->port.count)1390 _hso_serial_set_termios(tty);1391 else1392 tty->termios = *old;1393 spin_unlock_irqrestore(&serial->serial_lock, flags);1394 1395 /* done */1396}1397 1398/* how many characters in the buffer */1399static unsigned int hso_serial_chars_in_buffer(struct tty_struct *tty)1400{1401 struct hso_serial *serial = tty->driver_data;1402 unsigned long flags;1403 unsigned int chars;1404 1405 /* sanity check */1406 if (serial == NULL)1407 return 0;1408 1409 spin_lock_irqsave(&serial->serial_lock, flags);1410 chars = serial->tx_buffer_count;1411 spin_unlock_irqrestore(&serial->serial_lock, flags);1412 1413 return chars;1414}1415static int tiocmget_submit_urb(struct hso_serial *serial,1416 struct hso_tiocmget *tiocmget,1417 struct usb_device *usb)1418{1419 int result;1420 1421 if (serial->parent->usb_gone)1422 return -ENODEV;1423 usb_fill_int_urb(tiocmget->urb, usb,1424 usb_rcvintpipe(usb,1425 tiocmget->endp->1426 bEndpointAddress & 0x7F),1427 tiocmget->serial_state_notification,1428 sizeof(struct hso_serial_state_notification),1429 tiocmget_intr_callback, serial,1430 tiocmget->endp->bInterval);1431 result = usb_submit_urb(tiocmget->urb, GFP_ATOMIC);1432 if (result) {1433 dev_warn(&usb->dev, "%s usb_submit_urb failed %d\n", __func__,1434 result);1435 }1436 return result;1437 1438}1439 1440static void tiocmget_intr_callback(struct urb *urb)1441{1442 struct hso_serial *serial = urb->context;1443 struct hso_tiocmget *tiocmget;1444 int status = urb->status;1445 u16 UART_state_bitmap, prev_UART_state_bitmap;1446 struct uart_icount *icount;1447 struct hso_serial_state_notification *serial_state_notification;1448 struct usb_device *usb;1449 struct usb_interface *interface;1450 int if_num;1451 1452 /* Sanity checks */1453 if (!serial)1454 return;1455 if (status) {1456 handle_usb_error(status, __func__, serial->parent);1457 return;1458 }1459 1460 /* tiocmget is only supported on HSO_PORT_MODEM */1461 tiocmget = serial->tiocmget;1462 if (!tiocmget)1463 return;1464 BUG_ON((serial->parent->port_spec & HSO_PORT_MASK) != HSO_PORT_MODEM);1465 1466 usb = serial->parent->usb;1467 interface = serial->parent->interface;1468 1469 if_num = interface->cur_altsetting->desc.bInterfaceNumber;1470 1471 /* wIndex should be the USB interface number of the port to which the1472 * notification applies, which should always be the Modem port.1473 */1474 serial_state_notification = tiocmget->serial_state_notification;1475 if (serial_state_notification->bmRequestType != BM_REQUEST_TYPE ||1476 serial_state_notification->bNotification != B_NOTIFICATION ||1477 le16_to_cpu(serial_state_notification->wValue) != W_VALUE ||1478 le16_to_cpu(serial_state_notification->wIndex) != if_num ||1479 le16_to_cpu(serial_state_notification->wLength) != W_LENGTH) {1480 dev_warn(&usb->dev,1481 "hso received invalid serial state notification\n");1482 DUMP(serial_state_notification,1483 sizeof(struct hso_serial_state_notification));1484 } else {1485 unsigned long flags;1486 1487 UART_state_bitmap = le16_to_cpu(serial_state_notification->1488 UART_state_bitmap);1489 prev_UART_state_bitmap = tiocmget->prev_UART_state_bitmap;1490 icount = &tiocmget->icount;1491 spin_lock_irqsave(&serial->serial_lock, flags);1492 if ((UART_state_bitmap & B_OVERRUN) !=1493 (prev_UART_state_bitmap & B_OVERRUN))1494 icount->parity++;1495 if ((UART_state_bitmap & B_PARITY) !=1496 (prev_UART_state_bitmap & B_PARITY))1497 icount->parity++;1498 if ((UART_state_bitmap & B_FRAMING) !=1499 (prev_UART_state_bitmap & B_FRAMING))1500 icount->frame++;1501 if ((UART_state_bitmap & B_RING_SIGNAL) &&1502 !(prev_UART_state_bitmap & B_RING_SIGNAL))1503 icount->rng++;1504 if ((UART_state_bitmap & B_BREAK) !=1505 (prev_UART_state_bitmap & B_BREAK))1506 icount->brk++;1507 if ((UART_state_bitmap & B_TX_CARRIER) !=1508 (prev_UART_state_bitmap & B_TX_CARRIER))1509 icount->dsr++;1510 if ((UART_state_bitmap & B_RX_CARRIER) !=1511 (prev_UART_state_bitmap & B_RX_CARRIER))1512 icount->dcd++;1513 tiocmget->prev_UART_state_bitmap = UART_state_bitmap;1514 spin_unlock_irqrestore(&serial->serial_lock, flags);1515 tiocmget->intr_completed = 1;1516 wake_up_interruptible(&tiocmget->waitq);1517 }1518 memset(serial_state_notification, 0,1519 sizeof(struct hso_serial_state_notification));1520 tiocmget_submit_urb(serial,1521 tiocmget,1522 serial->parent->usb);1523}1524 1525/*1526 * next few functions largely stolen from drivers/serial/serial_core.c1527 */1528/* Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change1529 * - mask passed in arg for lines of interest1530 * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)1531 * Caller should use TIOCGICOUNT to see which one it was1532 */1533static int1534hso_wait_modem_status(struct hso_serial *serial, unsigned long arg)1535{1536 DECLARE_WAITQUEUE(wait, current);1537 struct uart_icount cprev, cnow;1538 struct hso_tiocmget *tiocmget;1539 int ret;1540 1541 tiocmget = serial->tiocmget;1542 if (!tiocmget)1543 return -ENOENT;1544 /*1545 * note the counters on entry1546 */1547 spin_lock_irq(&serial->serial_lock);1548 memcpy(&cprev, &tiocmget->icount, sizeof(struct uart_icount));1549 spin_unlock_irq(&serial->serial_lock);1550 add_wait_queue(&tiocmget->waitq, &wait);1551 for (;;) {1552 spin_lock_irq(&serial->serial_lock);1553 memcpy(&cnow, &tiocmget->icount, sizeof(struct uart_icount));1554 spin_unlock_irq(&serial->serial_lock);1555 set_current_state(TASK_INTERRUPTIBLE);1556 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||1557 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||1558 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd))) {1559 ret = 0;1560 break;1561 }1562 schedule();1563 /* see if a signal did it */1564 if (signal_pending(current)) {1565 ret = -ERESTARTSYS;1566 break;1567 }1568 cprev = cnow;1569 }1570 __set_current_state(TASK_RUNNING);1571 remove_wait_queue(&tiocmget->waitq, &wait);1572 1573 return ret;1574}1575 1576/*1577 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)1578 * Return: write counters to the user passed counter struct1579 * NB: both 1->0 and 0->1 transitions are counted except for1580 * RI where only 0->1 is counted.1581 */1582static int hso_get_count(struct tty_struct *tty,1583 struct serial_icounter_struct *icount)1584{1585 struct uart_icount cnow;1586 struct hso_serial *serial = tty->driver_data;1587 struct hso_tiocmget *tiocmget = serial->tiocmget;1588 1589 memset(icount, 0, sizeof(struct serial_icounter_struct));1590 1591 if (!tiocmget)1592 return -ENOENT;1593 spin_lock_irq(&serial->serial_lock);1594 memcpy(&cnow, &tiocmget->icount, sizeof(struct uart_icount));1595 spin_unlock_irq(&serial->serial_lock);1596 1597 icount->cts = cnow.cts;1598 icount->dsr = cnow.dsr;1599 icount->rng = cnow.rng;1600 icount->dcd = cnow.dcd;1601 icount->rx = cnow.rx;1602 icount->tx = cnow.tx;1603 icount->frame = cnow.frame;1604 icount->overrun = cnow.overrun;1605 icount->parity = cnow.parity;1606 icount->brk = cnow.brk;1607 icount->buf_overrun = cnow.buf_overrun;1608 1609 return 0;1610}1611 1612 1613static int hso_serial_tiocmget(struct tty_struct *tty)1614{1615 int retval;1616 struct hso_serial *serial = tty->driver_data;1617 struct hso_tiocmget *tiocmget;1618 u16 UART_state_bitmap;1619 1620 /* sanity check */1621 if (!serial) {1622 hso_dbg(0x1, "no tty structures\n");1623 return -EINVAL;1624 }1625 spin_lock_irq(&serial->serial_lock);1626 retval = ((serial->rts_state) ? TIOCM_RTS : 0) |1627 ((serial->dtr_state) ? TIOCM_DTR : 0);1628 tiocmget = serial->tiocmget;1629 if (tiocmget) {1630 1631 UART_state_bitmap = le16_to_cpu(1632 tiocmget->prev_UART_state_bitmap);1633 if (UART_state_bitmap & B_RING_SIGNAL)1634 retval |= TIOCM_RNG;1635 if (UART_state_bitmap & B_RX_CARRIER)1636 retval |= TIOCM_CD;1637 if (UART_state_bitmap & B_TX_CARRIER)1638 retval |= TIOCM_DSR;1639 }1640 spin_unlock_irq(&serial->serial_lock);1641 return retval;1642}1643 1644static int hso_serial_tiocmset(struct tty_struct *tty,1645 unsigned int set, unsigned int clear)1646{1647 int val = 0;1648 unsigned long flags;1649 int if_num;1650 struct hso_serial *serial = tty->driver_data;1651 struct usb_interface *interface;1652 1653 /* sanity check */1654 if (!serial) {1655 hso_dbg(0x1, "no tty structures\n");1656 return -EINVAL;1657 }1658 1659 if ((serial->parent->port_spec & HSO_PORT_MASK) != HSO_PORT_MODEM)1660 return -EINVAL;1661 1662 interface = serial->parent->interface;1663 if_num = interface->cur_altsetting->desc.bInterfaceNumber;1664 1665 spin_lock_irqsave(&serial->serial_lock, flags);1666 if (set & TIOCM_RTS)1667 serial->rts_state = 1;1668 if (set & TIOCM_DTR)1669 serial->dtr_state = 1;1670 1671 if (clear & TIOCM_RTS)1672 serial->rts_state = 0;1673 if (clear & TIOCM_DTR)1674 serial->dtr_state = 0;1675 1676 if (serial->dtr_state)1677 val |= 0x01;1678 if (serial->rts_state)1679 val |= 0x02;1680 1681 spin_unlock_irqrestore(&serial->serial_lock, flags);1682 1683 return usb_control_msg(serial->parent->usb,1684 usb_sndctrlpipe(serial->parent->usb, 0), 0x22,1685 0x21, val, if_num, NULL, 0,1686 USB_CTRL_SET_TIMEOUT);1687}1688 1689static int hso_serial_ioctl(struct tty_struct *tty,1690 unsigned int cmd, unsigned long arg)1691{1692 struct hso_serial *serial = tty->driver_data;1693 int ret = 0;1694 hso_dbg(0x8, "IOCTL cmd: %d, arg: %ld\n", cmd, arg);1695 1696 if (!serial)1697 return -ENODEV;1698 switch (cmd) {1699 case TIOCMIWAIT:1700 ret = hso_wait_modem_status(serial, arg);1701 break;1702 default:1703 ret = -ENOIOCTLCMD;1704 break;1705 }1706 return ret;1707}1708 1709 1710/* starts a transmit */1711static void hso_kick_transmit(struct hso_serial *serial)1712{1713 unsigned long flags;1714 int res;1715 1716 spin_lock_irqsave(&serial->serial_lock, flags);1717 if (!serial->tx_buffer_count)1718 goto out;1719 1720 if (serial->tx_urb_used)1721 goto out;1722 1723 /* Wakeup USB interface if necessary */1724 if (hso_get_activity(serial->parent) == -EAGAIN)1725 goto out;1726 1727 /* Switch pointers around to avoid memcpy */1728 swap(serial->tx_buffer, serial->tx_data);1729 serial->tx_data_count = serial->tx_buffer_count;1730 serial->tx_buffer_count = 0;1731 1732 /* If serial->tx_data is set, it means we switched buffers */1733 if (serial->tx_data && serial->write_data) {1734 res = serial->write_data(serial);1735 if (res >= 0)1736 serial->tx_urb_used = 1;1737 }1738out:1739 spin_unlock_irqrestore(&serial->serial_lock, flags);1740}1741 1742/* make a request (for reading and writing data to muxed serial port) */1743static int mux_device_request(struct hso_serial *serial, u8 type, u16 port,1744 struct urb *ctrl_urb,1745 struct usb_ctrlrequest *ctrl_req,1746 u8 *ctrl_urb_data, u32 size)1747{1748 int result;1749 int pipe;1750 1751 /* Sanity check */1752 if (!serial || !ctrl_urb || !ctrl_req) {1753 pr_err("%s: Wrong arguments\n", __func__);1754 return -EINVAL;1755 }1756 1757 /* initialize */1758 ctrl_req->wValue = 0;1759 ctrl_req->wIndex = cpu_to_le16(hso_port_to_mux(port));1760 ctrl_req->wLength = cpu_to_le16(size);1761 1762 if (type == USB_CDC_GET_ENCAPSULATED_RESPONSE) {1763 /* Reading command */1764 ctrl_req->bRequestType = USB_DIR_IN |1765 USB_TYPE_OPTION_VENDOR |1766 USB_RECIP_INTERFACE;1767 ctrl_req->bRequest = USB_CDC_GET_ENCAPSULATED_RESPONSE;1768 pipe = usb_rcvctrlpipe(serial->parent->usb, 0);1769 } else {1770 /* Writing command */1771 ctrl_req->bRequestType = USB_DIR_OUT |1772 USB_TYPE_OPTION_VENDOR |1773 USB_RECIP_INTERFACE;1774 ctrl_req->bRequest = USB_CDC_SEND_ENCAPSULATED_COMMAND;1775 pipe = usb_sndctrlpipe(serial->parent->usb, 0);1776 }1777 /* syslog */1778 hso_dbg(0x2, "%s command (%02x) len: %d, port: %d\n",1779 type == USB_CDC_GET_ENCAPSULATED_RESPONSE ? "Read" : "Write",1780 ctrl_req->bRequestType, ctrl_req->wLength, port);1781 1782 /* Load ctrl urb */1783 ctrl_urb->transfer_flags = 0;1784 usb_fill_control_urb(ctrl_urb,1785 serial->parent->usb,1786 pipe,1787 (u8 *) ctrl_req,1788 ctrl_urb_data, size, ctrl_callback, serial);1789 /* Send it on merry way */1790 result = usb_submit_urb(ctrl_urb, GFP_ATOMIC);1791 if (result) {1792 dev_err(&ctrl_urb->dev->dev,1793 "%s failed submit ctrl_urb %d type %d\n", __func__,1794 result, type);1795 return result;1796 }1797 1798 /* done */1799 return size;1800}1801 1802/* called by intr_callback when read occurs */1803static int hso_mux_serial_read(struct hso_serial *serial)1804{1805 if (!serial)1806 return -EINVAL;1807 1808 /* clean data */1809 memset(serial->rx_data[0], 0, CTRL_URB_RX_SIZE);1810 /* make the request */1811 1812 if (serial->num_rx_urbs != 1) {1813 dev_err(&serial->parent->interface->dev,1814 "ERROR: mux'd reads with multiple buffers "1815 "not possible\n");1816 return 0;1817 }1818 return mux_device_request(serial,1819 USB_CDC_GET_ENCAPSULATED_RESPONSE,1820 serial->parent->port_spec & HSO_PORT_MASK,1821 serial->rx_urb[0],1822 &serial->ctrl_req_rx,1823 serial->rx_data[0], serial->rx_data_length);1824}1825 1826/* used for muxed serial port callback (muxed serial read) */1827static void intr_callback(struct urb *urb)1828{1829 struct hso_shared_int *shared_int = urb->context;1830 struct hso_serial *serial;1831 unsigned char *port_req;1832 int status = urb->status;1833 unsigned long flags;1834 int i;1835 1836 usb_mark_last_busy(urb->dev);1837 1838 /* sanity check */1839 if (!shared_int)1840 return;1841 1842 /* status check */1843 if (status) {1844 handle_usb_error(status, __func__, NULL);1845 return;1846 }1847 hso_dbg(0x8, "--- Got intr callback 0x%02X ---\n", status);1848 1849 /* what request? */1850 port_req = urb->transfer_buffer;1851 hso_dbg(0x8, "port_req = 0x%.2X\n", *port_req);1852 /* loop over all muxed ports to find the one sending this */1853 for (i = 0; i < 8; i++) {1854 /* max 8 channels on MUX */1855 if (*port_req & (1 << i)) {1856 serial = get_serial_by_shared_int_and_type(shared_int,1857 (1 << i));1858 if (serial != NULL) {1859 hso_dbg(0x1, "Pending read interrupt on port %d\n",1860 i);1861 spin_lock_irqsave(&serial->serial_lock, flags);1862 if (serial->rx_state == RX_IDLE &&1863 serial->port.count > 0) {1864 /* Setup and send a ctrl req read on1865 * port i */1866 if (!serial->rx_urb_filled[0]) {1867 serial->rx_state = RX_SENT;1868 hso_mux_serial_read(serial);1869 } else1870 serial->rx_state = RX_PENDING;1871 } else {1872 hso_dbg(0x1, "Already a read pending on port %d or port not open\n",1873 i);1874 }1875 spin_unlock_irqrestore(&serial->serial_lock,1876 flags);1877 }1878 }1879 }1880 /* Resubmit interrupt urb */1881 hso_mux_submit_intr_urb(shared_int, urb->dev, GFP_ATOMIC);1882}1883 1884/* called for writing to muxed serial port */1885static int hso_mux_serial_write_data(struct hso_serial *serial)1886{1887 if (NULL == serial)1888 return -EINVAL;1889 1890 return mux_device_request(serial,1891 USB_CDC_SEND_ENCAPSULATED_COMMAND,1892 serial->parent->port_spec & HSO_PORT_MASK,1893 serial->tx_urb,1894 &serial->ctrl_req_tx,1895 serial->tx_data, serial->tx_data_count);1896}1897 1898/* write callback for Diag and CS port */1899static void hso_std_serial_write_bulk_callback(struct urb *urb)1900{1901 struct hso_serial *serial = urb->context;1902 int status = urb->status;1903 unsigned long flags;1904 1905 /* sanity check */1906 if (!serial) {1907 hso_dbg(0x1, "serial == NULL\n");1908 return;1909 }1910 1911 spin_lock_irqsave(&serial->serial_lock, flags);1912 serial->tx_urb_used = 0;1913 spin_unlock_irqrestore(&serial->serial_lock, flags);1914 if (status) {1915 handle_usb_error(status, __func__, serial->parent);1916 return;1917 }1918 hso_put_activity(serial->parent);1919 tty_port_tty_wakeup(&serial->port);1920 hso_kick_transmit(serial);1921 1922 hso_dbg(0x1, "\n");1923}1924 1925/* called for writing diag or CS serial port */1926static int hso_std_serial_write_data(struct hso_serial *serial)1927{1928 int count = serial->tx_data_count;1929 int result;1930 1931 usb_fill_bulk_urb(serial->tx_urb,1932 serial->parent->usb,1933 usb_sndbulkpipe(serial->parent->usb,1934 serial->out_endp->1935 bEndpointAddress & 0x7F),1936 serial->tx_data, serial->tx_data_count,1937 hso_std_serial_write_bulk_callback, serial);1938 1939 result = usb_submit_urb(serial->tx_urb, GFP_ATOMIC);1940 if (result) {1941 dev_warn(&serial->parent->usb->dev,1942 "Failed to submit urb - res %d\n", result);1943 return result;1944 }1945 1946 return count;1947}1948 1949/* callback after read or write on muxed serial port */1950static void ctrl_callback(struct urb *urb)1951{1952 struct hso_serial *serial = urb->context;1953 struct usb_ctrlrequest *req;1954 int status = urb->status;1955 unsigned long flags;1956 1957 /* sanity check */1958 if (!serial)1959 return;1960 1961 spin_lock_irqsave(&serial->serial_lock, flags);1962 serial->tx_urb_used = 0;1963 spin_unlock_irqrestore(&serial->serial_lock, flags);1964 if (status) {1965 handle_usb_error(status, __func__, serial->parent);1966 return;1967 }1968 1969 /* what request? */1970 req = (struct usb_ctrlrequest *)(urb->setup_packet);1971 hso_dbg(0x8, "--- Got muxed ctrl callback 0x%02X ---\n", status);1972 hso_dbg(0x8, "Actual length of urb = %d\n", urb->actual_length);1973 DUMP1(urb->transfer_buffer, urb->actual_length);1974 1975 if (req->bRequestType ==1976 (USB_DIR_IN | USB_TYPE_OPTION_VENDOR | USB_RECIP_INTERFACE)) {1977 /* response to a read command */1978 serial->rx_urb_filled[0] = 1;1979 spin_lock_irqsave(&serial->serial_lock, flags);1980 put_rxbuf_data_and_resubmit_ctrl_urb(serial);1981 spin_unlock_irqrestore(&serial->serial_lock, flags);1982 } else {1983 hso_put_activity(serial->parent);1984 tty_port_tty_wakeup(&serial->port);1985 /* response to a write command */1986 hso_kick_transmit(serial);1987 }1988}1989 1990/* handle RX data for serial port */1991static int put_rxbuf_data(struct urb *urb, struct hso_serial *serial)1992{1993 struct tty_struct *tty;1994 int count;1995 1996 /* Sanity check */1997 if (urb == NULL || serial == NULL) {1998 hso_dbg(0x1, "serial = NULL\n");1999 return -2;2000 }2001 2002 tty = tty_port_tty_get(&serial->port);2003 2004 if (tty && tty_throttled(tty)) {2005 tty_kref_put(tty);2006 return -1;2007 }2008 2009 /* Push data to tty */2010 hso_dbg(0x1, "data to push to tty\n");2011 count = tty_buffer_request_room(&serial->port, urb->actual_length);2012 if (count >= urb->actual_length) {2013 tty_insert_flip_string(&serial->port, urb->transfer_buffer,2014 urb->actual_length);2015 tty_flip_buffer_push(&serial->port);2016 } else {2017 dev_warn(&serial->parent->usb->dev,2018 "dropping data, %d bytes lost\n", urb->actual_length);2019 }2020 2021 tty_kref_put(tty);2022 2023 serial->rx_urb_filled[hso_urb_to_index(serial, urb)] = 0;2024 2025 return 0;2026}2027 2028 2029/* Base driver functions */2030 2031static void hso_log_port(struct hso_device *hso_dev)2032{2033 char *port_type;2034 char port_dev[20];2035 2036 switch (hso_dev->port_spec & HSO_PORT_MASK) {2037 case HSO_PORT_CONTROL:2038 port_type = "Control";2039 break;2040 case HSO_PORT_APP:2041 port_type = "Application";2042 break;2043 case HSO_PORT_GPS:2044 port_type = "GPS";2045 break;2046 case HSO_PORT_GPS_CONTROL:2047 port_type = "GPS control";2048 break;2049 case HSO_PORT_APP2:2050 port_type = "Application2";2051 break;2052 case HSO_PORT_PCSC:2053 port_type = "PCSC";2054 break;2055 case HSO_PORT_DIAG:2056 port_type = "Diagnostic";2057 break;2058 case HSO_PORT_DIAG2:2059 port_type = "Diagnostic2";2060 break;2061 case HSO_PORT_MODEM:2062 port_type = "Modem";2063 break;2064 case HSO_PORT_NETWORK:2065 port_type = "Network";2066 break;2067 default:2068 port_type = "Unknown";2069 break;2070 }2071 if ((hso_dev->port_spec & HSO_PORT_MASK) == HSO_PORT_NETWORK) {2072 sprintf(port_dev, "%s", dev2net(hso_dev)->net->name);2073 } else2074 sprintf(port_dev, "/dev/%s%d", tty_filename,2075 dev2ser(hso_dev)->minor);2076 2077 dev_dbg(&hso_dev->interface->dev, "HSO: Found %s port %s\n",2078 port_type, port_dev);2079}2080 2081static int hso_start_net_device(struct hso_device *hso_dev)2082{2083 int i, result = 0;2084 struct hso_net *hso_net = dev2net(hso_dev);2085 2086 if (!hso_net)2087 return -ENODEV;2088 2089 /* send URBs for all read buffers */2090 for (i = 0; i < MUX_BULK_RX_BUF_COUNT; i++) {2091 2092 /* Prep a receive URB */2093 usb_fill_bulk_urb(hso_net->mux_bulk_rx_urb_pool[i],2094 hso_dev->usb,2095 usb_rcvbulkpipe(hso_dev->usb,2096 hso_net->in_endp->2097 bEndpointAddress & 0x7F),2098 hso_net->mux_bulk_rx_buf_pool[i],2099 MUX_BULK_RX_BUF_SIZE, read_bulk_callback,2100 hso_net);2101 2102 /* Put it out there so the device can send us stuff */2103 result = usb_submit_urb(hso_net->mux_bulk_rx_urb_pool[i],2104 GFP_NOIO);2105 if (result)2106 dev_warn(&hso_dev->usb->dev,2107 "%s failed mux_bulk_rx_urb[%d] %d\n", __func__,2108 i, result);2109 }2110 2111 return result;2112}2113 2114static int hso_stop_net_device(struct hso_device *hso_dev)2115{2116 int i;2117 struct hso_net *hso_net = dev2net(hso_dev);2118 2119 if (!hso_net)2120 return -ENODEV;2121 2122 for (i = 0; i < MUX_BULK_RX_BUF_COUNT; i++) {2123 if (hso_net->mux_bulk_rx_urb_pool[i])2124 usb_kill_urb(hso_net->mux_bulk_rx_urb_pool[i]);2125 2126 }2127 if (hso_net->mux_bulk_tx_urb)2128 usb_kill_urb(hso_net->mux_bulk_tx_urb);2129 2130 return 0;2131}2132 2133static int hso_start_serial_device(struct hso_device *hso_dev, gfp_t flags)2134{2135 int i, result = 0;2136 struct hso_serial *serial = dev2ser(hso_dev);2137 2138 if (!serial)2139 return -ENODEV;2140 2141 /* If it is not the MUX port fill in and submit a bulk urb (already2142 * allocated in hso_serial_start) */2143 if (!(serial->parent->port_spec & HSO_INTF_MUX)) {2144 for (i = 0; i < serial->num_rx_urbs; i++) {2145 usb_fill_bulk_urb(serial->rx_urb[i],2146 serial->parent->usb,2147 usb_rcvbulkpipe(serial->parent->usb,2148 serial->in_endp->2149 bEndpointAddress &2150 0x7F),2151 serial->rx_data[i],2152 serial->rx_data_length,2153 hso_std_serial_read_bulk_callback,2154 serial);2155 result = usb_submit_urb(serial->rx_urb[i], flags);2156 if (result) {2157 dev_warn(&serial->parent->usb->dev,2158 "Failed to submit urb - res %d\n",2159 result);2160 break;2161 }2162 }2163 } else {2164 mutex_lock(&serial->shared_int->shared_int_lock);2165 if (!serial->shared_int->use_count) {2166 result =2167 hso_mux_submit_intr_urb(serial->shared_int,2168 hso_dev->usb, flags);2169 }2170 serial->shared_int->use_count++;2171 mutex_unlock(&serial->shared_int->shared_int_lock);2172 }2173 if (serial->tiocmget)2174 tiocmget_submit_urb(serial,2175 serial->tiocmget,2176 serial->parent->usb);2177 return result;2178}2179 2180static int hso_stop_serial_device(struct hso_device *hso_dev)2181{2182 int i;2183 struct hso_serial *serial = dev2ser(hso_dev);2184 struct hso_tiocmget *tiocmget;2185 2186 if (!serial)2187 return -ENODEV;2188 2189 for (i = 0; i < serial->num_rx_urbs; i++) {2190 if (serial->rx_urb[i]) {2191 usb_kill_urb(serial->rx_urb[i]);2192 serial->rx_urb_filled[i] = 0;2193 }2194 }2195 serial->curr_rx_urb_idx = 0;2196 2197 if (serial->tx_urb)2198 usb_kill_urb(serial->tx_urb);2199 2200 if (serial->shared_int) {2201 mutex_lock(&serial->shared_int->shared_int_lock);2202 if (serial->shared_int->use_count &&2203 (--serial->shared_int->use_count == 0)) {2204 struct urb *urb;2205 2206 urb = serial->shared_int->shared_intr_urb;2207 if (urb)2208 usb_kill_urb(urb);2209 }2210 mutex_unlock(&serial->shared_int->shared_int_lock);2211 }2212 tiocmget = serial->tiocmget;2213 if (tiocmget) {2214 wake_up_interruptible(&tiocmget->waitq);2215 usb_kill_urb(tiocmget->urb);2216 }2217 2218 return 0;2219}2220 2221static void hso_serial_tty_unregister(struct hso_serial *serial)2222{2223 tty_unregister_device(tty_drv, serial->minor);2224 release_minor(serial);2225}2226 2227static void hso_serial_common_free(struct hso_serial *serial)2228{2229 int i;2230 2231 for (i = 0; i < serial->num_rx_urbs; i++) {2232 /* unlink and free RX URB */2233 usb_free_urb(serial->rx_urb[i]);2234 /* free the RX buffer */2235 kfree(serial->rx_data[i]);2236 }2237 2238 /* unlink and free TX URB */2239 usb_free_urb(serial->tx_urb);2240 kfree(serial->tx_buffer);2241 kfree(serial->tx_data);2242 tty_port_destroy(&serial->port);2243}2244 2245static int hso_serial_common_create(struct hso_serial *serial, int num_urbs,2246 int rx_size, int tx_size)2247{2248 int i;2249 2250 tty_port_init(&serial->port);2251 2252 if (obtain_minor(serial))2253 goto exit2;2254 2255 /* register our minor number */2256 serial->parent->dev = tty_port_register_device_attr(&serial->port,2257 tty_drv, serial->minor, &serial->parent->interface->dev,2258 serial->parent, hso_serial_dev_groups);2259 if (IS_ERR(serial->parent->dev)) {2260 release_minor(serial);2261 goto exit2;2262 }2263 2264 serial->magic = HSO_SERIAL_MAGIC;2265 spin_lock_init(&serial->serial_lock);2266 serial->num_rx_urbs = num_urbs;2267 2268 /* RX, allocate urb and initialize */2269 2270 /* prepare our RX buffer */2271 serial->rx_data_length = rx_size;2272 for (i = 0; i < serial->num_rx_urbs; i++) {2273 serial->rx_urb[i] = usb_alloc_urb(0, GFP_KERNEL);2274 if (!serial->rx_urb[i])2275 goto exit;2276 serial->rx_urb[i]->transfer_buffer = NULL;2277 serial->rx_urb[i]->transfer_buffer_length = 0;2278 serial->rx_data[i] = kzalloc(serial->rx_data_length,2279 GFP_KERNEL);2280 if (!serial->rx_data[i])2281 goto exit;2282 }2283 2284 /* TX, allocate urb and initialize */2285 serial->tx_urb = usb_alloc_urb(0, GFP_KERNEL);2286 if (!serial->tx_urb)2287 goto exit;2288 serial->tx_urb->transfer_buffer = NULL;2289 serial->tx_urb->transfer_buffer_length = 0;2290 /* prepare our TX buffer */2291 serial->tx_data_count = 0;2292 serial->tx_buffer_count = 0;2293 serial->tx_data_length = tx_size;2294 serial->tx_data = kzalloc(serial->tx_data_length, GFP_KERNEL);2295 if (!serial->tx_data)2296 goto exit;2297 2298 serial->tx_buffer = kzalloc(serial->tx_data_length, GFP_KERNEL);2299 if (!serial->tx_buffer)2300 goto exit;2301 2302 return 0;2303exit:2304 hso_serial_tty_unregister(serial);2305exit2:2306 hso_serial_common_free(serial);2307 return -1;2308}2309 2310/* Creates a general hso device */2311static struct hso_device *hso_create_device(struct usb_interface *intf,2312 int port_spec)2313{2314 struct hso_device *hso_dev;2315 2316 hso_dev = kzalloc(sizeof(*hso_dev), GFP_KERNEL);2317 if (!hso_dev)2318 return NULL;2319 2320 hso_dev->port_spec = port_spec;2321 hso_dev->usb = interface_to_usbdev(intf);2322 hso_dev->interface = intf;2323 kref_init(&hso_dev->ref);2324 mutex_init(&hso_dev->mutex);2325 2326 INIT_WORK(&hso_dev->async_get_intf, async_get_intf);2327 INIT_WORK(&hso_dev->async_put_intf, async_put_intf);2328 2329 return hso_dev;2330}2331 2332/* Removes a network device in the network device table */2333static int remove_net_device(struct hso_device *hso_dev)2334{2335 int i;2336 2337 for (i = 0; i < HSO_MAX_NET_DEVICES; i++) {2338 if (network_table[i] == hso_dev) {2339 network_table[i] = NULL;2340 break;2341 }2342 }2343 if (i == HSO_MAX_NET_DEVICES)2344 return -1;2345 return 0;2346}2347 2348/* Frees our network device */2349static void hso_free_net_device(struct hso_device *hso_dev)2350{2351 int i;2352 struct hso_net *hso_net = dev2net(hso_dev);2353 2354 if (!hso_net)2355 return;2356 2357 remove_net_device(hso_net->parent);2358 2359 if (hso_net->net)2360 unregister_netdev(hso_net->net);2361 2362 /* start freeing */2363 for (i = 0; i < MUX_BULK_RX_BUF_COUNT; i++) {2364 usb_free_urb(hso_net->mux_bulk_rx_urb_pool[i]);2365 kfree(hso_net->mux_bulk_rx_buf_pool[i]);2366 hso_net->mux_bulk_rx_buf_pool[i] = NULL;2367 }2368 usb_free_urb(hso_net->mux_bulk_tx_urb);2369 kfree(hso_net->mux_bulk_tx_buf);2370 hso_net->mux_bulk_tx_buf = NULL;2371 2372 if (hso_net->net)2373 free_netdev(hso_net->net);2374 2375 kfree(hso_dev);2376}2377 2378static const struct net_device_ops hso_netdev_ops = {2379 .ndo_open = hso_net_open,2380 .ndo_stop = hso_net_close,2381 .ndo_start_xmit = hso_net_start_xmit,2382 .ndo_tx_timeout = hso_net_tx_timeout,2383};2384 2385/* initialize the network interface */2386static void hso_net_init(struct net_device *net)2387{2388 struct hso_net *hso_net = netdev_priv(net);2389 2390 hso_dbg(0x1, "sizeof hso_net is %zu\n", sizeof(*hso_net));2391 2392 /* fill in the other fields */2393 net->netdev_ops = &hso_netdev_ops;2394 net->watchdog_timeo = HSO_NET_TX_TIMEOUT;2395 net->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;2396 net->type = ARPHRD_NONE;2397 net->mtu = DEFAULT_MTU - 14;2398 net->tx_queue_len = 10;2399 net->ethtool_ops = &ops;2400 2401 /* and initialize the semaphore */2402 spin_lock_init(&hso_net->net_lock);2403}2404 2405/* Adds a network device in the network device table */2406static int add_net_device(struct hso_device *hso_dev)2407{2408 int i;2409 2410 for (i = 0; i < HSO_MAX_NET_DEVICES; i++) {2411 if (network_table[i] == NULL) {2412 network_table[i] = hso_dev;2413 break;2414 }2415 }2416 if (i == HSO_MAX_NET_DEVICES)2417 return -1;2418 return 0;2419}2420 2421static int hso_rfkill_set_block(void *data, bool blocked)2422{2423 struct hso_device *hso_dev = data;2424 int enabled = !blocked;2425 int rv;2426 2427 mutex_lock(&hso_dev->mutex);2428 if (hso_dev->usb_gone)2429 rv = 0;2430 else2431 rv = usb_control_msg(hso_dev->usb, usb_sndctrlpipe(hso_dev->usb, 0),2432 enabled ? 0x82 : 0x81, 0x40, 0, 0, NULL, 0,2433 USB_CTRL_SET_TIMEOUT);2434 mutex_unlock(&hso_dev->mutex);2435 return rv;2436}2437 2438static const struct rfkill_ops hso_rfkill_ops = {2439 .set_block = hso_rfkill_set_block,2440};2441 2442/* Creates and sets up everything for rfkill */2443static void hso_create_rfkill(struct hso_device *hso_dev,2444 struct usb_interface *interface)2445{2446 struct hso_net *hso_net = dev2net(hso_dev);2447 struct device *dev = &hso_net->net->dev;2448 static u32 rfkill_counter;2449 2450 snprintf(hso_net->name, sizeof(hso_net->name), "hso-%d",2451 rfkill_counter++);2452 2453 hso_net->rfkill = rfkill_alloc(hso_net->name,2454 &interface_to_usbdev(interface)->dev,2455 RFKILL_TYPE_WWAN,2456 &hso_rfkill_ops, hso_dev);2457 if (!hso_net->rfkill)2458 return;2459 2460 if (rfkill_register(hso_net->rfkill) < 0) {2461 rfkill_destroy(hso_net->rfkill);2462 hso_net->rfkill = NULL;2463 dev_err(dev, "%s - Failed to register rfkill\n", __func__);2464 return;2465 }2466}2467 2468static const struct device_type hso_type = {2469 .name = "wwan",2470};2471 2472/* Creates our network device */2473static struct hso_device *hso_create_net_device(struct usb_interface *interface,2474 int port_spec)2475{2476 int result, i;2477 struct net_device *net;2478 struct hso_net *hso_net;2479 struct hso_device *hso_dev;2480 2481 hso_dev = hso_create_device(interface, port_spec);2482 if (!hso_dev)2483 return NULL;2484 2485 /* allocate our network device, then we can put in our private data */2486 /* call hso_net_init to do the basic initialization */2487 net = alloc_netdev(sizeof(struct hso_net), "hso%d", NET_NAME_UNKNOWN,2488 hso_net_init);2489 if (!net) {2490 dev_err(&interface->dev, "Unable to create ethernet device\n");2491 goto err_hso_dev;2492 }2493 2494 hso_net = netdev_priv(net);2495 2496 hso_dev->port_data.dev_net = hso_net;2497 hso_net->net = net;2498 hso_net->parent = hso_dev;2499 2500 hso_net->in_endp = hso_get_ep(interface, USB_ENDPOINT_XFER_BULK,2501 USB_DIR_IN);2502 if (!hso_net->in_endp) {2503 dev_err(&interface->dev, "Can't find BULK IN endpoint\n");2504 goto err_net;2505 }2506 hso_net->out_endp = hso_get_ep(interface, USB_ENDPOINT_XFER_BULK,2507 USB_DIR_OUT);2508 if (!hso_net->out_endp) {2509 dev_err(&interface->dev, "Can't find BULK OUT endpoint\n");2510 goto err_net;2511 }2512 SET_NETDEV_DEV(net, &interface->dev);2513 SET_NETDEV_DEVTYPE(net, &hso_type);2514 2515 /* start allocating */2516 for (i = 0; i < MUX_BULK_RX_BUF_COUNT; i++) {2517 hso_net->mux_bulk_rx_urb_pool[i] = usb_alloc_urb(0, GFP_KERNEL);2518 if (!hso_net->mux_bulk_rx_urb_pool[i])2519 goto err_mux_bulk_rx;2520 hso_net->mux_bulk_rx_buf_pool[i] = kzalloc(MUX_BULK_RX_BUF_SIZE,2521 GFP_KERNEL);2522 if (!hso_net->mux_bulk_rx_buf_pool[i])2523 goto err_mux_bulk_rx;2524 }2525 hso_net->mux_bulk_tx_urb = usb_alloc_urb(0, GFP_KERNEL);2526 if (!hso_net->mux_bulk_tx_urb)2527 goto err_mux_bulk_rx;2528 hso_net->mux_bulk_tx_buf = kzalloc(MUX_BULK_TX_BUF_SIZE, GFP_KERNEL);2529 if (!hso_net->mux_bulk_tx_buf)2530 goto err_free_tx_urb;2531 2532 result = add_net_device(hso_dev);2533 if (result) {2534 dev_err(&interface->dev, "Failed to add net device\n");2535 goto err_free_tx_buf;2536 }2537 2538 /* registering our net device */2539 result = register_netdev(net);2540 if (result) {2541 dev_err(&interface->dev, "Failed to register device\n");2542 goto err_rmv_ndev;2543 }2544 2545 hso_log_port(hso_dev);2546 2547 hso_create_rfkill(hso_dev, interface);2548 2549 return hso_dev;2550 2551err_rmv_ndev:2552 remove_net_device(hso_dev);2553err_free_tx_buf:2554 kfree(hso_net->mux_bulk_tx_buf);2555err_free_tx_urb:2556 usb_free_urb(hso_net->mux_bulk_tx_urb);2557err_mux_bulk_rx:2558 for (i = 0; i < MUX_BULK_RX_BUF_COUNT; i++) {2559 usb_free_urb(hso_net->mux_bulk_rx_urb_pool[i]);2560 kfree(hso_net->mux_bulk_rx_buf_pool[i]);2561 }2562err_net:2563 free_netdev(net);2564err_hso_dev:2565 kfree(hso_dev);2566 return NULL;2567}2568 2569static void hso_free_tiomget(struct hso_serial *serial)2570{2571 struct hso_tiocmget *tiocmget;2572 if (!serial)2573 return;2574 tiocmget = serial->tiocmget;2575 if (tiocmget) {2576 usb_free_urb(tiocmget->urb);2577 tiocmget->urb = NULL;2578 serial->tiocmget = NULL;2579 kfree(tiocmget->serial_state_notification);2580 tiocmget->serial_state_notification = NULL;2581 kfree(tiocmget);2582 }2583}2584 2585/* Frees an AT channel ( goes for both mux and non-mux ) */2586static void hso_free_serial_device(struct hso_device *hso_dev)2587{2588 struct hso_serial *serial = dev2ser(hso_dev);2589 2590 if (!serial)2591 return;2592 2593 hso_serial_common_free(serial);2594 2595 if (serial->shared_int) {2596 mutex_lock(&serial->shared_int->shared_int_lock);2597 if (--serial->shared_int->ref_count == 0)2598 hso_free_shared_int(serial->shared_int);2599 else2600 mutex_unlock(&serial->shared_int->shared_int_lock);2601 }2602 hso_free_tiomget(serial);2603 kfree(serial);2604 kfree(hso_dev);2605}2606 2607/* Creates a bulk AT channel */2608static struct hso_device *hso_create_bulk_serial_device(2609 struct usb_interface *interface, int port)2610{2611 struct hso_device *hso_dev;2612 struct hso_serial *serial;2613 int num_urbs;2614 struct hso_tiocmget *tiocmget;2615 2616 hso_dev = hso_create_device(interface, port);2617 if (!hso_dev)2618 return NULL;2619 2620 serial = kzalloc(sizeof(*serial), GFP_KERNEL);2621 if (!serial)2622 goto exit;2623 2624 serial->parent = hso_dev;2625 hso_dev->port_data.dev_serial = serial;2626 2627 if ((port & HSO_PORT_MASK) == HSO_PORT_MODEM) {2628 num_urbs = 2;2629 serial->tiocmget = kzalloc(sizeof(struct hso_tiocmget),2630 GFP_KERNEL);2631 if (!serial->tiocmget)2632 goto exit;2633 serial->tiocmget->serial_state_notification2634 = kzalloc(sizeof(struct hso_serial_state_notification),2635 GFP_KERNEL);2636 if (!serial->tiocmget->serial_state_notification)2637 goto exit;2638 tiocmget = serial->tiocmget;2639 tiocmget->endp = hso_get_ep(interface,2640 USB_ENDPOINT_XFER_INT,2641 USB_DIR_IN);2642 if (!tiocmget->endp) {2643 dev_err(&interface->dev, "Failed to find INT IN ep\n");2644 goto exit;2645 }2646 2647 tiocmget->urb = usb_alloc_urb(0, GFP_KERNEL);2648 if (!tiocmget->urb)2649 goto exit;2650 2651 mutex_init(&tiocmget->mutex);2652 init_waitqueue_head(&tiocmget->waitq);2653 } else {2654 num_urbs = 1;2655 }2656 2657 if (hso_serial_common_create(serial, num_urbs, BULK_URB_RX_SIZE,2658 BULK_URB_TX_SIZE))2659 goto exit;2660 2661 serial->in_endp = hso_get_ep(interface, USB_ENDPOINT_XFER_BULK,2662 USB_DIR_IN);2663 if (!serial->in_endp) {2664 dev_err(&interface->dev, "Failed to find BULK IN ep\n");2665 goto exit2;2666 }2667 2668 if (!2669 (serial->out_endp =2670 hso_get_ep(interface, USB_ENDPOINT_XFER_BULK, USB_DIR_OUT))) {2671 dev_err(&interface->dev, "Failed to find BULK OUT ep\n");2672 goto exit2;2673 }2674 2675 serial->write_data = hso_std_serial_write_data;2676 2677 /* setup the proc dirs and files if needed */2678 hso_log_port(hso_dev);2679 2680 /* done, return it */2681 return hso_dev;2682 2683exit2:2684 hso_serial_tty_unregister(serial);2685 hso_serial_common_free(serial);2686exit:2687 hso_free_tiomget(serial);2688 kfree(serial);2689 kfree(hso_dev);2690 return NULL;2691}2692 2693/* Creates a multiplexed AT channel */2694static2695struct hso_device *hso_create_mux_serial_device(struct usb_interface *interface,2696 int port,2697 struct hso_shared_int *mux)2698{2699 struct hso_device *hso_dev;2700 struct hso_serial *serial;2701 int port_spec;2702 2703 port_spec = HSO_INTF_MUX;2704 port_spec &= ~HSO_PORT_MASK;2705 2706 port_spec |= hso_mux_to_port(port);2707 if ((port_spec & HSO_PORT_MASK) == HSO_PORT_NO_PORT)2708 return NULL;2709 2710 hso_dev = hso_create_device(interface, port_spec);2711 if (!hso_dev)2712 return NULL;2713 2714 serial = kzalloc(sizeof(*serial), GFP_KERNEL);2715 if (!serial)2716 goto err_free_dev;2717 2718 hso_dev->port_data.dev_serial = serial;2719 serial->parent = hso_dev;2720 2721 if (hso_serial_common_create2722 (serial, 1, CTRL_URB_RX_SIZE, CTRL_URB_TX_SIZE))2723 goto err_free_serial;2724 2725 serial->tx_data_length--;2726 serial->write_data = hso_mux_serial_write_data;2727 2728 serial->shared_int = mux;2729 mutex_lock(&serial->shared_int->shared_int_lock);2730 serial->shared_int->ref_count++;2731 mutex_unlock(&serial->shared_int->shared_int_lock);2732 2733 /* setup the proc dirs and files if needed */2734 hso_log_port(hso_dev);2735 2736 /* done, return it */2737 return hso_dev;2738 2739err_free_serial:2740 kfree(serial);2741err_free_dev:2742 kfree(hso_dev);2743 return NULL;2744 2745}2746 2747static void hso_free_shared_int(struct hso_shared_int *mux)2748{2749 usb_free_urb(mux->shared_intr_urb);2750 kfree(mux->shared_intr_buf);2751 mutex_unlock(&mux->shared_int_lock);2752 kfree(mux);2753}2754 2755static2756struct hso_shared_int *hso_create_shared_int(struct usb_interface *interface)2757{2758 struct hso_shared_int *mux = kzalloc(sizeof(*mux), GFP_KERNEL);2759 2760 if (!mux)2761 return NULL;2762 2763 mux->intr_endp = hso_get_ep(interface, USB_ENDPOINT_XFER_INT,2764 USB_DIR_IN);2765 if (!mux->intr_endp) {2766 dev_err(&interface->dev, "Can't find INT IN endpoint\n");2767 goto exit;2768 }2769 2770 mux->shared_intr_urb = usb_alloc_urb(0, GFP_KERNEL);2771 if (!mux->shared_intr_urb)2772 goto exit;2773 mux->shared_intr_buf =2774 kzalloc(le16_to_cpu(mux->intr_endp->wMaxPacketSize),2775 GFP_KERNEL);2776 if (!mux->shared_intr_buf)2777 goto exit;2778 2779 mutex_init(&mux->shared_int_lock);2780 2781 return mux;2782 2783exit:2784 kfree(mux->shared_intr_buf);2785 usb_free_urb(mux->shared_intr_urb);2786 kfree(mux);2787 return NULL;2788}2789 2790/* Gets the port spec for a certain interface */2791static int hso_get_config_data(struct usb_interface *interface)2792{2793 struct usb_device *usbdev = interface_to_usbdev(interface);2794 u8 *config_data = kmalloc(17, GFP_KERNEL);2795 u32 if_num = interface->cur_altsetting->desc.bInterfaceNumber;2796 s32 result;2797 2798 if (!config_data)2799 return -ENOMEM;2800 if (usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0),2801 0x86, 0xC0, 0, 0, config_data, 17,2802 USB_CTRL_SET_TIMEOUT) != 0x11) {2803 kfree(config_data);2804 return -EIO;2805 }2806 2807 /* check if we have a valid interface */2808 if (if_num > 16) {2809 kfree(config_data);2810 return -EINVAL;2811 }2812 2813 switch (config_data[if_num]) {2814 case 0x0:2815 result = 0;2816 break;2817 case 0x1:2818 result = HSO_PORT_DIAG;2819 break;2820 case 0x2:2821 result = HSO_PORT_GPS;2822 break;2823 case 0x3:2824 result = HSO_PORT_GPS_CONTROL;2825 break;2826 case 0x4:2827 result = HSO_PORT_APP;2828 break;2829 case 0x5:2830 result = HSO_PORT_APP2;2831 break;2832 case 0x6:2833 result = HSO_PORT_CONTROL;2834 break;2835 case 0x7:2836 result = HSO_PORT_NETWORK;2837 break;2838 case 0x8:2839 result = HSO_PORT_MODEM;2840 break;2841 case 0x9:2842 result = HSO_PORT_MSD;2843 break;2844 case 0xa:2845 result = HSO_PORT_PCSC;2846 break;2847 case 0xb:2848 result = HSO_PORT_VOICE;2849 break;2850 default:2851 result = 0;2852 }2853 2854 if (result)2855 result |= HSO_INTF_BULK;2856 2857 if (config_data[16] & 0x1)2858 result |= HSO_INFO_CRC_BUG;2859 2860 kfree(config_data);2861 return result;2862}2863 2864/* called once for each interface upon device insertion */2865static int hso_probe(struct usb_interface *interface,2866 const struct usb_device_id *id)2867{2868 int mux, i, if_num, port_spec;2869 unsigned char port_mask;2870 struct hso_device *hso_dev = NULL;2871 struct hso_shared_int *shared_int;2872 struct hso_device *tmp_dev = NULL;2873 2874 if (interface->cur_altsetting->desc.bInterfaceClass != 0xFF) {2875 dev_err(&interface->dev, "Not our interface\n");2876 return -ENODEV;2877 }2878 2879 if_num = interface->cur_altsetting->desc.bInterfaceNumber;2880 2881 /* Get the interface/port specification from either driver_info or from2882 * the device itself */2883 if (id->driver_info) {2884 /* if_num is controlled by the device, driver_info is a 0 terminated2885 * array. Make sure, the access is in bounds! */2886 for (i = 0; i <= if_num; ++i)2887 if (((u32 *)(id->driver_info))[i] == 0)2888 goto exit;2889 port_spec = ((u32 *)(id->driver_info))[if_num];2890 } else {2891 port_spec = hso_get_config_data(interface);2892 if (port_spec < 0)2893 goto exit;2894 }2895 2896 /* Check if we need to switch to alt interfaces prior to port2897 * configuration */2898 if (interface->num_altsetting > 1)2899 usb_set_interface(interface_to_usbdev(interface), if_num, 1);2900 interface->needs_remote_wakeup = 1;2901 2902 /* Allocate new hso device(s) */2903 switch (port_spec & HSO_INTF_MASK) {2904 case HSO_INTF_MUX:2905 if ((port_spec & HSO_PORT_MASK) == HSO_PORT_NETWORK) {2906 /* Create the network device */2907 if (!disable_net) {2908 hso_dev = hso_create_net_device(interface,2909 port_spec);2910 if (!hso_dev)2911 goto exit;2912 tmp_dev = hso_dev;2913 }2914 }2915 2916 if (hso_get_mux_ports(interface, &port_mask))2917 /* TODO: de-allocate everything */2918 goto exit;2919 2920 shared_int = hso_create_shared_int(interface);2921 if (!shared_int)2922 goto exit;2923 2924 for (i = 1, mux = 0; i < 0x100; i = i << 1, mux++) {2925 if (port_mask & i) {2926 hso_dev = hso_create_mux_serial_device(2927 interface, i, shared_int);2928 if (!hso_dev)2929 goto exit;2930 }2931 }2932 2933 if (tmp_dev)2934 hso_dev = tmp_dev;2935 break;2936 2937 case HSO_INTF_BULK:2938 /* It's a regular bulk interface */2939 if ((port_spec & HSO_PORT_MASK) == HSO_PORT_NETWORK) {2940 if (!disable_net)2941 hso_dev =2942 hso_create_net_device(interface, port_spec);2943 } else {2944 hso_dev =2945 hso_create_bulk_serial_device(interface, port_spec);2946 }2947 if (!hso_dev)2948 goto exit;2949 break;2950 default:2951 goto exit;2952 }2953 2954 /* save our data pointer in this device */2955 usb_set_intfdata(interface, hso_dev);2956 2957 /* done */2958 return 0;2959exit:2960 hso_free_interface(interface);2961 return -ENODEV;2962}2963 2964/* device removed, cleaning up */2965static void hso_disconnect(struct usb_interface *interface)2966{2967 hso_free_interface(interface);2968 2969 /* remove reference of our private data */2970 usb_set_intfdata(interface, NULL);2971}2972 2973static void async_get_intf(struct work_struct *data)2974{2975 struct hso_device *hso_dev =2976 container_of(data, struct hso_device, async_get_intf);2977 usb_autopm_get_interface(hso_dev->interface);2978}2979 2980static void async_put_intf(struct work_struct *data)2981{2982 struct hso_device *hso_dev =2983 container_of(data, struct hso_device, async_put_intf);2984 usb_autopm_put_interface(hso_dev->interface);2985}2986 2987static int hso_get_activity(struct hso_device *hso_dev)2988{2989 if (hso_dev->usb->state == USB_STATE_SUSPENDED) {2990 if (!hso_dev->is_active) {2991 hso_dev->is_active = 1;2992 schedule_work(&hso_dev->async_get_intf);2993 }2994 }2995 2996 if (hso_dev->usb->state != USB_STATE_CONFIGURED)2997 return -EAGAIN;2998 2999 usb_mark_last_busy(hso_dev->usb);3000 3001 return 0;3002}3003 3004static int hso_put_activity(struct hso_device *hso_dev)3005{3006 if (hso_dev->usb->state != USB_STATE_SUSPENDED) {3007 if (hso_dev->is_active) {3008 hso_dev->is_active = 0;3009 schedule_work(&hso_dev->async_put_intf);3010 return -EAGAIN;3011 }3012 }3013 hso_dev->is_active = 0;3014 return 0;3015}3016 3017/* called by kernel when we need to suspend device */3018static int hso_suspend(struct usb_interface *iface, pm_message_t message)3019{3020 int i, result;3021 3022 /* Stop all serial ports */3023 for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++) {3024 if (serial_table[i] && (serial_table[i]->interface == iface)) {3025 result = hso_stop_serial_device(serial_table[i]);3026 if (result)3027 goto out;3028 }3029 }3030 3031 /* Stop all network ports */3032 for (i = 0; i < HSO_MAX_NET_DEVICES; i++) {3033 if (network_table[i] &&3034 (network_table[i]->interface == iface)) {3035 result = hso_stop_net_device(network_table[i]);3036 if (result)3037 goto out;3038 }3039 }3040 3041out:3042 return 0;3043}3044 3045/* called by kernel when we need to resume device */3046static int hso_resume(struct usb_interface *iface)3047{3048 int i, result = 0;3049 struct hso_net *hso_net;3050 3051 /* Start all serial ports */3052 for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++) {3053 if (serial_table[i] && (serial_table[i]->interface == iface)) {3054 if (dev2ser(serial_table[i])->port.count) {3055 result =3056 hso_start_serial_device(serial_table[i], GFP_NOIO);3057 hso_kick_transmit(dev2ser(serial_table[i]));3058 if (result)3059 goto out;3060 }3061 }3062 }3063 3064 /* Start all network ports */3065 for (i = 0; i < HSO_MAX_NET_DEVICES; i++) {3066 if (network_table[i] &&3067 (network_table[i]->interface == iface)) {3068 hso_net = dev2net(network_table[i]);3069 if (hso_net->flags & IFF_UP) {3070 /* First transmit any lingering data,3071 then restart the device. */3072 if (hso_net->skb_tx_buf) {3073 dev_dbg(&iface->dev,3074 "Transmitting"3075 " lingering data\n");3076 hso_net_start_xmit(hso_net->skb_tx_buf,3077 hso_net->net);3078 hso_net->skb_tx_buf = NULL;3079 }3080 result = hso_start_net_device(network_table[i]);3081 if (result)3082 goto out;3083 }3084 }3085 }3086 3087out:3088 return result;3089}3090 3091static void hso_serial_ref_free(struct kref *ref)3092{3093 struct hso_device *hso_dev = container_of(ref, struct hso_device, ref);3094 3095 hso_free_serial_device(hso_dev);3096}3097 3098static void hso_free_interface(struct usb_interface *interface)3099{3100 struct hso_serial *serial;3101 int i;3102 3103 for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++) {3104 if (serial_table[i] &&3105 (serial_table[i]->interface == interface)) {3106 serial = dev2ser(serial_table[i]);3107 tty_port_tty_hangup(&serial->port, false);3108 mutex_lock(&serial->parent->mutex);3109 serial->parent->usb_gone = 1;3110 mutex_unlock(&serial->parent->mutex);3111 cancel_work_sync(&serial_table[i]->async_put_intf);3112 cancel_work_sync(&serial_table[i]->async_get_intf);3113 hso_serial_tty_unregister(serial);3114 kref_put(&serial->parent->ref, hso_serial_ref_free);3115 }3116 }3117 3118 for (i = 0; i < HSO_MAX_NET_DEVICES; i++) {3119 if (network_table[i] &&3120 (network_table[i]->interface == interface)) {3121 struct rfkill *rfk = dev2net(network_table[i])->rfkill;3122 /* hso_stop_net_device doesn't stop the net queue since3123 * traffic needs to start it again when suspended */3124 netif_stop_queue(dev2net(network_table[i])->net);3125 hso_stop_net_device(network_table[i]);3126 cancel_work_sync(&network_table[i]->async_put_intf);3127 cancel_work_sync(&network_table[i]->async_get_intf);3128 if (rfk) {3129 rfkill_unregister(rfk);3130 rfkill_destroy(rfk);3131 }3132 hso_free_net_device(network_table[i]);3133 }3134 }3135}3136 3137/* Helper functions */3138 3139/* Get the endpoint ! */3140static struct usb_endpoint_descriptor *hso_get_ep(struct usb_interface *intf,3141 int type, int dir)3142{3143 int i;3144 struct usb_host_interface *iface = intf->cur_altsetting;3145 struct usb_endpoint_descriptor *endp;3146 3147 for (i = 0; i < iface->desc.bNumEndpoints; i++) {3148 endp = &iface->endpoint[i].desc;3149 if (((endp->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == dir) &&3150 (usb_endpoint_type(endp) == type))3151 return endp;3152 }3153 3154 return NULL;3155}3156 3157/* Get the byte that describes which ports are enabled */3158static int hso_get_mux_ports(struct usb_interface *intf, unsigned char *ports)3159{3160 int i;3161 struct usb_host_interface *iface = intf->cur_altsetting;3162 3163 if (iface->extralen == 3) {3164 *ports = iface->extra[2];3165 return 0;3166 }3167 3168 for (i = 0; i < iface->desc.bNumEndpoints; i++) {3169 if (iface->endpoint[i].extralen == 3) {3170 *ports = iface->endpoint[i].extra[2];3171 return 0;3172 }3173 }3174 3175 return -1;3176}3177 3178/* interrupt urb needs to be submitted, used for serial read of muxed port */3179static int hso_mux_submit_intr_urb(struct hso_shared_int *shared_int,3180 struct usb_device *usb, gfp_t gfp)3181{3182 int result;3183 3184 usb_fill_int_urb(shared_int->shared_intr_urb, usb,3185 usb_rcvintpipe(usb,3186 shared_int->intr_endp->bEndpointAddress & 0x7F),3187 shared_int->shared_intr_buf,3188 1,3189 intr_callback, shared_int,3190 shared_int->intr_endp->bInterval);3191 3192 result = usb_submit_urb(shared_int->shared_intr_urb, gfp);3193 if (result)3194 dev_warn(&usb->dev, "%s failed mux_intr_urb %d\n", __func__,3195 result);3196 3197 return result;3198}3199 3200/* operations setup of the serial interface */3201static const struct tty_operations hso_serial_ops = {3202 .open = hso_serial_open,3203 .close = hso_serial_close,3204 .write = hso_serial_write,3205 .write_room = hso_serial_write_room,3206 .cleanup = hso_serial_cleanup,3207 .ioctl = hso_serial_ioctl,3208 .set_termios = hso_serial_set_termios,3209 .chars_in_buffer = hso_serial_chars_in_buffer,3210 .tiocmget = hso_serial_tiocmget,3211 .tiocmset = hso_serial_tiocmset,3212 .get_icount = hso_get_count,3213 .unthrottle = hso_unthrottle3214};3215 3216static struct usb_driver hso_driver = {3217 .name = driver_name,3218 .probe = hso_probe,3219 .disconnect = hso_disconnect,3220 .id_table = hso_ids,3221 .suspend = hso_suspend,3222 .resume = hso_resume,3223 .reset_resume = hso_resume,3224 .supports_autosuspend = 1,3225 .disable_hub_initiated_lpm = 1,3226};3227 3228static int __init hso_init(void)3229{3230 int result;3231 3232 /* allocate our driver using the proper amount of supported minors */3233 tty_drv = tty_alloc_driver(HSO_SERIAL_TTY_MINORS, TTY_DRIVER_REAL_RAW |3234 TTY_DRIVER_DYNAMIC_DEV);3235 if (IS_ERR(tty_drv))3236 return PTR_ERR(tty_drv);3237 3238 /* fill in all needed values */3239 tty_drv->driver_name = driver_name;3240 tty_drv->name = tty_filename;3241 3242 /* if major number is provided as parameter, use that one */3243 if (tty_major)3244 tty_drv->major = tty_major;3245 3246 tty_drv->minor_start = 0;3247 tty_drv->type = TTY_DRIVER_TYPE_SERIAL;3248 tty_drv->subtype = SERIAL_TYPE_NORMAL;3249 tty_drv->init_termios = tty_std_termios;3250 hso_init_termios(&tty_drv->init_termios);3251 tty_set_operations(tty_drv, &hso_serial_ops);3252 3253 /* register the tty driver */3254 result = tty_register_driver(tty_drv);3255 if (result) {3256 pr_err("%s - tty_register_driver failed(%d)\n",3257 __func__, result);3258 goto err_free_tty;3259 }3260 3261 /* register this module as an usb driver */3262 result = usb_register(&hso_driver);3263 if (result) {3264 pr_err("Could not register hso driver - error: %d\n", result);3265 goto err_unreg_tty;3266 }3267 3268 /* done */3269 return 0;3270err_unreg_tty:3271 tty_unregister_driver(tty_drv);3272err_free_tty:3273 tty_driver_kref_put(tty_drv);3274 return result;3275}3276 3277static void __exit hso_exit(void)3278{3279 tty_unregister_driver(tty_drv);3280 /* deregister the usb driver */3281 usb_deregister(&hso_driver);3282 tty_driver_kref_put(tty_drv);3283}3284 3285/* Module definitions */3286module_init(hso_init);3287module_exit(hso_exit);3288 3289MODULE_AUTHOR(MOD_AUTHOR);3290MODULE_DESCRIPTION(MOD_DESCRIPTION);3291MODULE_LICENSE("GPL");3292 3293/* change the debug level (eg: insmod hso.ko debug=0x04) */3294MODULE_PARM_DESC(debug, "debug level mask [0x01 | 0x02 | 0x04 | 0x08 | 0x10]");3295module_param(debug, int, 0644);3296 3297/* set the major tty number (eg: insmod hso.ko tty_major=245) */3298MODULE_PARM_DESC(tty_major, "Set the major tty number");3299module_param(tty_major, int, 0644);3300 3301/* disable network interface (eg: insmod hso.ko disable_net=1) */3302MODULE_PARM_DESC(disable_net, "Disable the network interface");3303module_param(disable_net, int, 0644);3304