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