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