drivers/usb/serial/sierra.c

   1 /*
   2   USB Driver for Sierra Wireless
   3
   4   Copyright (C) 2006  Kevin Lloyd <linux@sierrawireless.com>
   5
   6   IMPORTANT DISCLAIMER: This driver is not commercially supported by
   7   Sierra Wireless. Use at your own risk.
   8
   9   This driver is free software; you can redistribute it and/or modify
  10   it under the terms of Version 2 of the GNU General Public License as
  11   published by the Free Software Foundation.
  12
  13   Portions based on the option driver by Matthias Urlichs <smurf@smurf.noris.de>
  14   Whom based his on the Keyspan driver by Hugh Blemings <hugh@blemings.org>
  15
  16 */
  17
  18 #define DRIVER_VERSION "v.1.0.6"
  19 #define DRIVER_AUTHOR "Kevin Lloyd <linux@sierrawireless.com>"
  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/tty_flip.h>
  27 #include <linux/module.h>
  28 #include <linux/usb.h>
  29 #include <linux/usb/serial.h>
  30
  31
  32 static struct usb_device_id id_table [] = {
  33         { USB_DEVICE(0x1199, 0x0017) }, /* Sierra Wireless EM5625 */
  34         { USB_DEVICE(0x1199, 0x0018) }, /* Sierra Wireless MC5720 */
  35         { USB_DEVICE(0x1199, 0x0218) }, /* Sierra Wireless MC5720 */
  36         { USB_DEVICE(0x1199, 0x0020) }, /* Sierra Wireless MC5725 */
  37         { USB_DEVICE(0x1199, 0x0019) }, /* Sierra Wireless AirCard 595 */
  38         { USB_DEVICE(0x1199, 0x0120) }, /* Sierra Wireless AirCard 595U */
  39         { USB_DEVICE(0x1199, 0x0021) }, /* Sierra Wireless AirCard 597E */
  40         { USB_DEVICE(0x1199, 0x6802) }, /* Sierra Wireless MC8755 */
  41         { USB_DEVICE(0x1199, 0x6804) }, /* Sierra Wireless MC8755 */
  42         { USB_DEVICE(0x1199, 0x6803) }, /* Sierra Wireless MC8765 */
  43         { USB_DEVICE(0x1199, 0x6812) }, /* Sierra Wireless MC8775 */
  44         { USB_DEVICE(0x1199, 0x6820) }, /* Sierra Wireless AirCard 875 */
  45
  46         { USB_DEVICE(0x1199, 0x0112) }, /* Sierra Wireless AirCard 580 */
  47         { USB_DEVICE(0x0F3D, 0x0112) }, /* AirPrime/Sierra PC 5220 */
  48         { }
  49 };
  50 MODULE_DEVICE_TABLE(usb, id_table);
  51
  52 static struct usb_device_id id_table_1port [] = {
  53         { USB_DEVICE(0x1199, 0x0112) }, /* Sierra Wireless AirCard 580 */
  54         { USB_DEVICE(0x0F3D, 0x0112) }, /* AirPrime/Sierra PC 5220 */
  55         { }
  56 };
  57
  58 static struct usb_device_id id_table_3port [] = {
  59         { USB_DEVICE(0x1199, 0x0017) }, /* Sierra Wireless EM5625 */
  60         { USB_DEVICE(0x1199, 0x0018) }, /* Sierra Wireless MC5720 */
  61         { USB_DEVICE(0x1199, 0x0218) }, /* Sierra Wireless MC5720 */
  62         { USB_DEVICE(0x1199, 0x0020) }, /* Sierra Wireless MC5725 */
  63         { USB_DEVICE(0x1199, 0x0019) }, /* Sierra Wireless AirCard 595 */
  64         { USB_DEVICE(0x1199, 0x0120) }, /* Sierra Wireless AirCard 595U */
  65         { USB_DEVICE(0x1199, 0x0021) }, /* Sierra Wireless AirCard 597E */
  66         { USB_DEVICE(0x1199, 0x6802) }, /* Sierra Wireless MC8755 */
  67         { USB_DEVICE(0x1199, 0x6804) }, /* Sierra Wireless MC8755 */
  68         { USB_DEVICE(0x1199, 0x6803) }, /* Sierra Wireless MC8765 */
  69         { USB_DEVICE(0x1199, 0x6812) }, /* Sierra Wireless MC8775 */
  70         { USB_DEVICE(0x1199, 0x6820) }, /* Sierra Wireless AirCard 875 */
  71         { }
  72 };
  73
  74 static struct usb_driver sierra_driver = {
  75         .name       = "sierra",
  76         .probe      = usb_serial_probe,
  77         .disconnect = usb_serial_disconnect,
  78         .id_table   = id_table,
  79         .no_dynamic_id =        1,
  80 };
  81
  82
  83 static int debug;
  84
  85 /* per port private data */
  86 #define N_IN_URB        4
  87 #define N_OUT_URB       4
  88 #define IN_BUFLEN       4096
  89 #define OUT_BUFLEN      128
  90
  91 struct sierra_port_private {
  92         /* Input endpoints and buffer for this port */
  93         struct urb *in_urbs[N_IN_URB];
  94         char in_buffer[N_IN_URB][IN_BUFLEN];
  95         /* Output endpoints and buffer for this port */
  96         struct urb *out_urbs[N_OUT_URB];
  97         char out_buffer[N_OUT_URB][OUT_BUFLEN];
  98
  99         /* Settings for the port */
 100         int rts_state;  /* Handshaking pins (outputs) */
 101         int dtr_state;
 102         int cts_state;  /* Handshaking pins (inputs) */
 103         int dsr_state;
 104         int dcd_state;
 105         int ri_state;
 106
 107         unsigned long tx_start_time[N_OUT_URB];
 108 };
 109
 110 static int sierra_send_setup(struct usb_serial_port *port)
 111 {
 112         struct usb_serial *serial = port->serial;
 113         struct sierra_port_private *portdata;
 114
 115         dbg("%s", __FUNCTION__);
 116
 117         portdata = usb_get_serial_port_data(port);
 118
 119         if (port->tty) {
 120                 int val = 0;
 121                 if (portdata->dtr_state)
 122                         val |= 0x01;
 123                 if (portdata->rts_state)
 124                         val |= 0x02;
 125
 126                 return usb_control_msg(serial->dev,
 127                                 usb_rcvctrlpipe(serial->dev, 0),
 128                                 0x22,0x21,val,0,NULL,0,USB_CTRL_SET_TIMEOUT);
 129         }
 130
 131         return 0;
 132 }
 133
 134 static void sierra_rx_throttle(struct usb_serial_port *port)
 135 {
 136         dbg("%s", __FUNCTION__);
 137 }
 138
 139 static void sierra_rx_unthrottle(struct usb_serial_port *port)
 140 {
 141         dbg("%s", __FUNCTION__);
 142 }
 143
 144 static void sierra_break_ctl(struct usb_serial_port *port, int break_state)
 145 {
 146         /* Unfortunately, I don't know how to send a break */
 147         dbg("%s", __FUNCTION__);
 148 }
 149
 150 static void sierra_set_termios(struct usb_serial_port *port,
 151                         struct ktermios *old_termios)
 152 {
 153         dbg("%s", __FUNCTION__);
 154
 155         sierra_send_setup(port);
 156 }
 157
 158 static int sierra_tiocmget(struct usb_serial_port *port, struct file *file)
 159 {
 160         unsigned int value;
 161         struct sierra_port_private *portdata;
 162
 163         portdata = usb_get_serial_port_data(port);
 164
 165         value = ((portdata->rts_state) ? TIOCM_RTS : 0) |
 166                 ((portdata->dtr_state) ? TIOCM_DTR : 0) |
 167                 ((portdata->cts_state) ? TIOCM_CTS : 0) |
 168                 ((portdata->dsr_state) ? TIOCM_DSR : 0) |
 169                 ((portdata->dcd_state) ? TIOCM_CAR : 0) |
 170                 ((portdata->ri_state) ? TIOCM_RNG : 0);
 171
 172         return value;
 173 }
 174
 175 static int sierra_tiocmset(struct usb_serial_port *port, struct file *file,
 176                         unsigned int set, unsigned int clear)
 177 {
 178         struct sierra_port_private *portdata;
 179
 180         portdata = usb_get_serial_port_data(port);
 181
 182         if (set & TIOCM_RTS)
 183                 portdata->rts_state = 1;
 184         if (set & TIOCM_DTR)
 185                 portdata->dtr_state = 1;
 186
 187         if (clear & TIOCM_RTS)
 188                 portdata->rts_state = 0;
 189         if (clear & TIOCM_DTR)
 190                 portdata->dtr_state = 0;
 191         return sierra_send_setup(port);
 192 }
 193
 194 static int sierra_ioctl(struct usb_serial_port *port, struct file *file,
 195                         unsigned int cmd, unsigned long arg)
 196 {
 197         return -ENOIOCTLCMD;
 198 }
 199
 200 /* Write */
 201 static int sierra_write(struct usb_serial_port *port,
 202                         const unsigned char *buf, int count)
 203 {
 204         struct sierra_port_private *portdata;
 205         int i;
 206         int left, todo;
 207         struct urb *this_urb = NULL; /* spurious */
 208         int err;
 209
 210         portdata = usb_get_serial_port_data(port);
 211
 212         dbg("%s: write (%d chars)", __FUNCTION__, count);
 213
 214         i = 0;
 215         left = count;
 216         for (i=0; left > 0 && i < N_OUT_URB; i++) {
 217                 todo = left;
 218                 if (todo > OUT_BUFLEN)
 219                         todo = OUT_BUFLEN;
 220
 221                 this_urb = portdata->out_urbs[i];
 222                 if (this_urb->status == -EINPROGRESS) {
 223                         if (time_before(jiffies,
 224                                         portdata->tx_start_time[i] + 10 * HZ))
 225                                 continue;
 226                         usb_unlink_urb(this_urb);
 227                         continue;
 228                 }
 229                 if (this_urb->status != 0)
 230                         dbg("usb_write %p failed (err=%d)",
 231                                 this_urb, this_urb->status);
 232
 233                 dbg("%s: endpoint %d buf %d", __FUNCTION__,
 234                         usb_pipeendpoint(this_urb->pipe), i);
 235
 236                 /* send the data */
 237                 memcpy (this_urb->transfer_buffer, buf, todo);
 238                 this_urb->transfer_buffer_length = todo;
 239
 240                 this_urb->dev = port->serial->dev;
 241                 err = usb_submit_urb(this_urb, GFP_ATOMIC);
 242                 if (err) {
 243                         dbg("usb_submit_urb %p (write bulk) failed "
 244                                 "(%d, has %d)", this_urb,
 245                                 err, this_urb->status);
 246                         continue;
 247                 }
 248                 portdata->tx_start_time[i] = jiffies;
 249                 buf += todo;
 250                 left -= todo;
 251         }
 252
 253         count -= left;
 254         dbg("%s: wrote (did %d)", __FUNCTION__, count);
 255         return count;
 256 }
 257
 258 static void sierra_indat_callback(struct urb *urb)
 259 {
 260         int err;
 261         int endpoint;
 262         struct usb_serial_port *port;
 263         struct tty_struct *tty;
 264         unsigned char *data = urb->transfer_buffer;
 265
 266         dbg("%s: %p", __FUNCTION__, urb);
 267
 268         endpoint = usb_pipeendpoint(urb->pipe);
 269         port = (struct usb_serial_port *) urb->context;
 270
 271         if (urb->status) {
 272                 dbg("%s: nonzero status: %d on endpoint %02x.",
 273                     __FUNCTION__, urb->status, endpoint);
 274         } else {
 275                 tty = port->tty;
 276                 if (urb->actual_length) {
 277                         tty_buffer_request_room(tty, urb->actual_length);
 278                         tty_insert_flip_string(tty, data, urb->actual_length);
 279                         tty_flip_buffer_push(tty);
 280                 } else {
 281                         dbg("%s: empty read urb received", __FUNCTION__);
 282                 }
 283
 284                 /* Resubmit urb so we continue receiving */
 285                 if (port->open_count && urb->status != -ESHUTDOWN) {
 286                         err = usb_submit_urb(urb, GFP_ATOMIC);
 287                         if (err)
 288                                 printk(KERN_ERR "%s: resubmit read urb failed. "
 289                                         "(%d)", __FUNCTION__, err);
 290                 }
 291         }
 292         return;
 293 }
 294
 295 static void sierra_outdat_callback(struct urb *urb)
 296 {
 297         struct usb_serial_port *port;
 298
 299         dbg("%s", __FUNCTION__);
 300
 301         port = (struct usb_serial_port *) urb->context;
 302
 303         usb_serial_port_softint(port);
 304 }
 305
 306 static void sierra_instat_callback(struct urb *urb)
 307 {
 308         int err;
 309         struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
 310         struct sierra_port_private *portdata = usb_get_serial_port_data(port);
 311         struct usb_serial *serial = port->serial;
 312
 313         dbg("%s", __FUNCTION__);
 314         dbg("%s: urb %p port %p has data %p", __FUNCTION__,urb,port,portdata);
 315
 316         if (urb->status == 0) {
 317                 struct usb_ctrlrequest *req_pkt =
 318                                 (struct usb_ctrlrequest *)urb->transfer_buffer;
 319
 320                 if (!req_pkt) {
 321                         dbg("%s: NULL req_pkt\n", __FUNCTION__);
 322                         return;
 323                 }
 324                 if ((req_pkt->bRequestType == 0xA1) &&
 325                                 (req_pkt->bRequest == 0x20)) {
 326                         int old_dcd_state;
 327                         unsigned char signals = *((unsigned char *)
 328                                         urb->transfer_buffer +
 329                                         sizeof(struct usb_ctrlrequest));
 330
 331                         dbg("%s: signal x%x", __FUNCTION__, signals);
 332
 333                         old_dcd_state = portdata->dcd_state;
 334                         portdata->cts_state = 1;
 335                         portdata->dcd_state = ((signals & 0x01) ? 1 : 0);
 336                         portdata->dsr_state = ((signals & 0x02) ? 1 : 0);
 337                         portdata->ri_state = ((signals & 0x08) ? 1 : 0);
 338
 339                         if (port->tty && !C_CLOCAL(port->tty) &&
 340                                         old_dcd_state && !portdata->dcd_state)
 341                                 tty_hangup(port->tty);
 342                 } else {
 343                         dbg("%s: type %x req %x", __FUNCTION__,
 344                                 req_pkt->bRequestType,req_pkt->bRequest);
 345                 }
 346         } else
 347                 dbg("%s: error %d", __FUNCTION__, urb->status);
 348
 349         /* Resubmit urb so we continue receiving IRQ data */
 350         if (urb->status != -ESHUTDOWN) {
 351                 urb->dev = serial->dev;
 352                 err = usb_submit_urb(urb, GFP_ATOMIC);
 353                 if (err)
 354                         dbg("%s: resubmit intr urb failed. (%d)",
 355                                 __FUNCTION__, err);
 356         }
 357 }
 358
 359 static int sierra_write_room(struct usb_serial_port *port)
 360 {
 361         struct sierra_port_private *portdata;
 362         int i;
 363         int data_len = 0;
 364         struct urb *this_urb;
 365
 366         portdata = usb_get_serial_port_data(port);
 367
 368         for (i=0; i < N_OUT_URB; i++) {
 369                 this_urb = portdata->out_urbs[i];
 370                 if (this_urb && this_urb->status != -EINPROGRESS)
 371                         data_len += OUT_BUFLEN;
 372         }
 373
 374         dbg("%s: %d", __FUNCTION__, data_len);
 375         return data_len;
 376 }
 377
 378 static int sierra_chars_in_buffer(struct usb_serial_port *port)
 379 {
 380         struct sierra_port_private *portdata;
 381         int i;
 382         int data_len = 0;
 383         struct urb *this_urb;
 384
 385         portdata = usb_get_serial_port_data(port);
 386
 387         for (i=0; i < N_OUT_URB; i++) {
 388                 this_urb = portdata->out_urbs[i];
 389                 if (this_urb && this_urb->status == -EINPROGRESS)
 390                         data_len += this_urb->transfer_buffer_length;
 391         }
 392         dbg("%s: %d", __FUNCTION__, data_len);
 393         return data_len;
 394 }
 395
 396 static int sierra_open(struct usb_serial_port *port, struct file *filp)
 397 {
 398         struct sierra_port_private *portdata;
 399         struct usb_serial *serial = port->serial;
 400         int i, err;
 401         struct urb *urb;
 402         int result;
 403         __u16 set_mode_dzero = 0x0000;
 404
 405         portdata = usb_get_serial_port_data(port);
 406
 407         dbg("%s", __FUNCTION__);
 408
 409         /* Set some sane defaults */
 410         portdata->rts_state = 1;
 411         portdata->dtr_state = 1;
 412
 413         /* Reset low level data toggle and start reading from endpoints */
 414         for (i = 0; i < N_IN_URB; i++) {
 415                 urb = portdata->in_urbs[i];
 416                 if (! urb)
 417                         continue;
 418                 if (urb->dev != serial->dev) {
 419                         dbg("%s: dev %p != %p", __FUNCTION__,
 420                                 urb->dev, serial->dev);
 421                         continue;
 422                 }
 423
 424                 /*
 425                  * make sure endpoint data toggle is synchronized with the
 426                  * device
 427                  */
 428                 usb_clear_halt(urb->dev, urb->pipe);
 429
 430                 err = usb_submit_urb(urb, GFP_KERNEL);
 431                 if (err) {
 432                         dbg("%s: submit urb %d failed (%d) %d",
 433                                 __FUNCTION__, i, err,
 434                                 urb->transfer_buffer_length);
 435                 }
 436         }
 437
 438         /* Reset low level data toggle on out endpoints */
 439         for (i = 0; i < N_OUT_URB; i++) {
 440                 urb = portdata->out_urbs[i];
 441                 if (! urb)
 442                         continue;
 443                 urb->dev = serial->dev;
 444                 /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
 445                                 usb_pipeout(urb->pipe), 0); */
 446         }
 447
 448         port->tty->low_latency = 1;
 449
 450         /* set mode to D0 */
 451         result = usb_control_msg(serial->dev,
 452                                  usb_rcvctrlpipe(serial->dev, 0),
 453                                  0x00, 0x40, set_mode_dzero, 0, NULL,
 454                                  0, USB_CTRL_SET_TIMEOUT);
 455
 456         sierra_send_setup(port);
 457
 458         return (0);
 459 }
 460
 461 static void sierra_close(struct usb_serial_port *port, struct file *filp)
 462 {
 463         int i;
 464         struct usb_serial *serial = port->serial;
 465         struct sierra_port_private *portdata;
 466
 467         dbg("%s", __FUNCTION__);
 468         portdata = usb_get_serial_port_data(port);
 469
 470         portdata->rts_state = 0;
 471         portdata->dtr_state = 0;
 472
 473         if (serial->dev) {
 474                 sierra_send_setup(port);
 475
 476                 /* Stop reading/writing urbs */
 477                 for (i = 0; i < N_IN_URB; i++)
 478                         usb_unlink_urb(portdata->in_urbs[i]);
 479                 for (i = 0; i < N_OUT_URB; i++)
 480                         usb_unlink_urb(portdata->out_urbs[i]);
 481         }
 482         port->tty = NULL;
 483 }
 484
 485 /* Helper functions used by sierra_setup_urbs */
 486 static struct urb *sierra_setup_urb(struct usb_serial *serial, int endpoint,
 487                                     int dir, void *ctx, char *buf, int len,
 488                                     usb_complete_t callback)
 489 {
 490         struct urb *urb;
 491
 492         if (endpoint == -1)
 493                 return NULL;            /* endpoint not needed */
 494
 495         urb = usb_alloc_urb(0, GFP_KERNEL);             /* No ISO */
 496         if (urb == NULL) {
 497                 dbg("%s: alloc for endpoint %d failed.", __FUNCTION__, endpoint);
 498                 return NULL;
 499         }
 500
 501                 /* Fill URB using supplied data. */
 502         usb_fill_bulk_urb(urb, serial->dev,
 503                       usb_sndbulkpipe(serial->dev, endpoint) | dir,
 504                       buf, len, callback, ctx);
 505
 506         return urb;
 507 }
 508
 509 /* Setup urbs */
 510 static void sierra_setup_urbs(struct usb_serial *serial)
 511 {
 512         int i,j;
 513         struct usb_serial_port *port;
 514         struct sierra_port_private *portdata;
 515
 516         dbg("%s", __FUNCTION__);
 517
 518         for (i = 0; i < serial->num_ports; i++) {
 519                 port = serial->port[i];
 520                 portdata = usb_get_serial_port_data(port);
 521
 522         /* Do indat endpoints first */
 523                 for (j = 0; j < N_IN_URB; ++j) {
 524                         portdata->in_urbs[j] = sierra_setup_urb (serial,
 525                         port->bulk_in_endpointAddress, USB_DIR_IN, port,
 526                         portdata->in_buffer[j], IN_BUFLEN, sierra_indat_callback);
 527                 }
 528
 529                 /* outdat endpoints */
 530                 for (j = 0; j < N_OUT_URB; ++j) {
 531                         portdata->out_urbs[j] = sierra_setup_urb (serial,
 532                         port->bulk_out_endpointAddress, USB_DIR_OUT, port,
 533                         portdata->out_buffer[j], OUT_BUFLEN, sierra_outdat_callback);
 534                 }
 535         }
 536 }
 537
 538 static int sierra_startup(struct usb_serial *serial)
 539 {
 540         int i, err;
 541         struct usb_serial_port *port;
 542         struct sierra_port_private *portdata;
 543
 544         dbg("%s", __FUNCTION__);
 545
 546         /* Now setup per port private data */
 547         for (i = 0; i < serial->num_ports; i++) {
 548                 port = serial->port[i];
 549                 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
 550                 if (!portdata) {
 551                         dbg("%s: kmalloc for sierra_port_private (%d) failed!.",
 552                                         __FUNCTION__, i);
 553                         return (1);
 554                 }
 555
 556                 usb_set_serial_port_data(port, portdata);
 557
 558                 if (! port->interrupt_in_urb)
 559                         continue;
 560                 err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 561                 if (err)
 562                         dbg("%s: submit irq_in urb failed %d",
 563                                 __FUNCTION__, err);
 564         }
 565
 566         sierra_setup_urbs(serial);
 567
 568         return (0);
 569 }
 570
 571 static void sierra_shutdown(struct usb_serial *serial)
 572 {
 573         int i, j;
 574         struct usb_serial_port *port;
 575         struct sierra_port_private *portdata;
 576
 577         dbg("%s", __FUNCTION__);
 578
 579         /* Stop reading/writing urbs */
 580         for (i = 0; i < serial->num_ports; ++i) {
 581                 port = serial->port[i];
 582                 if (!port)
 583                         continue;
 584                 portdata = usb_get_serial_port_data(port);
 585                 if (!portdata)
 586                         continue;
 587
 588                 for (j = 0; j < N_IN_URB; j++)
 589                         usb_unlink_urb(portdata->in_urbs[j]);
 590                 for (j = 0; j < N_OUT_URB; j++)
 591                         usb_unlink_urb(portdata->out_urbs[j]);
 592         }
 593
 594         /* Now free them */
 595         for (i = 0; i < serial->num_ports; ++i) {
 596                 port = serial->port[i];
 597                 if (!port)
 598                         continue;
 599                 portdata = usb_get_serial_port_data(port);
 600                 if (!portdata)
 601                         continue;
 602
 603                 for (j = 0; j < N_IN_URB; j++) {
 604                         if (portdata->in_urbs[j]) {
 605                                 usb_free_urb(portdata->in_urbs[j]);
 606                                 portdata->in_urbs[j] = NULL;
 607                         }
 608                 }
 609                 for (j = 0; j < N_OUT_URB; j++) {
 610                         if (portdata->out_urbs[j]) {
 611                                 usb_free_urb(portdata->out_urbs[j]);
 612                                 portdata->out_urbs[j] = NULL;
 613                         }
 614                 }
 615         }
 616
 617         /* Now free per port private data */
 618         for (i = 0; i < serial->num_ports; i++) {
 619                 port = serial->port[i];
 620                 if (!port)
 621                         continue;
 622                 kfree(usb_get_serial_port_data(port));
 623         }
 624 }
 625
 626 static struct usb_serial_driver sierra_1port_device = {
 627         .driver = {
 628                 .owner =        THIS_MODULE,
 629                 .name =         "sierra1",
 630         },
 631         .description       = "Sierra USB modem (1 port)",
 632         .id_table          = id_table_1port,
 633         .usb_driver        = &sierra_driver,
 634         .num_interrupt_in  = NUM_DONT_CARE,
 635         .num_bulk_in       = 1,
 636         .num_bulk_out      = 1,
 637         .num_ports         = 1,
 638         .open              = sierra_open,
 639         .close             = sierra_close,
 640         .write             = sierra_write,
 641         .write_room        = sierra_write_room,
 642         .chars_in_buffer   = sierra_chars_in_buffer,
 643         .throttle          = sierra_rx_throttle,
 644         .unthrottle        = sierra_rx_unthrottle,
 645         .ioctl             = sierra_ioctl,
 646         .set_termios       = sierra_set_termios,
 647         .break_ctl         = sierra_break_ctl,
 648         .tiocmget          = sierra_tiocmget,
 649         .tiocmset          = sierra_tiocmset,
 650         .attach            = sierra_startup,
 651         .shutdown          = sierra_shutdown,
 652         .read_int_callback = sierra_instat_callback,
 653 };
 654
 655 static struct usb_serial_driver sierra_3port_device = {
 656         .driver = {
 657                 .owner =        THIS_MODULE,
 658                 .name =         "sierra3",
 659         },
 660         .description       = "Sierra USB modem (3 port)",
 661         .id_table          = id_table_3port,
 662         .usb_driver        = &sierra_driver,
 663         .num_interrupt_in  = NUM_DONT_CARE,
 664         .num_bulk_in       = 3,
 665         .num_bulk_out      = 3,
 666         .num_ports         = 3,
 667         .open              = sierra_open,
 668         .close             = sierra_close,
 669         .write             = sierra_write,
 670         .write_room        = sierra_write_room,
 671         .chars_in_buffer   = sierra_chars_in_buffer,
 672         .throttle          = sierra_rx_throttle,
 673         .unthrottle        = sierra_rx_unthrottle,
 674         .ioctl             = sierra_ioctl,
 675         .set_termios       = sierra_set_termios,
 676         .break_ctl         = sierra_break_ctl,
 677         .tiocmget          = sierra_tiocmget,
 678         .tiocmset          = sierra_tiocmset,
 679         .attach            = sierra_startup,
 680         .shutdown          = sierra_shutdown,
 681         .read_int_callback = sierra_instat_callback,
 682 };
 683
 684 /* Functions used by new usb-serial code. */
 685 static int __init sierra_init(void)
 686 {
 687         int retval;
 688         retval = usb_serial_register(&sierra_1port_device);
 689         if (retval)
 690                 goto failed_1port_device_register;
 691         retval = usb_serial_register(&sierra_3port_device);
 692         if (retval)
 693                 goto failed_3port_device_register;
 694
 695
 696         retval = usb_register(&sierra_driver);
 697         if (retval)
 698                 goto failed_driver_register;
 699
 700         info(DRIVER_DESC ": " DRIVER_VERSION);
 701
 702         return 0;
 703
 704 failed_driver_register:
 705         usb_serial_deregister(&sierra_3port_device);
 706 failed_3port_device_register:
 707         usb_serial_deregister(&sierra_1port_device);
 708 failed_1port_device_register:
 709         return retval;
 710 }
 711
 712 static void __exit sierra_exit(void)
 713 {
 714         usb_deregister (&sierra_driver);
 715         usb_serial_deregister(&sierra_1port_device);
 716         usb_serial_deregister(&sierra_3port_device);
 717 }
 718
 719 module_init(sierra_init);
 720 module_exit(sierra_exit);
 721
 722 MODULE_AUTHOR(DRIVER_AUTHOR);
 723 MODULE_DESCRIPTION(DRIVER_DESC);
 724 MODULE_VERSION(DRIVER_VERSION);
 725 MODULE_LICENSE("GPL");
 726
 727 #ifdef CONFIG_USB_DEBUG
 728 module_param(debug, bool, S_IRUGO | S_IWUSR);
 729 MODULE_PARM_DESC(debug, "Debug messages");
 730 #endif
 731