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