Context Navigation

source: src/linux/universal/linux-3.2/drivers/usb/serial/sierra.c @ 19243

Last change on this file since 19243 was 19243, checked in by BrainSlayer, 12 months ago
update kernel versions
File size: 32.2 KB

Line
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
49	static int debug;
50	static int nmea;
51
52	/* Used in interface blacklisting */
53	struct 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
58	struct sierra_intf_private {
59	spinlock_t susp_lock;
60	unsigned int suspended:1;
61	int in_flight;
62	};
63
64	static 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
79	static 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
94	static 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
114	static 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
131	static 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
148	static 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
169	static 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 */
211	static const u8 hi_memory_typeA_ifaces[] = { 0, 2 };
212	static const struct sierra_iface_info typeA_interface_list = {
213	.infolen = ARRAY_SIZE(hi_memory_typeA_ifaces),
214	.ifaceinfo = hi_memory_typeA_ifaces,
215	};
216
217	static const u8 hi_memory_typeB_ifaces[] = { 3, 4, 5, 6 };
218	static 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 */
224	static const u8 direct_ip_non_serial_ifaces[] = { 7, 8, 9, 10, 11, 19, 20 };
225	static 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
230	static 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	{ USB_DEVICE(0x1199, 0x0301) }, /* Sierra Wireless USB Dongle 250U */
249	/* Sierra Wireless C597 */
250	{ USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x0023, 0xFF, 0xFF, 0xFF) },
251	/* Sierra Wireless T598 */
252	{ USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x0025, 0xFF, 0xFF, 0xFF) },
253	{ USB_DEVICE(0x1199, 0x0026) }, /* Sierra Wireless T11 */
254	{ USB_DEVICE(0x1199, 0x0027) }, /* Sierra Wireless AC402 */
255	{ USB_DEVICE(0x1199, 0x0028) }, /* Sierra Wireless MC5728 */
256	{ USB_DEVICE(0x1199, 0x0029) }, /* Sierra Wireless Device */
257
258	{ USB_DEVICE(0x1199, 0x6802) }, /* Sierra Wireless MC8755 */
259	{ USB_DEVICE(0x1199, 0x6803) }, /* Sierra Wireless MC8765 */
260	{ USB_DEVICE(0x1199, 0x6804) }, /* Sierra Wireless MC8755 */
261	{ USB_DEVICE(0x1199, 0x6805) }, /* Sierra Wireless MC8765 */
262	{ USB_DEVICE(0x1199, 0x6808) }, /* Sierra Wireless MC8755 */
263	{ USB_DEVICE(0x1199, 0x6809) }, /* Sierra Wireless MC8765 */
264	{ USB_DEVICE(0x1199, 0x6812) }, /* Sierra Wireless MC8775 & AC 875U */
265	{ USB_DEVICE(0x1199, 0x6813) }, /* Sierra Wireless MC8775 */
266	{ USB_DEVICE(0x1199, 0x6815) }, /* Sierra Wireless MC8775 */
267	{ USB_DEVICE(0x1199, 0x6816) }, /* Sierra Wireless MC8775 */
268	{ USB_DEVICE(0x1199, 0x6820) }, /* Sierra Wireless AirCard 875 */
269	{ USB_DEVICE(0x1199, 0x6821) }, /* Sierra Wireless AirCard 875U */
270	{ USB_DEVICE(0x1199, 0x6822) }, /* Sierra Wireless AirCard 875E */
271	{ USB_DEVICE(0x1199, 0x6832) }, /* Sierra Wireless MC8780 */
272	{ USB_DEVICE(0x1199, 0x6833) }, /* Sierra Wireless MC8781 */
273	{ USB_DEVICE(0x1199, 0x6834) }, /* Sierra Wireless MC8780 */
274	{ USB_DEVICE(0x1199, 0x6835) }, /* Sierra Wireless MC8781 */
275	{ USB_DEVICE(0x1199, 0x6838) }, /* Sierra Wireless MC8780 */
276	{ USB_DEVICE(0x1199, 0x6839) }, /* Sierra Wireless MC8781 */
277	{ USB_DEVICE(0x1199, 0x683A) }, /* Sierra Wireless MC8785 */
278	{ USB_DEVICE(0x1199, 0x683B) }, /* Sierra Wireless MC8785 Composite */
279	/* Sierra Wireless MC8790, MC8791, MC8792 Composite */
280	{ USB_DEVICE(0x1199, 0x683C) },
281	{ USB_DEVICE(0x1199, 0x683D) }, /* Sierra Wireless MC8791 Composite */
282	/* Sierra Wireless MC8790, MC8791, MC8792 */
283	{ USB_DEVICE(0x1199, 0x683E) },
284	{ USB_DEVICE(0x1199, 0x6850) }, /* Sierra Wireless AirCard 880 */
285	{ USB_DEVICE(0x1199, 0x6851) }, /* Sierra Wireless AirCard 881 */
286	{ USB_DEVICE(0x1199, 0x6852) }, /* Sierra Wireless AirCard 880 E */
287	{ USB_DEVICE(0x1199, 0x6853) }, /* Sierra Wireless AirCard 881 E */
288	{ USB_DEVICE(0x1199, 0x6855) }, /* Sierra Wireless AirCard 880 U */
289	{ USB_DEVICE(0x1199, 0x6856) }, /* Sierra Wireless AirCard 881 U */
290	{ USB_DEVICE(0x1199, 0x6859) }, /* Sierra Wireless AirCard 885 E */
291	{ USB_DEVICE(0x1199, 0x685A) }, /* Sierra Wireless AirCard 885 E */
292	/* Sierra Wireless C885 */
293	{ USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x6880, 0xFF, 0xFF, 0xFF)},
294	/* Sierra Wireless C888, Air Card 501, USB 303, USB 304 */
295	{ USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x6890, 0xFF, 0xFF, 0xFF)},
296	/* Sierra Wireless C22/C33 */
297	{ USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x6891, 0xFF, 0xFF, 0xFF)},
298	/* Sierra Wireless HSPA Non-Composite Device */
299	{ USB_DEVICE_AND_INTERFACE_INFO(0x1199, 0x6892, 0xFF, 0xFF, 0xFF)},
300	{ USB_DEVICE(0x1199, 0x6893) }, /* Sierra Wireless Device */
301	{ USB_DEVICE(0x1199, 0x68A2), /* Sierra Wireless MC77xx in QMI mode */
302	.driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist
303	},
304	{ USB_DEVICE(0x1199, 0x68A3), /* Sierra Wireless Direct IP modems */
305	.driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist
306	},
307	{ USB_DEVICE(0x0f3d, 0x68A3), /* Airprime/Sierra Wireless Direct IP modems */
308	.driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist
309	},
310	{ USB_DEVICE(0x413C, 0x08133) }, /* Dell Computer Corp. Wireless 5720 VZW Mobile Broadband (EVDO Rev-A) Minicard GPS Port */
311
312	{ }
313	};
314	MODULE_DEVICE_TABLE(usb, id_table);
315
316
317	struct sierra_port_private {
318	spinlock_t lock; /* lock the structure */
319	int outstanding_urbs; /* number of out urbs in flight */
320	struct usb_anchor active;
321	struct usb_anchor delayed;
322
323	int num_out_urbs;
324	int num_in_urbs;
325	/* Input endpoints and buffers for this port */
326	struct urb *in_urbs[N_IN_URB_HM];
327
328	/* Settings for the port */
329	int rts_state; /* Handshaking pins (outputs) */
330	int dtr_state;
331	int cts_state; /* Handshaking pins (inputs) */
332	int dsr_state;
333	int dcd_state;
334	int ri_state;
335	unsigned int opened:1;
336	};
337
338	static int sierra_send_setup(struct usb_serial_port *port)
339	{
340	struct usb_serial *serial = port->serial;
341	struct sierra_port_private *portdata;
342	__u16 interface = 0;
343	int val = 0;
344	int do_send = 0;
345	int retval;
346
347	dev_dbg(&port->dev, "%s\n", __func__);
348
349	portdata = usb_get_serial_port_data(port);
350
351	if (portdata->dtr_state)
352	val \|= 0x01;
353	if (portdata->rts_state)
354	val \|= 0x02;
355
356	/* If composite device then properly report interface */
357	if (serial->num_ports == 1) {
358	interface = sierra_calc_interface(serial);
359	/* Control message is sent only to interfaces with
360	* interrupt_in endpoints
361	*/
362	if (port->interrupt_in_urb) {
363	/* send control message */
364	do_send = 1;
365	}
366	}
367
368	/* Otherwise the need to do non-composite mapping */
369	else {
370	if (port->bulk_out_endpointAddress == 2)
371	interface = 0;
372	else if (port->bulk_out_endpointAddress == 4)
373	interface = 1;
374	else if (port->bulk_out_endpointAddress == 5)
375	interface = 2;
376
377	do_send = 1;
378	}
379	if (!do_send)
380	return 0;
381
382	retval = usb_autopm_get_interface(serial->interface);
383	if (retval < 0)
384	return retval;
385
386	retval = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
387	0x22, 0x21, val, interface, NULL, 0, USB_CTRL_SET_TIMEOUT);
388	usb_autopm_put_interface(serial->interface);
389
390	return retval;
391	}
392
393	static void sierra_set_termios(struct tty_struct *tty,
394	struct usb_serial_port port, struct ktermios old_termios)
395	{
396	dev_dbg(&port->dev, "%s\n", __func__);
397	tty_termios_copy_hw(tty->termios, old_termios);
398	sierra_send_setup(port);
399	}
400
401	static int sierra_tiocmget(struct tty_struct *tty)
402	{
403	struct usb_serial_port *port = tty->driver_data;
404	unsigned int value;
405	struct sierra_port_private *portdata;
406
407	dev_dbg(&port->dev, "%s\n", __func__);
408	portdata = usb_get_serial_port_data(port);
409
410	value = ((portdata->rts_state) ? TIOCM_RTS : 0) \|
411	((portdata->dtr_state) ? TIOCM_DTR : 0) \|
412	((portdata->cts_state) ? TIOCM_CTS : 0) \|
413	((portdata->dsr_state) ? TIOCM_DSR : 0) \|
414	((portdata->dcd_state) ? TIOCM_CAR : 0) \|
415	((portdata->ri_state) ? TIOCM_RNG : 0);
416
417	return value;
418	}
419
420	static int sierra_tiocmset(struct tty_struct *tty,
421	unsigned int set, unsigned int clear)
422	{
423	struct usb_serial_port *port = tty->driver_data;
424	struct sierra_port_private *portdata;
425
426	portdata = usb_get_serial_port_data(port);
427
428	if (set & TIOCM_RTS)
429	portdata->rts_state = 1;
430	if (set & TIOCM_DTR)
431	portdata->dtr_state = 1;
432
433	if (clear & TIOCM_RTS)
434	portdata->rts_state = 0;
435	if (clear & TIOCM_DTR)
436	portdata->dtr_state = 0;
437	return sierra_send_setup(port);
438	}
439
440	static void sierra_release_urb(struct urb *urb)
441	{
442	struct usb_serial_port *port;
443	if (urb) {
444	port = urb->context;
445	dev_dbg(&port->dev, "%s: %p\n", __func__, urb);
446	kfree(urb->transfer_buffer);
447	usb_free_urb(urb);
448	}
449	}
450
451	static void sierra_outdat_callback(struct urb *urb)
452	{
453	struct usb_serial_port *port = urb->context;
454	struct sierra_port_private *portdata = usb_get_serial_port_data(port);
455	struct sierra_intf_private *intfdata;
456	int status = urb->status;
457
458	dev_dbg(&port->dev, "%s - port %d\n", __func__, port->number);
459	intfdata = port->serial->private;
460
461	/* free up the transfer buffer, as usb_free_urb() does not do this */
462	kfree(urb->transfer_buffer);
463	usb_autopm_put_interface_async(port->serial->interface);
464	if (status)
465	dev_dbg(&port->dev, "%s - nonzero write bulk status "
466	"received: %d\n", __func__, status);
467
468	spin_lock(&portdata->lock);
469	--portdata->outstanding_urbs;
470	spin_unlock(&portdata->lock);
471	spin_lock(&intfdata->susp_lock);
472	--intfdata->in_flight;
473	spin_unlock(&intfdata->susp_lock);
474
475	usb_serial_port_softint(port);
476	}
477
478	/* Write */
479	static int sierra_write(struct tty_struct tty, struct usb_serial_port port,
480	const unsigned char *buf, int count)
481	{
482	struct sierra_port_private *portdata;
483	struct sierra_intf_private *intfdata;
484	struct usb_serial *serial = port->serial;
485	unsigned long flags;
486	unsigned char *buffer;
487	struct urb *urb;
488	size_t writesize = min((size_t)count, (size_t)MAX_TRANSFER);
489	int retval = 0;
490
491	/* verify that we actually have some data to write */
492	if (count == 0)
493	return 0;
494
495	portdata = usb_get_serial_port_data(port);
496	intfdata = serial->private;
497
498	dev_dbg(&port->dev, "%s: write (%zd bytes)\n", __func__, writesize);
499	spin_lock_irqsave(&portdata->lock, flags);
500	dev_dbg(&port->dev, "%s - outstanding_urbs: %d\n", __func__,
501	portdata->outstanding_urbs);
502	if (portdata->outstanding_urbs > portdata->num_out_urbs) {
503	spin_unlock_irqrestore(&portdata->lock, flags);
504	dev_dbg(&port->dev, "%s - write limit hit\n", __func__);
505	return 0;
506	}
507	portdata->outstanding_urbs++;
508	dev_dbg(&port->dev, "%s - 1, outstanding_urbs: %d\n", __func__,
509	portdata->outstanding_urbs);
510	spin_unlock_irqrestore(&portdata->lock, flags);
511
512	retval = usb_autopm_get_interface_async(serial->interface);
513	if (retval < 0) {
514	spin_lock_irqsave(&portdata->lock, flags);
515	portdata->outstanding_urbs--;
516	spin_unlock_irqrestore(&portdata->lock, flags);
517	goto error_simple;
518	}
519
520	buffer = kmalloc(writesize, GFP_ATOMIC);
521	if (!buffer) {
522	dev_err(&port->dev, "out of memory\n");
523	retval = -ENOMEM;
524	goto error_no_buffer;
525	}
526
527	urb = usb_alloc_urb(0, GFP_ATOMIC);
528	if (!urb) {
529	dev_err(&port->dev, "no more free urbs\n");
530	retval = -ENOMEM;
531	goto error_no_urb;
532	}
533
534	memcpy(buffer, buf, writesize);
535
536	usb_serial_debug_data(debug, &port->dev, __func__, writesize, buffer);
537
538	usb_fill_bulk_urb(urb, serial->dev,
539	usb_sndbulkpipe(serial->dev,
540	port->bulk_out_endpointAddress),
541	buffer, writesize, sierra_outdat_callback, port);
542
543	/* Handle the need to send a zero length packet */
544	urb->transfer_flags \|= URB_ZERO_PACKET;
545
546	spin_lock_irqsave(&intfdata->susp_lock, flags);
547
548	if (intfdata->suspended) {
549	usb_anchor_urb(urb, &portdata->delayed);
550	spin_unlock_irqrestore(&intfdata->susp_lock, flags);
551	goto skip_power;
552	} else {
553	usb_anchor_urb(urb, &portdata->active);
554	}
555	/* send it down the pipe */
556	retval = usb_submit_urb(urb, GFP_ATOMIC);
557	if (retval) {
558	usb_unanchor_urb(urb);
559	spin_unlock_irqrestore(&intfdata->susp_lock, flags);
560	dev_err(&port->dev, "%s - usb_submit_urb(write bulk) failed "
561	"with status = %d\n", __func__, retval);
562	goto error;
563	} else {
564	intfdata->in_flight++;
565	spin_unlock_irqrestore(&intfdata->susp_lock, flags);
566	}
567
568	skip_power:
569	/* we are done with this urb, so let the host driver
570	* really free it when it is finished with it */
571	usb_free_urb(urb);
572
573	return writesize;
574	error:
575	usb_free_urb(urb);
576	error_no_urb:
577	kfree(buffer);
578	error_no_buffer:
579	spin_lock_irqsave(&portdata->lock, flags);
580	--portdata->outstanding_urbs;
581	dev_dbg(&port->dev, "%s - 2. outstanding_urbs: %d\n", __func__,
582	portdata->outstanding_urbs);
583	spin_unlock_irqrestore(&portdata->lock, flags);
584	usb_autopm_put_interface_async(serial->interface);
585	error_simple:
586	return retval;
587	}
588
589	static void sierra_indat_callback(struct urb *urb)
590	{
591	int err;
592	int endpoint;
593	struct usb_serial_port *port;
594	struct tty_struct *tty;
595	unsigned char *data = urb->transfer_buffer;
596	int status = urb->status;
597
598	endpoint = usb_pipeendpoint(urb->pipe);
599	port = urb->context;
600
601	dev_dbg(&port->dev, "%s: %p\n", __func__, urb);
602
603	if (status) {
604	dev_dbg(&port->dev, "%s: nonzero status: %d on"
605	" endpoint %02x\n", __func__, status, endpoint);
606	} else {
607	if (urb->actual_length) {
608	tty = tty_port_tty_get(&port->port);
609	if (tty) {
610	tty_insert_flip_string(tty, data,
611	urb->actual_length);
612	tty_flip_buffer_push(tty);
613
614	tty_kref_put(tty);
615	usb_serial_debug_data(debug, &port->dev,
616	__func__, urb->actual_length, data);
617	}
618	} else {
619	dev_dbg(&port->dev, "%s: empty read urb"
620	" received\n", __func__);
621	}
622	}
623
624	/* Resubmit urb so we continue receiving */
625	if (status != -ESHUTDOWN && status != -EPERM) {
626	usb_mark_last_busy(port->serial->dev);
627	err = usb_submit_urb(urb, GFP_ATOMIC);
628	if (err && err != -EPERM)
629	dev_err(&port->dev, "resubmit read urb failed."
630	"(%d)\n", err);
631	}
632	}
633
634	static void sierra_instat_callback(struct urb *urb)
635	{
636	int err;
637	int status = urb->status;
638	struct usb_serial_port *port = urb->context;
639	struct sierra_port_private *portdata = usb_get_serial_port_data(port);
640	struct usb_serial *serial = port->serial;
641
642	dev_dbg(&port->dev, "%s: urb %p port %p has data %p\n", __func__,
643	urb, port, portdata);
644
645	if (status == 0) {
646	struct usb_ctrlrequest *req_pkt =
647	(struct usb_ctrlrequest *)urb->transfer_buffer;
648
649	if (!req_pkt) {
650	dev_dbg(&port->dev, "%s: NULL req_pkt\n",
651	__func__);
652	return;
653	}
654	if ((req_pkt->bRequestType == 0xA1) &&
655	(req_pkt->bRequest == 0x20)) {
656	int old_dcd_state;
657	unsigned char signals = ((unsigned char )
658	urb->transfer_buffer +
659	sizeof(struct usb_ctrlrequest));
660	struct tty_struct *tty;
661
662	dev_dbg(&port->dev, "%s: signal x%x\n", __func__,
663	signals);
664
665	old_dcd_state = portdata->dcd_state;
666	portdata->cts_state = 1;
667	portdata->dcd_state = ((signals & 0x01) ? 1 : 0);
668	portdata->dsr_state = ((signals & 0x02) ? 1 : 0);
669	portdata->ri_state = ((signals & 0x08) ? 1 : 0);
670
671	tty = tty_port_tty_get(&port->port);
672	if (tty && !C_CLOCAL(tty) &&
673	old_dcd_state && !portdata->dcd_state)
674	tty_hangup(tty);
675	tty_kref_put(tty);
676	} else {
677	dev_dbg(&port->dev, "%s: type %x req %x\n",
678	__func__, req_pkt->bRequestType,
679	req_pkt->bRequest);
680	}
681	} else
682	dev_dbg(&port->dev, "%s: error %d\n", __func__, status);
683
684	/* Resubmit urb so we continue receiving IRQ data */
685	if (status != -ESHUTDOWN && status != -ENOENT) {
686	usb_mark_last_busy(serial->dev);
687	urb->dev = serial->dev;
688	err = usb_submit_urb(urb, GFP_ATOMIC);
689	if (err && err != -EPERM)
690	dev_err(&port->dev, "%s: resubmit intr urb "
691	"failed. (%d)\n", __func__, err);
692	}
693	}
694
695	static int sierra_write_room(struct tty_struct *tty)
696	{
697	struct usb_serial_port *port = tty->driver_data;
698	struct sierra_port_private *portdata = usb_get_serial_port_data(port);
699	unsigned long flags;
700
701	dev_dbg(&port->dev, "%s - port %d\n", __func__, port->number);
702
703	/* try to give a good number back based on if we have any free urbs at
704	* this point in time */
705	spin_lock_irqsave(&portdata->lock, flags);
706	if (portdata->outstanding_urbs > (portdata->num_out_urbs * 2) / 3) {
707	spin_unlock_irqrestore(&portdata->lock, flags);
708	dev_dbg(&port->dev, "%s - write limit hit\n", __func__);
709	return 0;
710	}
711	spin_unlock_irqrestore(&portdata->lock, flags);
712
713	return 2048;
714	}
715
716	static void sierra_stop_rx_urbs(struct usb_serial_port *port)
717	{
718	int i;
719	struct sierra_port_private *portdata = usb_get_serial_port_data(port);
720
721	for (i = 0; i < portdata->num_in_urbs; i++)
722	usb_kill_urb(portdata->in_urbs[i]);
723
724	usb_kill_urb(port->interrupt_in_urb);
725	}
726
727	static int sierra_submit_rx_urbs(struct usb_serial_port *port, gfp_t mem_flags)
728	{
729	int ok_cnt;
730	int err = -EINVAL;
731	int i;
732	struct urb *urb;
733	struct sierra_port_private *portdata = usb_get_serial_port_data(port);
734
735	ok_cnt = 0;
736	for (i = 0; i < portdata->num_in_urbs; i++) {
737	urb = portdata->in_urbs[i];
738	if (!urb)
739	continue;
740	err = usb_submit_urb(urb, mem_flags);
741	if (err) {
742	dev_err(&port->dev, "%s: submit urb failed: %d\n",
743	__func__, err);
744	} else {
745	ok_cnt++;
746	}
747	}
748
749	if (ok_cnt && port->interrupt_in_urb) {
750	err = usb_submit_urb(port->interrupt_in_urb, mem_flags);
751	if (err) {
752	dev_err(&port->dev, "%s: submit intr urb failed: %d\n",
753	__func__, err);
754	}
755	}
756
757	if (ok_cnt > 0) /* at least one rx urb submitted */
758	return 0;
759	else
760	return err;
761	}
762
763	static struct urb sierra_setup_urb(struct usb_serial serial, int endpoint,
764	int dir, void *ctx, int len,
765	gfp_t mem_flags,
766	usb_complete_t callback)
767	{
768	struct urb *urb;
769	u8 *buf;
770
771	if (endpoint == -1)
772	return NULL;
773
774	urb = usb_alloc_urb(0, mem_flags);
775	if (urb == NULL) {
776	dev_dbg(&serial->dev->dev, "%s: alloc for endpoint %d failed\n",
777	__func__, endpoint);
778	return NULL;
779	}
780
781	buf = kmalloc(len, mem_flags);
782	if (buf) {
783	/* Fill URB using supplied data */
784	usb_fill_bulk_urb(urb, serial->dev,
785	usb_sndbulkpipe(serial->dev, endpoint) \| dir,
786	buf, len, callback, ctx);
787
788	/* debug */
789	dev_dbg(&serial->dev->dev, "%s %c u : %p d:%p\n", __func__,
790	dir == USB_DIR_IN ? 'i' : 'o', urb, buf);
791	} else {
792	dev_dbg(&serial->dev->dev, "%s %c u:%p d:%p\n", __func__,
793	dir == USB_DIR_IN ? 'i' : 'o', urb, buf);
794
795	sierra_release_urb(urb);
796	urb = NULL;
797	}
798
799	return urb;
800	}
801
802	static void sierra_close(struct usb_serial_port *port)
803	{
804	int i;
805	struct usb_serial *serial = port->serial;
806	struct sierra_port_private *portdata;
807	struct sierra_intf_private *intfdata = port->serial->private;
808
809
810	dev_dbg(&port->dev, "%s\n", __func__);
811	portdata = usb_get_serial_port_data(port);
812
813	portdata->rts_state = 0;
814	portdata->dtr_state = 0;
815
816	if (serial->dev) {
817	mutex_lock(&serial->disc_mutex);
818	if (!serial->disconnected) {
819	serial->interface->needs_remote_wakeup = 0;
820	/* odd error handling due to pm counters */
821	if (!usb_autopm_get_interface(serial->interface))
822	sierra_send_setup(port);
823	else
824	usb_autopm_get_interface_no_resume(serial->interface);
825
826	}
827	mutex_unlock(&serial->disc_mutex);
828	spin_lock_irq(&intfdata->susp_lock);
829	portdata->opened = 0;
830	spin_unlock_irq(&intfdata->susp_lock);
831
832
833	/* Stop reading urbs */
834	sierra_stop_rx_urbs(port);
835	/* .. and release them */
836	for (i = 0; i < portdata->num_in_urbs; i++) {
837	sierra_release_urb(portdata->in_urbs[i]);
838	portdata->in_urbs[i] = NULL;
839	}
840	}
841	}
842
843	static int sierra_open(struct tty_struct tty, struct usb_serial_port port)
844	{
845	struct sierra_port_private *portdata;
846	struct usb_serial *serial = port->serial;
847	struct sierra_intf_private *intfdata = serial->private;
848	int i;
849	int err;
850	int endpoint;
851	struct urb *urb;
852
853	portdata = usb_get_serial_port_data(port);
854
855	dev_dbg(&port->dev, "%s\n", __func__);
856
857	/* Set some sane defaults */
858	portdata->rts_state = 1;
859	portdata->dtr_state = 1;
860
861
862	endpoint = port->bulk_in_endpointAddress;
863	for (i = 0; i < portdata->num_in_urbs; i++) {
864	urb = sierra_setup_urb(serial, endpoint, USB_DIR_IN, port,
865	IN_BUFLEN, GFP_KERNEL,
866	sierra_indat_callback);
867	portdata->in_urbs[i] = urb;
868	}
869	/* clear halt condition */
870	usb_clear_halt(serial->dev,
871	usb_sndbulkpipe(serial->dev, endpoint) \| USB_DIR_IN);
872
873	err = sierra_submit_rx_urbs(port, GFP_KERNEL);
874	if (err) {
875	/* get rid of everything as in close */
876	sierra_close(port);
877	/* restore balance for autopm */
878	if (!serial->disconnected)
879	usb_autopm_put_interface(serial->interface);
880	return err;
881	}
882	sierra_send_setup(port);
883
884	serial->interface->needs_remote_wakeup = 1;
885	spin_lock_irq(&intfdata->susp_lock);
886	portdata->opened = 1;
887	spin_unlock_irq(&intfdata->susp_lock);
888	usb_autopm_put_interface(serial->interface);
889
890	return 0;
891	}
892
893
894	static void sierra_dtr_rts(struct usb_serial_port *port, int on)
895	{
896	struct usb_serial *serial = port->serial;
897	struct sierra_port_private *portdata;
898
899	portdata = usb_get_serial_port_data(port);
900	portdata->rts_state = on;
901	portdata->dtr_state = on;
902
903	if (serial->dev) {
904	mutex_lock(&serial->disc_mutex);
905	if (!serial->disconnected)
906	sierra_send_setup(port);
907	mutex_unlock(&serial->disc_mutex);
908	}
909	}
910
911	static int sierra_startup(struct usb_serial *serial)
912	{
913	struct usb_serial_port *port;
914	struct sierra_port_private *portdata;
915	struct sierra_iface_info *himemoryp = NULL;
916	int i;
917	u8 ifnum;
918
919	dev_dbg(&serial->dev->dev, "%s\n", __func__);
920
921	/* Set Device mode to D0 */
922	sierra_set_power_state(serial->dev, 0x0000);
923
924	/* Check NMEA and set */
925	if (nmea)
926	sierra_vsc_set_nmea(serial->dev, 1);
927
928	/* Now setup per port private data */
929	for (i = 0; i < serial->num_ports; i++) {
930	port = serial->port[i];
931	portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
932	if (!portdata) {
933	dev_dbg(&port->dev, "%s: kmalloc for "
934	"sierra_port_private (%d) failed!\n",
935	__func__, i);
936	return -ENOMEM;
937	}
938	spin_lock_init(&portdata->lock);
939	init_usb_anchor(&portdata->active);
940	init_usb_anchor(&portdata->delayed);
941	ifnum = i;
942	/* Assume low memory requirements */
943	portdata->num_out_urbs = N_OUT_URB;
944	portdata->num_in_urbs = N_IN_URB;
945
946	/* Determine actual memory requirements */
947	if (serial->num_ports == 1) {
948	/* Get interface number for composite device */
949	ifnum = sierra_calc_interface(serial);
950	himemoryp =
951	(struct sierra_iface_info *)&typeB_interface_list;
952	if (is_himemory(ifnum, himemoryp)) {
953	portdata->num_out_urbs = N_OUT_URB_HM;
954	portdata->num_in_urbs = N_IN_URB_HM;
955	}
956	}
957	else {
958	himemoryp =
959	(struct sierra_iface_info *)&typeA_interface_list;
960	if (is_himemory(i, himemoryp)) {
961	portdata->num_out_urbs = N_OUT_URB_HM;
962	portdata->num_in_urbs = N_IN_URB_HM;
963	}
964	}
965	dev_dbg(&serial->dev->dev,
966	"Memory usage (urbs) interface #%d, in=%d, out=%d\n",
967	ifnum,portdata->num_in_urbs, portdata->num_out_urbs );
968	/* Set the port private data pointer */
969	usb_set_serial_port_data(port, portdata);
970	}
971
972	return 0;
973	}
974
975	static void sierra_release(struct usb_serial *serial)
976	{
977	int i;
978	struct usb_serial_port *port;
979	struct sierra_port_private *portdata;
980
981	dev_dbg(&serial->dev->dev, "%s\n", __func__);
982
983	for (i = 0; i < serial->num_ports; ++i) {
984	port = serial->port[i];
985	if (!port)
986	continue;
987	portdata = usb_get_serial_port_data(port);
988	if (!portdata)
989	continue;
990	kfree(portdata);
991	}
992	}
993
994	#ifdef CONFIG_PM
995	static void stop_read_write_urbs(struct usb_serial *serial)
996	{
997	int i;
998	struct usb_serial_port *port;
999	struct sierra_port_private *portdata;
1000
1001	/* Stop reading/writing urbs */
1002	for (i = 0; i < serial->num_ports; ++i) {
1003	port = serial->port[i];
1004	portdata = usb_get_serial_port_data(port);
1005	sierra_stop_rx_urbs(port);
1006	usb_kill_anchored_urbs(&portdata->active);
1007	}
1008	}
1009
1010	static int sierra_suspend(struct usb_serial *serial, pm_message_t message)
1011	{
1012	struct sierra_intf_private *intfdata;
1013	int b;
1014
1015	if (PMSG_IS_AUTO(message)) {
1016	intfdata = serial->private;
1017	spin_lock_irq(&intfdata->susp_lock);
1018	b = intfdata->in_flight;
1019
1020	if (b) {
1021	spin_unlock_irq(&intfdata->susp_lock);
1022	return -EBUSY;
1023	} else {
1024	intfdata->suspended = 1;
1025	spin_unlock_irq(&intfdata->susp_lock);
1026	}
1027	}
1028	stop_read_write_urbs(serial);
1029
1030	return 0;
1031	}
1032
1033	static int sierra_resume(struct usb_serial *serial)
1034	{
1035	struct usb_serial_port *port;
1036	struct sierra_intf_private *intfdata = serial->private;
1037	struct sierra_port_private *portdata;
1038	struct urb *urb;
1039	int ec = 0;
1040	int i, err;
1041
1042	spin_lock_irq(&intfdata->susp_lock);
1043	for (i = 0; i < serial->num_ports; i++) {
1044	port = serial->port[i];
1045	portdata = usb_get_serial_port_data(port);
1046
1047	while ((urb = usb_get_from_anchor(&portdata->delayed))) {
1048	usb_anchor_urb(urb, &portdata->active);
1049	intfdata->in_flight++;
1050	err = usb_submit_urb(urb, GFP_ATOMIC);
1051	if (err < 0) {
1052	intfdata->in_flight--;
1053	usb_unanchor_urb(urb);
1054	usb_scuttle_anchored_urbs(&portdata->delayed);
1055	break;
1056	}
1057	}
1058
1059	if (portdata->opened) {
1060	err = sierra_submit_rx_urbs(port, GFP_ATOMIC);
1061	if (err)
1062	ec++;
1063	}
1064	}
1065	intfdata->suspended = 0;
1066	spin_unlock_irq(&intfdata->susp_lock);
1067
1068	return ec ? -EIO : 0;
1069	}
1070
1071	static int sierra_reset_resume(struct usb_interface *intf)
1072	{
1073	struct usb_serial *serial = usb_get_intfdata(intf);
1074	dev_err(&serial->dev->dev, "%s\n", __func__);
1075	return usb_serial_resume(intf);
1076	}
1077	#else
1078	#define sierra_suspend NULL
1079	#define sierra_resume NULL
1080	#define sierra_reset_resume NULL
1081	#endif
1082
1083	static struct usb_driver sierra_driver = {
1084	.name = "sierra",
1085	.probe = usb_serial_probe,
1086	.disconnect = usb_serial_disconnect,
1087	.suspend = usb_serial_suspend,
1088	.resume = usb_serial_resume,
1089	.reset_resume = sierra_reset_resume,
1090	.id_table = id_table,
1091	.no_dynamic_id = 1,
1092	.supports_autosuspend = 1,
1093	};
1094
1095	static struct usb_serial_driver sierra_device = {
1096	.driver = {
1097	.owner = THIS_MODULE,
1098	.name = "sierra",
1099	},
1100	.description = "Sierra USB modem",
1101	.id_table = id_table,
1102	.usb_driver = &sierra_driver,
1103	.calc_num_ports = sierra_calc_num_ports,
1104	.probe = sierra_probe,
1105	.open = sierra_open,
1106	.close = sierra_close,
1107	.dtr_rts = sierra_dtr_rts,
1108	.write = sierra_write,
1109	.write_room = sierra_write_room,
1110	.set_termios = sierra_set_termios,
1111	.tiocmget = sierra_tiocmget,
1112	.tiocmset = sierra_tiocmset,
1113	.attach = sierra_startup,
1114	.release = sierra_release,
1115	.suspend = sierra_suspend,
1116	.resume = sierra_resume,
1117	.read_int_callback = sierra_instat_callback,
1118	};
1119
1120	/* Functions used by new usb-serial code. */
1121	static int __init sierra_init(void)
1122	{
1123	int retval;
1124	retval = usb_serial_register(&sierra_device);
1125	if (retval)
1126	goto failed_device_register;
1127
1128
1129	retval = usb_register(&sierra_driver);
1130	if (retval)
1131	goto failed_driver_register;
1132
1133	printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
1134	DRIVER_DESC "\n");
1135
1136	return 0;
1137
1138	failed_driver_register:
1139	usb_serial_deregister(&sierra_device);
1140	failed_device_register:
1141	return retval;
1142	}
1143
1144	static void __exit sierra_exit(void)
1145	{
1146	usb_deregister(&sierra_driver);
1147	usb_serial_deregister(&sierra_device);
1148	}
1149
1150	module_init(sierra_init);
1151	module_exit(sierra_exit);
1152
1153	MODULE_AUTHOR(DRIVER_AUTHOR);
1154	MODULE_DESCRIPTION(DRIVER_DESC);
1155	MODULE_VERSION(DRIVER_VERSION);
1156	MODULE_LICENSE("GPL");
1157
1158	module_param(nmea, bool, S_IRUGO \| S_IWUSR);
1159	MODULE_PARM_DESC(nmea, "NMEA streaming");
1160
1161	module_param(debug, bool, S_IRUGO \| S_IWUSR);
1162	MODULE_PARM_DESC(debug, "Debug messages");

Note: See TracBrowser for help on using the repository browser.

Download in other formats: