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