2006-07-01 01:17:55 +07:00
|
|
|
/*
|
2006-10-14 13:53:21 +07:00
|
|
|
USB Driver for Sierra Wireless
|
|
|
|
|
2009-04-30 00:26:46 +07:00
|
|
|
Copyright (C) 2006, 2007, 2008 Kevin Lloyd <klloyd@sierrawireless.com>,
|
|
|
|
|
|
|
|
Copyright (C) 2008, 2009 Elina Pasheva, Matthew Safar, Rory Filer
|
|
|
|
<linux@sierrawireless.com>
|
2006-10-14 13:53:21 +07:00
|
|
|
|
|
|
|
IMPORTANT DISCLAIMER: This driver is not commercially supported by
|
|
|
|
Sierra Wireless. Use at your own risk.
|
|
|
|
|
|
|
|
This driver is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of Version 2 of the GNU General Public License as
|
|
|
|
published by the Free Software Foundation.
|
|
|
|
|
|
|
|
Portions based on the option driver by Matthias Urlichs <smurf@smurf.noris.de>
|
|
|
|
Whom based his on the Keyspan driver by Hugh Blemings <hugh@blemings.org>
|
|
|
|
*/
|
2009-11-05 01:25:48 +07:00
|
|
|
/* Uncomment to log function calls */
|
|
|
|
/* #define DEBUG */
|
|
|
|
#define DRIVER_VERSION "v.1.7.16"
|
2009-04-30 00:26:46 +07:00
|
|
|
#define DRIVER_AUTHOR "Kevin Lloyd, Elina Pasheva, Matthew Safar, Rory Filer"
|
2006-10-14 13:53:21 +07:00
|
|
|
#define DRIVER_DESC "USB Driver for Sierra Wireless USB modems"
|
2006-07-01 01:17:55 +07:00
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
2006-10-14 13:53:21 +07:00
|
|
|
#include <linux/jiffies.h>
|
|
|
|
#include <linux/errno.h>
|
2006-07-01 01:17:55 +07:00
|
|
|
#include <linux/tty.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 15:04:11 +07:00
|
|
|
#include <linux/slab.h>
|
2006-10-14 13:53:21 +07:00
|
|
|
#include <linux/tty_flip.h>
|
2006-07-01 01:17:55 +07:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/usb.h>
|
2006-07-12 11:22:58 +07:00
|
|
|
#include <linux/usb/serial.h>
|
2006-07-01 01:17:55 +07:00
|
|
|
|
2008-01-11 02:11:04 +07:00
|
|
|
#define SWIMS_USB_REQUEST_SetPower 0x00
|
|
|
|
#define SWIMS_USB_REQUEST_SetNmea 0x07
|
2007-07-17 03:49:27 +07:00
|
|
|
|
2009-11-05 01:25:48 +07:00
|
|
|
#define N_IN_URB_HM 8
|
|
|
|
#define N_OUT_URB_HM 64
|
|
|
|
#define N_IN_URB 4
|
|
|
|
#define N_OUT_URB 4
|
2007-07-17 03:49:27 +07:00
|
|
|
#define IN_BUFLEN 4096
|
|
|
|
|
2009-04-30 00:26:46 +07:00
|
|
|
#define MAX_TRANSFER (PAGE_SIZE - 512)
|
|
|
|
/* MAX_TRANSFER is chosen so that the VM is not stressed by
|
|
|
|
allocations > PAGE_SIZE and the number of packets in a page
|
|
|
|
is an integer 512 is the largest possible packet on EHCI */
|
|
|
|
|
2012-01-13 06:02:20 +07:00
|
|
|
static bool debug;
|
|
|
|
static bool nmea;
|
2007-07-17 03:49:27 +07:00
|
|
|
|
2009-06-11 20:32:01 +07:00
|
|
|
/* Used in interface blacklisting */
|
|
|
|
struct sierra_iface_info {
|
|
|
|
const u32 infolen; /* number of interface numbers on blacklist */
|
|
|
|
const u8 *ifaceinfo; /* pointer to the array holding the numbers */
|
|
|
|
};
|
|
|
|
|
2009-09-05 04:19:53 +07:00
|
|
|
struct sierra_intf_private {
|
|
|
|
spinlock_t susp_lock;
|
|
|
|
unsigned int suspended:1;
|
|
|
|
int in_flight;
|
|
|
|
};
|
|
|
|
|
2007-07-29 21:59:02 +07:00
|
|
|
static int sierra_set_power_state(struct usb_device *udev, __u16 swiState)
|
2007-07-17 03:49:27 +07:00
|
|
|
{
|
2012-05-04 06:44:48 +07:00
|
|
|
return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
|
2008-01-11 02:11:04 +07:00
|
|
|
SWIMS_USB_REQUEST_SetPower, /* __u8 request */
|
2008-03-29 00:05:08 +07:00
|
|
|
USB_TYPE_VENDOR, /* __u8 request type */
|
2008-01-11 02:11:04 +07:00
|
|
|
swiState, /* __u16 value */
|
|
|
|
0, /* __u16 index */
|
|
|
|
NULL, /* void *data */
|
|
|
|
0, /* __u16 size */
|
|
|
|
USB_CTRL_SET_TIMEOUT); /* int timeout */
|
2007-07-17 03:49:27 +07:00
|
|
|
}
|
|
|
|
|
2008-01-11 02:11:04 +07:00
|
|
|
static int sierra_vsc_set_nmea(struct usb_device *udev, __u16 enable)
|
2007-07-17 03:49:27 +07:00
|
|
|
{
|
2012-05-04 06:44:48 +07:00
|
|
|
return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
|
2008-01-11 02:11:04 +07:00
|
|
|
SWIMS_USB_REQUEST_SetNmea, /* __u8 request */
|
2008-03-29 00:05:08 +07:00
|
|
|
USB_TYPE_VENDOR, /* __u8 request type */
|
2008-01-11 02:11:04 +07:00
|
|
|
enable, /* __u16 value */
|
|
|
|
0x0000, /* __u16 index */
|
|
|
|
NULL, /* void *data */
|
|
|
|
0, /* __u16 size */
|
|
|
|
USB_CTRL_SET_TIMEOUT); /* int timeout */
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sierra_calc_num_ports(struct usb_serial *serial)
|
|
|
|
{
|
2009-05-13 03:12:54 +07:00
|
|
|
int num_ports = 0;
|
|
|
|
u8 ifnum, numendpoints;
|
2008-01-11 02:11:04 +07:00
|
|
|
|
2009-05-13 03:12:54 +07:00
|
|
|
ifnum = serial->interface->cur_altsetting->desc.bInterfaceNumber;
|
|
|
|
numendpoints = serial->interface->cur_altsetting->desc.bNumEndpoints;
|
2008-01-11 02:11:04 +07:00
|
|
|
|
2009-05-13 03:12:54 +07:00
|
|
|
/* Dummy interface present on some SKUs should be ignored */
|
|
|
|
if (ifnum == 0x99)
|
|
|
|
num_ports = 0;
|
|
|
|
else if (numendpoints <= 3)
|
|
|
|
num_ports = 1;
|
|
|
|
else
|
|
|
|
num_ports = (numendpoints-1)/2;
|
|
|
|
return num_ports;
|
2008-01-11 02:11:04 +07:00
|
|
|
}
|
|
|
|
|
2009-06-11 20:32:01 +07:00
|
|
|
static int is_blacklisted(const u8 ifnum,
|
|
|
|
const struct sierra_iface_info *blacklist)
|
|
|
|
{
|
|
|
|
const u8 *info;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (blacklist) {
|
|
|
|
info = blacklist->ifaceinfo;
|
|
|
|
|
|
|
|
for (i = 0; i < blacklist->infolen; i++) {
|
|
|
|
if (info[i] == ifnum)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-11-05 01:25:48 +07:00
|
|
|
static int is_himemory(const u8 ifnum,
|
|
|
|
const struct sierra_iface_info *himemorylist)
|
|
|
|
{
|
|
|
|
const u8 *info;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (himemorylist) {
|
|
|
|
info = himemorylist->ifaceinfo;
|
|
|
|
|
|
|
|
for (i=0; i < himemorylist->infolen; i++) {
|
|
|
|
if (info[i] == ifnum)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-03 01:24:56 +07:00
|
|
|
static int sierra_calc_interface(struct usb_serial *serial)
|
|
|
|
{
|
2008-07-11 04:14:47 +07:00
|
|
|
int interface;
|
|
|
|
struct usb_interface *p_interface;
|
|
|
|
struct usb_host_interface *p_host_interface;
|
2008-04-03 01:24:56 +07:00
|
|
|
|
2008-07-11 04:14:47 +07:00
|
|
|
/* Get the interface structure pointer from the serial struct */
|
|
|
|
p_interface = serial->interface;
|
2008-04-03 01:24:56 +07:00
|
|
|
|
2008-07-11 04:14:47 +07:00
|
|
|
/* Get a pointer to the host interface structure */
|
|
|
|
p_host_interface = p_interface->cur_altsetting;
|
2008-04-03 01:24:56 +07:00
|
|
|
|
2008-07-11 04:14:47 +07:00
|
|
|
/* read the interface descriptor for this active altsetting
|
|
|
|
* to find out the interface number we are on
|
|
|
|
*/
|
|
|
|
interface = p_host_interface->desc.bInterfaceNumber;
|
2008-04-03 01:24:56 +07:00
|
|
|
|
2008-07-11 04:14:47 +07:00
|
|
|
return interface;
|
2008-04-03 01:24:56 +07:00
|
|
|
}
|
|
|
|
|
2008-01-11 02:11:04 +07:00
|
|
|
static int sierra_probe(struct usb_serial *serial,
|
|
|
|
const struct usb_device_id *id)
|
|
|
|
{
|
|
|
|
int result = 0;
|
2007-07-17 03:49:27 +07:00
|
|
|
struct usb_device *udev;
|
2009-09-05 04:19:53 +07:00
|
|
|
struct sierra_intf_private *data;
|
2008-01-11 02:11:04 +07:00
|
|
|
u8 ifnum;
|
2007-07-17 03:49:27 +07:00
|
|
|
|
2008-01-11 02:11:04 +07:00
|
|
|
udev = serial->dev;
|
2008-07-11 04:14:51 +07:00
|
|
|
ifnum = sierra_calc_interface(serial);
|
2012-05-04 06:44:48 +07:00
|
|
|
|
2008-07-11 04:14:51 +07:00
|
|
|
/*
|
|
|
|
* If this interface supports more than 1 alternate
|
|
|
|
* select the 2nd one
|
|
|
|
*/
|
|
|
|
if (serial->interface->num_altsetting == 2) {
|
|
|
|
dev_dbg(&udev->dev, "Selecting alt setting for interface %d\n",
|
|
|
|
ifnum);
|
|
|
|
/* We know the alternate setting is 1 for the MC8785 */
|
|
|
|
usb_set_interface(udev, ifnum, 1);
|
|
|
|
}
|
2008-04-03 01:24:56 +07:00
|
|
|
|
2009-06-11 20:32:01 +07:00
|
|
|
/* ifnum could have changed - by calling usb_set_interface */
|
|
|
|
ifnum = sierra_calc_interface(serial);
|
|
|
|
|
|
|
|
if (is_blacklisted(ifnum,
|
|
|
|
(struct sierra_iface_info *)id->driver_info)) {
|
|
|
|
dev_dbg(&serial->dev->dev,
|
|
|
|
"Ignoring blacklisted interface #%d\n", ifnum);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2009-09-05 04:19:53 +07:00
|
|
|
data = serial->private = kzalloc(sizeof(struct sierra_intf_private), GFP_KERNEL);
|
|
|
|
if (!data)
|
|
|
|
return -ENOMEM;
|
|
|
|
spin_lock_init(&data->susp_lock);
|
|
|
|
|
2008-01-11 02:11:04 +07:00
|
|
|
return result;
|
2007-07-17 03:49:27 +07:00
|
|
|
}
|
2006-10-14 13:53:21 +07:00
|
|
|
|
2009-11-05 01:25:48 +07:00
|
|
|
/* interfaces with higher memory requirements */
|
|
|
|
static const u8 hi_memory_typeA_ifaces[] = { 0, 2 };
|
|
|
|
static const struct sierra_iface_info typeA_interface_list = {
|
|
|
|
.infolen = ARRAY_SIZE(hi_memory_typeA_ifaces),
|
|
|
|
.ifaceinfo = hi_memory_typeA_ifaces,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const u8 hi_memory_typeB_ifaces[] = { 3, 4, 5, 6 };
|
|
|
|
static const struct sierra_iface_info typeB_interface_list = {
|
|
|
|
.infolen = ARRAY_SIZE(hi_memory_typeB_ifaces),
|
|
|
|
.ifaceinfo = hi_memory_typeB_ifaces,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* 'blacklist' of interfaces not served by this driver */
|
2012-04-18 02:37:29 +07:00
|
|
|
static const u8 direct_ip_non_serial_ifaces[] = { 7, 8, 9, 10, 11, 19, 20 };
|
2009-06-11 20:32:01 +07:00
|
|
|
static const struct sierra_iface_info direct_ip_interface_blacklist = {
|
|
|
|
.infolen = ARRAY_SIZE(direct_ip_non_serial_ifaces),
|
|
|
|
.ifaceinfo = direct_ip_non_serial_ifaces,
|
|
|
|
};
|
|
|
|
|
2010-01-10 21:34:24 +07:00
|
|
|
static const struct usb_device_id id_table[] = {
|
2009-07-10 07:55:18 +07:00
|
|
|
{ USB_DEVICE(0x0F3D, 0x0112) }, /* Airprime/Sierra PC 5220 */
|
|
|
|
{ USB_DEVICE(0x03F0, 0x1B1D) }, /* HP ev2200 a.k.a MC5720 */
|
2010-03-27 00:51:20 +07:00
|
|
|
{ USB_DEVICE(0x03F0, 0x211D) }, /* HP ev2210 a.k.a MC5725 */
|
2009-07-10 07:55:18 +07:00
|
|
|
{ USB_DEVICE(0x03F0, 0x1E1D) }, /* HP hs2300 a.k.a MC8775 */
|
|
|
|
|
2007-01-18 07:04:18 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x0017) }, /* Sierra Wireless EM5625 */
|
2006-07-01 01:17:55 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x0018) }, /* Sierra Wireless MC5720 */
|
2007-01-18 07:04:18 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x0218) }, /* Sierra Wireless MC5720 */
|
2006-07-01 01:17:55 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x0020) }, /* Sierra Wireless MC5725 */
|
2007-12-05 01:37:12 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x0220) }, /* Sierra Wireless MC5725 */
|
2009-07-10 07:55:18 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x0022) }, /* Sierra Wireless EM5725 */
|
|
|
|
{ USB_DEVICE(0x1199, 0x0024) }, /* Sierra Wireless MC5727 */
|
|
|
|
{ USB_DEVICE(0x1199, 0x0224) }, /* Sierra Wireless MC5727 */
|
2006-07-01 01:17:55 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x0019) }, /* Sierra Wireless AirCard 595 */
|
2007-01-18 07:04:18 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x0021) }, /* Sierra Wireless AirCard 597E */
|
2009-07-10 07:55:18 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x0112) }, /* Sierra Wireless AirCard 580 */
|
2007-07-17 03:49:29 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x0120) }, /* Sierra Wireless USB Dongle 595U */
|
2010-06-29 01:46:05 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x0301) }, /* Sierra Wireless USB Dongle 250U */
|
2009-07-10 07:55:18 +07:00
|
|
|
/* Sierra Wireless C597 */
|
2008-07-11 04:14:47 +07:00
|
|
|
{ USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x0023, 0xFF, 0xFF, 0xFF) },
|
2009-07-10 07:55:18 +07:00
|
|
|
/* Sierra Wireless T598 */
|
2008-07-11 04:14:51 +07:00
|
|
|
{ USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x0025, 0xFF, 0xFF, 0xFF) },
|
2009-07-10 07:55:18 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x0026) }, /* Sierra Wireless T11 */
|
|
|
|
{ USB_DEVICE(0x1199, 0x0027) }, /* Sierra Wireless AC402 */
|
|
|
|
{ USB_DEVICE(0x1199, 0x0028) }, /* Sierra Wireless MC5728 */
|
|
|
|
{ USB_DEVICE(0x1199, 0x0029) }, /* Sierra Wireless Device */
|
2007-07-17 03:49:29 +07:00
|
|
|
|
2006-07-01 01:17:55 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x6802) }, /* Sierra Wireless MC8755 */
|
|
|
|
{ USB_DEVICE(0x1199, 0x6803) }, /* Sierra Wireless MC8765 */
|
2009-07-10 07:55:18 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x6804) }, /* Sierra Wireless MC8755 */
|
|
|
|
{ USB_DEVICE(0x1199, 0x6805) }, /* Sierra Wireless MC8765 */
|
|
|
|
{ USB_DEVICE(0x1199, 0x6808) }, /* Sierra Wireless MC8755 */
|
|
|
|
{ USB_DEVICE(0x1199, 0x6809) }, /* Sierra Wireless MC8765 */
|
2007-07-17 03:49:29 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x6812) }, /* Sierra Wireless MC8775 & AC 875U */
|
2009-07-10 07:55:18 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x6813) }, /* Sierra Wireless MC8775 */
|
2008-03-14 14:53:24 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x6815) }, /* Sierra Wireless MC8775 */
|
2009-07-10 07:55:18 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x6816) }, /* Sierra Wireless MC8775 */
|
2006-07-01 01:17:55 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x6820) }, /* Sierra Wireless AirCard 875 */
|
2008-04-03 01:24:56 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x6821) }, /* Sierra Wireless AirCard 875U */
|
2009-07-10 07:55:18 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x6822) }, /* Sierra Wireless AirCard 875E */
|
2008-07-11 04:14:47 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x6832) }, /* Sierra Wireless MC8780 */
|
|
|
|
{ USB_DEVICE(0x1199, 0x6833) }, /* Sierra Wireless MC8781 */
|
2009-07-10 07:55:18 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x6834) }, /* Sierra Wireless MC8780 */
|
|
|
|
{ USB_DEVICE(0x1199, 0x6835) }, /* Sierra Wireless MC8781 */
|
|
|
|
{ USB_DEVICE(0x1199, 0x6838) }, /* Sierra Wireless MC8780 */
|
|
|
|
{ USB_DEVICE(0x1199, 0x6839) }, /* Sierra Wireless MC8781 */
|
2008-09-17 23:03:38 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x683A) }, /* Sierra Wireless MC8785 */
|
2008-07-11 04:14:51 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x683B) }, /* Sierra Wireless MC8785 Composite */
|
2009-06-11 20:32:01 +07:00
|
|
|
/* Sierra Wireless MC8790, MC8791, MC8792 Composite */
|
|
|
|
{ USB_DEVICE(0x1199, 0x683C) },
|
|
|
|
{ USB_DEVICE(0x1199, 0x683D) }, /* Sierra Wireless MC8791 Composite */
|
|
|
|
/* Sierra Wireless MC8790, MC8791, MC8792 */
|
|
|
|
{ USB_DEVICE(0x1199, 0x683E) },
|
2007-07-17 03:49:29 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x6850) }, /* Sierra Wireless AirCard 880 */
|
|
|
|
{ USB_DEVICE(0x1199, 0x6851) }, /* Sierra Wireless AirCard 881 */
|
|
|
|
{ USB_DEVICE(0x1199, 0x6852) }, /* Sierra Wireless AirCard 880 E */
|
|
|
|
{ USB_DEVICE(0x1199, 0x6853) }, /* Sierra Wireless AirCard 881 E */
|
2008-01-11 02:11:04 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x6855) }, /* Sierra Wireless AirCard 880 U */
|
2007-12-31 09:11:35 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x6856) }, /* Sierra Wireless AirCard 881 U */
|
2008-07-11 04:14:51 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x6859) }, /* Sierra Wireless AirCard 885 E */
|
|
|
|
{ USB_DEVICE(0x1199, 0x685A) }, /* Sierra Wireless AirCard 885 E */
|
|
|
|
/* Sierra Wireless C885 */
|
|
|
|
{ USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x6880, 0xFF, 0xFF, 0xFF)},
|
2009-07-10 07:55:18 +07:00
|
|
|
/* Sierra Wireless C888, Air Card 501, USB 303, USB 304 */
|
2008-07-11 04:14:51 +07:00
|
|
|
{ USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x6890, 0xFF, 0xFF, 0xFF)},
|
2009-07-10 07:55:18 +07:00
|
|
|
/* Sierra Wireless C22/C33 */
|
2008-08-26 09:20:40 +07:00
|
|
|
{ USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x6891, 0xFF, 0xFF, 0xFF)},
|
2009-07-10 07:55:18 +07:00
|
|
|
/* Sierra Wireless HSPA Non-Composite Device */
|
2008-07-11 04:14:51 +07:00
|
|
|
{ USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x6892, 0xFF, 0xFF, 0xFF)},
|
2009-07-10 07:55:18 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x6893) }, /* Sierra Wireless Device */
|
2009-06-11 20:32:01 +07:00
|
|
|
{ USB_DEVICE(0x1199, 0x68A3), /* Sierra Wireless Direct IP modems */
|
|
|
|
.driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist
|
2012-06-06 14:08:48 +07:00
|
|
|
},
|
|
|
|
/* AT&T Direct IP LTE modems */
|
|
|
|
{ USB_DEVICE_AND_INTERFACE_INFO(0x0F3D, 0x68AA, 0xFF, 0xFF, 0xFF),
|
|
|
|
.driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist
|
2009-06-11 20:32:01 +07:00
|
|
|
},
|
2011-02-16 23:02:34 +07:00
|
|
|
{ USB_DEVICE(0x0f3d, 0x68A3), /* Airprime/Sierra Wireless Direct IP modems */
|
|
|
|
.driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist
|
|
|
|
},
|
2010-01-21 04:42:33 +07:00
|
|
|
{ USB_DEVICE(0x413C, 0x08133) }, /* Dell Computer Corp. Wireless 5720 VZW Mobile Broadband (EVDO Rev-A) Minicard GPS Port */
|
2009-06-11 20:32:01 +07:00
|
|
|
|
2006-10-14 13:53:21 +07:00
|
|
|
{ }
|
|
|
|
};
|
2006-10-18 00:17:58 +07:00
|
|
|
MODULE_DEVICE_TABLE(usb, id_table);
|
2006-10-14 13:53:21 +07:00
|
|
|
|
|
|
|
|
|
|
|
struct sierra_port_private {
|
2007-06-20 12:22:23 +07:00
|
|
|
spinlock_t lock; /* lock the structure */
|
|
|
|
int outstanding_urbs; /* number of out urbs in flight */
|
2009-09-05 04:19:53 +07:00
|
|
|
struct usb_anchor active;
|
|
|
|
struct usb_anchor delayed;
|
2007-06-20 12:22:23 +07:00
|
|
|
|
2009-11-05 01:25:48 +07:00
|
|
|
int num_out_urbs;
|
|
|
|
int num_in_urbs;
|
2008-03-14 14:53:24 +07:00
|
|
|
/* Input endpoints and buffers for this port */
|
2009-11-05 01:25:48 +07:00
|
|
|
struct urb *in_urbs[N_IN_URB_HM];
|
2006-10-14 13:53:21 +07:00
|
|
|
|
|
|
|
/* Settings for the port */
|
|
|
|
int rts_state; /* Handshaking pins (outputs) */
|
|
|
|
int dtr_state;
|
|
|
|
int cts_state; /* Handshaking pins (inputs) */
|
|
|
|
int dsr_state;
|
|
|
|
int dcd_state;
|
|
|
|
int ri_state;
|
2009-09-05 04:19:53 +07:00
|
|
|
unsigned int opened:1;
|
2006-10-14 13:53:21 +07:00
|
|
|
};
|
|
|
|
|
2009-06-11 18:26:29 +07:00
|
|
|
static int sierra_send_setup(struct usb_serial_port *port)
|
2006-07-01 01:17:55 +07:00
|
|
|
{
|
2006-10-18 00:17:58 +07:00
|
|
|
struct usb_serial *serial = port->serial;
|
|
|
|
struct sierra_port_private *portdata;
|
2008-01-11 02:11:04 +07:00
|
|
|
__u16 interface = 0;
|
2009-06-11 18:26:29 +07:00
|
|
|
int val = 0;
|
2009-10-17 02:04:54 +07:00
|
|
|
int do_send = 0;
|
|
|
|
int retval;
|
2006-10-14 13:53:21 +07:00
|
|
|
|
2006-10-18 00:17:58 +07:00
|
|
|
portdata = usb_get_serial_port_data(port);
|
2006-10-14 13:53:21 +07:00
|
|
|
|
2009-06-11 18:26:29 +07:00
|
|
|
if (portdata->dtr_state)
|
|
|
|
val |= 0x01;
|
|
|
|
if (portdata->rts_state)
|
|
|
|
val |= 0x02;
|
|
|
|
|
|
|
|
/* If composite device then properly report interface */
|
2009-06-11 20:29:29 +07:00
|
|
|
if (serial->num_ports == 1) {
|
2009-06-11 18:26:29 +07:00
|
|
|
interface = sierra_calc_interface(serial);
|
2009-06-11 20:29:29 +07:00
|
|
|
/* Control message is sent only to interfaces with
|
|
|
|
* interrupt_in endpoints
|
|
|
|
*/
|
|
|
|
if (port->interrupt_in_urb) {
|
|
|
|
/* send control message */
|
2009-10-17 02:04:54 +07:00
|
|
|
do_send = 1;
|
2009-06-11 20:29:29 +07:00
|
|
|
}
|
|
|
|
}
|
2009-06-11 18:26:29 +07:00
|
|
|
|
|
|
|
/* Otherwise the need to do non-composite mapping */
|
|
|
|
else {
|
|
|
|
if (port->bulk_out_endpointAddress == 2)
|
|
|
|
interface = 0;
|
|
|
|
else if (port->bulk_out_endpointAddress == 4)
|
|
|
|
interface = 1;
|
|
|
|
else if (port->bulk_out_endpointAddress == 5)
|
|
|
|
interface = 2;
|
2009-10-17 02:04:54 +07:00
|
|
|
|
|
|
|
do_send = 1;
|
2009-06-11 20:29:29 +07:00
|
|
|
}
|
2009-10-17 02:04:54 +07:00
|
|
|
if (!do_send)
|
|
|
|
return 0;
|
|
|
|
|
2011-02-11 18:56:40 +07:00
|
|
|
retval = usb_autopm_get_interface(serial->interface);
|
|
|
|
if (retval < 0)
|
|
|
|
return retval;
|
|
|
|
|
2009-10-17 02:04:54 +07:00
|
|
|
retval = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
|
|
|
|
0x22, 0x21, val, interface, NULL, 0, USB_CTRL_SET_TIMEOUT);
|
|
|
|
usb_autopm_put_interface(serial->interface);
|
|
|
|
|
|
|
|
return retval;
|
2006-07-01 01:17:55 +07:00
|
|
|
}
|
|
|
|
|
2008-07-22 17:09:07 +07:00
|
|
|
static void sierra_set_termios(struct tty_struct *tty,
|
|
|
|
struct usb_serial_port *port, struct ktermios *old_termios)
|
2006-10-14 13:53:21 +07:00
|
|
|
{
|
2008-07-22 17:09:07 +07:00
|
|
|
tty_termios_copy_hw(tty->termios, old_termios);
|
2009-06-11 18:26:29 +07:00
|
|
|
sierra_send_setup(port);
|
2006-10-14 13:53:21 +07:00
|
|
|
}
|
|
|
|
|
2011-02-14 23:26:14 +07:00
|
|
|
static int sierra_tiocmget(struct tty_struct *tty)
|
2006-10-14 13:53:21 +07:00
|
|
|
{
|
2008-07-22 17:09:07 +07:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2006-10-14 13:53:21 +07:00
|
|
|
unsigned int value;
|
|
|
|
struct sierra_port_private *portdata;
|
|
|
|
|
|
|
|
portdata = usb_get_serial_port_data(port);
|
|
|
|
|
|
|
|
value = ((portdata->rts_state) ? TIOCM_RTS : 0) |
|
|
|
|
((portdata->dtr_state) ? TIOCM_DTR : 0) |
|
|
|
|
((portdata->cts_state) ? TIOCM_CTS : 0) |
|
|
|
|
((portdata->dsr_state) ? TIOCM_DSR : 0) |
|
|
|
|
((portdata->dcd_state) ? TIOCM_CAR : 0) |
|
|
|
|
((portdata->ri_state) ? TIOCM_RNG : 0);
|
|
|
|
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
2011-02-14 23:26:50 +07:00
|
|
|
static int sierra_tiocmset(struct tty_struct *tty,
|
2006-10-14 13:53:21 +07:00
|
|
|
unsigned int set, unsigned int clear)
|
|
|
|
{
|
2008-07-22 17:09:07 +07:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2006-10-14 13:53:21 +07:00
|
|
|
struct sierra_port_private *portdata;
|
|
|
|
|
|
|
|
portdata = usb_get_serial_port_data(port);
|
|
|
|
|
|
|
|
if (set & TIOCM_RTS)
|
|
|
|
portdata->rts_state = 1;
|
|
|
|
if (set & TIOCM_DTR)
|
|
|
|
portdata->dtr_state = 1;
|
|
|
|
|
|
|
|
if (clear & TIOCM_RTS)
|
|
|
|
portdata->rts_state = 0;
|
|
|
|
if (clear & TIOCM_DTR)
|
|
|
|
portdata->dtr_state = 0;
|
2009-06-11 18:26:29 +07:00
|
|
|
return sierra_send_setup(port);
|
2006-10-14 13:53:21 +07:00
|
|
|
}
|
|
|
|
|
2009-06-11 20:30:21 +07:00
|
|
|
static void sierra_release_urb(struct urb *urb)
|
|
|
|
{
|
|
|
|
struct usb_serial_port *port;
|
|
|
|
if (urb) {
|
2012-05-04 06:44:48 +07:00
|
|
|
port = urb->context;
|
2009-06-11 20:30:21 +07:00
|
|
|
kfree(urb->transfer_buffer);
|
|
|
|
usb_free_urb(urb);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-06-20 12:22:23 +07:00
|
|
|
static void sierra_outdat_callback(struct urb *urb)
|
|
|
|
{
|
|
|
|
struct usb_serial_port *port = urb->context;
|
|
|
|
struct sierra_port_private *portdata = usb_get_serial_port_data(port);
|
2009-09-05 04:19:53 +07:00
|
|
|
struct sierra_intf_private *intfdata;
|
2007-06-20 12:22:23 +07:00
|
|
|
int status = urb->status;
|
|
|
|
|
2009-09-05 04:19:53 +07:00
|
|
|
intfdata = port->serial->private;
|
2007-06-20 12:22:23 +07:00
|
|
|
|
|
|
|
/* free up the transfer buffer, as usb_free_urb() does not do this */
|
|
|
|
kfree(urb->transfer_buffer);
|
2009-09-05 04:19:53 +07:00
|
|
|
usb_autopm_put_interface_async(port->serial->interface);
|
2007-06-20 12:22:23 +07:00
|
|
|
if (status)
|
2008-09-17 11:05:24 +07:00
|
|
|
dev_dbg(&port->dev, "%s - nonzero write bulk status "
|
2009-04-28 08:41:52 +07:00
|
|
|
"received: %d\n", __func__, status);
|
2007-06-20 12:22:23 +07:00
|
|
|
|
2009-09-05 04:19:53 +07:00
|
|
|
spin_lock(&portdata->lock);
|
2007-06-20 12:22:23 +07:00
|
|
|
--portdata->outstanding_urbs;
|
2009-09-05 04:19:53 +07:00
|
|
|
spin_unlock(&portdata->lock);
|
|
|
|
spin_lock(&intfdata->susp_lock);
|
|
|
|
--intfdata->in_flight;
|
|
|
|
spin_unlock(&intfdata->susp_lock);
|
2007-06-20 12:22:23 +07:00
|
|
|
|
|
|
|
usb_serial_port_softint(port);
|
|
|
|
}
|
|
|
|
|
2006-10-14 13:53:21 +07:00
|
|
|
/* Write */
|
2008-07-22 17:09:07 +07:00
|
|
|
static int sierra_write(struct tty_struct *tty, struct usb_serial_port *port,
|
|
|
|
const unsigned char *buf, int count)
|
2006-10-14 13:53:21 +07:00
|
|
|
{
|
2010-01-16 22:59:51 +07:00
|
|
|
struct sierra_port_private *portdata;
|
2009-09-05 04:19:53 +07:00
|
|
|
struct sierra_intf_private *intfdata;
|
2007-06-20 12:22:23 +07:00
|
|
|
struct usb_serial *serial = port->serial;
|
|
|
|
unsigned long flags;
|
|
|
|
unsigned char *buffer;
|
|
|
|
struct urb *urb;
|
2009-04-30 00:26:46 +07:00
|
|
|
size_t writesize = min((size_t)count, (size_t)MAX_TRANSFER);
|
|
|
|
int retval = 0;
|
|
|
|
|
|
|
|
/* verify that we actually have some data to write */
|
|
|
|
if (count == 0)
|
|
|
|
return 0;
|
2006-10-14 13:53:21 +07:00
|
|
|
|
|
|
|
portdata = usb_get_serial_port_data(port);
|
2009-09-05 04:19:53 +07:00
|
|
|
intfdata = serial->private;
|
2006-10-14 13:53:21 +07:00
|
|
|
|
2009-05-13 05:27:59 +07:00
|
|
|
dev_dbg(&port->dev, "%s: write (%zd bytes)\n", __func__, writesize);
|
2007-06-20 12:22:23 +07:00
|
|
|
spin_lock_irqsave(&portdata->lock, flags);
|
2009-04-30 00:26:46 +07:00
|
|
|
dev_dbg(&port->dev, "%s - outstanding_urbs: %d\n", __func__,
|
|
|
|
portdata->outstanding_urbs);
|
2009-11-05 01:25:48 +07:00
|
|
|
if (portdata->outstanding_urbs > portdata->num_out_urbs) {
|
2007-06-20 12:22:23 +07:00
|
|
|
spin_unlock_irqrestore(&portdata->lock, flags);
|
2008-09-17 11:05:24 +07:00
|
|
|
dev_dbg(&port->dev, "%s - write limit hit\n", __func__);
|
2007-06-20 12:22:23 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
portdata->outstanding_urbs++;
|
2009-04-30 00:26:46 +07:00
|
|
|
dev_dbg(&port->dev, "%s - 1, outstanding_urbs: %d\n", __func__,
|
|
|
|
portdata->outstanding_urbs);
|
2007-06-20 12:22:23 +07:00
|
|
|
spin_unlock_irqrestore(&portdata->lock, flags);
|
|
|
|
|
2009-09-05 04:19:53 +07:00
|
|
|
retval = usb_autopm_get_interface_async(serial->interface);
|
|
|
|
if (retval < 0) {
|
|
|
|
spin_lock_irqsave(&portdata->lock, flags);
|
|
|
|
portdata->outstanding_urbs--;
|
|
|
|
spin_unlock_irqrestore(&portdata->lock, flags);
|
|
|
|
goto error_simple;
|
|
|
|
}
|
|
|
|
|
2009-04-30 00:26:46 +07:00
|
|
|
buffer = kmalloc(writesize, GFP_ATOMIC);
|
2007-06-20 12:22:23 +07:00
|
|
|
if (!buffer) {
|
|
|
|
dev_err(&port->dev, "out of memory\n");
|
2009-04-30 00:26:46 +07:00
|
|
|
retval = -ENOMEM;
|
2007-06-20 12:22:23 +07:00
|
|
|
goto error_no_buffer;
|
|
|
|
}
|
2006-10-14 13:53:21 +07:00
|
|
|
|
2007-06-20 12:22:23 +07:00
|
|
|
urb = usb_alloc_urb(0, GFP_ATOMIC);
|
|
|
|
if (!urb) {
|
|
|
|
dev_err(&port->dev, "no more free urbs\n");
|
2009-04-30 00:26:46 +07:00
|
|
|
retval = -ENOMEM;
|
2007-06-20 12:22:23 +07:00
|
|
|
goto error_no_urb;
|
|
|
|
}
|
2006-10-14 13:53:21 +07:00
|
|
|
|
2009-04-30 00:26:46 +07:00
|
|
|
memcpy(buffer, buf, writesize);
|
2006-10-14 13:53:21 +07:00
|
|
|
|
2009-04-30 00:26:46 +07:00
|
|
|
usb_serial_debug_data(debug, &port->dev, __func__, writesize, buffer);
|
2007-06-20 12:22:23 +07:00
|
|
|
|
|
|
|
usb_fill_bulk_urb(urb, serial->dev,
|
|
|
|
usb_sndbulkpipe(serial->dev,
|
|
|
|
port->bulk_out_endpointAddress),
|
2009-04-30 00:26:46 +07:00
|
|
|
buffer, writesize, sierra_outdat_callback, port);
|
2007-06-20 12:22:23 +07:00
|
|
|
|
2009-05-13 03:12:24 +07:00
|
|
|
/* Handle the need to send a zero length packet */
|
|
|
|
urb->transfer_flags |= URB_ZERO_PACKET;
|
|
|
|
|
2009-09-05 04:19:53 +07:00
|
|
|
spin_lock_irqsave(&intfdata->susp_lock, flags);
|
|
|
|
|
|
|
|
if (intfdata->suspended) {
|
|
|
|
usb_anchor_urb(urb, &portdata->delayed);
|
|
|
|
spin_unlock_irqrestore(&intfdata->susp_lock, flags);
|
|
|
|
goto skip_power;
|
|
|
|
} else {
|
|
|
|
usb_anchor_urb(urb, &portdata->active);
|
|
|
|
}
|
2007-06-20 12:22:23 +07:00
|
|
|
/* send it down the pipe */
|
2009-04-30 00:26:46 +07:00
|
|
|
retval = usb_submit_urb(urb, GFP_ATOMIC);
|
|
|
|
if (retval) {
|
2009-09-05 04:19:53 +07:00
|
|
|
usb_unanchor_urb(urb);
|
|
|
|
spin_unlock_irqrestore(&intfdata->susp_lock, flags);
|
2007-06-20 12:22:23 +07:00
|
|
|
dev_err(&port->dev, "%s - usb_submit_urb(write bulk) failed "
|
2009-04-30 00:26:46 +07:00
|
|
|
"with status = %d\n", __func__, retval);
|
2007-06-20 12:22:23 +07:00
|
|
|
goto error;
|
2009-09-05 04:19:53 +07:00
|
|
|
} else {
|
|
|
|
intfdata->in_flight++;
|
|
|
|
spin_unlock_irqrestore(&intfdata->susp_lock, flags);
|
2006-10-14 13:53:21 +07:00
|
|
|
}
|
|
|
|
|
2009-09-05 04:19:53 +07:00
|
|
|
skip_power:
|
2007-06-20 12:22:23 +07:00
|
|
|
/* we are done with this urb, so let the host driver
|
|
|
|
* really free it when it is finished with it */
|
|
|
|
usb_free_urb(urb);
|
|
|
|
|
2009-04-30 00:26:46 +07:00
|
|
|
return writesize;
|
2007-06-20 12:22:23 +07:00
|
|
|
error:
|
|
|
|
usb_free_urb(urb);
|
|
|
|
error_no_urb:
|
|
|
|
kfree(buffer);
|
|
|
|
error_no_buffer:
|
|
|
|
spin_lock_irqsave(&portdata->lock, flags);
|
|
|
|
--portdata->outstanding_urbs;
|
2009-04-30 00:26:46 +07:00
|
|
|
dev_dbg(&port->dev, "%s - 2. outstanding_urbs: %d\n", __func__,
|
|
|
|
portdata->outstanding_urbs);
|
2007-06-20 12:22:23 +07:00
|
|
|
spin_unlock_irqrestore(&portdata->lock, flags);
|
2009-09-05 04:19:53 +07:00
|
|
|
usb_autopm_put_interface_async(serial->interface);
|
|
|
|
error_simple:
|
2009-04-30 00:26:46 +07:00
|
|
|
return retval;
|
2006-10-14 13:53:21 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sierra_indat_callback(struct urb *urb)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
int endpoint;
|
|
|
|
struct usb_serial_port *port;
|
|
|
|
struct tty_struct *tty;
|
|
|
|
unsigned char *data = urb->transfer_buffer;
|
2007-06-16 05:44:13 +07:00
|
|
|
int status = urb->status;
|
2006-10-14 13:53:21 +07:00
|
|
|
|
|
|
|
endpoint = usb_pipeendpoint(urb->pipe);
|
2009-04-30 00:29:21 +07:00
|
|
|
port = urb->context;
|
|
|
|
|
2007-06-16 05:44:13 +07:00
|
|
|
if (status) {
|
2008-09-17 11:05:24 +07:00
|
|
|
dev_dbg(&port->dev, "%s: nonzero status: %d on"
|
2009-04-28 08:41:52 +07:00
|
|
|
" endpoint %02x\n", __func__, status, endpoint);
|
2006-10-14 13:53:21 +07:00
|
|
|
} else {
|
|
|
|
if (urb->actual_length) {
|
2009-01-02 20:42:56 +07:00
|
|
|
tty = tty_port_tty_get(&port->port);
|
2010-02-16 05:50:14 +07:00
|
|
|
if (tty) {
|
|
|
|
tty_insert_flip_string(tty, data,
|
|
|
|
urb->actual_length);
|
|
|
|
tty_flip_buffer_push(tty);
|
|
|
|
|
|
|
|
tty_kref_put(tty);
|
|
|
|
usb_serial_debug_data(debug, &port->dev,
|
|
|
|
__func__, urb->actual_length, data);
|
|
|
|
}
|
2009-04-30 00:29:21 +07:00
|
|
|
} else {
|
2008-09-17 11:05:24 +07:00
|
|
|
dev_dbg(&port->dev, "%s: empty read urb"
|
2009-04-28 08:41:52 +07:00
|
|
|
" received\n", __func__);
|
2006-10-14 13:53:21 +07:00
|
|
|
}
|
|
|
|
}
|
2009-04-30 00:29:21 +07:00
|
|
|
|
|
|
|
/* Resubmit urb so we continue receiving */
|
2010-02-17 22:05:47 +07:00
|
|
|
if (status != -ESHUTDOWN && status != -EPERM) {
|
2009-09-05 04:19:53 +07:00
|
|
|
usb_mark_last_busy(port->serial->dev);
|
2009-04-30 00:29:21 +07:00
|
|
|
err = usb_submit_urb(urb, GFP_ATOMIC);
|
2010-02-17 22:05:47 +07:00
|
|
|
if (err && err != -EPERM)
|
2009-04-30 00:29:21 +07:00
|
|
|
dev_err(&port->dev, "resubmit read urb failed."
|
|
|
|
"(%d)\n", err);
|
|
|
|
}
|
2006-10-14 13:53:21 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void sierra_instat_callback(struct urb *urb)
|
|
|
|
{
|
|
|
|
int err;
|
2007-06-16 05:44:13 +07:00
|
|
|
int status = urb->status;
|
2008-02-24 17:41:47 +07:00
|
|
|
struct usb_serial_port *port = urb->context;
|
2006-10-14 13:53:21 +07:00
|
|
|
struct sierra_port_private *portdata = usb_get_serial_port_data(port);
|
|
|
|
struct usb_serial *serial = port->serial;
|
|
|
|
|
2009-04-28 08:41:52 +07:00
|
|
|
dev_dbg(&port->dev, "%s: urb %p port %p has data %p\n", __func__,
|
2008-09-17 11:05:24 +07:00
|
|
|
urb, port, portdata);
|
2006-10-14 13:53:21 +07:00
|
|
|
|
2007-06-16 05:44:13 +07:00
|
|
|
if (status == 0) {
|
2006-10-14 13:53:21 +07:00
|
|
|
struct usb_ctrlrequest *req_pkt =
|
|
|
|
(struct usb_ctrlrequest *)urb->transfer_buffer;
|
|
|
|
|
|
|
|
if (!req_pkt) {
|
2008-09-17 11:05:24 +07:00
|
|
|
dev_dbg(&port->dev, "%s: NULL req_pkt\n",
|
|
|
|
__func__);
|
2006-10-14 13:53:21 +07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if ((req_pkt->bRequestType == 0xA1) &&
|
|
|
|
(req_pkt->bRequest == 0x20)) {
|
|
|
|
int old_dcd_state;
|
|
|
|
unsigned char signals = *((unsigned char *)
|
|
|
|
urb->transfer_buffer +
|
|
|
|
sizeof(struct usb_ctrlrequest));
|
2008-10-13 16:39:46 +07:00
|
|
|
struct tty_struct *tty;
|
2006-10-14 13:53:21 +07:00
|
|
|
|
2009-04-28 08:41:52 +07:00
|
|
|
dev_dbg(&port->dev, "%s: signal x%x\n", __func__,
|
2008-09-17 11:05:24 +07:00
|
|
|
signals);
|
2006-10-14 13:53:21 +07:00
|
|
|
|
|
|
|
old_dcd_state = portdata->dcd_state;
|
|
|
|
portdata->cts_state = 1;
|
|
|
|
portdata->dcd_state = ((signals & 0x01) ? 1 : 0);
|
|
|
|
portdata->dsr_state = ((signals & 0x02) ? 1 : 0);
|
|
|
|
portdata->ri_state = ((signals & 0x08) ? 1 : 0);
|
|
|
|
|
2008-10-13 16:39:46 +07:00
|
|
|
tty = tty_port_tty_get(&port->port);
|
|
|
|
if (tty && !C_CLOCAL(tty) &&
|
2006-10-14 13:53:21 +07:00
|
|
|
old_dcd_state && !portdata->dcd_state)
|
2008-10-13 16:39:46 +07:00
|
|
|
tty_hangup(tty);
|
|
|
|
tty_kref_put(tty);
|
2006-10-14 13:53:21 +07:00
|
|
|
} else {
|
2009-04-28 08:41:52 +07:00
|
|
|
dev_dbg(&port->dev, "%s: type %x req %x\n",
|
2008-09-17 11:05:24 +07:00
|
|
|
__func__, req_pkt->bRequestType,
|
|
|
|
req_pkt->bRequest);
|
2006-10-14 13:53:21 +07:00
|
|
|
}
|
|
|
|
} else
|
2009-04-28 08:41:52 +07:00
|
|
|
dev_dbg(&port->dev, "%s: error %d\n", __func__, status);
|
2006-10-14 13:53:21 +07:00
|
|
|
|
|
|
|
/* Resubmit urb so we continue receiving IRQ data */
|
2010-02-17 22:05:47 +07:00
|
|
|
if (status != -ESHUTDOWN && status != -ENOENT) {
|
2009-09-05 04:19:53 +07:00
|
|
|
usb_mark_last_busy(serial->dev);
|
2006-10-14 13:53:21 +07:00
|
|
|
err = usb_submit_urb(urb, GFP_ATOMIC);
|
2010-02-17 22:05:47 +07:00
|
|
|
if (err && err != -EPERM)
|
2009-05-13 03:12:37 +07:00
|
|
|
dev_err(&port->dev, "%s: resubmit intr urb "
|
|
|
|
"failed. (%d)\n", __func__, err);
|
2006-10-14 13:53:21 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-22 17:09:07 +07:00
|
|
|
static int sierra_write_room(struct tty_struct *tty)
|
2006-10-14 13:53:21 +07:00
|
|
|
{
|
2008-07-22 17:09:07 +07:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2007-06-20 12:22:23 +07:00
|
|
|
struct sierra_port_private *portdata = usb_get_serial_port_data(port);
|
|
|
|
unsigned long flags;
|
2006-10-14 13:53:21 +07:00
|
|
|
|
2007-06-20 12:22:23 +07:00
|
|
|
/* try to give a good number back based on if we have any free urbs at
|
|
|
|
* this point in time */
|
|
|
|
spin_lock_irqsave(&portdata->lock, flags);
|
2009-11-05 01:25:48 +07:00
|
|
|
if (portdata->outstanding_urbs > (portdata->num_out_urbs * 2) / 3) {
|
2007-06-20 12:22:23 +07:00
|
|
|
spin_unlock_irqrestore(&portdata->lock, flags);
|
2008-09-17 11:05:24 +07:00
|
|
|
dev_dbg(&port->dev, "%s - write limit hit\n", __func__);
|
2007-06-20 12:22:23 +07:00
|
|
|
return 0;
|
2006-10-14 13:53:21 +07:00
|
|
|
}
|
2007-06-20 12:22:23 +07:00
|
|
|
spin_unlock_irqrestore(&portdata->lock, flags);
|
2006-10-14 13:53:21 +07:00
|
|
|
|
2007-06-20 12:22:23 +07:00
|
|
|
return 2048;
|
2006-10-14 13:53:21 +07:00
|
|
|
}
|
|
|
|
|
2009-06-11 20:30:21 +07:00
|
|
|
static void sierra_stop_rx_urbs(struct usb_serial_port *port)
|
2006-10-14 13:53:21 +07:00
|
|
|
{
|
2007-06-20 12:22:23 +07:00
|
|
|
int i;
|
2009-06-11 20:30:21 +07:00
|
|
|
struct sierra_port_private *portdata = usb_get_serial_port_data(port);
|
2006-10-14 13:53:21 +07:00
|
|
|
|
2009-11-05 01:25:48 +07:00
|
|
|
for (i = 0; i < portdata->num_in_urbs; i++)
|
2009-06-11 20:30:21 +07:00
|
|
|
usb_kill_urb(portdata->in_urbs[i]);
|
2006-10-14 13:53:21 +07:00
|
|
|
|
2009-06-11 20:30:21 +07:00
|
|
|
usb_kill_urb(port->interrupt_in_urb);
|
|
|
|
}
|
2006-10-14 13:53:21 +07:00
|
|
|
|
2009-06-11 20:30:21 +07:00
|
|
|
static int sierra_submit_rx_urbs(struct usb_serial_port *port, gfp_t mem_flags)
|
|
|
|
{
|
|
|
|
int ok_cnt;
|
|
|
|
int err = -EINVAL;
|
|
|
|
int i;
|
|
|
|
struct urb *urb;
|
|
|
|
struct sierra_port_private *portdata = usb_get_serial_port_data(port);
|
2006-10-14 13:53:21 +07:00
|
|
|
|
2009-06-11 20:30:21 +07:00
|
|
|
ok_cnt = 0;
|
2009-11-05 01:25:48 +07:00
|
|
|
for (i = 0; i < portdata->num_in_urbs; i++) {
|
2006-10-14 13:53:21 +07:00
|
|
|
urb = portdata->in_urbs[i];
|
2007-06-20 12:22:23 +07:00
|
|
|
if (!urb)
|
2006-10-14 13:53:21 +07:00
|
|
|
continue;
|
2009-06-11 20:30:21 +07:00
|
|
|
err = usb_submit_urb(urb, mem_flags);
|
|
|
|
if (err) {
|
|
|
|
dev_err(&port->dev, "%s: submit urb failed: %d\n",
|
|
|
|
__func__, err);
|
|
|
|
} else {
|
|
|
|
ok_cnt++;
|
2006-10-14 13:53:21 +07:00
|
|
|
}
|
2009-06-11 20:30:21 +07:00
|
|
|
}
|
2006-10-14 13:53:21 +07:00
|
|
|
|
2009-06-11 20:30:21 +07:00
|
|
|
if (ok_cnt && port->interrupt_in_urb) {
|
|
|
|
err = usb_submit_urb(port->interrupt_in_urb, mem_flags);
|
|
|
|
if (err) {
|
|
|
|
dev_err(&port->dev, "%s: submit intr urb failed: %d\n",
|
|
|
|
__func__, err);
|
2006-10-14 13:53:21 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-11 20:30:21 +07:00
|
|
|
if (ok_cnt > 0) /* at least one rx urb submitted */
|
|
|
|
return 0;
|
|
|
|
else
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct urb *sierra_setup_urb(struct usb_serial *serial, int endpoint,
|
|
|
|
int dir, void *ctx, int len,
|
|
|
|
gfp_t mem_flags,
|
|
|
|
usb_complete_t callback)
|
|
|
|
{
|
|
|
|
struct urb *urb;
|
|
|
|
u8 *buf;
|
|
|
|
|
|
|
|
if (endpoint == -1)
|
|
|
|
return NULL;
|
2006-10-14 13:53:21 +07:00
|
|
|
|
2009-06-11 20:30:21 +07:00
|
|
|
urb = usb_alloc_urb(0, mem_flags);
|
|
|
|
if (urb == NULL) {
|
|
|
|
dev_dbg(&serial->dev->dev, "%s: alloc for endpoint %d failed\n",
|
|
|
|
__func__, endpoint);
|
|
|
|
return NULL;
|
2007-06-20 12:22:23 +07:00
|
|
|
}
|
2009-06-11 20:30:21 +07:00
|
|
|
|
|
|
|
buf = kmalloc(len, mem_flags);
|
|
|
|
if (buf) {
|
|
|
|
/* Fill URB using supplied data */
|
|
|
|
usb_fill_bulk_urb(urb, serial->dev,
|
|
|
|
usb_sndbulkpipe(serial->dev, endpoint) | dir,
|
|
|
|
buf, len, callback, ctx);
|
|
|
|
|
|
|
|
/* debug */
|
|
|
|
dev_dbg(&serial->dev->dev, "%s %c u : %p d:%p\n", __func__,
|
|
|
|
dir == USB_DIR_IN ? 'i' : 'o', urb, buf);
|
|
|
|
} else {
|
|
|
|
dev_dbg(&serial->dev->dev, "%s %c u:%p d:%p\n", __func__,
|
|
|
|
dir == USB_DIR_IN ? 'i' : 'o', urb, buf);
|
|
|
|
|
|
|
|
sierra_release_urb(urb);
|
|
|
|
urb = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return urb;
|
2006-10-14 13:53:21 +07:00
|
|
|
}
|
|
|
|
|
2009-06-11 20:30:21 +07:00
|
|
|
static void sierra_close(struct usb_serial_port *port)
|
2006-10-14 13:53:21 +07:00
|
|
|
{
|
2009-06-11 20:30:21 +07:00
|
|
|
int i;
|
2006-10-14 13:53:21 +07:00
|
|
|
struct usb_serial *serial = port->serial;
|
|
|
|
struct sierra_port_private *portdata;
|
2009-09-05 04:19:53 +07:00
|
|
|
struct sierra_intf_private *intfdata = port->serial->private;
|
|
|
|
|
2006-10-14 13:53:21 +07:00
|
|
|
portdata = usb_get_serial_port_data(port);
|
2009-06-11 20:30:21 +07:00
|
|
|
|
|
|
|
portdata->rts_state = 0;
|
|
|
|
portdata->dtr_state = 0;
|
2006-10-14 13:53:21 +07:00
|
|
|
|
|
|
|
if (serial->dev) {
|
2008-01-21 23:44:10 +07:00
|
|
|
mutex_lock(&serial->disc_mutex);
|
2009-10-28 03:49:59 +07:00
|
|
|
if (!serial->disconnected) {
|
|
|
|
serial->interface->needs_remote_wakeup = 0;
|
2011-02-11 18:56:40 +07:00
|
|
|
/* odd error handling due to pm counters */
|
|
|
|
if (!usb_autopm_get_interface(serial->interface))
|
|
|
|
sierra_send_setup(port);
|
|
|
|
else
|
|
|
|
usb_autopm_get_interface_no_resume(serial->interface);
|
|
|
|
|
2009-10-28 03:49:59 +07:00
|
|
|
}
|
2008-01-21 23:44:10 +07:00
|
|
|
mutex_unlock(&serial->disc_mutex);
|
2009-09-05 04:19:53 +07:00
|
|
|
spin_lock_irq(&intfdata->susp_lock);
|
|
|
|
portdata->opened = 0;
|
|
|
|
spin_unlock_irq(&intfdata->susp_lock);
|
|
|
|
|
2009-06-11 20:30:21 +07:00
|
|
|
|
|
|
|
/* Stop reading urbs */
|
|
|
|
sierra_stop_rx_urbs(port);
|
|
|
|
/* .. and release them */
|
2009-11-05 01:25:48 +07:00
|
|
|
for (i = 0; i < portdata->num_in_urbs; i++) {
|
2009-06-11 20:30:21 +07:00
|
|
|
sierra_release_urb(portdata->in_urbs[i]);
|
|
|
|
portdata->in_urbs[i] = NULL;
|
|
|
|
}
|
2009-06-11 18:26:29 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-20 03:13:26 +07:00
|
|
|
static int sierra_open(struct tty_struct *tty, struct usb_serial_port *port)
|
2009-06-11 18:26:29 +07:00
|
|
|
{
|
2009-06-11 20:30:21 +07:00
|
|
|
struct sierra_port_private *portdata;
|
|
|
|
struct usb_serial *serial = port->serial;
|
2009-09-05 04:19:53 +07:00
|
|
|
struct sierra_intf_private *intfdata = serial->private;
|
2009-06-11 18:26:29 +07:00
|
|
|
int i;
|
2009-06-11 20:30:21 +07:00
|
|
|
int err;
|
|
|
|
int endpoint;
|
|
|
|
struct urb *urb;
|
|
|
|
|
|
|
|
portdata = usb_get_serial_port_data(port);
|
|
|
|
|
|
|
|
/* Set some sane defaults */
|
|
|
|
portdata->rts_state = 1;
|
|
|
|
portdata->dtr_state = 1;
|
|
|
|
|
|
|
|
|
|
|
|
endpoint = port->bulk_in_endpointAddress;
|
2009-11-05 01:25:48 +07:00
|
|
|
for (i = 0; i < portdata->num_in_urbs; i++) {
|
2009-06-11 20:30:21 +07:00
|
|
|
urb = sierra_setup_urb(serial, endpoint, USB_DIR_IN, port,
|
|
|
|
IN_BUFLEN, GFP_KERNEL,
|
|
|
|
sierra_indat_callback);
|
|
|
|
portdata->in_urbs[i] = urb;
|
|
|
|
}
|
|
|
|
/* clear halt condition */
|
|
|
|
usb_clear_halt(serial->dev,
|
|
|
|
usb_sndbulkpipe(serial->dev, endpoint) | USB_DIR_IN);
|
|
|
|
|
|
|
|
err = sierra_submit_rx_urbs(port, GFP_KERNEL);
|
|
|
|
if (err) {
|
|
|
|
/* get rid of everything as in close */
|
|
|
|
sierra_close(port);
|
2009-10-28 03:49:59 +07:00
|
|
|
/* restore balance for autopm */
|
2011-02-11 18:56:40 +07:00
|
|
|
if (!serial->disconnected)
|
|
|
|
usb_autopm_put_interface(serial->interface);
|
2009-06-11 20:30:21 +07:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
sierra_send_setup(port);
|
|
|
|
|
2009-09-05 04:19:53 +07:00
|
|
|
serial->interface->needs_remote_wakeup = 1;
|
|
|
|
spin_lock_irq(&intfdata->susp_lock);
|
|
|
|
portdata->opened = 1;
|
|
|
|
spin_unlock_irq(&intfdata->susp_lock);
|
|
|
|
usb_autopm_put_interface(serial->interface);
|
|
|
|
|
2009-06-11 20:30:21 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void sierra_dtr_rts(struct usb_serial_port *port, int on)
|
|
|
|
{
|
2009-06-11 18:26:29 +07:00
|
|
|
struct usb_serial *serial = port->serial;
|
|
|
|
struct sierra_port_private *portdata;
|
2006-10-14 13:53:21 +07:00
|
|
|
|
2009-06-11 18:26:29 +07:00
|
|
|
portdata = usb_get_serial_port_data(port);
|
2009-06-11 20:30:21 +07:00
|
|
|
portdata->rts_state = on;
|
|
|
|
portdata->dtr_state = on;
|
2009-06-11 18:26:29 +07:00
|
|
|
|
|
|
|
if (serial->dev) {
|
2009-06-11 20:30:21 +07:00
|
|
|
mutex_lock(&serial->disc_mutex);
|
|
|
|
if (!serial->disconnected)
|
|
|
|
sierra_send_setup(port);
|
|
|
|
mutex_unlock(&serial->disc_mutex);
|
2006-10-14 13:53:21 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sierra_startup(struct usb_serial *serial)
|
|
|
|
{
|
|
|
|
struct usb_serial_port *port;
|
|
|
|
struct sierra_port_private *portdata;
|
2009-11-05 01:25:48 +07:00
|
|
|
struct sierra_iface_info *himemoryp = NULL;
|
2007-06-20 12:22:23 +07:00
|
|
|
int i;
|
2009-11-05 01:25:48 +07:00
|
|
|
u8 ifnum;
|
2006-10-14 13:53:21 +07:00
|
|
|
|
2008-01-11 02:11:04 +07:00
|
|
|
/* Set Device mode to D0 */
|
2007-07-17 03:49:27 +07:00
|
|
|
sierra_set_power_state(serial->dev, 0x0000);
|
|
|
|
|
2008-01-11 02:11:04 +07:00
|
|
|
/* Check NMEA and set */
|
|
|
|
if (nmea)
|
|
|
|
sierra_vsc_set_nmea(serial->dev, 1);
|
|
|
|
|
2006-10-14 13:53:21 +07:00
|
|
|
/* Now setup per port private data */
|
|
|
|
for (i = 0; i < serial->num_ports; i++) {
|
|
|
|
port = serial->port[i];
|
|
|
|
portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
|
|
|
|
if (!portdata) {
|
2008-09-17 11:05:24 +07:00
|
|
|
dev_dbg(&port->dev, "%s: kmalloc for "
|
2009-11-05 01:25:48 +07:00
|
|
|
"sierra_port_private (%d) failed!\n",
|
2008-09-17 11:05:24 +07:00
|
|
|
__func__, i);
|
2007-06-20 12:22:23 +07:00
|
|
|
return -ENOMEM;
|
2006-10-14 13:53:21 +07:00
|
|
|
}
|
2007-06-20 12:22:23 +07:00
|
|
|
spin_lock_init(&portdata->lock);
|
2009-09-05 04:19:53 +07:00
|
|
|
init_usb_anchor(&portdata->active);
|
|
|
|
init_usb_anchor(&portdata->delayed);
|
2009-11-05 01:25:48 +07:00
|
|
|
ifnum = i;
|
|
|
|
/* Assume low memory requirements */
|
|
|
|
portdata->num_out_urbs = N_OUT_URB;
|
|
|
|
portdata->num_in_urbs = N_IN_URB;
|
|
|
|
|
|
|
|
/* Determine actual memory requirements */
|
|
|
|
if (serial->num_ports == 1) {
|
|
|
|
/* Get interface number for composite device */
|
|
|
|
ifnum = sierra_calc_interface(serial);
|
|
|
|
himemoryp =
|
|
|
|
(struct sierra_iface_info *)&typeB_interface_list;
|
|
|
|
if (is_himemory(ifnum, himemoryp)) {
|
|
|
|
portdata->num_out_urbs = N_OUT_URB_HM;
|
|
|
|
portdata->num_in_urbs = N_IN_URB_HM;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
himemoryp =
|
|
|
|
(struct sierra_iface_info *)&typeA_interface_list;
|
|
|
|
if (is_himemory(i, himemoryp)) {
|
|
|
|
portdata->num_out_urbs = N_OUT_URB_HM;
|
|
|
|
portdata->num_in_urbs = N_IN_URB_HM;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
dev_dbg(&serial->dev->dev,
|
|
|
|
"Memory usage (urbs) interface #%d, in=%d, out=%d\n",
|
|
|
|
ifnum,portdata->num_in_urbs, portdata->num_out_urbs );
|
2009-06-11 20:30:21 +07:00
|
|
|
/* Set the port private data pointer */
|
2006-10-14 13:53:21 +07:00
|
|
|
usb_set_serial_port_data(port, portdata);
|
|
|
|
}
|
|
|
|
|
2007-06-20 12:22:23 +07:00
|
|
|
return 0;
|
2006-10-14 13:53:21 +07:00
|
|
|
}
|
|
|
|
|
2009-07-07 20:50:14 +07:00
|
|
|
static void sierra_release(struct usb_serial *serial)
|
2006-10-14 13:53:21 +07:00
|
|
|
{
|
2009-06-11 20:30:21 +07:00
|
|
|
int i;
|
2006-10-14 13:53:21 +07:00
|
|
|
struct usb_serial_port *port;
|
|
|
|
struct sierra_port_private *portdata;
|
|
|
|
|
|
|
|
for (i = 0; i < serial->num_ports; ++i) {
|
|
|
|
port = serial->port[i];
|
2007-04-26 14:12:01 +07:00
|
|
|
if (!port)
|
|
|
|
continue;
|
2006-10-14 13:53:21 +07:00
|
|
|
portdata = usb_get_serial_port_data(port);
|
2007-04-26 14:12:01 +07:00
|
|
|
if (!portdata)
|
|
|
|
continue;
|
2007-06-20 12:22:23 +07:00
|
|
|
kfree(portdata);
|
2006-10-14 13:53:21 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-24 05:57:43 +07:00
|
|
|
#ifdef CONFIG_PM
|
2009-09-05 04:19:53 +07:00
|
|
|
static void stop_read_write_urbs(struct usb_serial *serial)
|
|
|
|
{
|
2009-10-28 03:49:59 +07:00
|
|
|
int i;
|
2009-09-05 04:19:53 +07:00
|
|
|
struct usb_serial_port *port;
|
|
|
|
struct sierra_port_private *portdata;
|
|
|
|
|
|
|
|
/* Stop reading/writing urbs */
|
|
|
|
for (i = 0; i < serial->num_ports; ++i) {
|
|
|
|
port = serial->port[i];
|
|
|
|
portdata = usb_get_serial_port_data(port);
|
2009-10-28 03:49:59 +07:00
|
|
|
sierra_stop_rx_urbs(port);
|
2009-09-05 04:19:53 +07:00
|
|
|
usb_kill_anchored_urbs(&portdata->active);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sierra_suspend(struct usb_serial *serial, pm_message_t message)
|
|
|
|
{
|
|
|
|
struct sierra_intf_private *intfdata;
|
|
|
|
int b;
|
|
|
|
|
2011-08-20 04:49:48 +07:00
|
|
|
if (PMSG_IS_AUTO(message)) {
|
2009-09-05 04:19:53 +07:00
|
|
|
intfdata = serial->private;
|
|
|
|
spin_lock_irq(&intfdata->susp_lock);
|
|
|
|
b = intfdata->in_flight;
|
|
|
|
|
|
|
|
if (b) {
|
|
|
|
spin_unlock_irq(&intfdata->susp_lock);
|
|
|
|
return -EBUSY;
|
|
|
|
} else {
|
|
|
|
intfdata->suspended = 1;
|
|
|
|
spin_unlock_irq(&intfdata->susp_lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
stop_read_write_urbs(serial);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int sierra_resume(struct usb_serial *serial)
|
|
|
|
{
|
|
|
|
struct usb_serial_port *port;
|
|
|
|
struct sierra_intf_private *intfdata = serial->private;
|
|
|
|
struct sierra_port_private *portdata;
|
|
|
|
struct urb *urb;
|
|
|
|
int ec = 0;
|
|
|
|
int i, err;
|
|
|
|
|
|
|
|
spin_lock_irq(&intfdata->susp_lock);
|
|
|
|
for (i = 0; i < serial->num_ports; i++) {
|
|
|
|
port = serial->port[i];
|
|
|
|
portdata = usb_get_serial_port_data(port);
|
|
|
|
|
|
|
|
while ((urb = usb_get_from_anchor(&portdata->delayed))) {
|
|
|
|
usb_anchor_urb(urb, &portdata->active);
|
|
|
|
intfdata->in_flight++;
|
|
|
|
err = usb_submit_urb(urb, GFP_ATOMIC);
|
|
|
|
if (err < 0) {
|
|
|
|
intfdata->in_flight--;
|
|
|
|
usb_unanchor_urb(urb);
|
|
|
|
usb_scuttle_anchored_urbs(&portdata->delayed);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (portdata->opened) {
|
|
|
|
err = sierra_submit_rx_urbs(port, GFP_ATOMIC);
|
|
|
|
if (err)
|
|
|
|
ec++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
intfdata->suspended = 0;
|
|
|
|
spin_unlock_irq(&intfdata->susp_lock);
|
|
|
|
|
|
|
|
return ec ? -EIO : 0;
|
|
|
|
}
|
2010-02-12 09:37:40 +07:00
|
|
|
|
2009-09-24 05:57:43 +07:00
|
|
|
#else
|
|
|
|
#define sierra_suspend NULL
|
|
|
|
#define sierra_resume NULL
|
|
|
|
#endif
|
2009-09-05 04:19:53 +07:00
|
|
|
|
2008-01-11 02:11:04 +07:00
|
|
|
static struct usb_serial_driver sierra_device = {
|
2006-10-18 00:17:58 +07:00
|
|
|
.driver = {
|
|
|
|
.owner = THIS_MODULE,
|
2008-07-11 04:14:47 +07:00
|
|
|
.name = "sierra",
|
2006-10-18 00:17:58 +07:00
|
|
|
},
|
2008-01-11 02:11:04 +07:00
|
|
|
.description = "Sierra USB modem",
|
|
|
|
.id_table = id_table,
|
|
|
|
.calc_num_ports = sierra_calc_num_ports,
|
|
|
|
.probe = sierra_probe,
|
2006-10-18 00:17:58 +07:00
|
|
|
.open = sierra_open,
|
|
|
|
.close = sierra_close,
|
2009-06-11 18:26:29 +07:00
|
|
|
.dtr_rts = sierra_dtr_rts,
|
2006-10-18 00:17:58 +07:00
|
|
|
.write = sierra_write,
|
|
|
|
.write_room = sierra_write_room,
|
|
|
|
.set_termios = sierra_set_termios,
|
|
|
|
.tiocmget = sierra_tiocmget,
|
|
|
|
.tiocmset = sierra_tiocmset,
|
|
|
|
.attach = sierra_startup,
|
2009-07-07 20:50:14 +07:00
|
|
|
.release = sierra_release,
|
2009-09-05 04:19:53 +07:00
|
|
|
.suspend = sierra_suspend,
|
|
|
|
.resume = sierra_resume,
|
2006-10-18 00:17:58 +07:00
|
|
|
.read_int_callback = sierra_instat_callback,
|
|
|
|
};
|
|
|
|
|
2012-02-24 02:57:25 +07:00
|
|
|
static struct usb_serial_driver * const serial_drivers[] = {
|
|
|
|
&sierra_device, NULL
|
|
|
|
};
|
|
|
|
|
2012-05-09 05:46:14 +07:00
|
|
|
module_usb_serial_driver(serial_drivers, id_table);
|
2006-10-18 00:17:58 +07:00
|
|
|
|
2006-10-14 13:53:21 +07:00
|
|
|
MODULE_AUTHOR(DRIVER_AUTHOR);
|
|
|
|
MODULE_DESCRIPTION(DRIVER_DESC);
|
|
|
|
MODULE_VERSION(DRIVER_VERSION);
|
2006-07-01 01:17:55 +07:00
|
|
|
MODULE_LICENSE("GPL");
|
2006-10-14 13:53:21 +07:00
|
|
|
|
2008-07-11 04:14:47 +07:00
|
|
|
module_param(nmea, bool, S_IRUGO | S_IWUSR);
|
2008-01-11 02:11:04 +07:00
|
|
|
MODULE_PARM_DESC(nmea, "NMEA streaming");
|
|
|
|
|
2006-10-14 13:53:21 +07:00
|
|
|
module_param(debug, bool, S_IRUGO | S_IWUSR);
|
|
|
|
MODULE_PARM_DESC(debug, "Debug messages");
|