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 46 static bool nmea; 47 48 struct sierra_iface_list { 49 const u8 *nums; /* array of interface numbers */ 50 size_t count; /* number of elements in array */ 51 }; 52 53 struct sierra_intf_private { 54 spinlock_t susp_lock; 55 unsigned int suspended:1; 56 int in_flight; 57 unsigned int open_ports; 58 }; 59 60 static 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 72 static 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 84 static 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 103 static 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 118 static u8 sierra_interface_num(struct usb_serial *serial) 119 { 120 return serial->interface->cur_altsetting->desc.bInterfaceNumber; 121 } 122 123 static 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 */ 156 static const u8 hi_memory_typeA_ifaces[] = { 0, 2 }; 157 static const struct sierra_iface_list typeA_interface_list = { 158 .nums = hi_memory_typeA_ifaces, 159 .count = ARRAY_SIZE(hi_memory_typeA_ifaces), 160 }; 161 162 static const u8 hi_memory_typeB_ifaces[] = { 3, 4, 5, 6 }; 163 static 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 */ 169 static const u8 direct_ip_non_serial_ifaces[] = { 7, 8, 9, 10, 11, 19, 20 }; 170 static 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 175 static 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 }; 265 MODULE_DEVICE_TABLE(usb, id_table); 266 267 268 struct 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 288 static 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 341 static 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 359 static 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 379 static void sierra_release_urb(struct urb *urb) 380 { 381 if (urb) { 382 kfree(urb->transfer_buffer); 383 usb_free_urb(urb); 384 } 385 } 386 387 static 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 */ 415 static 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 502 skip_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; 508 error: 509 usb_free_urb(urb); 510 error_no_urb: 511 kfree(buffer); 512 error_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); 519 error_simple: 520 return retval; 521 } 522 523 static 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 561 static 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 616 static 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 635 static 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 652 static 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 663 static 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 699 static 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 728 static 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 initialized 741 */ 742 spin_lock_irq(&intfdata->susp_lock); 743 if (--intfdata->open_ports == 0) 744 serial->interface->needs_remote_wakeup = 0; 745 spin_unlock_irq(&intfdata->susp_lock); 746 747 for (;;) { 748 urb = usb_get_from_anchor(&portdata->delayed); 749 if (!urb) 750 break; 751 kfree(urb->transfer_buffer); 752 usb_free_urb(urb); 753 usb_autopm_put_interface_async(serial->interface); 754 spin_lock_irq(&portdata->lock); 755 portdata->outstanding_urbs--; 756 spin_unlock_irq(&portdata->lock); 757 } 758 759 sierra_stop_rx_urbs(port); 760 usb_kill_anchored_urbs(&portdata->active); 761 762 for (i = 0; i < portdata->num_in_urbs; i++) { 763 sierra_release_urb(portdata->in_urbs[i]); 764 portdata->in_urbs[i] = NULL; 765 } 766 767 usb_autopm_get_interface_no_resume(serial->interface); 768 } 769 770 static int sierra_open(struct tty_struct *tty, struct usb_serial_port *port) 771 { 772 struct sierra_port_private *portdata; 773 struct usb_serial *serial = port->serial; 774 struct sierra_intf_private *intfdata = usb_get_serial_data(serial); 775 int i; 776 int err; 777 int endpoint; 778 struct urb *urb; 779 780 portdata = usb_get_serial_port_data(port); 781 782 endpoint = port->bulk_in_endpointAddress; 783 for (i = 0; i < portdata->num_in_urbs; i++) { 784 urb = sierra_setup_urb(serial, endpoint, USB_DIR_IN, port, 785 IN_BUFLEN, GFP_KERNEL, 786 sierra_indat_callback); 787 portdata->in_urbs[i] = urb; 788 } 789 /* clear halt condition */ 790 usb_clear_halt(serial->dev, 791 usb_sndbulkpipe(serial->dev, endpoint) | USB_DIR_IN); 792 793 err = sierra_submit_rx_urbs(port, GFP_KERNEL); 794 if (err) 795 goto err_submit; 796 797 spin_lock_irq(&intfdata->susp_lock); 798 if (++intfdata->open_ports == 1) 799 serial->interface->needs_remote_wakeup = 1; 800 spin_unlock_irq(&intfdata->susp_lock); 801 usb_autopm_put_interface(serial->interface); 802 803 return 0; 804 805 err_submit: 806 sierra_stop_rx_urbs(port); 807 808 for (i = 0; i < portdata->num_in_urbs; i++) { 809 sierra_release_urb(portdata->in_urbs[i]); 810 portdata->in_urbs[i] = NULL; 811 } 812 813 return err; 814 } 815 816 817 static void sierra_dtr_rts(struct usb_serial_port *port, int on) 818 { 819 struct sierra_port_private *portdata; 820 821 portdata = usb_get_serial_port_data(port); 822 portdata->rts_state = on; 823 portdata->dtr_state = on; 824 825 sierra_send_setup(port); 826 } 827 828 static int sierra_startup(struct usb_serial *serial) 829 { 830 struct sierra_intf_private *intfdata; 831 832 intfdata = kzalloc(sizeof(*intfdata), GFP_KERNEL); 833 if (!intfdata) 834 return -ENOMEM; 835 836 spin_lock_init(&intfdata->susp_lock); 837 838 usb_set_serial_data(serial, intfdata); 839 840 /* Set Device mode to D0 */ 841 sierra_set_power_state(serial->dev, 0x0000); 842 843 /* Check NMEA and set */ 844 if (nmea) 845 sierra_vsc_set_nmea(serial->dev, 1); 846 847 return 0; 848 } 849 850 static void sierra_release(struct usb_serial *serial) 851 { 852 struct sierra_intf_private *intfdata; 853 854 intfdata = usb_get_serial_data(serial); 855 kfree(intfdata); 856 } 857 858 static int sierra_port_probe(struct usb_serial_port *port) 859 { 860 struct usb_serial *serial = port->serial; 861 struct sierra_port_private *portdata; 862 const struct sierra_iface_list *himemory_list; 863 u8 ifnum; 864 865 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL); 866 if (!portdata) 867 return -ENOMEM; 868 869 spin_lock_init(&portdata->lock); 870 init_usb_anchor(&portdata->active); 871 init_usb_anchor(&portdata->delayed); 872 873 /* Assume low memory requirements */ 874 portdata->num_out_urbs = N_OUT_URB; 875 portdata->num_in_urbs = N_IN_URB; 876 877 /* Determine actual memory requirements */ 878 if (serial->num_ports == 1) { 879 /* Get interface number for composite device */ 880 ifnum = sierra_interface_num(serial); 881 himemory_list = &typeB_interface_list; 882 } else { 883 /* This is really the usb-serial port number of the interface 884 * rather than the interface number. 885 */ 886 ifnum = port->port_number; 887 himemory_list = &typeA_interface_list; 888 } 889 890 if (is_listed(ifnum, himemory_list)) { 891 portdata->num_out_urbs = N_OUT_URB_HM; 892 portdata->num_in_urbs = N_IN_URB_HM; 893 } 894 895 dev_dbg(&port->dev, 896 "Memory usage (urbs) interface #%d, in=%d, out=%d\n", 897 ifnum, portdata->num_in_urbs, portdata->num_out_urbs); 898 899 usb_set_serial_port_data(port, portdata); 900 901 return 0; 902 } 903 904 static void sierra_port_remove(struct usb_serial_port *port) 905 { 906 struct sierra_port_private *portdata; 907 908 portdata = usb_get_serial_port_data(port); 909 usb_set_serial_port_data(port, NULL); 910 kfree(portdata); 911 } 912 913 #ifdef CONFIG_PM 914 static void stop_read_write_urbs(struct usb_serial *serial) 915 { 916 int i; 917 struct usb_serial_port *port; 918 struct sierra_port_private *portdata; 919 920 /* Stop reading/writing urbs */ 921 for (i = 0; i < serial->num_ports; ++i) { 922 port = serial->port[i]; 923 portdata = usb_get_serial_port_data(port); 924 if (!portdata) 925 continue; 926 sierra_stop_rx_urbs(port); 927 usb_kill_anchored_urbs(&portdata->active); 928 } 929 } 930 931 static int sierra_suspend(struct usb_serial *serial, pm_message_t message) 932 { 933 struct sierra_intf_private *intfdata = usb_get_serial_data(serial); 934 935 spin_lock_irq(&intfdata->susp_lock); 936 if (PMSG_IS_AUTO(message)) { 937 if (intfdata->in_flight) { 938 spin_unlock_irq(&intfdata->susp_lock); 939 return -EBUSY; 940 } 941 } 942 intfdata->suspended = 1; 943 spin_unlock_irq(&intfdata->susp_lock); 944 945 stop_read_write_urbs(serial); 946 947 return 0; 948 } 949 950 /* Caller must hold susp_lock. */ 951 static int sierra_submit_delayed_urbs(struct usb_serial_port *port) 952 { 953 struct sierra_port_private *portdata = usb_get_serial_port_data(port); 954 struct sierra_intf_private *intfdata; 955 struct urb *urb; 956 int ec = 0; 957 int err; 958 959 intfdata = usb_get_serial_data(port->serial); 960 961 for (;;) { 962 urb = usb_get_from_anchor(&portdata->delayed); 963 if (!urb) 964 break; 965 966 usb_anchor_urb(urb, &portdata->active); 967 intfdata->in_flight++; 968 err = usb_submit_urb(urb, GFP_ATOMIC); 969 if (err) { 970 dev_err(&port->dev, "%s - submit urb failed: %d", 971 __func__, err); 972 ec++; 973 intfdata->in_flight--; 974 usb_unanchor_urb(urb); 975 kfree(urb->transfer_buffer); 976 usb_free_urb(urb); 977 978 spin_lock(&portdata->lock); 979 portdata->outstanding_urbs--; 980 spin_unlock(&portdata->lock); 981 } 982 } 983 984 if (ec) 985 return -EIO; 986 987 return 0; 988 } 989 990 static int sierra_resume(struct usb_serial *serial) 991 { 992 struct usb_serial_port *port; 993 struct sierra_intf_private *intfdata = usb_get_serial_data(serial); 994 int ec = 0; 995 int i, err; 996 997 spin_lock_irq(&intfdata->susp_lock); 998 for (i = 0; i < serial->num_ports; i++) { 999 port = serial->port[i]; 1000 1001 if (!tty_port_initialized(&port->port)) 1002 continue; 1003 1004 err = sierra_submit_delayed_urbs(port); 1005 if (err) 1006 ec++; 1007 1008 err = sierra_submit_rx_urbs(port, GFP_ATOMIC); 1009 if (err) 1010 ec++; 1011 } 1012 intfdata->suspended = 0; 1013 spin_unlock_irq(&intfdata->susp_lock); 1014 1015 return ec ? -EIO : 0; 1016 } 1017 1018 #else 1019 #define sierra_suspend NULL 1020 #define sierra_resume NULL 1021 #endif 1022 1023 static struct usb_serial_driver sierra_device = { 1024 .driver = { 1025 .owner = THIS_MODULE, 1026 .name = "sierra", 1027 }, 1028 .description = "Sierra USB modem", 1029 .id_table = id_table, 1030 .calc_num_ports = sierra_calc_num_ports, 1031 .probe = sierra_probe, 1032 .open = sierra_open, 1033 .close = sierra_close, 1034 .dtr_rts = sierra_dtr_rts, 1035 .write = sierra_write, 1036 .write_room = sierra_write_room, 1037 .chars_in_buffer = sierra_chars_in_buffer, 1038 .tiocmget = sierra_tiocmget, 1039 .tiocmset = sierra_tiocmset, 1040 .attach = sierra_startup, 1041 .release = sierra_release, 1042 .port_probe = sierra_port_probe, 1043 .port_remove = sierra_port_remove, 1044 .suspend = sierra_suspend, 1045 .resume = sierra_resume, 1046 .read_int_callback = sierra_instat_callback, 1047 }; 1048 1049 static struct usb_serial_driver * const serial_drivers[] = { 1050 &sierra_device, NULL 1051 }; 1052 1053 module_usb_serial_driver(serial_drivers, id_table); 1054 1055 MODULE_AUTHOR(DRIVER_AUTHOR); 1056 MODULE_DESCRIPTION(DRIVER_DESC); 1057 MODULE_LICENSE("GPL v2"); 1058 1059 module_param(nmea, bool, S_IRUGO | S_IWUSR); 1060 MODULE_PARM_DESC(nmea, "NMEA streaming"); 1061