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 = kmemdup(buf, 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 usb_serial_debug_data(&port->dev, __func__, writesize, buffer); 469 470 usb_fill_bulk_urb(urb, serial->dev, 471 usb_sndbulkpipe(serial->dev, 472 port->bulk_out_endpointAddress), 473 buffer, writesize, sierra_outdat_callback, port); 474 475 /* Handle the need to send a zero length packet */ 476 urb->transfer_flags |= URB_ZERO_PACKET; 477 478 spin_lock_irqsave(&intfdata->susp_lock, flags); 479 480 if (intfdata->suspended) { 481 usb_anchor_urb(urb, &portdata->delayed); 482 spin_unlock_irqrestore(&intfdata->susp_lock, flags); 483 goto skip_power; 484 } else { 485 usb_anchor_urb(urb, &portdata->active); 486 } 487 /* send it down the pipe */ 488 retval = usb_submit_urb(urb, GFP_ATOMIC); 489 if (retval) { 490 usb_unanchor_urb(urb); 491 spin_unlock_irqrestore(&intfdata->susp_lock, flags); 492 dev_err(&port->dev, "%s - usb_submit_urb(write bulk) failed " 493 "with status = %d\n", __func__, retval); 494 goto error; 495 } else { 496 intfdata->in_flight++; 497 spin_unlock_irqrestore(&intfdata->susp_lock, flags); 498 } 499 500skip_power: 501 /* we are done with this urb, so let the host driver 502 * really free it when it is finished with it */ 503 usb_free_urb(urb); 504 505 return writesize; 506error: 507 usb_free_urb(urb); 508error_no_urb: 509 kfree(buffer); 510error_no_buffer: 511 spin_lock_irqsave(&portdata->lock, flags); 512 --portdata->outstanding_urbs; 513 dev_dbg(&port->dev, "%s - 2. outstanding_urbs: %d\n", __func__, 514 portdata->outstanding_urbs); 515 spin_unlock_irqrestore(&portdata->lock, flags); 516 usb_autopm_put_interface_async(serial->interface); 517error_simple: 518 return retval; 519} 520 521static void sierra_indat_callback(struct urb *urb) 522{ 523 int err; 524 int endpoint; 525 struct usb_serial_port *port; 526 unsigned char *data = urb->transfer_buffer; 527 int status = urb->status; 528 529 endpoint = usb_pipeendpoint(urb->pipe); 530 port = urb->context; 531 532 if (status) { 533 dev_dbg(&port->dev, "%s: nonzero status: %d on" 534 " endpoint %02x\n", __func__, status, endpoint); 535 } else { 536 if (urb->actual_length) { 537 tty_insert_flip_string(&port->port, data, 538 urb->actual_length); 539 tty_flip_buffer_push(&port->port); 540 541 usb_serial_debug_data(&port->dev, __func__, 542 urb->actual_length, data); 543 } else { 544 dev_dbg(&port->dev, "%s: empty read urb" 545 " received\n", __func__); 546 } 547 } 548 549 /* Resubmit urb so we continue receiving */ 550 if (status != -ESHUTDOWN && status != -EPERM) { 551 usb_mark_last_busy(port->serial->dev); 552 err = usb_submit_urb(urb, GFP_ATOMIC); 553 if (err && err != -EPERM) 554 dev_err(&port->dev, "resubmit read urb failed." 555 "(%d)\n", err); 556 } 557} 558 559static void sierra_instat_callback(struct urb *urb) 560{ 561 int err; 562 int status = urb->status; 563 struct usb_serial_port *port = urb->context; 564 struct sierra_port_private *portdata = usb_get_serial_port_data(port); 565 struct usb_serial *serial = port->serial; 566 567 dev_dbg(&port->dev, "%s: urb %p port %p has data %p\n", __func__, 568 urb, port, portdata); 569 570 if (status == 0) { 571 struct usb_ctrlrequest *req_pkt = urb->transfer_buffer; 572 573 if (!req_pkt) { 574 dev_dbg(&port->dev, "%s: NULL req_pkt\n", 575 __func__); 576 return; 577 } 578 if ((req_pkt->bRequestType == 0xA1) && 579 (req_pkt->bRequest == 0x20)) { 580 int old_dcd_state; 581 unsigned char signals = *((unsigned char *) 582 urb->transfer_buffer + 583 sizeof(struct usb_ctrlrequest)); 584 585 dev_dbg(&port->dev, "%s: signal x%x\n", __func__, 586 signals); 587 588 old_dcd_state = portdata->dcd_state; 589 portdata->cts_state = 1; 590 portdata->dcd_state = ((signals & 0x01) ? 1 : 0); 591 portdata->dsr_state = ((signals & 0x02) ? 1 : 0); 592 portdata->ri_state = ((signals & 0x08) ? 1 : 0); 593 594 if (old_dcd_state && !portdata->dcd_state) 595 tty_port_tty_hangup(&port->port, true); 596 } else { 597 dev_dbg(&port->dev, "%s: type %x req %x\n", 598 __func__, req_pkt->bRequestType, 599 req_pkt->bRequest); 600 } 601 } else 602 dev_dbg(&port->dev, "%s: error %d\n", __func__, status); 603 604 /* Resubmit urb so we continue receiving IRQ data */ 605 if (status != -ESHUTDOWN && status != -ENOENT) { 606 usb_mark_last_busy(serial->dev); 607 err = usb_submit_urb(urb, GFP_ATOMIC); 608 if (err && err != -EPERM) 609 dev_err(&port->dev, "%s: resubmit intr urb " 610 "failed. (%d)\n", __func__, err); 611 } 612} 613 614static unsigned int sierra_write_room(struct tty_struct *tty) 615{ 616 struct usb_serial_port *port = tty->driver_data; 617 struct sierra_port_private *portdata = usb_get_serial_port_data(port); 618 unsigned long flags; 619 620 /* try to give a good number back based on if we have any free urbs at 621 * this point in time */ 622 spin_lock_irqsave(&portdata->lock, flags); 623 if (portdata->outstanding_urbs > (portdata->num_out_urbs * 2) / 3) { 624 spin_unlock_irqrestore(&portdata->lock, flags); 625 dev_dbg(&port->dev, "%s - write limit hit\n", __func__); 626 return 0; 627 } 628 spin_unlock_irqrestore(&portdata->lock, flags); 629 630 return 2048; 631} 632 633static unsigned int sierra_chars_in_buffer(struct tty_struct *tty) 634{ 635 struct usb_serial_port *port = tty->driver_data; 636 struct sierra_port_private *portdata = usb_get_serial_port_data(port); 637 unsigned long flags; 638 unsigned int chars; 639 640 /* NOTE: This overcounts somewhat. */ 641 spin_lock_irqsave(&portdata->lock, flags); 642 chars = portdata->outstanding_urbs * MAX_TRANSFER; 643 spin_unlock_irqrestore(&portdata->lock, flags); 644 645 dev_dbg(&port->dev, "%s - %u\n", __func__, chars); 646 647 return chars; 648} 649 650static void sierra_stop_rx_urbs(struct usb_serial_port *port) 651{ 652 int i; 653 struct sierra_port_private *portdata = usb_get_serial_port_data(port); 654 655 for (i = 0; i < portdata->num_in_urbs; i++) 656 usb_kill_urb(portdata->in_urbs[i]); 657 658 usb_kill_urb(port->interrupt_in_urb); 659} 660 661static int sierra_submit_rx_urbs(struct usb_serial_port *port, gfp_t mem_flags) 662{ 663 int ok_cnt; 664 int err = -EINVAL; 665 int i; 666 struct urb *urb; 667 struct sierra_port_private *portdata = usb_get_serial_port_data(port); 668 669 ok_cnt = 0; 670 for (i = 0; i < portdata->num_in_urbs; i++) { 671 urb = portdata->in_urbs[i]; 672 if (!urb) 673 continue; 674 err = usb_submit_urb(urb, mem_flags); 675 if (err) { 676 dev_err(&port->dev, "%s: submit urb failed: %d\n", 677 __func__, err); 678 } else { 679 ok_cnt++; 680 } 681 } 682 683 if (ok_cnt && port->interrupt_in_urb) { 684 err = usb_submit_urb(port->interrupt_in_urb, mem_flags); 685 if (err) { 686 dev_err(&port->dev, "%s: submit intr urb failed: %d\n", 687 __func__, err); 688 } 689 } 690 691 if (ok_cnt > 0) /* at least one rx urb submitted */ 692 return 0; 693 else 694 return err; 695} 696 697static struct urb *sierra_setup_urb(struct usb_serial *serial, int endpoint, 698 int dir, void *ctx, int len, 699 gfp_t mem_flags, 700 usb_complete_t callback) 701{ 702 struct urb *urb; 703 u8 *buf; 704 705 urb = usb_alloc_urb(0, mem_flags); 706 if (!urb) 707 return NULL; 708 709 buf = kmalloc(len, mem_flags); 710 if (buf) { 711 /* Fill URB using supplied data */ 712 usb_fill_bulk_urb(urb, serial->dev, 713 usb_sndbulkpipe(serial->dev, endpoint) | dir, 714 buf, len, callback, ctx); 715 716 dev_dbg(&serial->dev->dev, "%s %c u : %p d:%p\n", __func__, 717 dir == USB_DIR_IN ? 'i' : 'o', urb, buf); 718 } else { 719 sierra_release_urb(urb); 720 urb = NULL; 721 } 722 723 return urb; 724} 725 726static void sierra_close(struct usb_serial_port *port) 727{ 728 int i; 729 struct usb_serial *serial = port->serial; 730 struct sierra_port_private *portdata; 731 struct sierra_intf_private *intfdata = usb_get_serial_data(serial); 732 struct urb *urb; 733 734 portdata = usb_get_serial_port_data(port); 735 736 /* 737 * Need to take susp_lock to make sure port is not already being 738 * resumed, but no need to hold it due to the tty-port initialized 739 * flag. 740 */ 741 spin_lock_irq(&intfdata->susp_lock); 742 if (--intfdata->open_ports == 0) 743 serial->interface->needs_remote_wakeup = 0; 744 spin_unlock_irq(&intfdata->susp_lock); 745 746 for (;;) { 747 urb = usb_get_from_anchor(&portdata->delayed); 748 if (!urb) 749 break; 750 kfree(urb->transfer_buffer); 751 usb_free_urb(urb); 752 usb_autopm_put_interface_async(serial->interface); 753 spin_lock_irq(&portdata->lock); 754 portdata->outstanding_urbs--; 755 spin_unlock_irq(&portdata->lock); 756 } 757 758 sierra_stop_rx_urbs(port); 759 usb_kill_anchored_urbs(&portdata->active); 760 761 for (i = 0; i < portdata->num_in_urbs; i++) { 762 sierra_release_urb(portdata->in_urbs[i]); 763 portdata->in_urbs[i] = NULL; 764 } 765 766 usb_autopm_get_interface_no_resume(serial->interface); 767} 768 769static int sierra_open(struct tty_struct *tty, struct usb_serial_port *port) 770{ 771 struct sierra_port_private *portdata; 772 struct usb_serial *serial = port->serial; 773 struct sierra_intf_private *intfdata = usb_get_serial_data(serial); 774 int i; 775 int err; 776 int endpoint; 777 struct urb *urb; 778 779 portdata = usb_get_serial_port_data(port); 780 781 endpoint = port->bulk_in_endpointAddress; 782 for (i = 0; i < portdata->num_in_urbs; i++) { 783 urb = sierra_setup_urb(serial, endpoint, USB_DIR_IN, port, 784 IN_BUFLEN, GFP_KERNEL, 785 sierra_indat_callback); 786 portdata->in_urbs[i] = urb; 787 } 788 /* clear halt condition */ 789 usb_clear_halt(serial->dev, 790 usb_sndbulkpipe(serial->dev, endpoint) | USB_DIR_IN); 791 792 err = sierra_submit_rx_urbs(port, GFP_KERNEL); 793 if (err) 794 goto err_submit; 795 796 spin_lock_irq(&intfdata->susp_lock); 797 if (++intfdata->open_ports == 1) 798 serial->interface->needs_remote_wakeup = 1; 799 spin_unlock_irq(&intfdata->susp_lock); 800 usb_autopm_put_interface(serial->interface); 801 802 return 0; 803 804err_submit: 805 sierra_stop_rx_urbs(port); 806 807 for (i = 0; i < portdata->num_in_urbs; i++) { 808 sierra_release_urb(portdata->in_urbs[i]); 809 portdata->in_urbs[i] = NULL; 810 } 811 812 return err; 813} 814 815 816static void sierra_dtr_rts(struct usb_serial_port *port, int on) 817{ 818 struct sierra_port_private *portdata; 819 820 portdata = usb_get_serial_port_data(port); 821 portdata->rts_state = on; 822 portdata->dtr_state = on; 823 824 sierra_send_setup(port); 825} 826 827static int sierra_startup(struct usb_serial *serial) 828{ 829 struct sierra_intf_private *intfdata; 830 831 intfdata = kzalloc(sizeof(*intfdata), GFP_KERNEL); 832 if (!intfdata) 833 return -ENOMEM; 834 835 spin_lock_init(&intfdata->susp_lock); 836 837 usb_set_serial_data(serial, intfdata); 838 839 /* Set Device mode to D0 */ 840 sierra_set_power_state(serial->dev, 0x0000); 841 842 /* Check NMEA and set */ 843 if (nmea) 844 sierra_vsc_set_nmea(serial->dev, 1); 845 846 return 0; 847} 848 849static void sierra_release(struct usb_serial *serial) 850{ 851 struct sierra_intf_private *intfdata; 852 853 intfdata = usb_get_serial_data(serial); 854 kfree(intfdata); 855} 856 857static int sierra_port_probe(struct usb_serial_port *port) 858{ 859 struct usb_serial *serial = port->serial; 860 struct sierra_port_private *portdata; 861 const struct sierra_iface_list *himemory_list; 862 u8 ifnum; 863 864 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL); 865 if (!portdata) 866 return -ENOMEM; 867 868 spin_lock_init(&portdata->lock); 869 init_usb_anchor(&portdata->active); 870 init_usb_anchor(&portdata->delayed); 871 872 /* Assume low memory requirements */ 873 portdata->num_out_urbs = N_OUT_URB; 874 portdata->num_in_urbs = N_IN_URB; 875 876 /* Determine actual memory requirements */ 877 if (serial->num_ports == 1) { 878 /* Get interface number for composite device */ 879 ifnum = sierra_interface_num(serial); 880 himemory_list = &typeB_interface_list; 881 } else { 882 /* This is really the usb-serial port number of the interface 883 * rather than the interface number. 884 */ 885 ifnum = port->port_number; 886 himemory_list = &typeA_interface_list; 887 } 888 889 if (is_listed(ifnum, himemory_list)) { 890 portdata->num_out_urbs = N_OUT_URB_HM; 891 portdata->num_in_urbs = N_IN_URB_HM; 892 } 893 894 dev_dbg(&port->dev, 895 "Memory usage (urbs) interface #%d, in=%d, out=%d\n", 896 ifnum, portdata->num_in_urbs, portdata->num_out_urbs); 897 898 usb_set_serial_port_data(port, portdata); 899 900 return 0; 901} 902 903static void sierra_port_remove(struct usb_serial_port *port) 904{ 905 struct sierra_port_private *portdata; 906 907 portdata = usb_get_serial_port_data(port); 908 usb_set_serial_port_data(port, NULL); 909 kfree(portdata); 910} 911 912#ifdef CONFIG_PM 913static void stop_read_write_urbs(struct usb_serial *serial) 914{ 915 int i; 916 struct usb_serial_port *port; 917 struct sierra_port_private *portdata; 918 919 /* Stop reading/writing urbs */ 920 for (i = 0; i < serial->num_ports; ++i) { 921 port = serial->port[i]; 922 portdata = usb_get_serial_port_data(port); 923 if (!portdata) 924 continue; 925 sierra_stop_rx_urbs(port); 926 usb_kill_anchored_urbs(&portdata->active); 927 } 928} 929 930static int sierra_suspend(struct usb_serial *serial, pm_message_t message) 931{ 932 struct sierra_intf_private *intfdata = usb_get_serial_data(serial); 933 934 spin_lock_irq(&intfdata->susp_lock); 935 if (PMSG_IS_AUTO(message)) { 936 if (intfdata->in_flight) { 937 spin_unlock_irq(&intfdata->susp_lock); 938 return -EBUSY; 939 } 940 } 941 intfdata->suspended = 1; 942 spin_unlock_irq(&intfdata->susp_lock); 943 944 stop_read_write_urbs(serial); 945 946 return 0; 947} 948 949/* Caller must hold susp_lock. */ 950static int sierra_submit_delayed_urbs(struct usb_serial_port *port) 951{ 952 struct sierra_port_private *portdata = usb_get_serial_port_data(port); 953 struct sierra_intf_private *intfdata; 954 struct urb *urb; 955 int ec = 0; 956 int err; 957 958 intfdata = usb_get_serial_data(port->serial); 959 960 for (;;) { 961 urb = usb_get_from_anchor(&portdata->delayed); 962 if (!urb) 963 break; 964 965 usb_anchor_urb(urb, &portdata->active); 966 intfdata->in_flight++; 967 err = usb_submit_urb(urb, GFP_ATOMIC); 968 if (err) { 969 dev_err(&port->dev, "%s - submit urb failed: %d", 970 __func__, err); 971 ec++; 972 intfdata->in_flight--; 973 usb_unanchor_urb(urb); 974 kfree(urb->transfer_buffer); 975 usb_free_urb(urb); 976 977 spin_lock(&portdata->lock); 978 portdata->outstanding_urbs--; 979 spin_unlock(&portdata->lock); 980 } 981 } 982 983 if (ec) 984 return -EIO; 985 986 return 0; 987} 988 989static int sierra_resume(struct usb_serial *serial) 990{ 991 struct usb_serial_port *port; 992 struct sierra_intf_private *intfdata = usb_get_serial_data(serial); 993 int ec = 0; 994 int i, err; 995 996 spin_lock_irq(&intfdata->susp_lock); 997 for (i = 0; i < serial->num_ports; i++) { 998 port = serial->port[i]; 999 1000 if (!tty_port_initialized(&port->port)) 1001 continue; 1002 1003 err = sierra_submit_delayed_urbs(port); 1004 if (err) 1005 ec++; 1006 1007 err = sierra_submit_rx_urbs(port, GFP_ATOMIC); 1008 if (err) 1009 ec++; 1010 } 1011 intfdata->suspended = 0; 1012 spin_unlock_irq(&intfdata->susp_lock); 1013 1014 return ec ? -EIO : 0; 1015} 1016 1017#else 1018#define sierra_suspend NULL 1019#define sierra_resume NULL 1020#endif 1021 1022static struct usb_serial_driver sierra_device = { 1023 .driver = { 1024 .owner = THIS_MODULE, 1025 .name = "sierra", 1026 }, 1027 .description = "Sierra USB modem", 1028 .id_table = id_table, 1029 .calc_num_ports = sierra_calc_num_ports, 1030 .probe = sierra_probe, 1031 .open = sierra_open, 1032 .close = sierra_close, 1033 .dtr_rts = sierra_dtr_rts, 1034 .write = sierra_write, 1035 .write_room = sierra_write_room, 1036 .chars_in_buffer = sierra_chars_in_buffer, 1037 .tiocmget = sierra_tiocmget, 1038 .tiocmset = sierra_tiocmset, 1039 .attach = sierra_startup, 1040 .release = sierra_release, 1041 .port_probe = sierra_port_probe, 1042 .port_remove = sierra_port_remove, 1043 .suspend = sierra_suspend, 1044 .resume = sierra_resume, 1045 .read_int_callback = sierra_instat_callback, 1046}; 1047 1048static struct usb_serial_driver * const serial_drivers[] = { 1049 &sierra_device, NULL 1050}; 1051 1052module_usb_serial_driver(serial_drivers, id_table); 1053 1054MODULE_AUTHOR(DRIVER_AUTHOR); 1055MODULE_DESCRIPTION(DRIVER_DESC); 1056MODULE_LICENSE("GPL v2"); 1057 1058module_param(nmea, bool, 0644); 1059MODULE_PARM_DESC(nmea, "NMEA streaming"); 1060