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