1// SPDX-License-Identifier: GPL-2.0 2/* 3 USB Driver for Sierra Wireless 4 5 Copyright (C) 2006, 2007, 2008 Kevin Lloyd <klloyd@sierrawireless.com>, 6 7 Copyright (C) 2008, 2009 Elina Pasheva, Matthew Safar, Rory Filer 8 <linux@sierrawireless.com> 9 10 IMPORTANT DISCLAIMER: This driver is not commercially supported by 11 Sierra Wireless. Use at your own risk. 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/* Uncomment to log function calls */ 17/* #define DEBUG */ 18 19#define DRIVER_AUTHOR "Kevin Lloyd, Elina Pasheva, Matthew Safar, Rory Filer" 20#define DRIVER_DESC "USB Driver for Sierra Wireless USB modems" 21 22#include <linux/kernel.h> 23#include <linux/jiffies.h> 24#include <linux/errno.h> 25#include <linux/tty.h> 26#include <linux/slab.h> 27#include <linux/tty_flip.h> 28#include <linux/module.h> 29#include <linux/usb.h> 30#include <linux/usb/serial.h> 31 32#define SWIMS_USB_REQUEST_SetPower 0x00 33#define SWIMS_USB_REQUEST_SetNmea 0x07 34 35#define N_IN_URB_HM 8 36#define N_OUT_URB_HM 64 37#define N_IN_URB 4 38#define N_OUT_URB 4 39#define IN_BUFLEN 4096 40 41#define MAX_TRANSFER (PAGE_SIZE - 512) 42/* MAX_TRANSFER is chosen so that the VM is not stressed by 43 allocations > PAGE_SIZE and the number of packets in a page 44 is an integer 512 is the largest possible packet on EHCI */ 45 46static bool nmea; 47 48struct sierra_iface_list { 49 const u8 *nums; /* array of interface numbers */ 50 size_t count; /* number of elements in array */ 51}; 52 53struct sierra_intf_private { 54 spinlock_t susp_lock; 55 unsigned int suspended:1; 56 int in_flight; 57 unsigned int open_ports; 58}; 59 60static int sierra_set_power_state(struct usb_device *udev, __u16 swiState) 61{ 62 return usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 63 SWIMS_USB_REQUEST_SetPower, /* __u8 request */ 64 USB_TYPE_VENDOR, /* __u8 request type */ 65 swiState, /* __u16 value */ 66 0, /* __u16 index */ 67 NULL, /* void *data */ 68 0, /* __u16 size */ 69 USB_CTRL_SET_TIMEOUT); /* int timeout */ 70} 71 72static int sierra_vsc_set_nmea(struct usb_device *udev, __u16 enable) 73{ 74 return usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 75 SWIMS_USB_REQUEST_SetNmea, /* __u8 request */ 76 USB_TYPE_VENDOR, /* __u8 request type */ 77 enable, /* __u16 value */ 78 0x0000, /* __u16 index */ 79 NULL, /* void *data */ 80 0, /* __u16 size */ 81 USB_CTRL_SET_TIMEOUT); /* int timeout */ 82} 83 84static int sierra_calc_num_ports(struct usb_serial *serial, 85 struct usb_serial_endpoints *epds) 86{ 87 int num_ports = 0; 88 u8 ifnum, numendpoints; 89 90 ifnum = serial->interface->cur_altsetting->desc.bInterfaceNumber; 91 numendpoints = serial->interface->cur_altsetting->desc.bNumEndpoints; 92 93 /* Dummy interface present on some SKUs should be ignored */ 94 if (ifnum == 0x99) 95 num_ports = 0; 96 else if (numendpoints <= 3) 97 num_ports = 1; 98 else 99 num_ports = (numendpoints-1)/2; 100 return num_ports; 101} 102 103static bool is_listed(const u8 ifnum, const struct sierra_iface_list *list) 104{ 105 int i; 106 107 if (!list) 108 return false; 109 110 for (i = 0; i < list->count; i++) { 111 if (list->nums[i] == ifnum) 112 return true; 113 } 114 115 return false; 116} 117 118static u8 sierra_interface_num(struct usb_serial *serial) 119{ 120 return serial->interface->cur_altsetting->desc.bInterfaceNumber; 121} 122 123static int sierra_probe(struct usb_serial *serial, 124 const struct usb_device_id *id) 125{ 126 const struct sierra_iface_list *ignore_list; 127 int result = 0; 128 struct usb_device *udev; 129 u8 ifnum; 130 131 udev = serial->dev; 132 ifnum = sierra_interface_num(serial); 133 134 /* 135 * If this interface supports more than 1 alternate 136 * select the 2nd one 137 */ 138 if (serial->interface->num_altsetting == 2) { 139 dev_dbg(&udev->dev, "Selecting alt setting for interface %d\n", 140 ifnum); 141 /* We know the alternate setting is 1 for the MC8785 */ 142 usb_set_interface(udev, ifnum, 1); 143 } 144 145 ignore_list = (const struct sierra_iface_list *)id->driver_info; 146 147 if (is_listed(ifnum, ignore_list)) { 148 dev_dbg(&serial->dev->dev, "Ignoring interface #%d\n", ifnum); 149 return -ENODEV; 150 } 151 152 return result; 153} 154 155/* interfaces with higher memory requirements */ 156static const u8 hi_memory_typeA_ifaces[] = { 0, 2 }; 157static const struct sierra_iface_list typeA_interface_list = { 158 .nums = hi_memory_typeA_ifaces, 159 .count = ARRAY_SIZE(hi_memory_typeA_ifaces), 160}; 161 162static const u8 hi_memory_typeB_ifaces[] = { 3, 4, 5, 6 }; 163static const struct sierra_iface_list typeB_interface_list = { 164 .nums = hi_memory_typeB_ifaces, 165 .count = ARRAY_SIZE(hi_memory_typeB_ifaces), 166}; 167 168/* 'ignorelist' of interfaces not served by this driver */ 169static const u8 direct_ip_non_serial_ifaces[] = { 7, 8, 9, 10, 11, 19, 20 }; 170static const struct sierra_iface_list direct_ip_interface_ignore = { 171 .nums = direct_ip_non_serial_ifaces, 172 .count = ARRAY_SIZE(direct_ip_non_serial_ifaces), 173}; 174 175static const struct usb_device_id id_table[] = { 176 { USB_DEVICE(0x0F3D, 0x0112) }, /* Airprime/Sierra PC 5220 */ 177 { USB_DEVICE(0x03F0, 0x1B1D) }, /* HP ev2200 a.k.a MC5720 */ 178 { USB_DEVICE(0x03F0, 0x211D) }, /* HP ev2210 a.k.a MC5725 */ 179 { USB_DEVICE(0x03F0, 0x1E1D) }, /* HP hs2300 a.k.a MC8775 */ 180 181 { USB_DEVICE(0x1199, 0x0017) }, /* Sierra Wireless EM5625 */ 182 { USB_DEVICE(0x1199, 0x0018) }, /* Sierra Wireless MC5720 */ 183 { USB_DEVICE(0x1199, 0x0218) }, /* Sierra Wireless MC5720 */ 184 { USB_DEVICE(0x1199, 0x0020) }, /* Sierra Wireless MC5725 */ 185 { USB_DEVICE(0x1199, 0x0220) }, /* Sierra Wireless MC5725 */ 186 { USB_DEVICE(0x1199, 0x0022) }, /* Sierra Wireless EM5725 */ 187 { USB_DEVICE(0x1199, 0x0024) }, /* Sierra Wireless MC5727 */ 188 { USB_DEVICE(0x1199, 0x0224) }, /* Sierra Wireless MC5727 */ 189 { USB_DEVICE(0x1199, 0x0019) }, /* Sierra Wireless AirCard 595 */ 190 { USB_DEVICE(0x1199, 0x0021) }, /* Sierra Wireless AirCard 597E */ 191 { USB_DEVICE(0x1199, 0x0112) }, /* Sierra Wireless AirCard 580 */ 192 { USB_DEVICE(0x1199, 0x0120) }, /* Sierra Wireless USB Dongle 595U */ 193 { USB_DEVICE(0x1199, 0x0301) }, /* Sierra Wireless USB Dongle 250U */ 194 /* Sierra Wireless C597 */ 195 { USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x0023, 0xFF, 0xFF, 0xFF) }, 196 /* Sierra Wireless T598 */ 197 { USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x0025, 0xFF, 0xFF, 0xFF) }, 198 { USB_DEVICE(0x1199, 0x0026) }, /* Sierra Wireless T11 */ 199 { USB_DEVICE(0x1199, 0x0027) }, /* Sierra Wireless AC402 */ 200 { USB_DEVICE(0x1199, 0x0028) }, /* Sierra Wireless MC5728 */ 201 { USB_DEVICE(0x1199, 0x0029) }, /* Sierra Wireless Device */ 202 203 { USB_DEVICE(0x1199, 0x6802) }, /* Sierra Wireless MC8755 */ 204 { USB_DEVICE(0x1199, 0x6803) }, /* Sierra Wireless MC8765 */ 205 { USB_DEVICE(0x1199, 0x6804) }, /* Sierra Wireless MC8755 */ 206 { USB_DEVICE(0x1199, 0x6805) }, /* Sierra Wireless MC8765 */ 207 { USB_DEVICE(0x1199, 0x6808) }, /* Sierra Wireless MC8755 */ 208 { USB_DEVICE(0x1199, 0x6809) }, /* Sierra Wireless MC8765 */ 209 { USB_DEVICE(0x1199, 0x6812) }, /* Sierra Wireless MC8775 & AC 875U */ 210 { USB_DEVICE(0x1199, 0x6813) }, /* Sierra Wireless MC8775 */ 211 { USB_DEVICE(0x1199, 0x6815) }, /* Sierra Wireless MC8775 */ 212 { USB_DEVICE(0x1199, 0x6816) }, /* Sierra Wireless MC8775 */ 213 { USB_DEVICE(0x1199, 0x6820) }, /* Sierra Wireless AirCard 875 */ 214 { USB_DEVICE(0x1199, 0x6821) }, /* Sierra Wireless AirCard 875U */ 215 { USB_DEVICE(0x1199, 0x6822) }, /* Sierra Wireless AirCard 875E */ 216 { USB_DEVICE(0x1199, 0x6832) }, /* Sierra Wireless MC8780 */ 217 { USB_DEVICE(0x1199, 0x6833) }, /* Sierra Wireless MC8781 */ 218 { USB_DEVICE(0x1199, 0x6834) }, /* Sierra Wireless MC8780 */ 219 { USB_DEVICE(0x1199, 0x6835) }, /* Sierra Wireless MC8781 */ 220 { USB_DEVICE(0x1199, 0x6838) }, /* Sierra Wireless MC8780 */ 221 { USB_DEVICE(0x1199, 0x6839) }, /* Sierra Wireless MC8781 */ 222 { USB_DEVICE(0x1199, 0x683A) }, /* Sierra Wireless MC8785 */ 223 { USB_DEVICE(0x1199, 0x683B) }, /* Sierra Wireless MC8785 Composite */ 224 /* Sierra Wireless MC8790, MC8791, MC8792 Composite */ 225 { USB_DEVICE(0x1199, 0x683C) }, 226 { USB_DEVICE(0x1199, 0x683D) }, /* Sierra Wireless MC8791 Composite */ 227 /* Sierra Wireless MC8790, MC8791, MC8792 */ 228 { USB_DEVICE(0x1199, 0x683E) }, 229 { USB_DEVICE(0x1199, 0x6850) }, /* Sierra Wireless AirCard 880 */ 230 { USB_DEVICE(0x1199, 0x6851) }, /* Sierra Wireless AirCard 881 */ 231 { USB_DEVICE(0x1199, 0x6852) }, /* Sierra Wireless AirCard 880 E */ 232 { USB_DEVICE(0x1199, 0x6853) }, /* Sierra Wireless AirCard 881 E */ 233 { USB_DEVICE(0x1199, 0x6855) }, /* Sierra Wireless AirCard 880 U */ 234 { USB_DEVICE(0x1199, 0x6856) }, /* Sierra Wireless AirCard 881 U */ 235 { USB_DEVICE(0x1199, 0x6859) }, /* Sierra Wireless AirCard 885 E */ 236 { USB_DEVICE(0x1199, 0x685A) }, /* Sierra Wireless AirCard 885 E */ 237 /* Sierra Wireless C885 */ 238 { USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x6880, 0xFF, 0xFF, 0xFF)}, 239 /* Sierra Wireless C888, Air Card 501, USB 303, USB 304 */ 240 { USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x6890, 0xFF, 0xFF, 0xFF)}, 241 /* Sierra Wireless C22/C33 */ 242 { USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x6891, 0xFF, 0xFF, 0xFF)}, 243 /* Sierra Wireless HSPA Non-Composite Device */ 244 { USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x6892, 0xFF, 0xFF, 0xFF)}, 245 { USB_DEVICE(0x1199, 0x6893) }, /* Sierra Wireless Device */ 246 /* Sierra Wireless Direct IP modems */ 247 { USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x68A3, 0xFF, 0xFF, 0xFF), 248 .driver_info = (kernel_ulong_t)&direct_ip_interface_ignore 249 }, 250 { USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x68AA, 0xFF, 0xFF, 0xFF), 251 .driver_info = (kernel_ulong_t)&direct_ip_interface_ignore 252 }, 253 { USB_DEVICE(0x1199, 0x68AB) }, /* Sierra Wireless AR8550 */ 254 /* AT&T Direct IP LTE modems */ 255 { USB_DEVICE_AND_INTERFACE_INFO(0x0F3D, 0x68AA, 0xFF, 0xFF, 0xFF), 256 .driver_info = (kernel_ulong_t)&direct_ip_interface_ignore 257 }, 258 /* Airprime/Sierra Wireless Direct IP modems */ 259 { USB_DEVICE_AND_INTERFACE_INFO(0x0F3D, 0x68A3, 0xFF, 0xFF, 0xFF), 260 .driver_info = (kernel_ulong_t)&direct_ip_interface_ignore 261 }, 262 263 { } 264}; 265MODULE_DEVICE_TABLE(usb, id_table); 266 267 268struct sierra_port_private { 269 spinlock_t lock; /* lock the structure */ 270 int outstanding_urbs; /* number of out urbs in flight */ 271 struct usb_anchor active; 272 struct usb_anchor delayed; 273 274 int num_out_urbs; 275 int num_in_urbs; 276 /* Input endpoints and buffers for this port */ 277 struct urb *in_urbs[N_IN_URB_HM]; 278 279 /* Settings for the port */ 280 int rts_state; /* Handshaking pins (outputs) */ 281 int dtr_state; 282 int cts_state; /* Handshaking pins (inputs) */ 283 int dsr_state; 284 int dcd_state; 285 int ri_state; 286}; 287 288static int sierra_send_setup(struct usb_serial_port *port) 289{ 290 struct usb_serial *serial = port->serial; 291 struct sierra_port_private *portdata; 292 __u16 interface = 0; 293 int val = 0; 294 int do_send = 0; 295 int retval; 296 297 portdata = usb_get_serial_port_data(port); 298 299 if (portdata->dtr_state) 300 val |= 0x01; 301 if (portdata->rts_state) 302 val |= 0x02; 303 304 /* If composite device then properly report interface */ 305 if (serial->num_ports == 1) { 306 interface = sierra_interface_num(serial); 307 /* Control message is sent only to interfaces with 308 * interrupt_in endpoints 309 */ 310 if (port->interrupt_in_urb) { 311 /* send control message */ 312 do_send = 1; 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 325 do_send = 1; 326 } 327 if (!do_send) 328 return 0; 329 330 retval = usb_autopm_get_interface(serial->interface); 331 if (retval < 0) 332 return retval; 333 334 retval = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 335 0x22, 0x21, val, interface, NULL, 0, USB_CTRL_SET_TIMEOUT); 336 usb_autopm_put_interface(serial->interface); 337 338 return retval; 339} 340 341static int sierra_tiocmget(struct tty_struct *tty) 342{ 343 struct usb_serial_port *port = tty->driver_data; 344 unsigned int value; 345 struct sierra_port_private *portdata; 346 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, 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 if (urb) { 382 kfree(urb->transfer_buffer); 383 usb_free_urb(urb); 384 } 385} 386 387static void sierra_outdat_callback(struct urb *urb) 388{ 389 struct usb_serial_port *port = urb->context; 390 struct sierra_port_private *portdata = usb_get_serial_port_data(port); 391 struct sierra_intf_private *intfdata; 392 int status = urb->status; 393 unsigned long flags; 394 395 intfdata = usb_get_serial_data(port->serial); 396 397 /* free up the transfer buffer, as usb_free_urb() does not do this */ 398 kfree(urb->transfer_buffer); 399 usb_autopm_put_interface_async(port->serial->interface); 400 if (status) 401 dev_dbg(&port->dev, "%s - nonzero write bulk status " 402 "received: %d\n", __func__, status); 403 404 spin_lock_irqsave(&portdata->lock, flags); 405 --portdata->outstanding_urbs; 406 spin_unlock_irqrestore(&portdata->lock, flags); 407 spin_lock_irqsave(&intfdata->susp_lock, flags); 408 --intfdata->in_flight; 409 spin_unlock_irqrestore(&intfdata->susp_lock, flags); 410 411 usb_serial_port_softint(port); 412} 413 414/* Write */ 415static int sierra_write(struct tty_struct *tty, struct usb_serial_port *port, 416 const unsigned char *buf, int count) 417{ 418 struct sierra_port_private *portdata; 419 struct sierra_intf_private *intfdata; 420 struct usb_serial *serial = port->serial; 421 unsigned long flags; 422 unsigned char *buffer; 423 struct urb *urb; 424 size_t writesize = min((size_t)count, (size_t)MAX_TRANSFER); 425 int retval = 0; 426 427 /* verify that we actually have some data to write */ 428 if (count == 0) 429 return 0; 430 431 portdata = usb_get_serial_port_data(port); 432 intfdata = usb_get_serial_data(serial); 433 434 dev_dbg(&port->dev, "%s: write (%zd bytes)\n", __func__, writesize); 435 spin_lock_irqsave(&portdata->lock, flags); 436 dev_dbg(&port->dev, "%s - outstanding_urbs: %d\n", __func__, 437 portdata->outstanding_urbs); 438 if (portdata->outstanding_urbs > portdata->num_out_urbs) { 439 spin_unlock_irqrestore(&portdata->lock, flags); 440 dev_dbg(&port->dev, "%s - write limit hit\n", __func__); 441 return 0; 442 } 443 portdata->outstanding_urbs++; 444 dev_dbg(&port->dev, "%s - 1, outstanding_urbs: %d\n", __func__, 445 portdata->outstanding_urbs); 446 spin_unlock_irqrestore(&portdata->lock, flags); 447 448 retval = usb_autopm_get_interface_async(serial->interface); 449 if (retval < 0) { 450 spin_lock_irqsave(&portdata->lock, flags); 451 portdata->outstanding_urbs--; 452 spin_unlock_irqrestore(&portdata->lock, flags); 453 goto error_simple; 454 } 455 456 buffer = kmalloc(writesize, GFP_ATOMIC); 457 if (!buffer) { 458 retval = -ENOMEM; 459 goto error_no_buffer; 460 } 461 462 urb = usb_alloc_urb(0, GFP_ATOMIC); 463 if (!urb) { 464 retval = -ENOMEM; 465 goto error_no_urb; 466 } 467 468 memcpy(buffer, buf, writesize); 469 470 usb_serial_debug_data(&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 spin_lock_irqsave(&intfdata->susp_lock, flags); 481 482 if (intfdata->suspended) { 483 usb_anchor_urb(urb, &portdata->delayed); 484 spin_unlock_irqrestore(&intfdata->susp_lock, flags); 485 goto skip_power; 486 } else { 487 usb_anchor_urb(urb, &portdata->active); 488 } 489 /* send it down the pipe */ 490 retval = usb_submit_urb(urb, GFP_ATOMIC); 491 if (retval) { 492 usb_unanchor_urb(urb); 493 spin_unlock_irqrestore(&intfdata->susp_lock, flags); 494 dev_err(&port->dev, "%s - usb_submit_urb(write bulk) failed " 495 "with status = %d\n", __func__, retval); 496 goto error; 497 } else { 498 intfdata->in_flight++; 499 spin_unlock_irqrestore(&intfdata->susp_lock, flags); 500 } 501 502skip_power: 503 /* we are done with this urb, so let the host driver 504 * really free it when it is finished with it */ 505 usb_free_urb(urb); 506 507 return writesize; 508error: 509 usb_free_urb(urb); 510error_no_urb: 511 kfree(buffer); 512error_no_buffer: 513 spin_lock_irqsave(&portdata->lock, flags); 514 --portdata->outstanding_urbs; 515 dev_dbg(&port->dev, "%s - 2. outstanding_urbs: %d\n", __func__, 516 portdata->outstanding_urbs); 517 spin_unlock_irqrestore(&portdata->lock, flags); 518 usb_autopm_put_interface_async(serial->interface); 519error_simple: 520 return retval; 521} 522 523static void sierra_indat_callback(struct urb *urb) 524{ 525 int err; 526 int endpoint; 527 struct usb_serial_port *port; 528 unsigned char *data = urb->transfer_buffer; 529 int status = urb->status; 530 531 endpoint = usb_pipeendpoint(urb->pipe); 532 port = urb->context; 533 534 if (status) { 535 dev_dbg(&port->dev, "%s: nonzero status: %d on" 536 " endpoint %02x\n", __func__, status, endpoint); 537 } else { 538 if (urb->actual_length) { 539 tty_insert_flip_string(&port->port, data, 540 urb->actual_length); 541 tty_flip_buffer_push(&port->port); 542 543 usb_serial_debug_data(&port->dev, __func__, 544 urb->actual_length, data); 545 } else { 546 dev_dbg(&port->dev, "%s: empty read urb" 547 " received\n", __func__); 548 } 549 } 550 551 /* Resubmit urb so we continue receiving */ 552 if (status != -ESHUTDOWN && status != -EPERM) { 553 usb_mark_last_busy(port->serial->dev); 554 err = usb_submit_urb(urb, GFP_ATOMIC); 555 if (err && err != -EPERM) 556 dev_err(&port->dev, "resubmit read urb failed." 557 "(%d)\n", err); 558 } 559} 560 561static void sierra_instat_callback(struct urb *urb) 562{ 563 int err; 564 int status = urb->status; 565 struct usb_serial_port *port = urb->context; 566 struct sierra_port_private *portdata = usb_get_serial_port_data(port); 567 struct usb_serial *serial = port->serial; 568 569 dev_dbg(&port->dev, "%s: urb %p port %p has data %p\n", __func__, 570 urb, port, portdata); 571 572 if (status == 0) { 573 struct usb_ctrlrequest *req_pkt = urb->transfer_buffer; 574 575 if (!req_pkt) { 576 dev_dbg(&port->dev, "%s: NULL req_pkt\n", 577 __func__); 578 return; 579 } 580 if ((req_pkt->bRequestType == 0xA1) && 581 (req_pkt->bRequest == 0x20)) { 582 int old_dcd_state; 583 unsigned char signals = *((unsigned char *) 584 urb->transfer_buffer + 585 sizeof(struct usb_ctrlrequest)); 586 587 dev_dbg(&port->dev, "%s: signal x%x\n", __func__, 588 signals); 589 590 old_dcd_state = portdata->dcd_state; 591 portdata->cts_state = 1; 592 portdata->dcd_state = ((signals & 0x01) ? 1 : 0); 593 portdata->dsr_state = ((signals & 0x02) ? 1 : 0); 594 portdata->ri_state = ((signals & 0x08) ? 1 : 0); 595 596 if (old_dcd_state && !portdata->dcd_state) 597 tty_port_tty_hangup(&port->port, true); 598 } else { 599 dev_dbg(&port->dev, "%s: type %x req %x\n", 600 __func__, req_pkt->bRequestType, 601 req_pkt->bRequest); 602 } 603 } else 604 dev_dbg(&port->dev, "%s: error %d\n", __func__, status); 605 606 /* Resubmit urb so we continue receiving IRQ data */ 607 if (status != -ESHUTDOWN && status != -ENOENT) { 608 usb_mark_last_busy(serial->dev); 609 err = usb_submit_urb(urb, GFP_ATOMIC); 610 if (err && err != -EPERM) 611 dev_err(&port->dev, "%s: resubmit intr urb " 612 "failed. (%d)\n", __func__, err); 613 } 614} 615 616static int sierra_write_room(struct tty_struct *tty) 617{ 618 struct usb_serial_port *port = tty->driver_data; 619 struct sierra_port_private *portdata = usb_get_serial_port_data(port); 620 unsigned long flags; 621 622 /* try to give a good number back based on if we have any free urbs at 623 * this point in time */ 624 spin_lock_irqsave(&portdata->lock, flags); 625 if (portdata->outstanding_urbs > (portdata->num_out_urbs * 2) / 3) { 626 spin_unlock_irqrestore(&portdata->lock, flags); 627 dev_dbg(&port->dev, "%s - write limit hit\n", __func__); 628 return 0; 629 } 630 spin_unlock_irqrestore(&portdata->lock, flags); 631 632 return 2048; 633} 634 635static int sierra_chars_in_buffer(struct tty_struct *tty) 636{ 637 struct usb_serial_port *port = tty->driver_data; 638 struct sierra_port_private *portdata = usb_get_serial_port_data(port); 639 unsigned long flags; 640 int chars; 641 642 /* NOTE: This overcounts somewhat. */ 643 spin_lock_irqsave(&portdata->lock, flags); 644 chars = portdata->outstanding_urbs * MAX_TRANSFER; 645 spin_unlock_irqrestore(&portdata->lock, flags); 646 647 dev_dbg(&port->dev, "%s - %d\n", __func__, chars); 648 649 return chars; 650} 651 652static void sierra_stop_rx_urbs(struct usb_serial_port *port) 653{ 654 int i; 655 struct sierra_port_private *portdata = usb_get_serial_port_data(port); 656 657 for (i = 0; i < portdata->num_in_urbs; i++) 658 usb_kill_urb(portdata->in_urbs[i]); 659 660 usb_kill_urb(port->interrupt_in_urb); 661} 662 663static int sierra_submit_rx_urbs(struct usb_serial_port *port, gfp_t mem_flags) 664{ 665 int ok_cnt; 666 int err = -EINVAL; 667 int i; 668 struct urb *urb; 669 struct sierra_port_private *portdata = usb_get_serial_port_data(port); 670 671 ok_cnt = 0; 672 for (i = 0; i < portdata->num_in_urbs; i++) { 673 urb = portdata->in_urbs[i]; 674 if (!urb) 675 continue; 676 err = usb_submit_urb(urb, mem_flags); 677 if (err) { 678 dev_err(&port->dev, "%s: submit urb failed: %d\n", 679 __func__, err); 680 } else { 681 ok_cnt++; 682 } 683 } 684 685 if (ok_cnt && port->interrupt_in_urb) { 686 err = usb_submit_urb(port->interrupt_in_urb, mem_flags); 687 if (err) { 688 dev_err(&port->dev, "%s: submit intr urb failed: %d\n", 689 __func__, err); 690 } 691 } 692 693 if (ok_cnt > 0) /* at least one rx urb submitted */ 694 return 0; 695 else 696 return err; 697} 698 699static struct urb *sierra_setup_urb(struct usb_serial *serial, int endpoint, 700 int dir, void *ctx, int len, 701 gfp_t mem_flags, 702 usb_complete_t callback) 703{ 704 struct urb *urb; 705 u8 *buf; 706 707 urb = usb_alloc_urb(0, mem_flags); 708 if (!urb) 709 return NULL; 710 711 buf = kmalloc(len, mem_flags); 712 if (buf) { 713 /* Fill URB using supplied data */ 714 usb_fill_bulk_urb(urb, serial->dev, 715 usb_sndbulkpipe(serial->dev, endpoint) | dir, 716 buf, len, callback, ctx); 717 718 dev_dbg(&serial->dev->dev, "%s %c u : %p d:%p\n", __func__, 719 dir == USB_DIR_IN ? 'i' : 'o', urb, buf); 720 } else { 721 sierra_release_urb(urb); 722 urb = NULL; 723 } 724 725 return urb; 726} 727 728static void sierra_close(struct usb_serial_port *port) 729{ 730 int i; 731 struct usb_serial *serial = port->serial; 732 struct sierra_port_private *portdata; 733 struct sierra_intf_private *intfdata = usb_get_serial_data(serial); 734 struct urb *urb; 735 736 portdata = usb_get_serial_port_data(port); 737 738 /* 739 * Need to take susp_lock to make sure port is not already being 740 * resumed, but no need to hold it due to the tty-port initialized 741 * flag. 742 */ 743 spin_lock_irq(&intfdata->susp_lock); 744 if (--intfdata->open_ports == 0) 745 serial->interface->needs_remote_wakeup = 0; 746 spin_unlock_irq(&intfdata->susp_lock); 747 748 for (;;) { 749 urb = usb_get_from_anchor(&portdata->delayed); 750 if (!urb) 751 break; 752 kfree(urb->transfer_buffer); 753 usb_free_urb(urb); 754 usb_autopm_put_interface_async(serial->interface); 755 spin_lock_irq(&portdata->lock); 756 portdata->outstanding_urbs--; 757 spin_unlock_irq(&portdata->lock); 758 } 759 760 sierra_stop_rx_urbs(port); 761 usb_kill_anchored_urbs(&portdata->active); 762 763 for (i = 0; i < portdata->num_in_urbs; i++) { 764 sierra_release_urb(portdata->in_urbs[i]); 765 portdata->in_urbs[i] = NULL; 766 } 767 768 usb_autopm_get_interface_no_resume(serial->interface); 769} 770 771static int sierra_open(struct tty_struct *tty, struct usb_serial_port *port) 772{ 773 struct sierra_port_private *portdata; 774 struct usb_serial *serial = port->serial; 775 struct sierra_intf_private *intfdata = usb_get_serial_data(serial); 776 int i; 777 int err; 778 int endpoint; 779 struct urb *urb; 780 781 portdata = usb_get_serial_port_data(port); 782 783 endpoint = port->bulk_in_endpointAddress; 784 for (i = 0; i < portdata->num_in_urbs; i++) { 785 urb = sierra_setup_urb(serial, endpoint, USB_DIR_IN, port, 786 IN_BUFLEN, GFP_KERNEL, 787 sierra_indat_callback); 788 portdata->in_urbs[i] = urb; 789 } 790 /* clear halt condition */ 791 usb_clear_halt(serial->dev, 792 usb_sndbulkpipe(serial->dev, endpoint) | USB_DIR_IN); 793 794 err = sierra_submit_rx_urbs(port, GFP_KERNEL); 795 if (err) 796 goto err_submit; 797 798 spin_lock_irq(&intfdata->susp_lock); 799 if (++intfdata->open_ports == 1) 800 serial->interface->needs_remote_wakeup = 1; 801 spin_unlock_irq(&intfdata->susp_lock); 802 usb_autopm_put_interface(serial->interface); 803 804 return 0; 805 806err_submit: 807 sierra_stop_rx_urbs(port); 808 809 for (i = 0; i < portdata->num_in_urbs; i++) { 810 sierra_release_urb(portdata->in_urbs[i]); 811 portdata->in_urbs[i] = NULL; 812 } 813 814 return err; 815} 816 817 818static void sierra_dtr_rts(struct usb_serial_port *port, int on) 819{ 820 struct sierra_port_private *portdata; 821 822 portdata = usb_get_serial_port_data(port); 823 portdata->rts_state = on; 824 portdata->dtr_state = on; 825 826 sierra_send_setup(port); 827} 828 829static int sierra_startup(struct usb_serial *serial) 830{ 831 struct sierra_intf_private *intfdata; 832 833 intfdata = kzalloc(sizeof(*intfdata), GFP_KERNEL); 834 if (!intfdata) 835 return -ENOMEM; 836 837 spin_lock_init(&intfdata->susp_lock); 838 839 usb_set_serial_data(serial, intfdata); 840 841 /* Set Device mode to D0 */ 842 sierra_set_power_state(serial->dev, 0x0000); 843 844 /* Check NMEA and set */ 845 if (nmea) 846 sierra_vsc_set_nmea(serial->dev, 1); 847 848 return 0; 849} 850 851static void sierra_release(struct usb_serial *serial) 852{ 853 struct sierra_intf_private *intfdata; 854 855 intfdata = usb_get_serial_data(serial); 856 kfree(intfdata); 857} 858 859static int sierra_port_probe(struct usb_serial_port *port) 860{ 861 struct usb_serial *serial = port->serial; 862 struct sierra_port_private *portdata; 863 const struct sierra_iface_list *himemory_list; 864 u8 ifnum; 865 866 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL); 867 if (!portdata) 868 return -ENOMEM; 869 870 spin_lock_init(&portdata->lock); 871 init_usb_anchor(&portdata->active); 872 init_usb_anchor(&portdata->delayed); 873 874 /* Assume low memory requirements */ 875 portdata->num_out_urbs = N_OUT_URB; 876 portdata->num_in_urbs = N_IN_URB; 877 878 /* Determine actual memory requirements */ 879 if (serial->num_ports == 1) { 880 /* Get interface number for composite device */ 881 ifnum = sierra_interface_num(serial); 882 himemory_list = &typeB_interface_list; 883 } else { 884 /* This is really the usb-serial port number of the interface 885 * rather than the interface number. 886 */ 887 ifnum = port->port_number; 888 himemory_list = &typeA_interface_list; 889 } 890 891 if (is_listed(ifnum, himemory_list)) { 892 portdata->num_out_urbs = N_OUT_URB_HM; 893 portdata->num_in_urbs = N_IN_URB_HM; 894 } 895 896 dev_dbg(&port->dev, 897 "Memory usage (urbs) interface #%d, in=%d, out=%d\n", 898 ifnum, portdata->num_in_urbs, portdata->num_out_urbs); 899 900 usb_set_serial_port_data(port, portdata); 901 902 return 0; 903} 904 905static int sierra_port_remove(struct usb_serial_port *port) 906{ 907 struct sierra_port_private *portdata; 908 909 portdata = usb_get_serial_port_data(port); 910 usb_set_serial_port_data(port, NULL); 911 kfree(portdata); 912 913 return 0; 914} 915 916#ifdef CONFIG_PM 917static void stop_read_write_urbs(struct usb_serial *serial) 918{ 919 int i; 920 struct usb_serial_port *port; 921 struct sierra_port_private *portdata; 922 923 /* Stop reading/writing urbs */ 924 for (i = 0; i < serial->num_ports; ++i) { 925 port = serial->port[i]; 926 portdata = usb_get_serial_port_data(port); 927 if (!portdata) 928 continue; 929 sierra_stop_rx_urbs(port); 930 usb_kill_anchored_urbs(&portdata->active); 931 } 932} 933 934static int sierra_suspend(struct usb_serial *serial, pm_message_t message) 935{ 936 struct sierra_intf_private *intfdata = usb_get_serial_data(serial); 937 938 spin_lock_irq(&intfdata->susp_lock); 939 if (PMSG_IS_AUTO(message)) { 940 if (intfdata->in_flight) { 941 spin_unlock_irq(&intfdata->susp_lock); 942 return -EBUSY; 943 } 944 } 945 intfdata->suspended = 1; 946 spin_unlock_irq(&intfdata->susp_lock); 947 948 stop_read_write_urbs(serial); 949 950 return 0; 951} 952 953/* Caller must hold susp_lock. */ 954static int sierra_submit_delayed_urbs(struct usb_serial_port *port) 955{ 956 struct sierra_port_private *portdata = usb_get_serial_port_data(port); 957 struct sierra_intf_private *intfdata; 958 struct urb *urb; 959 int ec = 0; 960 int err; 961 962 intfdata = usb_get_serial_data(port->serial); 963 964 for (;;) { 965 urb = usb_get_from_anchor(&portdata->delayed); 966 if (!urb) 967 break; 968 969 usb_anchor_urb(urb, &portdata->active); 970 intfdata->in_flight++; 971 err = usb_submit_urb(urb, GFP_ATOMIC); 972 if (err) { 973 dev_err(&port->dev, "%s - submit urb failed: %d", 974 __func__, err); 975 ec++; 976 intfdata->in_flight--; 977 usb_unanchor_urb(urb); 978 kfree(urb->transfer_buffer); 979 usb_free_urb(urb); 980 981 spin_lock(&portdata->lock); 982 portdata->outstanding_urbs--; 983 spin_unlock(&portdata->lock); 984 } 985 } 986 987 if (ec) 988 return -EIO; 989 990 return 0; 991} 992 993static int sierra_resume(struct usb_serial *serial) 994{ 995 struct usb_serial_port *port; 996 struct sierra_intf_private *intfdata = usb_get_serial_data(serial); 997 int ec = 0; 998 int i, err; 999 1000 spin_lock_irq(&intfdata->susp_lock); 1001 for (i = 0; i < serial->num_ports; i++) { 1002 port = serial->port[i]; 1003 1004 if (!tty_port_initialized(&port->port)) 1005 continue; 1006 1007 err = sierra_submit_delayed_urbs(port); 1008 if (err) 1009 ec++; 1010 1011 err = sierra_submit_rx_urbs(port, GFP_ATOMIC); 1012 if (err) 1013 ec++; 1014 } 1015 intfdata->suspended = 0; 1016 spin_unlock_irq(&intfdata->susp_lock); 1017 1018 return ec ? -EIO : 0; 1019} 1020 1021#else 1022#define sierra_suspend NULL 1023#define sierra_resume NULL 1024#endif 1025 1026static struct usb_serial_driver sierra_device = { 1027 .driver = { 1028 .owner = THIS_MODULE, 1029 .name = "sierra", 1030 }, 1031 .description = "Sierra USB modem", 1032 .id_table = id_table, 1033 .calc_num_ports = sierra_calc_num_ports, 1034 .probe = sierra_probe, 1035 .open = sierra_open, 1036 .close = sierra_close, 1037 .dtr_rts = sierra_dtr_rts, 1038 .write = sierra_write, 1039 .write_room = sierra_write_room, 1040 .chars_in_buffer = sierra_chars_in_buffer, 1041 .tiocmget = sierra_tiocmget, 1042 .tiocmset = sierra_tiocmset, 1043 .attach = sierra_startup, 1044 .release = sierra_release, 1045 .port_probe = sierra_port_probe, 1046 .port_remove = sierra_port_remove, 1047 .suspend = sierra_suspend, 1048 .resume = sierra_resume, 1049 .read_int_callback = sierra_instat_callback, 1050}; 1051 1052static struct usb_serial_driver * const serial_drivers[] = { 1053 &sierra_device, NULL 1054}; 1055 1056module_usb_serial_driver(serial_drivers, id_table); 1057 1058MODULE_AUTHOR(DRIVER_AUTHOR); 1059MODULE_DESCRIPTION(DRIVER_DESC); 1060MODULE_LICENSE("GPL v2"); 1061 1062module_param(nmea, bool, S_IRUGO | S_IWUSR); 1063MODULE_PARM_DESC(nmea, "NMEA streaming"); 1064