sierra.c revision c76a23da8e9a39222c4a7c29b0c5348cd8902a2b
1/* 2 USB Driver for Sierra Wireless 3 4 Copyright (C) 2006, 2007, 2008 Kevin Lloyd <klloyd@sierrawireless.com>, 5 6 Copyright (C) 2008, 2009 Elina Pasheva, Matthew Safar, Rory Filer 7 <linux@sierrawireless.com> 8 9 IMPORTANT DISCLAIMER: This driver is not commercially supported by 10 Sierra Wireless. Use at your own risk. 11 12 This driver is free software; you can redistribute it and/or modify 13 it under the terms of Version 2 of the GNU General Public License as 14 published by the Free Software Foundation. 15 16 Portions based on the option driver by Matthias Urlichs <smurf@smurf.noris.de> 17 Whom based his on the Keyspan driver by Hugh Blemings <hugh@blemings.org> 18*/ 19 20#define DRIVER_VERSION "v.1.3.7" 21#define DRIVER_AUTHOR "Kevin Lloyd, Elina Pasheva, Matthew Safar, Rory Filer" 22#define DRIVER_DESC "USB Driver for Sierra Wireless USB modems" 23 24#include <linux/kernel.h> 25#include <linux/jiffies.h> 26#include <linux/errno.h> 27#include <linux/tty.h> 28#include <linux/tty_flip.h> 29#include <linux/module.h> 30#include <linux/usb.h> 31#include <linux/usb/serial.h> 32 33#define SWIMS_USB_REQUEST_SetPower 0x00 34#define SWIMS_USB_REQUEST_SetNmea 0x07 35 36#define N_IN_URB 8 37#define N_OUT_URB 64 38#define IN_BUFLEN 4096 39 40#define MAX_TRANSFER (PAGE_SIZE - 512) 41/* MAX_TRANSFER is chosen so that the VM is not stressed by 42 allocations > PAGE_SIZE and the number of packets in a page 43 is an integer 512 is the largest possible packet on EHCI */ 44 45static int debug; 46static int nmea; 47 48/* Used in interface blacklisting */ 49struct sierra_iface_info { 50 const u32 infolen; /* number of interface numbers on blacklist */ 51 const u8 *ifaceinfo; /* pointer to the array holding the numbers */ 52}; 53 54static int sierra_set_power_state(struct usb_device *udev, __u16 swiState) 55{ 56 int result; 57 dev_dbg(&udev->dev, "%s\n", __func__); 58 result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 59 SWIMS_USB_REQUEST_SetPower, /* __u8 request */ 60 USB_TYPE_VENDOR, /* __u8 request type */ 61 swiState, /* __u16 value */ 62 0, /* __u16 index */ 63 NULL, /* void *data */ 64 0, /* __u16 size */ 65 USB_CTRL_SET_TIMEOUT); /* int timeout */ 66 return result; 67} 68 69static int sierra_vsc_set_nmea(struct usb_device *udev, __u16 enable) 70{ 71 int result; 72 dev_dbg(&udev->dev, "%s\n", __func__); 73 result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 74 SWIMS_USB_REQUEST_SetNmea, /* __u8 request */ 75 USB_TYPE_VENDOR, /* __u8 request type */ 76 enable, /* __u16 value */ 77 0x0000, /* __u16 index */ 78 NULL, /* void *data */ 79 0, /* __u16 size */ 80 USB_CTRL_SET_TIMEOUT); /* int timeout */ 81 return result; 82} 83 84static int sierra_calc_num_ports(struct usb_serial *serial) 85{ 86 int result; 87 int *num_ports = usb_get_serial_data(serial); 88 dev_dbg(&serial->dev->dev, "%s\n", __func__); 89 90 result = *num_ports; 91 92 if (result) { 93 kfree(num_ports); 94 usb_set_serial_data(serial, NULL); 95 } 96 97 return result; 98} 99 100static int is_blacklisted(const u8 ifnum, 101 const struct sierra_iface_info *blacklist) 102{ 103 const u8 *info; 104 int i; 105 106 if (blacklist) { 107 info = blacklist->ifaceinfo; 108 109 for (i = 0; i < blacklist->infolen; i++) { 110 if (info[i] == ifnum) 111 return 1; 112 } 113 } 114 return 0; 115} 116 117static int sierra_calc_interface(struct usb_serial *serial) 118{ 119 int interface; 120 struct usb_interface *p_interface; 121 struct usb_host_interface *p_host_interface; 122 dev_dbg(&serial->dev->dev, "%s\n", __func__); 123 124 /* Get the interface structure pointer from the serial struct */ 125 p_interface = serial->interface; 126 127 /* Get a pointer to the host interface structure */ 128 p_host_interface = p_interface->cur_altsetting; 129 130 /* read the interface descriptor for this active altsetting 131 * to find out the interface number we are on 132 */ 133 interface = p_host_interface->desc.bInterfaceNumber; 134 135 return interface; 136} 137 138static int sierra_probe(struct usb_serial *serial, 139 const struct usb_device_id *id) 140{ 141 int result = 0; 142 struct usb_device *udev; 143 int *num_ports; 144 u8 ifnum; 145 u8 numendpoints; 146 147 dev_dbg(&serial->dev->dev, "%s\n", __func__); 148 149 num_ports = kmalloc(sizeof(*num_ports), GFP_KERNEL); 150 if (!num_ports) 151 return -ENOMEM; 152 153 ifnum = serial->interface->cur_altsetting->desc.bInterfaceNumber; 154 numendpoints = serial->interface->cur_altsetting->desc.bNumEndpoints; 155 udev = serial->dev; 156 157 /* Figure out the interface number from the serial structure */ 158 ifnum = sierra_calc_interface(serial); 159 160 /* 161 * If this interface supports more than 1 alternate 162 * select the 2nd one 163 */ 164 if (serial->interface->num_altsetting == 2) { 165 dev_dbg(&udev->dev, "Selecting alt setting for interface %d\n", 166 ifnum); 167 /* We know the alternate setting is 1 for the MC8785 */ 168 usb_set_interface(udev, ifnum, 1); 169 } 170 171 /* Dummy interface present on some SKUs should be ignored */ 172 if (ifnum == 0x99) 173 *num_ports = 0; 174 else if (numendpoints <= 3) 175 *num_ports = 1; 176 else 177 *num_ports = (numendpoints-1)/2; 178 179 /* 180 * save off our num_ports info so that we can use it in the 181 * calc_num_ports callback 182 */ 183 usb_set_serial_data(serial, (void *)num_ports); 184 185 /* ifnum could have changed - by calling usb_set_interface */ 186 ifnum = sierra_calc_interface(serial); 187 188 if (is_blacklisted(ifnum, 189 (struct sierra_iface_info *)id->driver_info)) { 190 dev_dbg(&serial->dev->dev, 191 "Ignoring blacklisted interface #%d\n", ifnum); 192 return -ENODEV; 193 } 194 195 return result; 196} 197 198static const u8 direct_ip_non_serial_ifaces[] = { 7, 8, 9, 10, 11 }; 199static const struct sierra_iface_info direct_ip_interface_blacklist = { 200 .infolen = ARRAY_SIZE(direct_ip_non_serial_ifaces), 201 .ifaceinfo = direct_ip_non_serial_ifaces, 202}; 203 204static struct usb_device_id id_table [] = { 205 { USB_DEVICE(0x1199, 0x0017) }, /* Sierra Wireless EM5625 */ 206 { USB_DEVICE(0x1199, 0x0018) }, /* Sierra Wireless MC5720 */ 207 { USB_DEVICE(0x1199, 0x0218) }, /* Sierra Wireless MC5720 */ 208 { USB_DEVICE(0x03f0, 0x1b1d) }, /* HP ev2200 a.k.a MC5720 */ 209 { USB_DEVICE(0x1199, 0x0020) }, /* Sierra Wireless MC5725 */ 210 { USB_DEVICE(0x1199, 0x0024) }, /* Sierra Wireless MC5727 */ 211 { USB_DEVICE(0x1199, 0x0220) }, /* Sierra Wireless MC5725 */ 212 { USB_DEVICE(0x1199, 0x0019) }, /* Sierra Wireless AirCard 595 */ 213 { USB_DEVICE(0x1199, 0x0021) }, /* Sierra Wireless AirCard 597E */ 214 { USB_DEVICE(0x1199, 0x0120) }, /* Sierra Wireless USB Dongle 595U */ 215 /* Sierra Wireless C597 */ 216 { USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x0023, 0xFF, 0xFF, 0xFF) }, 217 /* Sierra Wireless Device */ 218 { USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x0025, 0xFF, 0xFF, 0xFF) }, 219 { USB_DEVICE(0x1199, 0x0026) }, /* Sierra Wireless Device */ 220 { USB_DEVICE(0x1199, 0x0027) }, /* Sierra Wireless Device */ 221 { USB_DEVICE(0x1199, 0x0028) }, /* Sierra Wireless Device */ 222 223 { USB_DEVICE(0x1199, 0x6802) }, /* Sierra Wireless MC8755 */ 224 { USB_DEVICE(0x1199, 0x6804) }, /* Sierra Wireless MC8755 */ 225 { USB_DEVICE(0x1199, 0x6803) }, /* Sierra Wireless MC8765 */ 226 { USB_DEVICE(0x1199, 0x6812) }, /* Sierra Wireless MC8775 & AC 875U */ 227 { USB_DEVICE(0x1199, 0x6813) }, /* Sierra Wireless MC8775 (Lenovo) */ 228 { USB_DEVICE(0x1199, 0x6815) }, /* Sierra Wireless MC8775 */ 229 { USB_DEVICE(0x03f0, 0x1e1d) }, /* HP hs2300 a.k.a MC8775 */ 230 { USB_DEVICE(0x1199, 0x6820) }, /* Sierra Wireless AirCard 875 */ 231 { USB_DEVICE(0x1199, 0x6821) }, /* Sierra Wireless AirCard 875U */ 232 { USB_DEVICE(0x1199, 0x6832) }, /* Sierra Wireless MC8780 */ 233 { USB_DEVICE(0x1199, 0x6833) }, /* Sierra Wireless MC8781 */ 234 { USB_DEVICE(0x1199, 0x683A) }, /* Sierra Wireless MC8785 */ 235 { USB_DEVICE(0x1199, 0x683B) }, /* Sierra Wireless MC8785 Composite */ 236 /* Sierra Wireless MC8790, MC8791, MC8792 Composite */ 237 { USB_DEVICE(0x1199, 0x683C) }, 238 { USB_DEVICE(0x1199, 0x683D) }, /* Sierra Wireless MC8791 Composite */ 239 /* Sierra Wireless MC8790, MC8791, MC8792 */ 240 { USB_DEVICE(0x1199, 0x683E) }, 241 { USB_DEVICE(0x1199, 0x6850) }, /* Sierra Wireless AirCard 880 */ 242 { USB_DEVICE(0x1199, 0x6851) }, /* Sierra Wireless AirCard 881 */ 243 { USB_DEVICE(0x1199, 0x6852) }, /* Sierra Wireless AirCard 880 E */ 244 { USB_DEVICE(0x1199, 0x6853) }, /* Sierra Wireless AirCard 881 E */ 245 { USB_DEVICE(0x1199, 0x6855) }, /* Sierra Wireless AirCard 880 U */ 246 { USB_DEVICE(0x1199, 0x6856) }, /* Sierra Wireless AirCard 881 U */ 247 { USB_DEVICE(0x1199, 0x6859) }, /* Sierra Wireless AirCard 885 E */ 248 { USB_DEVICE(0x1199, 0x685A) }, /* Sierra Wireless AirCard 885 E */ 249 /* Sierra Wireless C885 */ 250 { USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x6880, 0xFF, 0xFF, 0xFF)}, 251 /* Sierra Wireless Device */ 252 { USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x6890, 0xFF, 0xFF, 0xFF)}, 253 /* Sierra Wireless Device */ 254 { USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x6891, 0xFF, 0xFF, 0xFF)}, 255 /* Sierra Wireless Device */ 256 { USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x6892, 0xFF, 0xFF, 0xFF)}, 257 258 { USB_DEVICE(0x1199, 0x0112) }, /* Sierra Wireless AirCard 580 */ 259 { USB_DEVICE(0x0F3D, 0x0112) }, /* Airprime/Sierra PC 5220 */ 260 261 { USB_DEVICE(0x1199, 0x68A3), /* Sierra Wireless Direct IP modems */ 262 .driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist 263 }, 264 265 { } 266}; 267MODULE_DEVICE_TABLE(usb, id_table); 268 269static struct usb_driver sierra_driver = { 270 .name = "sierra", 271 .probe = usb_serial_probe, 272 .disconnect = usb_serial_disconnect, 273 .id_table = id_table, 274 .no_dynamic_id = 1, 275}; 276 277struct sierra_port_private { 278 spinlock_t lock; /* lock the structure */ 279 int outstanding_urbs; /* number of out urbs in flight */ 280 281 /* Input endpoints and buffers for this port */ 282 struct urb *in_urbs[N_IN_URB]; 283 284 /* Settings for the port */ 285 int rts_state; /* Handshaking pins (outputs) */ 286 int dtr_state; 287 int cts_state; /* Handshaking pins (inputs) */ 288 int dsr_state; 289 int dcd_state; 290 int ri_state; 291}; 292 293static int sierra_send_setup(struct usb_serial_port *port) 294{ 295 struct usb_serial *serial = port->serial; 296 struct sierra_port_private *portdata; 297 __u16 interface = 0; 298 int val = 0; 299 300 dev_dbg(&port->dev, "%s\n", __func__); 301 302 portdata = usb_get_serial_port_data(port); 303 304 if (portdata->dtr_state) 305 val |= 0x01; 306 if (portdata->rts_state) 307 val |= 0x02; 308 309 /* If composite device then properly report interface */ 310 if (serial->num_ports == 1) { 311 interface = sierra_calc_interface(serial); 312 /* Control message is sent only to interfaces with 313 * interrupt_in endpoints 314 */ 315 if (port->interrupt_in_urb) { 316 /* send control message */ 317 return usb_control_msg(serial->dev, 318 usb_rcvctrlpipe(serial->dev, 0), 319 0x22, 0x21, val, interface, 320 NULL, 0, USB_CTRL_SET_TIMEOUT); 321 } 322 } 323 324 /* Otherwise the need to do non-composite mapping */ 325 else { 326 if (port->bulk_out_endpointAddress == 2) 327 interface = 0; 328 else if (port->bulk_out_endpointAddress == 4) 329 interface = 1; 330 else if (port->bulk_out_endpointAddress == 5) 331 interface = 2; 332 return usb_control_msg(serial->dev, 333 usb_rcvctrlpipe(serial->dev, 0), 334 0x22, 0x21, val, interface, 335 NULL, 0, USB_CTRL_SET_TIMEOUT); 336 } 337 return 0; 338} 339 340static void sierra_set_termios(struct tty_struct *tty, 341 struct usb_serial_port *port, struct ktermios *old_termios) 342{ 343 dev_dbg(&port->dev, "%s\n", __func__); 344 tty_termios_copy_hw(tty->termios, old_termios); 345 sierra_send_setup(port); 346} 347 348static int sierra_tiocmget(struct tty_struct *tty, struct file *file) 349{ 350 struct usb_serial_port *port = tty->driver_data; 351 unsigned int value; 352 struct sierra_port_private *portdata; 353 354 dev_dbg(&port->dev, "%s\n", __func__); 355 portdata = usb_get_serial_port_data(port); 356 357 value = ((portdata->rts_state) ? TIOCM_RTS : 0) | 358 ((portdata->dtr_state) ? TIOCM_DTR : 0) | 359 ((portdata->cts_state) ? TIOCM_CTS : 0) | 360 ((portdata->dsr_state) ? TIOCM_DSR : 0) | 361 ((portdata->dcd_state) ? TIOCM_CAR : 0) | 362 ((portdata->ri_state) ? TIOCM_RNG : 0); 363 364 return value; 365} 366 367static int sierra_tiocmset(struct tty_struct *tty, struct file *file, 368 unsigned int set, unsigned int clear) 369{ 370 struct usb_serial_port *port = tty->driver_data; 371 struct sierra_port_private *portdata; 372 373 portdata = usb_get_serial_port_data(port); 374 375 if (set & TIOCM_RTS) 376 portdata->rts_state = 1; 377 if (set & TIOCM_DTR) 378 portdata->dtr_state = 1; 379 380 if (clear & TIOCM_RTS) 381 portdata->rts_state = 0; 382 if (clear & TIOCM_DTR) 383 portdata->dtr_state = 0; 384 return sierra_send_setup(port); 385} 386 387static void sierra_release_urb(struct urb *urb) 388{ 389 struct usb_serial_port *port; 390 if (urb) { 391 port = urb->context; 392 dev_dbg(&port->dev, "%s: %p\n", __func__, urb); 393 kfree(urb->transfer_buffer); 394 usb_free_urb(urb); 395 } 396} 397 398static void sierra_outdat_callback(struct urb *urb) 399{ 400 struct usb_serial_port *port = urb->context; 401 struct sierra_port_private *portdata = usb_get_serial_port_data(port); 402 int status = urb->status; 403 unsigned long flags; 404 405 dev_dbg(&port->dev, "%s - port %d\n", __func__, port->number); 406 407 /* free up the transfer buffer, as usb_free_urb() does not do this */ 408 kfree(urb->transfer_buffer); 409 410 if (status) 411 dev_dbg(&port->dev, "%s - nonzero write bulk status " 412 "received: %d\n", __func__, status); 413 414 spin_lock_irqsave(&portdata->lock, flags); 415 --portdata->outstanding_urbs; 416 spin_unlock_irqrestore(&portdata->lock, flags); 417 418 usb_serial_port_softint(port); 419} 420 421/* Write */ 422static int sierra_write(struct tty_struct *tty, struct usb_serial_port *port, 423 const unsigned char *buf, int count) 424{ 425 struct sierra_port_private *portdata = usb_get_serial_port_data(port); 426 struct usb_serial *serial = port->serial; 427 unsigned long flags; 428 unsigned char *buffer; 429 struct urb *urb; 430 size_t writesize = min((size_t)count, (size_t)MAX_TRANSFER); 431 int retval = 0; 432 433 /* verify that we actually have some data to write */ 434 if (count == 0) 435 return 0; 436 437 portdata = usb_get_serial_port_data(port); 438 439 dev_dbg(&port->dev, "%s: write (%d bytes)\n", __func__, writesize); 440 441 spin_lock_irqsave(&portdata->lock, flags); 442 dev_dbg(&port->dev, "%s - outstanding_urbs: %d\n", __func__, 443 portdata->outstanding_urbs); 444 if (portdata->outstanding_urbs > N_OUT_URB) { 445 spin_unlock_irqrestore(&portdata->lock, flags); 446 dev_dbg(&port->dev, "%s - write limit hit\n", __func__); 447 return 0; 448 } 449 portdata->outstanding_urbs++; 450 dev_dbg(&port->dev, "%s - 1, outstanding_urbs: %d\n", __func__, 451 portdata->outstanding_urbs); 452 spin_unlock_irqrestore(&portdata->lock, flags); 453 454 buffer = kmalloc(writesize, GFP_ATOMIC); 455 if (!buffer) { 456 dev_err(&port->dev, "out of memory\n"); 457 retval = -ENOMEM; 458 goto error_no_buffer; 459 } 460 461 urb = usb_alloc_urb(0, GFP_ATOMIC); 462 if (!urb) { 463 dev_err(&port->dev, "no more free urbs\n"); 464 retval = -ENOMEM; 465 goto error_no_urb; 466 } 467 468 memcpy(buffer, buf, writesize); 469 470 usb_serial_debug_data(debug, &port->dev, __func__, writesize, buffer); 471 472 usb_fill_bulk_urb(urb, serial->dev, 473 usb_sndbulkpipe(serial->dev, 474 port->bulk_out_endpointAddress), 475 buffer, writesize, sierra_outdat_callback, port); 476 477 /* Handle the need to send a zero length packet */ 478 urb->transfer_flags |= URB_ZERO_PACKET; 479 480 /* send it down the pipe */ 481 retval = usb_submit_urb(urb, GFP_ATOMIC); 482 if (retval) { 483 dev_err(&port->dev, "%s - usb_submit_urb(write bulk) failed " 484 "with status = %d\n", __func__, retval); 485 goto error; 486 } 487 488 /* we are done with this urb, so let the host driver 489 * really free it when it is finished with it */ 490 usb_free_urb(urb); 491 492 return writesize; 493error: 494 usb_free_urb(urb); 495error_no_urb: 496 kfree(buffer); 497error_no_buffer: 498 spin_lock_irqsave(&portdata->lock, flags); 499 --portdata->outstanding_urbs; 500 dev_dbg(&port->dev, "%s - 2. outstanding_urbs: %d\n", __func__, 501 portdata->outstanding_urbs); 502 spin_unlock_irqrestore(&portdata->lock, flags); 503 return retval; 504} 505 506static void sierra_indat_callback(struct urb *urb) 507{ 508 int err; 509 int endpoint; 510 struct usb_serial_port *port; 511 struct tty_struct *tty; 512 unsigned char *data = urb->transfer_buffer; 513 int status = urb->status; 514 515 endpoint = usb_pipeendpoint(urb->pipe); 516 port = urb->context; 517 518 dev_dbg(&port->dev, "%s: %p\n", __func__, urb); 519 520 if (status) { 521 dev_dbg(&port->dev, "%s: nonzero status: %d on" 522 " endpoint %02x\n", __func__, status, endpoint); 523 } else { 524 if (urb->actual_length) { 525 tty = tty_port_tty_get(&port->port); 526 527 tty_buffer_request_room(tty, urb->actual_length); 528 tty_insert_flip_string(tty, data, urb->actual_length); 529 tty_flip_buffer_push(tty); 530 531 tty_kref_put(tty); 532 usb_serial_debug_data(debug, &port->dev, __func__, 533 urb->actual_length, data); 534 } else { 535 dev_dbg(&port->dev, "%s: empty read urb" 536 " received\n", __func__); 537 } 538 } 539 540 /* Resubmit urb so we continue receiving */ 541 if (port->port.count && status != -ESHUTDOWN && status != -EPERM) { 542 err = usb_submit_urb(urb, GFP_ATOMIC); 543 if (err) 544 dev_err(&port->dev, "resubmit read urb failed." 545 "(%d)\n", err); 546 } 547 548 return; 549} 550 551static void sierra_instat_callback(struct urb *urb) 552{ 553 int err; 554 int status = urb->status; 555 struct usb_serial_port *port = urb->context; 556 struct sierra_port_private *portdata = usb_get_serial_port_data(port); 557 struct usb_serial *serial = port->serial; 558 559 dev_dbg(&port->dev, "%s: urb %p port %p has data %p\n", __func__, 560 urb, port, portdata); 561 562 if (status == 0) { 563 struct usb_ctrlrequest *req_pkt = 564 (struct usb_ctrlrequest *)urb->transfer_buffer; 565 566 if (!req_pkt) { 567 dev_dbg(&port->dev, "%s: NULL req_pkt\n", 568 __func__); 569 return; 570 } 571 if ((req_pkt->bRequestType == 0xA1) && 572 (req_pkt->bRequest == 0x20)) { 573 int old_dcd_state; 574 unsigned char signals = *((unsigned char *) 575 urb->transfer_buffer + 576 sizeof(struct usb_ctrlrequest)); 577 struct tty_struct *tty; 578 579 dev_dbg(&port->dev, "%s: signal x%x\n", __func__, 580 signals); 581 582 old_dcd_state = portdata->dcd_state; 583 portdata->cts_state = 1; 584 portdata->dcd_state = ((signals & 0x01) ? 1 : 0); 585 portdata->dsr_state = ((signals & 0x02) ? 1 : 0); 586 portdata->ri_state = ((signals & 0x08) ? 1 : 0); 587 588 tty = tty_port_tty_get(&port->port); 589 if (tty && !C_CLOCAL(tty) && 590 old_dcd_state && !portdata->dcd_state) 591 tty_hangup(tty); 592 tty_kref_put(tty); 593 } else { 594 dev_dbg(&port->dev, "%s: type %x req %x\n", 595 __func__, req_pkt->bRequestType, 596 req_pkt->bRequest); 597 } 598 } else 599 dev_dbg(&port->dev, "%s: error %d\n", __func__, status); 600 601 /* Resubmit urb so we continue receiving IRQ data */ 602 if (port->port.count && status != -ESHUTDOWN && status != -ENOENT) { 603 urb->dev = serial->dev; 604 err = usb_submit_urb(urb, GFP_ATOMIC); 605 if (err) 606 dev_err(&port->dev, "%s: resubmit intr urb " 607 "failed. (%d)\n", __func__, err); 608 } 609} 610 611static int sierra_write_room(struct tty_struct *tty) 612{ 613 struct usb_serial_port *port = tty->driver_data; 614 struct sierra_port_private *portdata = usb_get_serial_port_data(port); 615 unsigned long flags; 616 617 dev_dbg(&port->dev, "%s - port %d\n", __func__, port->number); 618 619 /* try to give a good number back based on if we have any free urbs at 620 * this point in time */ 621 spin_lock_irqsave(&portdata->lock, flags); 622 if (portdata->outstanding_urbs > N_OUT_URB * 2 / 3) { 623 spin_unlock_irqrestore(&portdata->lock, flags); 624 dev_dbg(&port->dev, "%s - write limit hit\n", __func__); 625 return 0; 626 } 627 spin_unlock_irqrestore(&portdata->lock, flags); 628 629 return 2048; 630} 631 632static void sierra_stop_rx_urbs(struct usb_serial_port *port) 633{ 634 int i; 635 struct sierra_port_private *portdata = usb_get_serial_port_data(port); 636 637 for (i = 0; i < ARRAY_SIZE(portdata->in_urbs); i++) 638 usb_kill_urb(portdata->in_urbs[i]); 639 640 usb_kill_urb(port->interrupt_in_urb); 641} 642 643static int sierra_submit_rx_urbs(struct usb_serial_port *port, gfp_t mem_flags) 644{ 645 int ok_cnt; 646 int err = -EINVAL; 647 int i; 648 struct urb *urb; 649 struct sierra_port_private *portdata = usb_get_serial_port_data(port); 650 651 ok_cnt = 0; 652 for (i = 0; i < ARRAY_SIZE(portdata->in_urbs); i++) { 653 urb = portdata->in_urbs[i]; 654 if (!urb) 655 continue; 656 err = usb_submit_urb(urb, mem_flags); 657 if (err) { 658 dev_err(&port->dev, "%s: submit urb failed: %d\n", 659 __func__, err); 660 } else { 661 ok_cnt++; 662 } 663 } 664 665 if (ok_cnt && port->interrupt_in_urb) { 666 err = usb_submit_urb(port->interrupt_in_urb, mem_flags); 667 if (err) { 668 dev_err(&port->dev, "%s: submit intr urb failed: %d\n", 669 __func__, err); 670 } 671 } 672 673 if (ok_cnt > 0) /* at least one rx urb submitted */ 674 return 0; 675 else 676 return err; 677} 678 679static struct urb *sierra_setup_urb(struct usb_serial *serial, int endpoint, 680 int dir, void *ctx, int len, 681 gfp_t mem_flags, 682 usb_complete_t callback) 683{ 684 struct urb *urb; 685 u8 *buf; 686 687 if (endpoint == -1) 688 return NULL; 689 690 urb = usb_alloc_urb(0, mem_flags); 691 if (urb == NULL) { 692 dev_dbg(&serial->dev->dev, "%s: alloc for endpoint %d failed\n", 693 __func__, endpoint); 694 return NULL; 695 } 696 697 buf = kmalloc(len, mem_flags); 698 if (buf) { 699 /* Fill URB using supplied data */ 700 usb_fill_bulk_urb(urb, serial->dev, 701 usb_sndbulkpipe(serial->dev, endpoint) | dir, 702 buf, len, callback, ctx); 703 704 /* debug */ 705 dev_dbg(&serial->dev->dev, "%s %c u : %p d:%p\n", __func__, 706 dir == USB_DIR_IN ? 'i' : 'o', urb, buf); 707 } else { 708 dev_dbg(&serial->dev->dev, "%s %c u:%p d:%p\n", __func__, 709 dir == USB_DIR_IN ? 'i' : 'o', urb, buf); 710 711 sierra_release_urb(urb); 712 urb = NULL; 713 } 714 715 return urb; 716} 717 718static void sierra_close(struct usb_serial_port *port) 719{ 720 int i; 721 struct usb_serial *serial = port->serial; 722 struct sierra_port_private *portdata; 723 724 dev_dbg(&port->dev, "%s\n", __func__); 725 portdata = usb_get_serial_port_data(port); 726 727 portdata->rts_state = 0; 728 portdata->dtr_state = 0; 729 730 if (serial->dev) { 731 mutex_lock(&serial->disc_mutex); 732 if (!serial->disconnected) 733 sierra_send_setup(port); 734 mutex_unlock(&serial->disc_mutex); 735 736 /* Stop reading urbs */ 737 sierra_stop_rx_urbs(port); 738 /* .. and release them */ 739 for (i = 0; i < N_IN_URB; i++) { 740 sierra_release_urb(portdata->in_urbs[i]); 741 portdata->in_urbs[i] = NULL; 742 } 743 } 744} 745 746static int sierra_open(struct tty_struct *tty, 747 struct usb_serial_port *port, struct file *filp) 748{ 749 struct sierra_port_private *portdata; 750 struct usb_serial *serial = port->serial; 751 int i; 752 int err; 753 int endpoint; 754 struct urb *urb; 755 756 portdata = usb_get_serial_port_data(port); 757 758 dev_dbg(&port->dev, "%s\n", __func__); 759 760 /* Set some sane defaults */ 761 portdata->rts_state = 1; 762 portdata->dtr_state = 1; 763 764 765 endpoint = port->bulk_in_endpointAddress; 766 for (i = 0; i < ARRAY_SIZE(portdata->in_urbs); i++) { 767 urb = sierra_setup_urb(serial, endpoint, USB_DIR_IN, port, 768 IN_BUFLEN, GFP_KERNEL, 769 sierra_indat_callback); 770 portdata->in_urbs[i] = urb; 771 } 772 /* clear halt condition */ 773 usb_clear_halt(serial->dev, 774 usb_sndbulkpipe(serial->dev, endpoint) | USB_DIR_IN); 775 776 err = sierra_submit_rx_urbs(port, GFP_KERNEL); 777 if (err) { 778 /* get rid of everything as in close */ 779 sierra_close(port); 780 return err; 781 } 782 sierra_send_setup(port); 783 784 return 0; 785} 786 787 788static void sierra_dtr_rts(struct usb_serial_port *port, int on) 789{ 790 struct usb_serial *serial = port->serial; 791 struct sierra_port_private *portdata; 792 793 portdata = usb_get_serial_port_data(port); 794 portdata->rts_state = on; 795 portdata->dtr_state = on; 796 797 if (serial->dev) { 798 mutex_lock(&serial->disc_mutex); 799 if (!serial->disconnected) 800 sierra_send_setup(port); 801 mutex_unlock(&serial->disc_mutex); 802 } 803} 804 805static int sierra_startup(struct usb_serial *serial) 806{ 807 struct usb_serial_port *port; 808 struct sierra_port_private *portdata; 809 int i; 810 811 dev_dbg(&serial->dev->dev, "%s\n", __func__); 812 813 /* Set Device mode to D0 */ 814 sierra_set_power_state(serial->dev, 0x0000); 815 816 /* Check NMEA and set */ 817 if (nmea) 818 sierra_vsc_set_nmea(serial->dev, 1); 819 820 /* Now setup per port private data */ 821 for (i = 0; i < serial->num_ports; i++) { 822 port = serial->port[i]; 823 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL); 824 if (!portdata) { 825 dev_dbg(&port->dev, "%s: kmalloc for " 826 "sierra_port_private (%d) failed!.\n", 827 __func__, i); 828 return -ENOMEM; 829 } 830 spin_lock_init(&portdata->lock); 831 /* Set the port private data pointer */ 832 usb_set_serial_port_data(port, portdata); 833 } 834 835 return 0; 836} 837 838static void sierra_shutdown(struct usb_serial *serial) 839{ 840 int i; 841 struct usb_serial_port *port; 842 struct sierra_port_private *portdata; 843 844 dev_dbg(&serial->dev->dev, "%s\n", __func__); 845 846 for (i = 0; i < serial->num_ports; ++i) { 847 port = serial->port[i]; 848 if (!port) 849 continue; 850 portdata = usb_get_serial_port_data(port); 851 if (!portdata) 852 continue; 853 kfree(portdata); 854 usb_set_serial_port_data(port, NULL); 855 } 856} 857 858static struct usb_serial_driver sierra_device = { 859 .driver = { 860 .owner = THIS_MODULE, 861 .name = "sierra", 862 }, 863 .description = "Sierra USB modem", 864 .id_table = id_table, 865 .usb_driver = &sierra_driver, 866 .calc_num_ports = sierra_calc_num_ports, 867 .probe = sierra_probe, 868 .open = sierra_open, 869 .close = sierra_close, 870 .dtr_rts = sierra_dtr_rts, 871 .write = sierra_write, 872 .write_room = sierra_write_room, 873 .set_termios = sierra_set_termios, 874 .tiocmget = sierra_tiocmget, 875 .tiocmset = sierra_tiocmset, 876 .attach = sierra_startup, 877 .shutdown = sierra_shutdown, 878 .read_int_callback = sierra_instat_callback, 879}; 880 881/* Functions used by new usb-serial code. */ 882static int __init sierra_init(void) 883{ 884 int retval; 885 retval = usb_serial_register(&sierra_device); 886 if (retval) 887 goto failed_device_register; 888 889 890 retval = usb_register(&sierra_driver); 891 if (retval) 892 goto failed_driver_register; 893 894 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":" 895 DRIVER_DESC "\n"); 896 897 return 0; 898 899failed_driver_register: 900 usb_serial_deregister(&sierra_device); 901failed_device_register: 902 return retval; 903} 904 905static void __exit sierra_exit(void) 906{ 907 usb_deregister(&sierra_driver); 908 usb_serial_deregister(&sierra_device); 909} 910 911module_init(sierra_init); 912module_exit(sierra_exit); 913 914MODULE_AUTHOR(DRIVER_AUTHOR); 915MODULE_DESCRIPTION(DRIVER_DESC); 916MODULE_VERSION(DRIVER_VERSION); 917MODULE_LICENSE("GPL"); 918 919module_param(nmea, bool, S_IRUGO | S_IWUSR); 920MODULE_PARM_DESC(nmea, "NMEA streaming"); 921 922module_param(debug, bool, S_IRUGO | S_IWUSR); 923MODULE_PARM_DESC(debug, "Debug messages"); 924