xref: /openbmc/linux/drivers/net/usb/hso.c (revision 8795a739)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /******************************************************************************
3  *
4  * Driver for Option High Speed Mobile Devices.
5  *
6  *  Copyright (C) 2008 Option International
7  *                     Filip Aben <f.aben@option.com>
8  *                     Denis Joseph Barrow <d.barow@option.com>
9  *                     Jan Dumon <j.dumon@option.com>
10  *  Copyright (C) 2007 Andrew Bird (Sphere Systems Ltd)
11  *  			<ajb@spheresystems.co.uk>
12  *  Copyright (C) 2008 Greg Kroah-Hartman <gregkh@suse.de>
13  *  Copyright (C) 2008 Novell, Inc.
14  *
15  *****************************************************************************/
16 
17 /******************************************************************************
18  *
19  * Description of the device:
20  *
21  * Interface 0:	Contains the IP network interface on the bulk end points.
22  *		The multiplexed serial ports are using the interrupt and
23  *		control endpoints.
24  *		Interrupt contains a bitmap telling which multiplexed
25  *		serialport needs servicing.
26  *
27  * Interface 1:	Diagnostics port, uses bulk only, do not submit urbs until the
28  *		port is opened, as this have a huge impact on the network port
29  *		throughput.
30  *
31  * Interface 2:	Standard modem interface - circuit switched interface, this
32  *		can be used to make a standard ppp connection however it
33  *              should not be used in conjunction with the IP network interface
34  *              enabled for USB performance reasons i.e. if using this set
35  *              ideally disable_net=1.
36  *
37  *****************************************************************************/
38 
39 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
40 
41 #include <linux/sched/signal.h>
42 #include <linux/slab.h>
43 #include <linux/init.h>
44 #include <linux/delay.h>
45 #include <linux/netdevice.h>
46 #include <linux/module.h>
47 #include <linux/ethtool.h>
48 #include <linux/usb.h>
49 #include <linux/tty.h>
50 #include <linux/tty_driver.h>
51 #include <linux/tty_flip.h>
52 #include <linux/kmod.h>
53 #include <linux/rfkill.h>
54 #include <linux/ip.h>
55 #include <linux/uaccess.h>
56 #include <linux/usb/cdc.h>
57 #include <net/arp.h>
58 #include <asm/byteorder.h>
59 #include <linux/serial_core.h>
60 #include <linux/serial.h>
61 
62 
63 #define MOD_AUTHOR			"Option Wireless"
64 #define MOD_DESCRIPTION			"USB High Speed Option driver"
65 
66 #define HSO_MAX_NET_DEVICES		10
67 #define HSO__MAX_MTU			2048
68 #define DEFAULT_MTU			1500
69 #define DEFAULT_MRU			1500
70 
71 #define CTRL_URB_RX_SIZE		1024
72 #define CTRL_URB_TX_SIZE		64
73 
74 #define BULK_URB_RX_SIZE		4096
75 #define BULK_URB_TX_SIZE		8192
76 
77 #define MUX_BULK_RX_BUF_SIZE		HSO__MAX_MTU
78 #define MUX_BULK_TX_BUF_SIZE		HSO__MAX_MTU
79 #define MUX_BULK_RX_BUF_COUNT		4
80 #define USB_TYPE_OPTION_VENDOR		0x20
81 
82 /* These definitions are used with the struct hso_net flags element */
83 /* - use *_bit operations on it. (bit indices not values.) */
84 #define HSO_NET_RUNNING			0
85 
86 #define	HSO_NET_TX_TIMEOUT		(HZ*10)
87 
88 #define HSO_SERIAL_MAGIC		0x48534f31
89 
90 /* Number of ttys to handle */
91 #define HSO_SERIAL_TTY_MINORS		256
92 
93 #define MAX_RX_URBS			2
94 
95 /*****************************************************************************/
96 /* Debugging functions                                                       */
97 /*****************************************************************************/
98 #define hso_dbg(lvl, fmt, ...)						\
99 do {									\
100 	if ((lvl) & debug)						\
101 		pr_info("[%d:%s] " fmt,					\
102 			__LINE__, __func__, ##__VA_ARGS__);		\
103 } while (0)
104 
105 /*****************************************************************************/
106 /* Enumerators                                                               */
107 /*****************************************************************************/
108 enum pkt_parse_state {
109 	WAIT_IP,
110 	WAIT_DATA,
111 	WAIT_SYNC
112 };
113 
114 /*****************************************************************************/
115 /* Structs                                                                   */
116 /*****************************************************************************/
117 
118 struct hso_shared_int {
119 	struct usb_endpoint_descriptor *intr_endp;
120 	void *shared_intr_buf;
121 	struct urb *shared_intr_urb;
122 	struct usb_device *usb;
123 	int use_count;
124 	int ref_count;
125 	struct mutex shared_int_lock;
126 };
127 
128 struct hso_net {
129 	struct hso_device *parent;
130 	struct net_device *net;
131 	struct rfkill *rfkill;
132 	char name[24];
133 
134 	struct usb_endpoint_descriptor *in_endp;
135 	struct usb_endpoint_descriptor *out_endp;
136 
137 	struct urb *mux_bulk_rx_urb_pool[MUX_BULK_RX_BUF_COUNT];
138 	struct urb *mux_bulk_tx_urb;
139 	void *mux_bulk_rx_buf_pool[MUX_BULK_RX_BUF_COUNT];
140 	void *mux_bulk_tx_buf;
141 
142 	struct sk_buff *skb_rx_buf;
143 	struct sk_buff *skb_tx_buf;
144 
145 	enum pkt_parse_state rx_parse_state;
146 	spinlock_t net_lock;
147 
148 	unsigned short rx_buf_size;
149 	unsigned short rx_buf_missing;
150 	struct iphdr rx_ip_hdr;
151 
152 	unsigned long flags;
153 };
154 
155 enum rx_ctrl_state{
156 	RX_IDLE,
157 	RX_SENT,
158 	RX_PENDING
159 };
160 
161 #define BM_REQUEST_TYPE (0xa1)
162 #define B_NOTIFICATION  (0x20)
163 #define W_VALUE         (0x0)
164 #define W_LENGTH        (0x2)
165 
166 #define B_OVERRUN       (0x1<<6)
167 #define B_PARITY        (0x1<<5)
168 #define B_FRAMING       (0x1<<4)
169 #define B_RING_SIGNAL   (0x1<<3)
170 #define B_BREAK         (0x1<<2)
171 #define B_TX_CARRIER    (0x1<<1)
172 #define B_RX_CARRIER    (0x1<<0)
173 
174 struct hso_serial_state_notification {
175 	u8 bmRequestType;
176 	u8 bNotification;
177 	u16 wValue;
178 	u16 wIndex;
179 	u16 wLength;
180 	u16 UART_state_bitmap;
181 } __packed;
182 
183 struct hso_tiocmget {
184 	struct mutex mutex;
185 	wait_queue_head_t waitq;
186 	int    intr_completed;
187 	struct usb_endpoint_descriptor *endp;
188 	struct urb *urb;
189 	struct hso_serial_state_notification serial_state_notification;
190 	u16    prev_UART_state_bitmap;
191 	struct uart_icount icount;
192 };
193 
194 
195 struct hso_serial {
196 	struct hso_device *parent;
197 	int magic;
198 	u8 minor;
199 
200 	struct hso_shared_int *shared_int;
201 
202 	/* rx/tx urb could be either a bulk urb or a control urb depending
203 	   on which serial port it is used on. */
204 	struct urb *rx_urb[MAX_RX_URBS];
205 	u8 num_rx_urbs;
206 	u8 *rx_data[MAX_RX_URBS];
207 	u16 rx_data_length;	/* should contain allocated length */
208 
209 	struct urb *tx_urb;
210 	u8 *tx_data;
211 	u8 *tx_buffer;
212 	u16 tx_data_length;	/* should contain allocated length */
213 	u16 tx_data_count;
214 	u16 tx_buffer_count;
215 	struct usb_ctrlrequest ctrl_req_tx;
216 	struct usb_ctrlrequest ctrl_req_rx;
217 
218 	struct usb_endpoint_descriptor *in_endp;
219 	struct usb_endpoint_descriptor *out_endp;
220 
221 	enum rx_ctrl_state rx_state;
222 	u8 rts_state;
223 	u8 dtr_state;
224 	unsigned tx_urb_used:1;
225 
226 	struct tty_port port;
227 	/* from usb_serial_port */
228 	spinlock_t serial_lock;
229 
230 	int (*write_data) (struct hso_serial *serial);
231 	struct hso_tiocmget  *tiocmget;
232 	/* Hacks required to get flow control
233 	 * working on the serial receive buffers
234 	 * so as not to drop characters on the floor.
235 	 */
236 	int  curr_rx_urb_idx;
237 	u8   rx_urb_filled[MAX_RX_URBS];
238 	struct tasklet_struct unthrottle_tasklet;
239 };
240 
241 struct hso_device {
242 	union {
243 		struct hso_serial *dev_serial;
244 		struct hso_net *dev_net;
245 	} port_data;
246 
247 	u32 port_spec;
248 
249 	u8 is_active;
250 	u8 usb_gone;
251 	struct work_struct async_get_intf;
252 	struct work_struct async_put_intf;
253 
254 	struct usb_device *usb;
255 	struct usb_interface *interface;
256 
257 	struct device *dev;
258 	struct kref ref;
259 	struct mutex mutex;
260 };
261 
262 /* Type of interface */
263 #define HSO_INTF_MASK		0xFF00
264 #define	HSO_INTF_MUX		0x0100
265 #define	HSO_INTF_BULK   	0x0200
266 
267 /* Type of port */
268 #define HSO_PORT_MASK		0xFF
269 #define HSO_PORT_NO_PORT	0x0
270 #define	HSO_PORT_CONTROL	0x1
271 #define	HSO_PORT_APP		0x2
272 #define	HSO_PORT_GPS		0x3
273 #define	HSO_PORT_PCSC		0x4
274 #define	HSO_PORT_APP2		0x5
275 #define HSO_PORT_GPS_CONTROL	0x6
276 #define HSO_PORT_MSD		0x7
277 #define HSO_PORT_VOICE		0x8
278 #define HSO_PORT_DIAG2		0x9
279 #define	HSO_PORT_DIAG		0x10
280 #define	HSO_PORT_MODEM		0x11
281 #define	HSO_PORT_NETWORK	0x12
282 
283 /* Additional device info */
284 #define HSO_INFO_MASK		0xFF000000
285 #define HSO_INFO_CRC_BUG	0x01000000
286 
287 /*****************************************************************************/
288 /* Prototypes                                                                */
289 /*****************************************************************************/
290 /* Serial driver functions */
291 static int hso_serial_tiocmset(struct tty_struct *tty,
292 			       unsigned int set, unsigned int clear);
293 static void ctrl_callback(struct urb *urb);
294 static int put_rxbuf_data(struct urb *urb, struct hso_serial *serial);
295 static void hso_kick_transmit(struct hso_serial *serial);
296 /* Helper functions */
297 static int hso_mux_submit_intr_urb(struct hso_shared_int *mux_int,
298 				   struct usb_device *usb, gfp_t gfp);
299 static void handle_usb_error(int status, const char *function,
300 			     struct hso_device *hso_dev);
301 static struct usb_endpoint_descriptor *hso_get_ep(struct usb_interface *intf,
302 						  int type, int dir);
303 static int hso_get_mux_ports(struct usb_interface *intf, unsigned char *ports);
304 static void hso_free_interface(struct usb_interface *intf);
305 static int hso_start_serial_device(struct hso_device *hso_dev, gfp_t flags);
306 static int hso_stop_serial_device(struct hso_device *hso_dev);
307 static int hso_start_net_device(struct hso_device *hso_dev);
308 static void hso_free_shared_int(struct hso_shared_int *shared_int);
309 static int hso_stop_net_device(struct hso_device *hso_dev);
310 static void hso_serial_ref_free(struct kref *ref);
311 static void hso_std_serial_read_bulk_callback(struct urb *urb);
312 static int hso_mux_serial_read(struct hso_serial *serial);
313 static void async_get_intf(struct work_struct *data);
314 static void async_put_intf(struct work_struct *data);
315 static int hso_put_activity(struct hso_device *hso_dev);
316 static int hso_get_activity(struct hso_device *hso_dev);
317 static void tiocmget_intr_callback(struct urb *urb);
318 /*****************************************************************************/
319 /* Helping functions                                                         */
320 /*****************************************************************************/
321 
322 /* #define DEBUG */
323 
324 static inline struct hso_net *dev2net(struct hso_device *hso_dev)
325 {
326 	return hso_dev->port_data.dev_net;
327 }
328 
329 static inline struct hso_serial *dev2ser(struct hso_device *hso_dev)
330 {
331 	return hso_dev->port_data.dev_serial;
332 }
333 
334 /* Debugging functions */
335 #ifdef DEBUG
336 static void dbg_dump(int line_count, const char *func_name, unsigned char *buf,
337 		     unsigned int len)
338 {
339 	static char name[255];
340 
341 	sprintf(name, "hso[%d:%s]", line_count, func_name);
342 	print_hex_dump_bytes(name, DUMP_PREFIX_NONE, buf, len);
343 }
344 
345 #define DUMP(buf_, len_)	\
346 	dbg_dump(__LINE__, __func__, (unsigned char *)buf_, len_)
347 
348 #define DUMP1(buf_, len_)			\
349 	do {					\
350 		if (0x01 & debug)		\
351 			DUMP(buf_, len_);	\
352 	} while (0)
353 #else
354 #define DUMP(buf_, len_)
355 #define DUMP1(buf_, len_)
356 #endif
357 
358 /* module parameters */
359 static int debug;
360 static int tty_major;
361 static int disable_net;
362 
363 /* driver info */
364 static const char driver_name[] = "hso";
365 static const char tty_filename[] = "ttyHS";
366 static const char *version = __FILE__ ": " MOD_AUTHOR;
367 /* the usb driver itself (registered in hso_init) */
368 static struct usb_driver hso_driver;
369 /* serial structures */
370 static struct tty_driver *tty_drv;
371 static struct hso_device *serial_table[HSO_SERIAL_TTY_MINORS];
372 static struct hso_device *network_table[HSO_MAX_NET_DEVICES];
373 static spinlock_t serial_table_lock;
374 
375 static const s32 default_port_spec[] = {
376 	HSO_INTF_MUX | HSO_PORT_NETWORK,
377 	HSO_INTF_BULK | HSO_PORT_DIAG,
378 	HSO_INTF_BULK | HSO_PORT_MODEM,
379 	0
380 };
381 
382 static const s32 icon321_port_spec[] = {
383 	HSO_INTF_MUX | HSO_PORT_NETWORK,
384 	HSO_INTF_BULK | HSO_PORT_DIAG2,
385 	HSO_INTF_BULK | HSO_PORT_MODEM,
386 	HSO_INTF_BULK | HSO_PORT_DIAG,
387 	0
388 };
389 
390 #define default_port_device(vendor, product)	\
391 	USB_DEVICE(vendor, product),	\
392 		.driver_info = (kernel_ulong_t)default_port_spec
393 
394 #define icon321_port_device(vendor, product)	\
395 	USB_DEVICE(vendor, product),	\
396 		.driver_info = (kernel_ulong_t)icon321_port_spec
397 
398 /* list of devices we support */
399 static const struct usb_device_id hso_ids[] = {
400 	{default_port_device(0x0af0, 0x6711)},
401 	{default_port_device(0x0af0, 0x6731)},
402 	{default_port_device(0x0af0, 0x6751)},
403 	{default_port_device(0x0af0, 0x6771)},
404 	{default_port_device(0x0af0, 0x6791)},
405 	{default_port_device(0x0af0, 0x6811)},
406 	{default_port_device(0x0af0, 0x6911)},
407 	{default_port_device(0x0af0, 0x6951)},
408 	{default_port_device(0x0af0, 0x6971)},
409 	{default_port_device(0x0af0, 0x7011)},
410 	{default_port_device(0x0af0, 0x7031)},
411 	{default_port_device(0x0af0, 0x7051)},
412 	{default_port_device(0x0af0, 0x7071)},
413 	{default_port_device(0x0af0, 0x7111)},
414 	{default_port_device(0x0af0, 0x7211)},
415 	{default_port_device(0x0af0, 0x7251)},
416 	{default_port_device(0x0af0, 0x7271)},
417 	{default_port_device(0x0af0, 0x7311)},
418 	{default_port_device(0x0af0, 0xc031)},	/* Icon-Edge */
419 	{icon321_port_device(0x0af0, 0xd013)},	/* Module HSxPA */
420 	{icon321_port_device(0x0af0, 0xd031)},	/* Icon-321 */
421 	{icon321_port_device(0x0af0, 0xd033)},	/* Icon-322 */
422 	{USB_DEVICE(0x0af0, 0x7301)},		/* GE40x */
423 	{USB_DEVICE(0x0af0, 0x7361)},		/* GE40x */
424 	{USB_DEVICE(0x0af0, 0x7381)},		/* GE40x */
425 	{USB_DEVICE(0x0af0, 0x7401)},		/* GI 0401 */
426 	{USB_DEVICE(0x0af0, 0x7501)},		/* GTM 382 */
427 	{USB_DEVICE(0x0af0, 0x7601)},		/* GE40x */
428 	{USB_DEVICE(0x0af0, 0x7701)},
429 	{USB_DEVICE(0x0af0, 0x7706)},
430 	{USB_DEVICE(0x0af0, 0x7801)},
431 	{USB_DEVICE(0x0af0, 0x7901)},
432 	{USB_DEVICE(0x0af0, 0x7A01)},
433 	{USB_DEVICE(0x0af0, 0x7A05)},
434 	{USB_DEVICE(0x0af0, 0x8200)},
435 	{USB_DEVICE(0x0af0, 0x8201)},
436 	{USB_DEVICE(0x0af0, 0x8300)},
437 	{USB_DEVICE(0x0af0, 0x8302)},
438 	{USB_DEVICE(0x0af0, 0x8304)},
439 	{USB_DEVICE(0x0af0, 0x8400)},
440 	{USB_DEVICE(0x0af0, 0x8600)},
441 	{USB_DEVICE(0x0af0, 0x8800)},
442 	{USB_DEVICE(0x0af0, 0x8900)},
443 	{USB_DEVICE(0x0af0, 0x9000)},
444 	{USB_DEVICE(0x0af0, 0x9200)},		/* Option GTM671WFS */
445 	{USB_DEVICE(0x0af0, 0xd035)},
446 	{USB_DEVICE(0x0af0, 0xd055)},
447 	{USB_DEVICE(0x0af0, 0xd155)},
448 	{USB_DEVICE(0x0af0, 0xd255)},
449 	{USB_DEVICE(0x0af0, 0xd057)},
450 	{USB_DEVICE(0x0af0, 0xd157)},
451 	{USB_DEVICE(0x0af0, 0xd257)},
452 	{USB_DEVICE(0x0af0, 0xd357)},
453 	{USB_DEVICE(0x0af0, 0xd058)},
454 	{USB_DEVICE(0x0af0, 0xc100)},
455 	{}
456 };
457 MODULE_DEVICE_TABLE(usb, hso_ids);
458 
459 /* Sysfs attribute */
460 static ssize_t hso_sysfs_show_porttype(struct device *dev,
461 				       struct device_attribute *attr,
462 				       char *buf)
463 {
464 	struct hso_device *hso_dev = dev_get_drvdata(dev);
465 	char *port_name;
466 
467 	if (!hso_dev)
468 		return 0;
469 
470 	switch (hso_dev->port_spec & HSO_PORT_MASK) {
471 	case HSO_PORT_CONTROL:
472 		port_name = "Control";
473 		break;
474 	case HSO_PORT_APP:
475 		port_name = "Application";
476 		break;
477 	case HSO_PORT_APP2:
478 		port_name = "Application2";
479 		break;
480 	case HSO_PORT_GPS:
481 		port_name = "GPS";
482 		break;
483 	case HSO_PORT_GPS_CONTROL:
484 		port_name = "GPS Control";
485 		break;
486 	case HSO_PORT_PCSC:
487 		port_name = "PCSC";
488 		break;
489 	case HSO_PORT_DIAG:
490 		port_name = "Diagnostic";
491 		break;
492 	case HSO_PORT_DIAG2:
493 		port_name = "Diagnostic2";
494 		break;
495 	case HSO_PORT_MODEM:
496 		port_name = "Modem";
497 		break;
498 	case HSO_PORT_NETWORK:
499 		port_name = "Network";
500 		break;
501 	default:
502 		port_name = "Unknown";
503 		break;
504 	}
505 
506 	return sprintf(buf, "%s\n", port_name);
507 }
508 static DEVICE_ATTR(hsotype, 0444, hso_sysfs_show_porttype, NULL);
509 
510 static struct attribute *hso_serial_dev_attrs[] = {
511 	&dev_attr_hsotype.attr,
512 	NULL
513 };
514 
515 ATTRIBUTE_GROUPS(hso_serial_dev);
516 
517 static int hso_urb_to_index(struct hso_serial *serial, struct urb *urb)
518 {
519 	int idx;
520 
521 	for (idx = 0; idx < serial->num_rx_urbs; idx++)
522 		if (serial->rx_urb[idx] == urb)
523 			return idx;
524 	dev_err(serial->parent->dev, "hso_urb_to_index failed\n");
525 	return -1;
526 }
527 
528 /* converts mux value to a port spec value */
529 static u32 hso_mux_to_port(int mux)
530 {
531 	u32 result;
532 
533 	switch (mux) {
534 	case 0x1:
535 		result = HSO_PORT_CONTROL;
536 		break;
537 	case 0x2:
538 		result = HSO_PORT_APP;
539 		break;
540 	case 0x4:
541 		result = HSO_PORT_PCSC;
542 		break;
543 	case 0x8:
544 		result = HSO_PORT_GPS;
545 		break;
546 	case 0x10:
547 		result = HSO_PORT_APP2;
548 		break;
549 	default:
550 		result = HSO_PORT_NO_PORT;
551 	}
552 	return result;
553 }
554 
555 /* converts port spec value to a mux value */
556 static u32 hso_port_to_mux(int port)
557 {
558 	u32 result;
559 
560 	switch (port & HSO_PORT_MASK) {
561 	case HSO_PORT_CONTROL:
562 		result = 0x0;
563 		break;
564 	case HSO_PORT_APP:
565 		result = 0x1;
566 		break;
567 	case HSO_PORT_PCSC:
568 		result = 0x2;
569 		break;
570 	case HSO_PORT_GPS:
571 		result = 0x3;
572 		break;
573 	case HSO_PORT_APP2:
574 		result = 0x4;
575 		break;
576 	default:
577 		result = 0x0;
578 	}
579 	return result;
580 }
581 
582 static struct hso_serial *get_serial_by_shared_int_and_type(
583 					struct hso_shared_int *shared_int,
584 					int mux)
585 {
586 	int i, port;
587 
588 	port = hso_mux_to_port(mux);
589 
590 	for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++) {
591 		if (serial_table[i] &&
592 		    (dev2ser(serial_table[i])->shared_int == shared_int) &&
593 		    ((serial_table[i]->port_spec & HSO_PORT_MASK) == port)) {
594 			return dev2ser(serial_table[i]);
595 		}
596 	}
597 
598 	return NULL;
599 }
600 
601 static struct hso_serial *get_serial_by_index(unsigned index)
602 {
603 	struct hso_serial *serial = NULL;
604 	unsigned long flags;
605 
606 	spin_lock_irqsave(&serial_table_lock, flags);
607 	if (serial_table[index])
608 		serial = dev2ser(serial_table[index]);
609 	spin_unlock_irqrestore(&serial_table_lock, flags);
610 
611 	return serial;
612 }
613 
614 static int get_free_serial_index(void)
615 {
616 	int index;
617 	unsigned long flags;
618 
619 	spin_lock_irqsave(&serial_table_lock, flags);
620 	for (index = 0; index < HSO_SERIAL_TTY_MINORS; index++) {
621 		if (serial_table[index] == NULL) {
622 			spin_unlock_irqrestore(&serial_table_lock, flags);
623 			return index;
624 		}
625 	}
626 	spin_unlock_irqrestore(&serial_table_lock, flags);
627 
628 	pr_err("%s: no free serial devices in table\n", __func__);
629 	return -1;
630 }
631 
632 static void set_serial_by_index(unsigned index, struct hso_serial *serial)
633 {
634 	unsigned long flags;
635 
636 	spin_lock_irqsave(&serial_table_lock, flags);
637 	if (serial)
638 		serial_table[index] = serial->parent;
639 	else
640 		serial_table[index] = NULL;
641 	spin_unlock_irqrestore(&serial_table_lock, flags);
642 }
643 
644 static void handle_usb_error(int status, const char *function,
645 			     struct hso_device *hso_dev)
646 {
647 	char *explanation;
648 
649 	switch (status) {
650 	case -ENODEV:
651 		explanation = "no device";
652 		break;
653 	case -ENOENT:
654 		explanation = "endpoint not enabled";
655 		break;
656 	case -EPIPE:
657 		explanation = "endpoint stalled";
658 		break;
659 	case -ENOSPC:
660 		explanation = "not enough bandwidth";
661 		break;
662 	case -ESHUTDOWN:
663 		explanation = "device disabled";
664 		break;
665 	case -EHOSTUNREACH:
666 		explanation = "device suspended";
667 		break;
668 	case -EINVAL:
669 	case -EAGAIN:
670 	case -EFBIG:
671 	case -EMSGSIZE:
672 		explanation = "internal error";
673 		break;
674 	case -EILSEQ:
675 	case -EPROTO:
676 	case -ETIME:
677 	case -ETIMEDOUT:
678 		explanation = "protocol error";
679 		if (hso_dev)
680 			usb_queue_reset_device(hso_dev->interface);
681 		break;
682 	default:
683 		explanation = "unknown status";
684 		break;
685 	}
686 
687 	/* log a meaningful explanation of an USB status */
688 	hso_dbg(0x1, "%s: received USB status - %s (%d)\n",
689 		function, explanation, status);
690 }
691 
692 /* Network interface functions */
693 
694 /* called when net interface is brought up by ifconfig */
695 static int hso_net_open(struct net_device *net)
696 {
697 	struct hso_net *odev = netdev_priv(net);
698 	unsigned long flags = 0;
699 
700 	if (!odev) {
701 		dev_err(&net->dev, "No net device !\n");
702 		return -ENODEV;
703 	}
704 
705 	odev->skb_tx_buf = NULL;
706 
707 	/* setup environment */
708 	spin_lock_irqsave(&odev->net_lock, flags);
709 	odev->rx_parse_state = WAIT_IP;
710 	odev->rx_buf_size = 0;
711 	odev->rx_buf_missing = sizeof(struct iphdr);
712 	spin_unlock_irqrestore(&odev->net_lock, flags);
713 
714 	/* We are up and running. */
715 	set_bit(HSO_NET_RUNNING, &odev->flags);
716 	hso_start_net_device(odev->parent);
717 
718 	/* Tell the kernel we are ready to start receiving from it */
719 	netif_start_queue(net);
720 
721 	return 0;
722 }
723 
724 /* called when interface is brought down by ifconfig */
725 static int hso_net_close(struct net_device *net)
726 {
727 	struct hso_net *odev = netdev_priv(net);
728 
729 	/* we don't need the queue anymore */
730 	netif_stop_queue(net);
731 	/* no longer running */
732 	clear_bit(HSO_NET_RUNNING, &odev->flags);
733 
734 	hso_stop_net_device(odev->parent);
735 
736 	/* done */
737 	return 0;
738 }
739 
740 /* USB tells is xmit done, we should start the netqueue again */
741 static void write_bulk_callback(struct urb *urb)
742 {
743 	struct hso_net *odev = urb->context;
744 	int status = urb->status;
745 
746 	/* Sanity check */
747 	if (!odev || !test_bit(HSO_NET_RUNNING, &odev->flags)) {
748 		dev_err(&urb->dev->dev, "%s: device not running\n", __func__);
749 		return;
750 	}
751 
752 	/* Do we still have a valid kernel network device? */
753 	if (!netif_device_present(odev->net)) {
754 		dev_err(&urb->dev->dev, "%s: net device not present\n",
755 			__func__);
756 		return;
757 	}
758 
759 	/* log status, but don't act on it, we don't need to resubmit anything
760 	 * anyhow */
761 	if (status)
762 		handle_usb_error(status, __func__, odev->parent);
763 
764 	hso_put_activity(odev->parent);
765 
766 	/* Tell the network interface we are ready for another frame */
767 	netif_wake_queue(odev->net);
768 }
769 
770 /* called by kernel when we need to transmit a packet */
771 static netdev_tx_t hso_net_start_xmit(struct sk_buff *skb,
772 					    struct net_device *net)
773 {
774 	struct hso_net *odev = netdev_priv(net);
775 	int result;
776 
777 	/* Tell the kernel, "No more frames 'til we are done with this one." */
778 	netif_stop_queue(net);
779 	if (hso_get_activity(odev->parent) == -EAGAIN) {
780 		odev->skb_tx_buf = skb;
781 		return NETDEV_TX_OK;
782 	}
783 
784 	/* log if asked */
785 	DUMP1(skb->data, skb->len);
786 	/* Copy it from kernel memory to OUR memory */
787 	memcpy(odev->mux_bulk_tx_buf, skb->data, skb->len);
788 	hso_dbg(0x1, "len: %d/%d\n", skb->len, MUX_BULK_TX_BUF_SIZE);
789 
790 	/* Fill in the URB for shipping it out. */
791 	usb_fill_bulk_urb(odev->mux_bulk_tx_urb,
792 			  odev->parent->usb,
793 			  usb_sndbulkpipe(odev->parent->usb,
794 					  odev->out_endp->
795 					  bEndpointAddress & 0x7F),
796 			  odev->mux_bulk_tx_buf, skb->len, write_bulk_callback,
797 			  odev);
798 
799 	/* Deal with the Zero Length packet problem, I hope */
800 	odev->mux_bulk_tx_urb->transfer_flags |= URB_ZERO_PACKET;
801 
802 	/* Send the URB on its merry way. */
803 	result = usb_submit_urb(odev->mux_bulk_tx_urb, GFP_ATOMIC);
804 	if (result) {
805 		dev_warn(&odev->parent->interface->dev,
806 			"failed mux_bulk_tx_urb %d\n", result);
807 		net->stats.tx_errors++;
808 		netif_start_queue(net);
809 	} else {
810 		net->stats.tx_packets++;
811 		net->stats.tx_bytes += skb->len;
812 	}
813 	dev_kfree_skb(skb);
814 	/* we're done */
815 	return NETDEV_TX_OK;
816 }
817 
818 static const struct ethtool_ops ops = {
819 	.get_link = ethtool_op_get_link
820 };
821 
822 /* called when a packet did not ack after watchdogtimeout */
823 static void hso_net_tx_timeout(struct net_device *net)
824 {
825 	struct hso_net *odev = netdev_priv(net);
826 
827 	if (!odev)
828 		return;
829 
830 	/* Tell syslog we are hosed. */
831 	dev_warn(&net->dev, "Tx timed out.\n");
832 
833 	/* Tear the waiting frame off the list */
834 	if (odev->mux_bulk_tx_urb &&
835 	    (odev->mux_bulk_tx_urb->status == -EINPROGRESS))
836 		usb_unlink_urb(odev->mux_bulk_tx_urb);
837 
838 	/* Update statistics */
839 	net->stats.tx_errors++;
840 }
841 
842 /* make a real packet from the received USB buffer */
843 static void packetizeRx(struct hso_net *odev, unsigned char *ip_pkt,
844 			unsigned int count, unsigned char is_eop)
845 {
846 	unsigned short temp_bytes;
847 	unsigned short buffer_offset = 0;
848 	unsigned short frame_len;
849 
850 	/* log if needed */
851 	hso_dbg(0x1, "Rx %d bytes\n", count);
852 	DUMP(ip_pkt, min(128, (int)count));
853 
854 	while (count) {
855 		switch (odev->rx_parse_state) {
856 		case WAIT_IP:
857 			/* waiting for IP header. */
858 			/* wanted bytes - size of ip header */
859 			temp_bytes =
860 			    (count <
861 			     odev->rx_buf_missing) ? count : odev->
862 			    rx_buf_missing;
863 
864 			memcpy(((unsigned char *)(&odev->rx_ip_hdr)) +
865 			       odev->rx_buf_size, ip_pkt + buffer_offset,
866 			       temp_bytes);
867 
868 			odev->rx_buf_size += temp_bytes;
869 			buffer_offset += temp_bytes;
870 			odev->rx_buf_missing -= temp_bytes;
871 			count -= temp_bytes;
872 
873 			if (!odev->rx_buf_missing) {
874 				/* header is complete allocate an sk_buffer and
875 				 * continue to WAIT_DATA */
876 				frame_len = ntohs(odev->rx_ip_hdr.tot_len);
877 
878 				if ((frame_len > DEFAULT_MRU) ||
879 				    (frame_len < sizeof(struct iphdr))) {
880 					dev_err(&odev->net->dev,
881 						"Invalid frame (%d) length\n",
882 						frame_len);
883 					odev->rx_parse_state = WAIT_SYNC;
884 					continue;
885 				}
886 				/* Allocate an sk_buff */
887 				odev->skb_rx_buf = netdev_alloc_skb(odev->net,
888 								    frame_len);
889 				if (!odev->skb_rx_buf) {
890 					/* We got no receive buffer. */
891 					hso_dbg(0x1, "could not allocate memory\n");
892 					odev->rx_parse_state = WAIT_SYNC;
893 					continue;
894 				}
895 
896 				/* Copy what we got so far. make room for iphdr
897 				 * after tail. */
898 				skb_put_data(odev->skb_rx_buf,
899 					     (char *)&(odev->rx_ip_hdr),
900 					     sizeof(struct iphdr));
901 
902 				/* ETH_HLEN */
903 				odev->rx_buf_size = sizeof(struct iphdr);
904 
905 				/* Filip actually use .tot_len */
906 				odev->rx_buf_missing =
907 				    frame_len - sizeof(struct iphdr);
908 				odev->rx_parse_state = WAIT_DATA;
909 			}
910 			break;
911 
912 		case WAIT_DATA:
913 			temp_bytes = (count < odev->rx_buf_missing)
914 					? count : odev->rx_buf_missing;
915 
916 			/* Copy the rest of the bytes that are left in the
917 			 * buffer into the waiting sk_buf. */
918 			/* Make room for temp_bytes after tail. */
919 			skb_put_data(odev->skb_rx_buf,
920 				     ip_pkt + buffer_offset,
921 				     temp_bytes);
922 
923 			odev->rx_buf_missing -= temp_bytes;
924 			count -= temp_bytes;
925 			buffer_offset += temp_bytes;
926 			odev->rx_buf_size += temp_bytes;
927 			if (!odev->rx_buf_missing) {
928 				/* Packet is complete. Inject into stack. */
929 				/* We have IP packet here */
930 				odev->skb_rx_buf->protocol = cpu_to_be16(ETH_P_IP);
931 				skb_reset_mac_header(odev->skb_rx_buf);
932 
933 				/* Ship it off to the kernel */
934 				netif_rx(odev->skb_rx_buf);
935 				/* No longer our buffer. */
936 				odev->skb_rx_buf = NULL;
937 
938 				/* update out statistics */
939 				odev->net->stats.rx_packets++;
940 
941 				odev->net->stats.rx_bytes += odev->rx_buf_size;
942 
943 				odev->rx_buf_size = 0;
944 				odev->rx_buf_missing = sizeof(struct iphdr);
945 				odev->rx_parse_state = WAIT_IP;
946 			}
947 			break;
948 
949 		case WAIT_SYNC:
950 			hso_dbg(0x1, " W_S\n");
951 			count = 0;
952 			break;
953 		default:
954 			hso_dbg(0x1, "\n");
955 			count--;
956 			break;
957 		}
958 	}
959 
960 	/* Recovery mechanism for WAIT_SYNC state. */
961 	if (is_eop) {
962 		if (odev->rx_parse_state == WAIT_SYNC) {
963 			odev->rx_parse_state = WAIT_IP;
964 			odev->rx_buf_size = 0;
965 			odev->rx_buf_missing = sizeof(struct iphdr);
966 		}
967 	}
968 }
969 
970 static void fix_crc_bug(struct urb *urb, __le16 max_packet_size)
971 {
972 	static const u8 crc_check[4] = { 0xDE, 0xAD, 0xBE, 0xEF };
973 	u32 rest = urb->actual_length % le16_to_cpu(max_packet_size);
974 
975 	if (((rest == 5) || (rest == 6)) &&
976 	    !memcmp(((u8 *)urb->transfer_buffer) + urb->actual_length - 4,
977 		    crc_check, 4)) {
978 		urb->actual_length -= 4;
979 	}
980 }
981 
982 /* Moving data from usb to kernel (in interrupt state) */
983 static void read_bulk_callback(struct urb *urb)
984 {
985 	struct hso_net *odev = urb->context;
986 	struct net_device *net;
987 	int result;
988 	unsigned long flags;
989 	int status = urb->status;
990 
991 	/* is al ok?  (Filip: Who's Al ?) */
992 	if (status) {
993 		handle_usb_error(status, __func__, odev->parent);
994 		return;
995 	}
996 
997 	/* Sanity check */
998 	if (!odev || !test_bit(HSO_NET_RUNNING, &odev->flags)) {
999 		hso_dbg(0x1, "BULK IN callback but driver is not active!\n");
1000 		return;
1001 	}
1002 	usb_mark_last_busy(urb->dev);
1003 
1004 	net = odev->net;
1005 
1006 	if (!netif_device_present(net)) {
1007 		/* Somebody killed our network interface... */
1008 		return;
1009 	}
1010 
1011 	if (odev->parent->port_spec & HSO_INFO_CRC_BUG)
1012 		fix_crc_bug(urb, odev->in_endp->wMaxPacketSize);
1013 
1014 	/* do we even have a packet? */
1015 	if (urb->actual_length) {
1016 		/* Handle the IP stream, add header and push it onto network
1017 		 * stack if the packet is complete. */
1018 		spin_lock_irqsave(&odev->net_lock, flags);
1019 		packetizeRx(odev, urb->transfer_buffer, urb->actual_length,
1020 			    (urb->transfer_buffer_length >
1021 			     urb->actual_length) ? 1 : 0);
1022 		spin_unlock_irqrestore(&odev->net_lock, flags);
1023 	}
1024 
1025 	/* We are done with this URB, resubmit it. Prep the USB to wait for
1026 	 * another frame. Reuse same as received. */
1027 	usb_fill_bulk_urb(urb,
1028 			  odev->parent->usb,
1029 			  usb_rcvbulkpipe(odev->parent->usb,
1030 					  odev->in_endp->
1031 					  bEndpointAddress & 0x7F),
1032 			  urb->transfer_buffer, MUX_BULK_RX_BUF_SIZE,
1033 			  read_bulk_callback, odev);
1034 
1035 	/* Give this to the USB subsystem so it can tell us when more data
1036 	 * arrives. */
1037 	result = usb_submit_urb(urb, GFP_ATOMIC);
1038 	if (result)
1039 		dev_warn(&odev->parent->interface->dev,
1040 			 "%s failed submit mux_bulk_rx_urb %d\n", __func__,
1041 			 result);
1042 }
1043 
1044 /* Serial driver functions */
1045 
1046 static void hso_init_termios(struct ktermios *termios)
1047 {
1048 	/*
1049 	 * The default requirements for this device are:
1050 	 */
1051 	termios->c_iflag &=
1052 		~(IGNBRK	/* disable ignore break */
1053 		| BRKINT	/* disable break causes interrupt */
1054 		| PARMRK	/* disable mark parity errors */
1055 		| ISTRIP	/* disable clear high bit of input characters */
1056 		| INLCR		/* disable translate NL to CR */
1057 		| IGNCR		/* disable ignore CR */
1058 		| ICRNL		/* disable translate CR to NL */
1059 		| IXON);	/* disable enable XON/XOFF flow control */
1060 
1061 	/* disable postprocess output characters */
1062 	termios->c_oflag &= ~OPOST;
1063 
1064 	termios->c_lflag &=
1065 		~(ECHO		/* disable echo input characters */
1066 		| ECHONL	/* disable echo new line */
1067 		| ICANON	/* disable erase, kill, werase, and rprnt
1068 				   special characters */
1069 		| ISIG		/* disable interrupt, quit, and suspend special
1070 				   characters */
1071 		| IEXTEN);	/* disable non-POSIX special characters */
1072 
1073 	termios->c_cflag &=
1074 		~(CSIZE		/* no size */
1075 		| PARENB	/* disable parity bit */
1076 		| CBAUD		/* clear current baud rate */
1077 		| CBAUDEX);	/* clear current buad rate */
1078 
1079 	termios->c_cflag |= CS8;	/* character size 8 bits */
1080 
1081 	/* baud rate 115200 */
1082 	tty_termios_encode_baud_rate(termios, 115200, 115200);
1083 }
1084 
1085 static void _hso_serial_set_termios(struct tty_struct *tty,
1086 				    struct ktermios *old)
1087 {
1088 	struct hso_serial *serial = tty->driver_data;
1089 
1090 	if (!serial) {
1091 		pr_err("%s: no tty structures", __func__);
1092 		return;
1093 	}
1094 
1095 	hso_dbg(0x8, "port %d\n", serial->minor);
1096 
1097 	/*
1098 	 *	Fix up unsupported bits
1099 	 */
1100 	tty->termios.c_iflag &= ~IXON; /* disable enable XON/XOFF flow control */
1101 
1102 	tty->termios.c_cflag &=
1103 		~(CSIZE		/* no size */
1104 		| PARENB	/* disable parity bit */
1105 		| CBAUD		/* clear current baud rate */
1106 		| CBAUDEX);	/* clear current buad rate */
1107 
1108 	tty->termios.c_cflag |= CS8;	/* character size 8 bits */
1109 
1110 	/* baud rate 115200 */
1111 	tty_encode_baud_rate(tty, 115200, 115200);
1112 }
1113 
1114 static void hso_resubmit_rx_bulk_urb(struct hso_serial *serial, struct urb *urb)
1115 {
1116 	int result;
1117 	/* We are done with this URB, resubmit it. Prep the USB to wait for
1118 	 * another frame */
1119 	usb_fill_bulk_urb(urb, serial->parent->usb,
1120 			  usb_rcvbulkpipe(serial->parent->usb,
1121 					  serial->in_endp->
1122 					  bEndpointAddress & 0x7F),
1123 			  urb->transfer_buffer, serial->rx_data_length,
1124 			  hso_std_serial_read_bulk_callback, serial);
1125 	/* Give this to the USB subsystem so it can tell us when more data
1126 	 * arrives. */
1127 	result = usb_submit_urb(urb, GFP_ATOMIC);
1128 	if (result) {
1129 		dev_err(&urb->dev->dev, "%s failed submit serial rx_urb %d\n",
1130 			__func__, result);
1131 	}
1132 }
1133 
1134 
1135 
1136 
1137 static void put_rxbuf_data_and_resubmit_bulk_urb(struct hso_serial *serial)
1138 {
1139 	int count;
1140 	struct urb *curr_urb;
1141 
1142 	while (serial->rx_urb_filled[serial->curr_rx_urb_idx]) {
1143 		curr_urb = serial->rx_urb[serial->curr_rx_urb_idx];
1144 		count = put_rxbuf_data(curr_urb, serial);
1145 		if (count == -1)
1146 			return;
1147 		if (count == 0) {
1148 			serial->curr_rx_urb_idx++;
1149 			if (serial->curr_rx_urb_idx >= serial->num_rx_urbs)
1150 				serial->curr_rx_urb_idx = 0;
1151 			hso_resubmit_rx_bulk_urb(serial, curr_urb);
1152 		}
1153 	}
1154 }
1155 
1156 static void put_rxbuf_data_and_resubmit_ctrl_urb(struct hso_serial *serial)
1157 {
1158 	int count = 0;
1159 	struct urb *urb;
1160 
1161 	urb = serial->rx_urb[0];
1162 	if (serial->port.count > 0) {
1163 		count = put_rxbuf_data(urb, serial);
1164 		if (count == -1)
1165 			return;
1166 	}
1167 	/* Re issue a read as long as we receive data. */
1168 
1169 	if (count == 0 && ((urb->actual_length != 0) ||
1170 			   (serial->rx_state == RX_PENDING))) {
1171 		serial->rx_state = RX_SENT;
1172 		hso_mux_serial_read(serial);
1173 	} else
1174 		serial->rx_state = RX_IDLE;
1175 }
1176 
1177 
1178 /* read callback for Diag and CS port */
1179 static void hso_std_serial_read_bulk_callback(struct urb *urb)
1180 {
1181 	struct hso_serial *serial = urb->context;
1182 	int status = urb->status;
1183 	unsigned long flags;
1184 
1185 	hso_dbg(0x8, "--- Got serial_read_bulk callback %02x ---\n", status);
1186 
1187 	/* sanity check */
1188 	if (!serial) {
1189 		hso_dbg(0x1, "serial == NULL\n");
1190 		return;
1191 	}
1192 	if (status) {
1193 		handle_usb_error(status, __func__, serial->parent);
1194 		return;
1195 	}
1196 
1197 	hso_dbg(0x1, "Actual length = %d\n", urb->actual_length);
1198 	DUMP1(urb->transfer_buffer, urb->actual_length);
1199 
1200 	/* Anyone listening? */
1201 	if (serial->port.count == 0)
1202 		return;
1203 
1204 	if (serial->parent->port_spec & HSO_INFO_CRC_BUG)
1205 		fix_crc_bug(urb, serial->in_endp->wMaxPacketSize);
1206 	/* Valid data, handle RX data */
1207 	spin_lock_irqsave(&serial->serial_lock, flags);
1208 	serial->rx_urb_filled[hso_urb_to_index(serial, urb)] = 1;
1209 	put_rxbuf_data_and_resubmit_bulk_urb(serial);
1210 	spin_unlock_irqrestore(&serial->serial_lock, flags);
1211 }
1212 
1213 /*
1214  * This needs to be a tasklet otherwise we will
1215  * end up recursively calling this function.
1216  */
1217 static void hso_unthrottle_tasklet(struct hso_serial *serial)
1218 {
1219 	unsigned long flags;
1220 
1221 	spin_lock_irqsave(&serial->serial_lock, flags);
1222 	if ((serial->parent->port_spec & HSO_INTF_MUX))
1223 		put_rxbuf_data_and_resubmit_ctrl_urb(serial);
1224 	else
1225 		put_rxbuf_data_and_resubmit_bulk_urb(serial);
1226 	spin_unlock_irqrestore(&serial->serial_lock, flags);
1227 }
1228 
1229 static	void hso_unthrottle(struct tty_struct *tty)
1230 {
1231 	struct hso_serial *serial = tty->driver_data;
1232 
1233 	tasklet_hi_schedule(&serial->unthrottle_tasklet);
1234 }
1235 
1236 /* open the requested serial port */
1237 static int hso_serial_open(struct tty_struct *tty, struct file *filp)
1238 {
1239 	struct hso_serial *serial = get_serial_by_index(tty->index);
1240 	int result;
1241 
1242 	/* sanity check */
1243 	if (serial == NULL || serial->magic != HSO_SERIAL_MAGIC) {
1244 		WARN_ON(1);
1245 		tty->driver_data = NULL;
1246 		hso_dbg(0x1, "Failed to open port\n");
1247 		return -ENODEV;
1248 	}
1249 
1250 	mutex_lock(&serial->parent->mutex);
1251 	result = usb_autopm_get_interface(serial->parent->interface);
1252 	if (result < 0)
1253 		goto err_out;
1254 
1255 	hso_dbg(0x1, "Opening %d\n", serial->minor);
1256 
1257 	/* setup */
1258 	tty->driver_data = serial;
1259 	tty_port_tty_set(&serial->port, tty);
1260 
1261 	/* check for port already opened, if not set the termios */
1262 	serial->port.count++;
1263 	if (serial->port.count == 1) {
1264 		serial->rx_state = RX_IDLE;
1265 		/* Force default termio settings */
1266 		_hso_serial_set_termios(tty, NULL);
1267 		tasklet_init(&serial->unthrottle_tasklet,
1268 			     (void (*)(unsigned long))hso_unthrottle_tasklet,
1269 			     (unsigned long)serial);
1270 		result = hso_start_serial_device(serial->parent, GFP_KERNEL);
1271 		if (result) {
1272 			hso_stop_serial_device(serial->parent);
1273 			serial->port.count--;
1274 		} else {
1275 			kref_get(&serial->parent->ref);
1276 		}
1277 	} else {
1278 		hso_dbg(0x1, "Port was already open\n");
1279 	}
1280 
1281 	usb_autopm_put_interface(serial->parent->interface);
1282 
1283 	/* done */
1284 	if (result)
1285 		hso_serial_tiocmset(tty, TIOCM_RTS | TIOCM_DTR, 0);
1286 err_out:
1287 	mutex_unlock(&serial->parent->mutex);
1288 	return result;
1289 }
1290 
1291 /* close the requested serial port */
1292 static void hso_serial_close(struct tty_struct *tty, struct file *filp)
1293 {
1294 	struct hso_serial *serial = tty->driver_data;
1295 	u8 usb_gone;
1296 
1297 	hso_dbg(0x1, "Closing serial port\n");
1298 
1299 	/* Open failed, no close cleanup required */
1300 	if (serial == NULL)
1301 		return;
1302 
1303 	mutex_lock(&serial->parent->mutex);
1304 	usb_gone = serial->parent->usb_gone;
1305 
1306 	if (!usb_gone)
1307 		usb_autopm_get_interface(serial->parent->interface);
1308 
1309 	/* reset the rts and dtr */
1310 	/* do the actual close */
1311 	serial->port.count--;
1312 
1313 	if (serial->port.count <= 0) {
1314 		serial->port.count = 0;
1315 		tty_port_tty_set(&serial->port, NULL);
1316 		if (!usb_gone)
1317 			hso_stop_serial_device(serial->parent);
1318 		tasklet_kill(&serial->unthrottle_tasklet);
1319 	}
1320 
1321 	if (!usb_gone)
1322 		usb_autopm_put_interface(serial->parent->interface);
1323 
1324 	mutex_unlock(&serial->parent->mutex);
1325 }
1326 
1327 /* close the requested serial port */
1328 static int hso_serial_write(struct tty_struct *tty, const unsigned char *buf,
1329 			    int count)
1330 {
1331 	struct hso_serial *serial = tty->driver_data;
1332 	int space, tx_bytes;
1333 	unsigned long flags;
1334 
1335 	/* sanity check */
1336 	if (serial == NULL) {
1337 		pr_err("%s: serial is NULL\n", __func__);
1338 		return -ENODEV;
1339 	}
1340 
1341 	spin_lock_irqsave(&serial->serial_lock, flags);
1342 
1343 	space = serial->tx_data_length - serial->tx_buffer_count;
1344 	tx_bytes = (count < space) ? count : space;
1345 
1346 	if (!tx_bytes)
1347 		goto out;
1348 
1349 	memcpy(serial->tx_buffer + serial->tx_buffer_count, buf, tx_bytes);
1350 	serial->tx_buffer_count += tx_bytes;
1351 
1352 out:
1353 	spin_unlock_irqrestore(&serial->serial_lock, flags);
1354 
1355 	hso_kick_transmit(serial);
1356 	/* done */
1357 	return tx_bytes;
1358 }
1359 
1360 /* how much room is there for writing */
1361 static int hso_serial_write_room(struct tty_struct *tty)
1362 {
1363 	struct hso_serial *serial = tty->driver_data;
1364 	int room;
1365 	unsigned long flags;
1366 
1367 	spin_lock_irqsave(&serial->serial_lock, flags);
1368 	room = serial->tx_data_length - serial->tx_buffer_count;
1369 	spin_unlock_irqrestore(&serial->serial_lock, flags);
1370 
1371 	/* return free room */
1372 	return room;
1373 }
1374 
1375 static void hso_serial_cleanup(struct tty_struct *tty)
1376 {
1377 	struct hso_serial *serial = tty->driver_data;
1378 
1379 	if (!serial)
1380 		return;
1381 
1382 	kref_put(&serial->parent->ref, hso_serial_ref_free);
1383 }
1384 
1385 /* setup the term */
1386 static void hso_serial_set_termios(struct tty_struct *tty, struct ktermios *old)
1387 {
1388 	struct hso_serial *serial = tty->driver_data;
1389 	unsigned long flags;
1390 
1391 	if (old)
1392 		hso_dbg(0x16, "Termios called with: cflags new[%d] - old[%d]\n",
1393 			tty->termios.c_cflag, old->c_cflag);
1394 
1395 	/* the actual setup */
1396 	spin_lock_irqsave(&serial->serial_lock, flags);
1397 	if (serial->port.count)
1398 		_hso_serial_set_termios(tty, old);
1399 	else
1400 		tty->termios = *old;
1401 	spin_unlock_irqrestore(&serial->serial_lock, flags);
1402 
1403 	/* done */
1404 }
1405 
1406 /* how many characters in the buffer */
1407 static int hso_serial_chars_in_buffer(struct tty_struct *tty)
1408 {
1409 	struct hso_serial *serial = tty->driver_data;
1410 	int chars;
1411 	unsigned long flags;
1412 
1413 	/* sanity check */
1414 	if (serial == NULL)
1415 		return 0;
1416 
1417 	spin_lock_irqsave(&serial->serial_lock, flags);
1418 	chars = serial->tx_buffer_count;
1419 	spin_unlock_irqrestore(&serial->serial_lock, flags);
1420 
1421 	return chars;
1422 }
1423 static int tiocmget_submit_urb(struct hso_serial *serial,
1424 			       struct hso_tiocmget *tiocmget,
1425 			       struct usb_device *usb)
1426 {
1427 	int result;
1428 
1429 	if (serial->parent->usb_gone)
1430 		return -ENODEV;
1431 	usb_fill_int_urb(tiocmget->urb, usb,
1432 			 usb_rcvintpipe(usb,
1433 					tiocmget->endp->
1434 					bEndpointAddress & 0x7F),
1435 			 &tiocmget->serial_state_notification,
1436 			 sizeof(struct hso_serial_state_notification),
1437 			 tiocmget_intr_callback, serial,
1438 			 tiocmget->endp->bInterval);
1439 	result = usb_submit_urb(tiocmget->urb, GFP_ATOMIC);
1440 	if (result) {
1441 		dev_warn(&usb->dev, "%s usb_submit_urb failed %d\n", __func__,
1442 			 result);
1443 	}
1444 	return result;
1445 
1446 }
1447 
1448 static void tiocmget_intr_callback(struct urb *urb)
1449 {
1450 	struct hso_serial *serial = urb->context;
1451 	struct hso_tiocmget *tiocmget;
1452 	int status = urb->status;
1453 	u16 UART_state_bitmap, prev_UART_state_bitmap;
1454 	struct uart_icount *icount;
1455 	struct hso_serial_state_notification *serial_state_notification;
1456 	struct usb_device *usb;
1457 	struct usb_interface *interface;
1458 	int if_num;
1459 
1460 	/* Sanity checks */
1461 	if (!serial)
1462 		return;
1463 	if (status) {
1464 		handle_usb_error(status, __func__, serial->parent);
1465 		return;
1466 	}
1467 
1468 	/* tiocmget is only supported on HSO_PORT_MODEM */
1469 	tiocmget = serial->tiocmget;
1470 	if (!tiocmget)
1471 		return;
1472 	BUG_ON((serial->parent->port_spec & HSO_PORT_MASK) != HSO_PORT_MODEM);
1473 
1474 	usb = serial->parent->usb;
1475 	interface = serial->parent->interface;
1476 
1477 	if_num = interface->cur_altsetting->desc.bInterfaceNumber;
1478 
1479 	/* wIndex should be the USB interface number of the port to which the
1480 	 * notification applies, which should always be the Modem port.
1481 	 */
1482 	serial_state_notification = &tiocmget->serial_state_notification;
1483 	if (serial_state_notification->bmRequestType != BM_REQUEST_TYPE ||
1484 	    serial_state_notification->bNotification != B_NOTIFICATION ||
1485 	    le16_to_cpu(serial_state_notification->wValue) != W_VALUE ||
1486 	    le16_to_cpu(serial_state_notification->wIndex) != if_num ||
1487 	    le16_to_cpu(serial_state_notification->wLength) != W_LENGTH) {
1488 		dev_warn(&usb->dev,
1489 			 "hso received invalid serial state notification\n");
1490 		DUMP(serial_state_notification,
1491 		     sizeof(struct hso_serial_state_notification));
1492 	} else {
1493 		unsigned long flags;
1494 
1495 		UART_state_bitmap = le16_to_cpu(serial_state_notification->
1496 						UART_state_bitmap);
1497 		prev_UART_state_bitmap = tiocmget->prev_UART_state_bitmap;
1498 		icount = &tiocmget->icount;
1499 		spin_lock_irqsave(&serial->serial_lock, flags);
1500 		if ((UART_state_bitmap & B_OVERRUN) !=
1501 		   (prev_UART_state_bitmap & B_OVERRUN))
1502 			icount->parity++;
1503 		if ((UART_state_bitmap & B_PARITY) !=
1504 		   (prev_UART_state_bitmap & B_PARITY))
1505 			icount->parity++;
1506 		if ((UART_state_bitmap & B_FRAMING) !=
1507 		   (prev_UART_state_bitmap & B_FRAMING))
1508 			icount->frame++;
1509 		if ((UART_state_bitmap & B_RING_SIGNAL) &&
1510 		   !(prev_UART_state_bitmap & B_RING_SIGNAL))
1511 			icount->rng++;
1512 		if ((UART_state_bitmap & B_BREAK) !=
1513 		   (prev_UART_state_bitmap & B_BREAK))
1514 			icount->brk++;
1515 		if ((UART_state_bitmap & B_TX_CARRIER) !=
1516 		   (prev_UART_state_bitmap & B_TX_CARRIER))
1517 			icount->dsr++;
1518 		if ((UART_state_bitmap & B_RX_CARRIER) !=
1519 		   (prev_UART_state_bitmap & B_RX_CARRIER))
1520 			icount->dcd++;
1521 		tiocmget->prev_UART_state_bitmap = UART_state_bitmap;
1522 		spin_unlock_irqrestore(&serial->serial_lock, flags);
1523 		tiocmget->intr_completed = 1;
1524 		wake_up_interruptible(&tiocmget->waitq);
1525 	}
1526 	memset(serial_state_notification, 0,
1527 	       sizeof(struct hso_serial_state_notification));
1528 	tiocmget_submit_urb(serial,
1529 			    tiocmget,
1530 			    serial->parent->usb);
1531 }
1532 
1533 /*
1534  * next few functions largely stolen from drivers/serial/serial_core.c
1535  */
1536 /* Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
1537  * - mask passed in arg for lines of interest
1538  *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
1539  * Caller should use TIOCGICOUNT to see which one it was
1540  */
1541 static int
1542 hso_wait_modem_status(struct hso_serial *serial, unsigned long arg)
1543 {
1544 	DECLARE_WAITQUEUE(wait, current);
1545 	struct uart_icount cprev, cnow;
1546 	struct hso_tiocmget  *tiocmget;
1547 	int ret;
1548 
1549 	tiocmget = serial->tiocmget;
1550 	if (!tiocmget)
1551 		return -ENOENT;
1552 	/*
1553 	 * note the counters on entry
1554 	 */
1555 	spin_lock_irq(&serial->serial_lock);
1556 	memcpy(&cprev, &tiocmget->icount, sizeof(struct uart_icount));
1557 	spin_unlock_irq(&serial->serial_lock);
1558 	add_wait_queue(&tiocmget->waitq, &wait);
1559 	for (;;) {
1560 		spin_lock_irq(&serial->serial_lock);
1561 		memcpy(&cnow, &tiocmget->icount, sizeof(struct uart_icount));
1562 		spin_unlock_irq(&serial->serial_lock);
1563 		set_current_state(TASK_INTERRUPTIBLE);
1564 		if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
1565 		    ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
1566 		    ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd))) {
1567 			ret = 0;
1568 			break;
1569 		}
1570 		schedule();
1571 		/* see if a signal did it */
1572 		if (signal_pending(current)) {
1573 			ret = -ERESTARTSYS;
1574 			break;
1575 		}
1576 		cprev = cnow;
1577 	}
1578 	__set_current_state(TASK_RUNNING);
1579 	remove_wait_queue(&tiocmget->waitq, &wait);
1580 
1581 	return ret;
1582 }
1583 
1584 /*
1585  * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
1586  * Return: write counters to the user passed counter struct
1587  * NB: both 1->0 and 0->1 transitions are counted except for
1588  *     RI where only 0->1 is counted.
1589  */
1590 static int hso_get_count(struct tty_struct *tty,
1591 		  struct serial_icounter_struct *icount)
1592 {
1593 	struct uart_icount cnow;
1594 	struct hso_serial *serial = tty->driver_data;
1595 	struct hso_tiocmget  *tiocmget = serial->tiocmget;
1596 
1597 	memset(icount, 0, sizeof(struct serial_icounter_struct));
1598 
1599 	if (!tiocmget)
1600 		 return -ENOENT;
1601 	spin_lock_irq(&serial->serial_lock);
1602 	memcpy(&cnow, &tiocmget->icount, sizeof(struct uart_icount));
1603 	spin_unlock_irq(&serial->serial_lock);
1604 
1605 	icount->cts         = cnow.cts;
1606 	icount->dsr         = cnow.dsr;
1607 	icount->rng         = cnow.rng;
1608 	icount->dcd         = cnow.dcd;
1609 	icount->rx          = cnow.rx;
1610 	icount->tx          = cnow.tx;
1611 	icount->frame       = cnow.frame;
1612 	icount->overrun     = cnow.overrun;
1613 	icount->parity      = cnow.parity;
1614 	icount->brk         = cnow.brk;
1615 	icount->buf_overrun = cnow.buf_overrun;
1616 
1617 	return 0;
1618 }
1619 
1620 
1621 static int hso_serial_tiocmget(struct tty_struct *tty)
1622 {
1623 	int retval;
1624 	struct hso_serial *serial = tty->driver_data;
1625 	struct hso_tiocmget  *tiocmget;
1626 	u16 UART_state_bitmap;
1627 
1628 	/* sanity check */
1629 	if (!serial) {
1630 		hso_dbg(0x1, "no tty structures\n");
1631 		return -EINVAL;
1632 	}
1633 	spin_lock_irq(&serial->serial_lock);
1634 	retval = ((serial->rts_state) ? TIOCM_RTS : 0) |
1635 	    ((serial->dtr_state) ? TIOCM_DTR : 0);
1636 	tiocmget = serial->tiocmget;
1637 	if (tiocmget) {
1638 
1639 		UART_state_bitmap = le16_to_cpu(
1640 			tiocmget->prev_UART_state_bitmap);
1641 		if (UART_state_bitmap & B_RING_SIGNAL)
1642 			retval |=  TIOCM_RNG;
1643 		if (UART_state_bitmap & B_RX_CARRIER)
1644 			retval |=  TIOCM_CD;
1645 		if (UART_state_bitmap & B_TX_CARRIER)
1646 			retval |=  TIOCM_DSR;
1647 	}
1648 	spin_unlock_irq(&serial->serial_lock);
1649 	return retval;
1650 }
1651 
1652 static int hso_serial_tiocmset(struct tty_struct *tty,
1653 			       unsigned int set, unsigned int clear)
1654 {
1655 	int val = 0;
1656 	unsigned long flags;
1657 	int if_num;
1658 	struct hso_serial *serial = tty->driver_data;
1659 	struct usb_interface *interface;
1660 
1661 	/* sanity check */
1662 	if (!serial) {
1663 		hso_dbg(0x1, "no tty structures\n");
1664 		return -EINVAL;
1665 	}
1666 
1667 	if ((serial->parent->port_spec & HSO_PORT_MASK) != HSO_PORT_MODEM)
1668 		return -EINVAL;
1669 
1670 	interface = serial->parent->interface;
1671 	if_num = interface->cur_altsetting->desc.bInterfaceNumber;
1672 
1673 	spin_lock_irqsave(&serial->serial_lock, flags);
1674 	if (set & TIOCM_RTS)
1675 		serial->rts_state = 1;
1676 	if (set & TIOCM_DTR)
1677 		serial->dtr_state = 1;
1678 
1679 	if (clear & TIOCM_RTS)
1680 		serial->rts_state = 0;
1681 	if (clear & TIOCM_DTR)
1682 		serial->dtr_state = 0;
1683 
1684 	if (serial->dtr_state)
1685 		val |= 0x01;
1686 	if (serial->rts_state)
1687 		val |= 0x02;
1688 
1689 	spin_unlock_irqrestore(&serial->serial_lock, flags);
1690 
1691 	return usb_control_msg(serial->parent->usb,
1692 			       usb_rcvctrlpipe(serial->parent->usb, 0), 0x22,
1693 			       0x21, val, if_num, NULL, 0,
1694 			       USB_CTRL_SET_TIMEOUT);
1695 }
1696 
1697 static int hso_serial_ioctl(struct tty_struct *tty,
1698 			    unsigned int cmd, unsigned long arg)
1699 {
1700 	struct hso_serial *serial = tty->driver_data;
1701 	int ret = 0;
1702 	hso_dbg(0x8, "IOCTL cmd: %d, arg: %ld\n", cmd, arg);
1703 
1704 	if (!serial)
1705 		return -ENODEV;
1706 	switch (cmd) {
1707 	case TIOCMIWAIT:
1708 		ret = hso_wait_modem_status(serial, arg);
1709 		break;
1710 	default:
1711 		ret = -ENOIOCTLCMD;
1712 		break;
1713 	}
1714 	return ret;
1715 }
1716 
1717 
1718 /* starts a transmit */
1719 static void hso_kick_transmit(struct hso_serial *serial)
1720 {
1721 	unsigned long flags;
1722 	int res;
1723 
1724 	spin_lock_irqsave(&serial->serial_lock, flags);
1725 	if (!serial->tx_buffer_count)
1726 		goto out;
1727 
1728 	if (serial->tx_urb_used)
1729 		goto out;
1730 
1731 	/* Wakeup USB interface if necessary */
1732 	if (hso_get_activity(serial->parent) == -EAGAIN)
1733 		goto out;
1734 
1735 	/* Switch pointers around to avoid memcpy */
1736 	swap(serial->tx_buffer, serial->tx_data);
1737 	serial->tx_data_count = serial->tx_buffer_count;
1738 	serial->tx_buffer_count = 0;
1739 
1740 	/* If serial->tx_data is set, it means we switched buffers */
1741 	if (serial->tx_data && serial->write_data) {
1742 		res = serial->write_data(serial);
1743 		if (res >= 0)
1744 			serial->tx_urb_used = 1;
1745 	}
1746 out:
1747 	spin_unlock_irqrestore(&serial->serial_lock, flags);
1748 }
1749 
1750 /* make a request (for reading and writing data to muxed serial port) */
1751 static int mux_device_request(struct hso_serial *serial, u8 type, u16 port,
1752 			      struct urb *ctrl_urb,
1753 			      struct usb_ctrlrequest *ctrl_req,
1754 			      u8 *ctrl_urb_data, u32 size)
1755 {
1756 	int result;
1757 	int pipe;
1758 
1759 	/* Sanity check */
1760 	if (!serial || !ctrl_urb || !ctrl_req) {
1761 		pr_err("%s: Wrong arguments\n", __func__);
1762 		return -EINVAL;
1763 	}
1764 
1765 	/* initialize */
1766 	ctrl_req->wValue = 0;
1767 	ctrl_req->wIndex = cpu_to_le16(hso_port_to_mux(port));
1768 	ctrl_req->wLength = cpu_to_le16(size);
1769 
1770 	if (type == USB_CDC_GET_ENCAPSULATED_RESPONSE) {
1771 		/* Reading command */
1772 		ctrl_req->bRequestType = USB_DIR_IN |
1773 					 USB_TYPE_OPTION_VENDOR |
1774 					 USB_RECIP_INTERFACE;
1775 		ctrl_req->bRequest = USB_CDC_GET_ENCAPSULATED_RESPONSE;
1776 		pipe = usb_rcvctrlpipe(serial->parent->usb, 0);
1777 	} else {
1778 		/* Writing command */
1779 		ctrl_req->bRequestType = USB_DIR_OUT |
1780 					 USB_TYPE_OPTION_VENDOR |
1781 					 USB_RECIP_INTERFACE;
1782 		ctrl_req->bRequest = USB_CDC_SEND_ENCAPSULATED_COMMAND;
1783 		pipe = usb_sndctrlpipe(serial->parent->usb, 0);
1784 	}
1785 	/* syslog */
1786 	hso_dbg(0x2, "%s command (%02x) len: %d, port: %d\n",
1787 		type == USB_CDC_GET_ENCAPSULATED_RESPONSE ? "Read" : "Write",
1788 		ctrl_req->bRequestType, ctrl_req->wLength, port);
1789 
1790 	/* Load ctrl urb */
1791 	ctrl_urb->transfer_flags = 0;
1792 	usb_fill_control_urb(ctrl_urb,
1793 			     serial->parent->usb,
1794 			     pipe,
1795 			     (u8 *) ctrl_req,
1796 			     ctrl_urb_data, size, ctrl_callback, serial);
1797 	/* Send it on merry way */
1798 	result = usb_submit_urb(ctrl_urb, GFP_ATOMIC);
1799 	if (result) {
1800 		dev_err(&ctrl_urb->dev->dev,
1801 			"%s failed submit ctrl_urb %d type %d\n", __func__,
1802 			result, type);
1803 		return result;
1804 	}
1805 
1806 	/* done */
1807 	return size;
1808 }
1809 
1810 /* called by intr_callback when read occurs */
1811 static int hso_mux_serial_read(struct hso_serial *serial)
1812 {
1813 	if (!serial)
1814 		return -EINVAL;
1815 
1816 	/* clean data */
1817 	memset(serial->rx_data[0], 0, CTRL_URB_RX_SIZE);
1818 	/* make the request */
1819 
1820 	if (serial->num_rx_urbs != 1) {
1821 		dev_err(&serial->parent->interface->dev,
1822 			"ERROR: mux'd reads with multiple buffers "
1823 			"not possible\n");
1824 		return 0;
1825 	}
1826 	return mux_device_request(serial,
1827 				  USB_CDC_GET_ENCAPSULATED_RESPONSE,
1828 				  serial->parent->port_spec & HSO_PORT_MASK,
1829 				  serial->rx_urb[0],
1830 				  &serial->ctrl_req_rx,
1831 				  serial->rx_data[0], serial->rx_data_length);
1832 }
1833 
1834 /* used for muxed serial port callback (muxed serial read) */
1835 static void intr_callback(struct urb *urb)
1836 {
1837 	struct hso_shared_int *shared_int = urb->context;
1838 	struct hso_serial *serial;
1839 	unsigned char *port_req;
1840 	int status = urb->status;
1841 	unsigned long flags;
1842 	int i;
1843 
1844 	usb_mark_last_busy(urb->dev);
1845 
1846 	/* sanity check */
1847 	if (!shared_int)
1848 		return;
1849 
1850 	/* status check */
1851 	if (status) {
1852 		handle_usb_error(status, __func__, NULL);
1853 		return;
1854 	}
1855 	hso_dbg(0x8, "--- Got intr callback 0x%02X ---\n", status);
1856 
1857 	/* what request? */
1858 	port_req = urb->transfer_buffer;
1859 	hso_dbg(0x8, "port_req = 0x%.2X\n", *port_req);
1860 	/* loop over all muxed ports to find the one sending this */
1861 	for (i = 0; i < 8; i++) {
1862 		/* max 8 channels on MUX */
1863 		if (*port_req & (1 << i)) {
1864 			serial = get_serial_by_shared_int_and_type(shared_int,
1865 								   (1 << i));
1866 			if (serial != NULL) {
1867 				hso_dbg(0x1, "Pending read interrupt on port %d\n",
1868 					i);
1869 				spin_lock_irqsave(&serial->serial_lock, flags);
1870 				if (serial->rx_state == RX_IDLE &&
1871 					serial->port.count > 0) {
1872 					/* Setup and send a ctrl req read on
1873 					 * port i */
1874 					if (!serial->rx_urb_filled[0]) {
1875 						serial->rx_state = RX_SENT;
1876 						hso_mux_serial_read(serial);
1877 					} else
1878 						serial->rx_state = RX_PENDING;
1879 				} else {
1880 					hso_dbg(0x1, "Already a read pending on port %d or port not open\n",
1881 						i);
1882 				}
1883 				spin_unlock_irqrestore(&serial->serial_lock,
1884 						       flags);
1885 			}
1886 		}
1887 	}
1888 	/* Resubmit interrupt urb */
1889 	hso_mux_submit_intr_urb(shared_int, urb->dev, GFP_ATOMIC);
1890 }
1891 
1892 /* called for writing to muxed serial port */
1893 static int hso_mux_serial_write_data(struct hso_serial *serial)
1894 {
1895 	if (NULL == serial)
1896 		return -EINVAL;
1897 
1898 	return mux_device_request(serial,
1899 				  USB_CDC_SEND_ENCAPSULATED_COMMAND,
1900 				  serial->parent->port_spec & HSO_PORT_MASK,
1901 				  serial->tx_urb,
1902 				  &serial->ctrl_req_tx,
1903 				  serial->tx_data, serial->tx_data_count);
1904 }
1905 
1906 /* write callback for Diag and CS port */
1907 static void hso_std_serial_write_bulk_callback(struct urb *urb)
1908 {
1909 	struct hso_serial *serial = urb->context;
1910 	int status = urb->status;
1911 	unsigned long flags;
1912 
1913 	/* sanity check */
1914 	if (!serial) {
1915 		hso_dbg(0x1, "serial == NULL\n");
1916 		return;
1917 	}
1918 
1919 	spin_lock_irqsave(&serial->serial_lock, flags);
1920 	serial->tx_urb_used = 0;
1921 	spin_unlock_irqrestore(&serial->serial_lock, flags);
1922 	if (status) {
1923 		handle_usb_error(status, __func__, serial->parent);
1924 		return;
1925 	}
1926 	hso_put_activity(serial->parent);
1927 	tty_port_tty_wakeup(&serial->port);
1928 	hso_kick_transmit(serial);
1929 
1930 	hso_dbg(0x1, "\n");
1931 }
1932 
1933 /* called for writing diag or CS serial port */
1934 static int hso_std_serial_write_data(struct hso_serial *serial)
1935 {
1936 	int count = serial->tx_data_count;
1937 	int result;
1938 
1939 	usb_fill_bulk_urb(serial->tx_urb,
1940 			  serial->parent->usb,
1941 			  usb_sndbulkpipe(serial->parent->usb,
1942 					  serial->out_endp->
1943 					  bEndpointAddress & 0x7F),
1944 			  serial->tx_data, serial->tx_data_count,
1945 			  hso_std_serial_write_bulk_callback, serial);
1946 
1947 	result = usb_submit_urb(serial->tx_urb, GFP_ATOMIC);
1948 	if (result) {
1949 		dev_warn(&serial->parent->usb->dev,
1950 			 "Failed to submit urb - res %d\n", result);
1951 		return result;
1952 	}
1953 
1954 	return count;
1955 }
1956 
1957 /* callback after read or write on muxed serial port */
1958 static void ctrl_callback(struct urb *urb)
1959 {
1960 	struct hso_serial *serial = urb->context;
1961 	struct usb_ctrlrequest *req;
1962 	int status = urb->status;
1963 	unsigned long flags;
1964 
1965 	/* sanity check */
1966 	if (!serial)
1967 		return;
1968 
1969 	spin_lock_irqsave(&serial->serial_lock, flags);
1970 	serial->tx_urb_used = 0;
1971 	spin_unlock_irqrestore(&serial->serial_lock, flags);
1972 	if (status) {
1973 		handle_usb_error(status, __func__, serial->parent);
1974 		return;
1975 	}
1976 
1977 	/* what request? */
1978 	req = (struct usb_ctrlrequest *)(urb->setup_packet);
1979 	hso_dbg(0x8, "--- Got muxed ctrl callback 0x%02X ---\n", status);
1980 	hso_dbg(0x8, "Actual length of urb = %d\n", urb->actual_length);
1981 	DUMP1(urb->transfer_buffer, urb->actual_length);
1982 
1983 	if (req->bRequestType ==
1984 	    (USB_DIR_IN | USB_TYPE_OPTION_VENDOR | USB_RECIP_INTERFACE)) {
1985 		/* response to a read command */
1986 		serial->rx_urb_filled[0] = 1;
1987 		spin_lock_irqsave(&serial->serial_lock, flags);
1988 		put_rxbuf_data_and_resubmit_ctrl_urb(serial);
1989 		spin_unlock_irqrestore(&serial->serial_lock, flags);
1990 	} else {
1991 		hso_put_activity(serial->parent);
1992 		tty_port_tty_wakeup(&serial->port);
1993 		/* response to a write command */
1994 		hso_kick_transmit(serial);
1995 	}
1996 }
1997 
1998 /* handle RX data for serial port */
1999 static int put_rxbuf_data(struct urb *urb, struct hso_serial *serial)
2000 {
2001 	struct tty_struct *tty;
2002 	int count;
2003 
2004 	/* Sanity check */
2005 	if (urb == NULL || serial == NULL) {
2006 		hso_dbg(0x1, "serial = NULL\n");
2007 		return -2;
2008 	}
2009 
2010 	tty = tty_port_tty_get(&serial->port);
2011 
2012 	if (tty && tty_throttled(tty)) {
2013 		tty_kref_put(tty);
2014 		return -1;
2015 	}
2016 
2017 	/* Push data to tty */
2018 	hso_dbg(0x1, "data to push to tty\n");
2019 	count = tty_buffer_request_room(&serial->port, urb->actual_length);
2020 	if (count >= urb->actual_length) {
2021 		tty_insert_flip_string(&serial->port, urb->transfer_buffer,
2022 				       urb->actual_length);
2023 		tty_flip_buffer_push(&serial->port);
2024 	} else {
2025 		dev_warn(&serial->parent->usb->dev,
2026 			 "dropping data, %d bytes lost\n", urb->actual_length);
2027 	}
2028 
2029 	tty_kref_put(tty);
2030 
2031 	serial->rx_urb_filled[hso_urb_to_index(serial, urb)] = 0;
2032 
2033 	return 0;
2034 }
2035 
2036 
2037 /* Base driver functions */
2038 
2039 static void hso_log_port(struct hso_device *hso_dev)
2040 {
2041 	char *port_type;
2042 	char port_dev[20];
2043 
2044 	switch (hso_dev->port_spec & HSO_PORT_MASK) {
2045 	case HSO_PORT_CONTROL:
2046 		port_type = "Control";
2047 		break;
2048 	case HSO_PORT_APP:
2049 		port_type = "Application";
2050 		break;
2051 	case HSO_PORT_GPS:
2052 		port_type = "GPS";
2053 		break;
2054 	case HSO_PORT_GPS_CONTROL:
2055 		port_type = "GPS control";
2056 		break;
2057 	case HSO_PORT_APP2:
2058 		port_type = "Application2";
2059 		break;
2060 	case HSO_PORT_PCSC:
2061 		port_type = "PCSC";
2062 		break;
2063 	case HSO_PORT_DIAG:
2064 		port_type = "Diagnostic";
2065 		break;
2066 	case HSO_PORT_DIAG2:
2067 		port_type = "Diagnostic2";
2068 		break;
2069 	case HSO_PORT_MODEM:
2070 		port_type = "Modem";
2071 		break;
2072 	case HSO_PORT_NETWORK:
2073 		port_type = "Network";
2074 		break;
2075 	default:
2076 		port_type = "Unknown";
2077 		break;
2078 	}
2079 	if ((hso_dev->port_spec & HSO_PORT_MASK) == HSO_PORT_NETWORK) {
2080 		sprintf(port_dev, "%s", dev2net(hso_dev)->net->name);
2081 	} else
2082 		sprintf(port_dev, "/dev/%s%d", tty_filename,
2083 			dev2ser(hso_dev)->minor);
2084 
2085 	dev_dbg(&hso_dev->interface->dev, "HSO: Found %s port %s\n",
2086 		port_type, port_dev);
2087 }
2088 
2089 static int hso_start_net_device(struct hso_device *hso_dev)
2090 {
2091 	int i, result = 0;
2092 	struct hso_net *hso_net = dev2net(hso_dev);
2093 
2094 	if (!hso_net)
2095 		return -ENODEV;
2096 
2097 	/* send URBs for all read buffers */
2098 	for (i = 0; i < MUX_BULK_RX_BUF_COUNT; i++) {
2099 
2100 		/* Prep a receive URB */
2101 		usb_fill_bulk_urb(hso_net->mux_bulk_rx_urb_pool[i],
2102 				  hso_dev->usb,
2103 				  usb_rcvbulkpipe(hso_dev->usb,
2104 						  hso_net->in_endp->
2105 						  bEndpointAddress & 0x7F),
2106 				  hso_net->mux_bulk_rx_buf_pool[i],
2107 				  MUX_BULK_RX_BUF_SIZE, read_bulk_callback,
2108 				  hso_net);
2109 
2110 		/* Put it out there so the device can send us stuff */
2111 		result = usb_submit_urb(hso_net->mux_bulk_rx_urb_pool[i],
2112 					GFP_NOIO);
2113 		if (result)
2114 			dev_warn(&hso_dev->usb->dev,
2115 				"%s failed mux_bulk_rx_urb[%d] %d\n", __func__,
2116 				i, result);
2117 	}
2118 
2119 	return result;
2120 }
2121 
2122 static int hso_stop_net_device(struct hso_device *hso_dev)
2123 {
2124 	int i;
2125 	struct hso_net *hso_net = dev2net(hso_dev);
2126 
2127 	if (!hso_net)
2128 		return -ENODEV;
2129 
2130 	for (i = 0; i < MUX_BULK_RX_BUF_COUNT; i++) {
2131 		if (hso_net->mux_bulk_rx_urb_pool[i])
2132 			usb_kill_urb(hso_net->mux_bulk_rx_urb_pool[i]);
2133 
2134 	}
2135 	if (hso_net->mux_bulk_tx_urb)
2136 		usb_kill_urb(hso_net->mux_bulk_tx_urb);
2137 
2138 	return 0;
2139 }
2140 
2141 static int hso_start_serial_device(struct hso_device *hso_dev, gfp_t flags)
2142 {
2143 	int i, result = 0;
2144 	struct hso_serial *serial = dev2ser(hso_dev);
2145 
2146 	if (!serial)
2147 		return -ENODEV;
2148 
2149 	/* If it is not the MUX port fill in and submit a bulk urb (already
2150 	 * allocated in hso_serial_start) */
2151 	if (!(serial->parent->port_spec & HSO_INTF_MUX)) {
2152 		for (i = 0; i < serial->num_rx_urbs; i++) {
2153 			usb_fill_bulk_urb(serial->rx_urb[i],
2154 					  serial->parent->usb,
2155 					  usb_rcvbulkpipe(serial->parent->usb,
2156 							  serial->in_endp->
2157 							  bEndpointAddress &
2158 							  0x7F),
2159 					  serial->rx_data[i],
2160 					  serial->rx_data_length,
2161 					  hso_std_serial_read_bulk_callback,
2162 					  serial);
2163 			result = usb_submit_urb(serial->rx_urb[i], flags);
2164 			if (result) {
2165 				dev_warn(&serial->parent->usb->dev,
2166 					 "Failed to submit urb - res %d\n",
2167 					 result);
2168 				break;
2169 			}
2170 		}
2171 	} else {
2172 		mutex_lock(&serial->shared_int->shared_int_lock);
2173 		if (!serial->shared_int->use_count) {
2174 			result =
2175 			    hso_mux_submit_intr_urb(serial->shared_int,
2176 						    hso_dev->usb, flags);
2177 		}
2178 		serial->shared_int->use_count++;
2179 		mutex_unlock(&serial->shared_int->shared_int_lock);
2180 	}
2181 	if (serial->tiocmget)
2182 		tiocmget_submit_urb(serial,
2183 				    serial->tiocmget,
2184 				    serial->parent->usb);
2185 	return result;
2186 }
2187 
2188 static int hso_stop_serial_device(struct hso_device *hso_dev)
2189 {
2190 	int i;
2191 	struct hso_serial *serial = dev2ser(hso_dev);
2192 	struct hso_tiocmget  *tiocmget;
2193 
2194 	if (!serial)
2195 		return -ENODEV;
2196 
2197 	for (i = 0; i < serial->num_rx_urbs; i++) {
2198 		if (serial->rx_urb[i]) {
2199 			usb_kill_urb(serial->rx_urb[i]);
2200 			serial->rx_urb_filled[i] = 0;
2201 		}
2202 	}
2203 	serial->curr_rx_urb_idx = 0;
2204 
2205 	if (serial->tx_urb)
2206 		usb_kill_urb(serial->tx_urb);
2207 
2208 	if (serial->shared_int) {
2209 		mutex_lock(&serial->shared_int->shared_int_lock);
2210 		if (serial->shared_int->use_count &&
2211 		    (--serial->shared_int->use_count == 0)) {
2212 			struct urb *urb;
2213 
2214 			urb = serial->shared_int->shared_intr_urb;
2215 			if (urb)
2216 				usb_kill_urb(urb);
2217 		}
2218 		mutex_unlock(&serial->shared_int->shared_int_lock);
2219 	}
2220 	tiocmget = serial->tiocmget;
2221 	if (tiocmget) {
2222 		wake_up_interruptible(&tiocmget->waitq);
2223 		usb_kill_urb(tiocmget->urb);
2224 	}
2225 
2226 	return 0;
2227 }
2228 
2229 static void hso_serial_tty_unregister(struct hso_serial *serial)
2230 {
2231 	tty_unregister_device(tty_drv, serial->minor);
2232 }
2233 
2234 static void hso_serial_common_free(struct hso_serial *serial)
2235 {
2236 	int i;
2237 
2238 	for (i = 0; i < serial->num_rx_urbs; i++) {
2239 		/* unlink and free RX URB */
2240 		usb_free_urb(serial->rx_urb[i]);
2241 		/* free the RX buffer */
2242 		kfree(serial->rx_data[i]);
2243 	}
2244 
2245 	/* unlink and free TX URB */
2246 	usb_free_urb(serial->tx_urb);
2247 	kfree(serial->tx_buffer);
2248 	kfree(serial->tx_data);
2249 	tty_port_destroy(&serial->port);
2250 }
2251 
2252 static int hso_serial_common_create(struct hso_serial *serial, int num_urbs,
2253 				    int rx_size, int tx_size)
2254 {
2255 	int minor;
2256 	int i;
2257 
2258 	tty_port_init(&serial->port);
2259 
2260 	minor = get_free_serial_index();
2261 	if (minor < 0)
2262 		goto exit;
2263 
2264 	/* register our minor number */
2265 	serial->parent->dev = tty_port_register_device_attr(&serial->port,
2266 			tty_drv, minor, &serial->parent->interface->dev,
2267 			serial->parent, hso_serial_dev_groups);
2268 
2269 	/* fill in specific data for later use */
2270 	serial->minor = minor;
2271 	serial->magic = HSO_SERIAL_MAGIC;
2272 	spin_lock_init(&serial->serial_lock);
2273 	serial->num_rx_urbs = num_urbs;
2274 
2275 	/* RX, allocate urb and initialize */
2276 
2277 	/* prepare our RX buffer */
2278 	serial->rx_data_length = rx_size;
2279 	for (i = 0; i < serial->num_rx_urbs; i++) {
2280 		serial->rx_urb[i] = usb_alloc_urb(0, GFP_KERNEL);
2281 		if (!serial->rx_urb[i])
2282 			goto exit;
2283 		serial->rx_urb[i]->transfer_buffer = NULL;
2284 		serial->rx_urb[i]->transfer_buffer_length = 0;
2285 		serial->rx_data[i] = kzalloc(serial->rx_data_length,
2286 					     GFP_KERNEL);
2287 		if (!serial->rx_data[i])
2288 			goto exit;
2289 	}
2290 
2291 	/* TX, allocate urb and initialize */
2292 	serial->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
2293 	if (!serial->tx_urb)
2294 		goto exit;
2295 	serial->tx_urb->transfer_buffer = NULL;
2296 	serial->tx_urb->transfer_buffer_length = 0;
2297 	/* prepare our TX buffer */
2298 	serial->tx_data_count = 0;
2299 	serial->tx_buffer_count = 0;
2300 	serial->tx_data_length = tx_size;
2301 	serial->tx_data = kzalloc(serial->tx_data_length, GFP_KERNEL);
2302 	if (!serial->tx_data)
2303 		goto exit;
2304 
2305 	serial->tx_buffer = kzalloc(serial->tx_data_length, GFP_KERNEL);
2306 	if (!serial->tx_buffer)
2307 		goto exit;
2308 
2309 	return 0;
2310 exit:
2311 	hso_serial_tty_unregister(serial);
2312 	hso_serial_common_free(serial);
2313 	return -1;
2314 }
2315 
2316 /* Creates a general hso device */
2317 static struct hso_device *hso_create_device(struct usb_interface *intf,
2318 					    int port_spec)
2319 {
2320 	struct hso_device *hso_dev;
2321 
2322 	hso_dev = kzalloc(sizeof(*hso_dev), GFP_ATOMIC);
2323 	if (!hso_dev)
2324 		return NULL;
2325 
2326 	hso_dev->port_spec = port_spec;
2327 	hso_dev->usb = interface_to_usbdev(intf);
2328 	hso_dev->interface = intf;
2329 	kref_init(&hso_dev->ref);
2330 	mutex_init(&hso_dev->mutex);
2331 
2332 	INIT_WORK(&hso_dev->async_get_intf, async_get_intf);
2333 	INIT_WORK(&hso_dev->async_put_intf, async_put_intf);
2334 
2335 	return hso_dev;
2336 }
2337 
2338 /* Removes a network device in the network device table */
2339 static int remove_net_device(struct hso_device *hso_dev)
2340 {
2341 	int i;
2342 
2343 	for (i = 0; i < HSO_MAX_NET_DEVICES; i++) {
2344 		if (network_table[i] == hso_dev) {
2345 			network_table[i] = NULL;
2346 			break;
2347 		}
2348 	}
2349 	if (i == HSO_MAX_NET_DEVICES)
2350 		return -1;
2351 	return 0;
2352 }
2353 
2354 /* Frees our network device */
2355 static void hso_free_net_device(struct hso_device *hso_dev)
2356 {
2357 	int i;
2358 	struct hso_net *hso_net = dev2net(hso_dev);
2359 
2360 	if (!hso_net)
2361 		return;
2362 
2363 	remove_net_device(hso_net->parent);
2364 
2365 	if (hso_net->net)
2366 		unregister_netdev(hso_net->net);
2367 
2368 	/* start freeing */
2369 	for (i = 0; i < MUX_BULK_RX_BUF_COUNT; i++) {
2370 		usb_free_urb(hso_net->mux_bulk_rx_urb_pool[i]);
2371 		kfree(hso_net->mux_bulk_rx_buf_pool[i]);
2372 		hso_net->mux_bulk_rx_buf_pool[i] = NULL;
2373 	}
2374 	usb_free_urb(hso_net->mux_bulk_tx_urb);
2375 	kfree(hso_net->mux_bulk_tx_buf);
2376 	hso_net->mux_bulk_tx_buf = NULL;
2377 
2378 	if (hso_net->net)
2379 		free_netdev(hso_net->net);
2380 
2381 	kfree(hso_dev);
2382 }
2383 
2384 static const struct net_device_ops hso_netdev_ops = {
2385 	.ndo_open	= hso_net_open,
2386 	.ndo_stop	= hso_net_close,
2387 	.ndo_start_xmit = hso_net_start_xmit,
2388 	.ndo_tx_timeout = hso_net_tx_timeout,
2389 };
2390 
2391 /* initialize the network interface */
2392 static void hso_net_init(struct net_device *net)
2393 {
2394 	struct hso_net *hso_net = netdev_priv(net);
2395 
2396 	hso_dbg(0x1, "sizeof hso_net is %zu\n", sizeof(*hso_net));
2397 
2398 	/* fill in the other fields */
2399 	net->netdev_ops = &hso_netdev_ops;
2400 	net->watchdog_timeo = HSO_NET_TX_TIMEOUT;
2401 	net->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
2402 	net->type = ARPHRD_NONE;
2403 	net->mtu = DEFAULT_MTU - 14;
2404 	net->tx_queue_len = 10;
2405 	net->ethtool_ops = &ops;
2406 
2407 	/* and initialize the semaphore */
2408 	spin_lock_init(&hso_net->net_lock);
2409 }
2410 
2411 /* Adds a network device in the network device table */
2412 static int add_net_device(struct hso_device *hso_dev)
2413 {
2414 	int i;
2415 
2416 	for (i = 0; i < HSO_MAX_NET_DEVICES; i++) {
2417 		if (network_table[i] == NULL) {
2418 			network_table[i] = hso_dev;
2419 			break;
2420 		}
2421 	}
2422 	if (i == HSO_MAX_NET_DEVICES)
2423 		return -1;
2424 	return 0;
2425 }
2426 
2427 static int hso_rfkill_set_block(void *data, bool blocked)
2428 {
2429 	struct hso_device *hso_dev = data;
2430 	int enabled = !blocked;
2431 	int rv;
2432 
2433 	mutex_lock(&hso_dev->mutex);
2434 	if (hso_dev->usb_gone)
2435 		rv = 0;
2436 	else
2437 		rv = usb_control_msg(hso_dev->usb, usb_rcvctrlpipe(hso_dev->usb, 0),
2438 				       enabled ? 0x82 : 0x81, 0x40, 0, 0, NULL, 0,
2439 				       USB_CTRL_SET_TIMEOUT);
2440 	mutex_unlock(&hso_dev->mutex);
2441 	return rv;
2442 }
2443 
2444 static const struct rfkill_ops hso_rfkill_ops = {
2445 	.set_block = hso_rfkill_set_block,
2446 };
2447 
2448 /* Creates and sets up everything for rfkill */
2449 static void hso_create_rfkill(struct hso_device *hso_dev,
2450 			     struct usb_interface *interface)
2451 {
2452 	struct hso_net *hso_net = dev2net(hso_dev);
2453 	struct device *dev = &hso_net->net->dev;
2454 	static u32 rfkill_counter;
2455 
2456 	snprintf(hso_net->name, sizeof(hso_net->name), "hso-%d",
2457 		 rfkill_counter++);
2458 
2459 	hso_net->rfkill = rfkill_alloc(hso_net->name,
2460 				       &interface_to_usbdev(interface)->dev,
2461 				       RFKILL_TYPE_WWAN,
2462 				       &hso_rfkill_ops, hso_dev);
2463 	if (!hso_net->rfkill) {
2464 		dev_err(dev, "%s - Out of memory\n", __func__);
2465 		return;
2466 	}
2467 	if (rfkill_register(hso_net->rfkill) < 0) {
2468 		rfkill_destroy(hso_net->rfkill);
2469 		hso_net->rfkill = NULL;
2470 		dev_err(dev, "%s - Failed to register rfkill\n", __func__);
2471 		return;
2472 	}
2473 }
2474 
2475 static struct device_type hso_type = {
2476 	.name	= "wwan",
2477 };
2478 
2479 /* Creates our network device */
2480 static struct hso_device *hso_create_net_device(struct usb_interface *interface,
2481 						int port_spec)
2482 {
2483 	int result, i;
2484 	struct net_device *net;
2485 	struct hso_net *hso_net;
2486 	struct hso_device *hso_dev;
2487 
2488 	hso_dev = hso_create_device(interface, port_spec);
2489 	if (!hso_dev)
2490 		return NULL;
2491 
2492 	/* allocate our network device, then we can put in our private data */
2493 	/* call hso_net_init to do the basic initialization */
2494 	net = alloc_netdev(sizeof(struct hso_net), "hso%d", NET_NAME_UNKNOWN,
2495 			   hso_net_init);
2496 	if (!net) {
2497 		dev_err(&interface->dev, "Unable to create ethernet device\n");
2498 		goto exit;
2499 	}
2500 
2501 	hso_net = netdev_priv(net);
2502 
2503 	hso_dev->port_data.dev_net = hso_net;
2504 	hso_net->net = net;
2505 	hso_net->parent = hso_dev;
2506 
2507 	hso_net->in_endp = hso_get_ep(interface, USB_ENDPOINT_XFER_BULK,
2508 				      USB_DIR_IN);
2509 	if (!hso_net->in_endp) {
2510 		dev_err(&interface->dev, "Can't find BULK IN endpoint\n");
2511 		goto exit;
2512 	}
2513 	hso_net->out_endp = hso_get_ep(interface, USB_ENDPOINT_XFER_BULK,
2514 				       USB_DIR_OUT);
2515 	if (!hso_net->out_endp) {
2516 		dev_err(&interface->dev, "Can't find BULK OUT endpoint\n");
2517 		goto exit;
2518 	}
2519 	SET_NETDEV_DEV(net, &interface->dev);
2520 	SET_NETDEV_DEVTYPE(net, &hso_type);
2521 
2522 	/* start allocating */
2523 	for (i = 0; i < MUX_BULK_RX_BUF_COUNT; i++) {
2524 		hso_net->mux_bulk_rx_urb_pool[i] = usb_alloc_urb(0, GFP_KERNEL);
2525 		if (!hso_net->mux_bulk_rx_urb_pool[i])
2526 			goto exit;
2527 		hso_net->mux_bulk_rx_buf_pool[i] = kzalloc(MUX_BULK_RX_BUF_SIZE,
2528 							   GFP_KERNEL);
2529 		if (!hso_net->mux_bulk_rx_buf_pool[i])
2530 			goto exit;
2531 	}
2532 	hso_net->mux_bulk_tx_urb = usb_alloc_urb(0, GFP_KERNEL);
2533 	if (!hso_net->mux_bulk_tx_urb)
2534 		goto exit;
2535 	hso_net->mux_bulk_tx_buf = kzalloc(MUX_BULK_TX_BUF_SIZE, GFP_KERNEL);
2536 	if (!hso_net->mux_bulk_tx_buf)
2537 		goto exit;
2538 
2539 	add_net_device(hso_dev);
2540 
2541 	/* registering our net device */
2542 	result = register_netdev(net);
2543 	if (result) {
2544 		dev_err(&interface->dev, "Failed to register device\n");
2545 		goto exit;
2546 	}
2547 
2548 	hso_log_port(hso_dev);
2549 
2550 	hso_create_rfkill(hso_dev, interface);
2551 
2552 	return hso_dev;
2553 exit:
2554 	hso_free_net_device(hso_dev);
2555 	return NULL;
2556 }
2557 
2558 static void hso_free_tiomget(struct hso_serial *serial)
2559 {
2560 	struct hso_tiocmget *tiocmget;
2561 	if (!serial)
2562 		return;
2563 	tiocmget = serial->tiocmget;
2564 	if (tiocmget) {
2565 		usb_free_urb(tiocmget->urb);
2566 		tiocmget->urb = NULL;
2567 		serial->tiocmget = NULL;
2568 		kfree(tiocmget);
2569 	}
2570 }
2571 
2572 /* Frees an AT channel ( goes for both mux and non-mux ) */
2573 static void hso_free_serial_device(struct hso_device *hso_dev)
2574 {
2575 	struct hso_serial *serial = dev2ser(hso_dev);
2576 
2577 	if (!serial)
2578 		return;
2579 
2580 	hso_serial_common_free(serial);
2581 
2582 	if (serial->shared_int) {
2583 		mutex_lock(&serial->shared_int->shared_int_lock);
2584 		if (--serial->shared_int->ref_count == 0)
2585 			hso_free_shared_int(serial->shared_int);
2586 		else
2587 			mutex_unlock(&serial->shared_int->shared_int_lock);
2588 	}
2589 	hso_free_tiomget(serial);
2590 	kfree(serial);
2591 	kfree(hso_dev);
2592 }
2593 
2594 /* Creates a bulk AT channel */
2595 static struct hso_device *hso_create_bulk_serial_device(
2596 			struct usb_interface *interface, int port)
2597 {
2598 	struct hso_device *hso_dev;
2599 	struct hso_serial *serial;
2600 	int num_urbs;
2601 	struct hso_tiocmget *tiocmget;
2602 
2603 	hso_dev = hso_create_device(interface, port);
2604 	if (!hso_dev)
2605 		return NULL;
2606 
2607 	serial = kzalloc(sizeof(*serial), GFP_KERNEL);
2608 	if (!serial)
2609 		goto exit;
2610 
2611 	serial->parent = hso_dev;
2612 	hso_dev->port_data.dev_serial = serial;
2613 
2614 	if ((port & HSO_PORT_MASK) == HSO_PORT_MODEM) {
2615 		num_urbs = 2;
2616 		serial->tiocmget = kzalloc(sizeof(struct hso_tiocmget),
2617 					   GFP_KERNEL);
2618 		/* it isn't going to break our heart if serial->tiocmget
2619 		 *  allocation fails don't bother checking this.
2620 		 */
2621 		if (serial->tiocmget) {
2622 			tiocmget = serial->tiocmget;
2623 			tiocmget->endp = hso_get_ep(interface,
2624 						    USB_ENDPOINT_XFER_INT,
2625 						    USB_DIR_IN);
2626 			if (!tiocmget->endp) {
2627 				dev_err(&interface->dev, "Failed to find INT IN ep\n");
2628 				goto exit;
2629 			}
2630 
2631 			tiocmget->urb = usb_alloc_urb(0, GFP_KERNEL);
2632 			if (tiocmget->urb) {
2633 				mutex_init(&tiocmget->mutex);
2634 				init_waitqueue_head(&tiocmget->waitq);
2635 			} else
2636 				hso_free_tiomget(serial);
2637 		}
2638 	}
2639 	else
2640 		num_urbs = 1;
2641 
2642 	if (hso_serial_common_create(serial, num_urbs, BULK_URB_RX_SIZE,
2643 				     BULK_URB_TX_SIZE))
2644 		goto exit;
2645 
2646 	serial->in_endp = hso_get_ep(interface, USB_ENDPOINT_XFER_BULK,
2647 				     USB_DIR_IN);
2648 	if (!serial->in_endp) {
2649 		dev_err(&interface->dev, "Failed to find BULK IN ep\n");
2650 		goto exit2;
2651 	}
2652 
2653 	if (!
2654 	    (serial->out_endp =
2655 	     hso_get_ep(interface, USB_ENDPOINT_XFER_BULK, USB_DIR_OUT))) {
2656 		dev_err(&interface->dev, "Failed to find BULK IN ep\n");
2657 		goto exit2;
2658 	}
2659 
2660 	serial->write_data = hso_std_serial_write_data;
2661 
2662 	/* and record this serial */
2663 	set_serial_by_index(serial->minor, serial);
2664 
2665 	/* setup the proc dirs and files if needed */
2666 	hso_log_port(hso_dev);
2667 
2668 	/* done, return it */
2669 	return hso_dev;
2670 
2671 exit2:
2672 	hso_serial_tty_unregister(serial);
2673 	hso_serial_common_free(serial);
2674 exit:
2675 	hso_free_tiomget(serial);
2676 	kfree(serial);
2677 	kfree(hso_dev);
2678 	return NULL;
2679 }
2680 
2681 /* Creates a multiplexed AT channel */
2682 static
2683 struct hso_device *hso_create_mux_serial_device(struct usb_interface *interface,
2684 						int port,
2685 						struct hso_shared_int *mux)
2686 {
2687 	struct hso_device *hso_dev;
2688 	struct hso_serial *serial;
2689 	int port_spec;
2690 
2691 	port_spec = HSO_INTF_MUX;
2692 	port_spec &= ~HSO_PORT_MASK;
2693 
2694 	port_spec |= hso_mux_to_port(port);
2695 	if ((port_spec & HSO_PORT_MASK) == HSO_PORT_NO_PORT)
2696 		return NULL;
2697 
2698 	hso_dev = hso_create_device(interface, port_spec);
2699 	if (!hso_dev)
2700 		return NULL;
2701 
2702 	serial = kzalloc(sizeof(*serial), GFP_KERNEL);
2703 	if (!serial)
2704 		goto exit;
2705 
2706 	hso_dev->port_data.dev_serial = serial;
2707 	serial->parent = hso_dev;
2708 
2709 	if (hso_serial_common_create
2710 	    (serial, 1, CTRL_URB_RX_SIZE, CTRL_URB_TX_SIZE))
2711 		goto exit;
2712 
2713 	serial->tx_data_length--;
2714 	serial->write_data = hso_mux_serial_write_data;
2715 
2716 	serial->shared_int = mux;
2717 	mutex_lock(&serial->shared_int->shared_int_lock);
2718 	serial->shared_int->ref_count++;
2719 	mutex_unlock(&serial->shared_int->shared_int_lock);
2720 
2721 	/* and record this serial */
2722 	set_serial_by_index(serial->minor, serial);
2723 
2724 	/* setup the proc dirs and files if needed */
2725 	hso_log_port(hso_dev);
2726 
2727 	/* done, return it */
2728 	return hso_dev;
2729 
2730 exit:
2731 	if (serial) {
2732 		tty_unregister_device(tty_drv, serial->minor);
2733 		kfree(serial);
2734 	}
2735 	kfree(hso_dev);
2736 	return NULL;
2737 
2738 }
2739 
2740 static void hso_free_shared_int(struct hso_shared_int *mux)
2741 {
2742 	usb_free_urb(mux->shared_intr_urb);
2743 	kfree(mux->shared_intr_buf);
2744 	mutex_unlock(&mux->shared_int_lock);
2745 	kfree(mux);
2746 }
2747 
2748 static
2749 struct hso_shared_int *hso_create_shared_int(struct usb_interface *interface)
2750 {
2751 	struct hso_shared_int *mux = kzalloc(sizeof(*mux), GFP_KERNEL);
2752 
2753 	if (!mux)
2754 		return NULL;
2755 
2756 	mux->intr_endp = hso_get_ep(interface, USB_ENDPOINT_XFER_INT,
2757 				    USB_DIR_IN);
2758 	if (!mux->intr_endp) {
2759 		dev_err(&interface->dev, "Can't find INT IN endpoint\n");
2760 		goto exit;
2761 	}
2762 
2763 	mux->shared_intr_urb = usb_alloc_urb(0, GFP_KERNEL);
2764 	if (!mux->shared_intr_urb)
2765 		goto exit;
2766 	mux->shared_intr_buf =
2767 		kzalloc(le16_to_cpu(mux->intr_endp->wMaxPacketSize),
2768 			GFP_KERNEL);
2769 	if (!mux->shared_intr_buf)
2770 		goto exit;
2771 
2772 	mutex_init(&mux->shared_int_lock);
2773 
2774 	return mux;
2775 
2776 exit:
2777 	kfree(mux->shared_intr_buf);
2778 	usb_free_urb(mux->shared_intr_urb);
2779 	kfree(mux);
2780 	return NULL;
2781 }
2782 
2783 /* Gets the port spec for a certain interface */
2784 static int hso_get_config_data(struct usb_interface *interface)
2785 {
2786 	struct usb_device *usbdev = interface_to_usbdev(interface);
2787 	u8 *config_data = kmalloc(17, GFP_KERNEL);
2788 	u32 if_num = interface->cur_altsetting->desc.bInterfaceNumber;
2789 	s32 result;
2790 
2791 	if (!config_data)
2792 		return -ENOMEM;
2793 	if (usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0),
2794 			    0x86, 0xC0, 0, 0, config_data, 17,
2795 			    USB_CTRL_SET_TIMEOUT) != 0x11) {
2796 		kfree(config_data);
2797 		return -EIO;
2798 	}
2799 
2800 	/* check if we have a valid interface */
2801 	if (if_num > 16) {
2802 		kfree(config_data);
2803 		return -EINVAL;
2804 	}
2805 
2806 	switch (config_data[if_num]) {
2807 	case 0x0:
2808 		result = 0;
2809 		break;
2810 	case 0x1:
2811 		result = HSO_PORT_DIAG;
2812 		break;
2813 	case 0x2:
2814 		result = HSO_PORT_GPS;
2815 		break;
2816 	case 0x3:
2817 		result = HSO_PORT_GPS_CONTROL;
2818 		break;
2819 	case 0x4:
2820 		result = HSO_PORT_APP;
2821 		break;
2822 	case 0x5:
2823 		result = HSO_PORT_APP2;
2824 		break;
2825 	case 0x6:
2826 		result = HSO_PORT_CONTROL;
2827 		break;
2828 	case 0x7:
2829 		result = HSO_PORT_NETWORK;
2830 		break;
2831 	case 0x8:
2832 		result = HSO_PORT_MODEM;
2833 		break;
2834 	case 0x9:
2835 		result = HSO_PORT_MSD;
2836 		break;
2837 	case 0xa:
2838 		result = HSO_PORT_PCSC;
2839 		break;
2840 	case 0xb:
2841 		result = HSO_PORT_VOICE;
2842 		break;
2843 	default:
2844 		result = 0;
2845 	}
2846 
2847 	if (result)
2848 		result |= HSO_INTF_BULK;
2849 
2850 	if (config_data[16] & 0x1)
2851 		result |= HSO_INFO_CRC_BUG;
2852 
2853 	kfree(config_data);
2854 	return result;
2855 }
2856 
2857 /* called once for each interface upon device insertion */
2858 static int hso_probe(struct usb_interface *interface,
2859 		     const struct usb_device_id *id)
2860 {
2861 	int mux, i, if_num, port_spec;
2862 	unsigned char port_mask;
2863 	struct hso_device *hso_dev = NULL;
2864 	struct hso_shared_int *shared_int;
2865 	struct hso_device *tmp_dev = NULL;
2866 
2867 	if (interface->cur_altsetting->desc.bInterfaceClass != 0xFF) {
2868 		dev_err(&interface->dev, "Not our interface\n");
2869 		return -ENODEV;
2870 	}
2871 
2872 	if_num = interface->cur_altsetting->desc.bInterfaceNumber;
2873 
2874 	/* Get the interface/port specification from either driver_info or from
2875 	 * the device itself */
2876 	if (id->driver_info) {
2877 		/* if_num is controlled by the device, driver_info is a 0 terminated
2878 		 * array. Make sure, the access is in bounds! */
2879 		for (i = 0; i <= if_num; ++i)
2880 			if (((u32 *)(id->driver_info))[i] == 0)
2881 				goto exit;
2882 		port_spec = ((u32 *)(id->driver_info))[if_num];
2883 	} else {
2884 		port_spec = hso_get_config_data(interface);
2885 		if (port_spec < 0)
2886 			goto exit;
2887 	}
2888 
2889 	/* Check if we need to switch to alt interfaces prior to port
2890 	 * configuration */
2891 	if (interface->num_altsetting > 1)
2892 		usb_set_interface(interface_to_usbdev(interface), if_num, 1);
2893 	interface->needs_remote_wakeup = 1;
2894 
2895 	/* Allocate new hso device(s) */
2896 	switch (port_spec & HSO_INTF_MASK) {
2897 	case HSO_INTF_MUX:
2898 		if ((port_spec & HSO_PORT_MASK) == HSO_PORT_NETWORK) {
2899 			/* Create the network device */
2900 			if (!disable_net) {
2901 				hso_dev = hso_create_net_device(interface,
2902 								port_spec);
2903 				if (!hso_dev)
2904 					goto exit;
2905 				tmp_dev = hso_dev;
2906 			}
2907 		}
2908 
2909 		if (hso_get_mux_ports(interface, &port_mask))
2910 			/* TODO: de-allocate everything */
2911 			goto exit;
2912 
2913 		shared_int = hso_create_shared_int(interface);
2914 		if (!shared_int)
2915 			goto exit;
2916 
2917 		for (i = 1, mux = 0; i < 0x100; i = i << 1, mux++) {
2918 			if (port_mask & i) {
2919 				hso_dev = hso_create_mux_serial_device(
2920 						interface, i, shared_int);
2921 				if (!hso_dev)
2922 					goto exit;
2923 			}
2924 		}
2925 
2926 		if (tmp_dev)
2927 			hso_dev = tmp_dev;
2928 		break;
2929 
2930 	case HSO_INTF_BULK:
2931 		/* It's a regular bulk interface */
2932 		if ((port_spec & HSO_PORT_MASK) == HSO_PORT_NETWORK) {
2933 			if (!disable_net)
2934 				hso_dev =
2935 				    hso_create_net_device(interface, port_spec);
2936 		} else {
2937 			hso_dev =
2938 			    hso_create_bulk_serial_device(interface, port_spec);
2939 		}
2940 		if (!hso_dev)
2941 			goto exit;
2942 		break;
2943 	default:
2944 		goto exit;
2945 	}
2946 
2947 	/* save our data pointer in this device */
2948 	usb_set_intfdata(interface, hso_dev);
2949 
2950 	/* done */
2951 	return 0;
2952 exit:
2953 	hso_free_interface(interface);
2954 	return -ENODEV;
2955 }
2956 
2957 /* device removed, cleaning up */
2958 static void hso_disconnect(struct usb_interface *interface)
2959 {
2960 	hso_free_interface(interface);
2961 
2962 	/* remove reference of our private data */
2963 	usb_set_intfdata(interface, NULL);
2964 }
2965 
2966 static void async_get_intf(struct work_struct *data)
2967 {
2968 	struct hso_device *hso_dev =
2969 	    container_of(data, struct hso_device, async_get_intf);
2970 	usb_autopm_get_interface(hso_dev->interface);
2971 }
2972 
2973 static void async_put_intf(struct work_struct *data)
2974 {
2975 	struct hso_device *hso_dev =
2976 	    container_of(data, struct hso_device, async_put_intf);
2977 	usb_autopm_put_interface(hso_dev->interface);
2978 }
2979 
2980 static int hso_get_activity(struct hso_device *hso_dev)
2981 {
2982 	if (hso_dev->usb->state == USB_STATE_SUSPENDED) {
2983 		if (!hso_dev->is_active) {
2984 			hso_dev->is_active = 1;
2985 			schedule_work(&hso_dev->async_get_intf);
2986 		}
2987 	}
2988 
2989 	if (hso_dev->usb->state != USB_STATE_CONFIGURED)
2990 		return -EAGAIN;
2991 
2992 	usb_mark_last_busy(hso_dev->usb);
2993 
2994 	return 0;
2995 }
2996 
2997 static int hso_put_activity(struct hso_device *hso_dev)
2998 {
2999 	if (hso_dev->usb->state != USB_STATE_SUSPENDED) {
3000 		if (hso_dev->is_active) {
3001 			hso_dev->is_active = 0;
3002 			schedule_work(&hso_dev->async_put_intf);
3003 			return -EAGAIN;
3004 		}
3005 	}
3006 	hso_dev->is_active = 0;
3007 	return 0;
3008 }
3009 
3010 /* called by kernel when we need to suspend device */
3011 static int hso_suspend(struct usb_interface *iface, pm_message_t message)
3012 {
3013 	int i, result;
3014 
3015 	/* Stop all serial ports */
3016 	for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++) {
3017 		if (serial_table[i] && (serial_table[i]->interface == iface)) {
3018 			result = hso_stop_serial_device(serial_table[i]);
3019 			if (result)
3020 				goto out;
3021 		}
3022 	}
3023 
3024 	/* Stop all network ports */
3025 	for (i = 0; i < HSO_MAX_NET_DEVICES; i++) {
3026 		if (network_table[i] &&
3027 		    (network_table[i]->interface == iface)) {
3028 			result = hso_stop_net_device(network_table[i]);
3029 			if (result)
3030 				goto out;
3031 		}
3032 	}
3033 
3034 out:
3035 	return 0;
3036 }
3037 
3038 /* called by kernel when we need to resume device */
3039 static int hso_resume(struct usb_interface *iface)
3040 {
3041 	int i, result = 0;
3042 	struct hso_net *hso_net;
3043 
3044 	/* Start all serial ports */
3045 	for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++) {
3046 		if (serial_table[i] && (serial_table[i]->interface == iface)) {
3047 			if (dev2ser(serial_table[i])->port.count) {
3048 				result =
3049 				    hso_start_serial_device(serial_table[i], GFP_NOIO);
3050 				hso_kick_transmit(dev2ser(serial_table[i]));
3051 				if (result)
3052 					goto out;
3053 			}
3054 		}
3055 	}
3056 
3057 	/* Start all network ports */
3058 	for (i = 0; i < HSO_MAX_NET_DEVICES; i++) {
3059 		if (network_table[i] &&
3060 		    (network_table[i]->interface == iface)) {
3061 			hso_net = dev2net(network_table[i]);
3062 			if (hso_net->flags & IFF_UP) {
3063 				/* First transmit any lingering data,
3064 				   then restart the device. */
3065 				if (hso_net->skb_tx_buf) {
3066 					dev_dbg(&iface->dev,
3067 						"Transmitting"
3068 						" lingering data\n");
3069 					hso_net_start_xmit(hso_net->skb_tx_buf,
3070 							   hso_net->net);
3071 					hso_net->skb_tx_buf = NULL;
3072 				}
3073 				result = hso_start_net_device(network_table[i]);
3074 				if (result)
3075 					goto out;
3076 			}
3077 		}
3078 	}
3079 
3080 out:
3081 	return result;
3082 }
3083 
3084 static void hso_serial_ref_free(struct kref *ref)
3085 {
3086 	struct hso_device *hso_dev = container_of(ref, struct hso_device, ref);
3087 
3088 	hso_free_serial_device(hso_dev);
3089 }
3090 
3091 static void hso_free_interface(struct usb_interface *interface)
3092 {
3093 	struct hso_serial *serial;
3094 	int i;
3095 
3096 	for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++) {
3097 		if (serial_table[i] &&
3098 		    (serial_table[i]->interface == interface)) {
3099 			serial = dev2ser(serial_table[i]);
3100 			tty_port_tty_hangup(&serial->port, false);
3101 			mutex_lock(&serial->parent->mutex);
3102 			serial->parent->usb_gone = 1;
3103 			mutex_unlock(&serial->parent->mutex);
3104 			cancel_work_sync(&serial_table[i]->async_put_intf);
3105 			cancel_work_sync(&serial_table[i]->async_get_intf);
3106 			hso_serial_tty_unregister(serial);
3107 			kref_put(&serial_table[i]->ref, hso_serial_ref_free);
3108 			set_serial_by_index(i, NULL);
3109 		}
3110 	}
3111 
3112 	for (i = 0; i < HSO_MAX_NET_DEVICES; i++) {
3113 		if (network_table[i] &&
3114 		    (network_table[i]->interface == interface)) {
3115 			struct rfkill *rfk = dev2net(network_table[i])->rfkill;
3116 			/* hso_stop_net_device doesn't stop the net queue since
3117 			 * traffic needs to start it again when suspended */
3118 			netif_stop_queue(dev2net(network_table[i])->net);
3119 			hso_stop_net_device(network_table[i]);
3120 			cancel_work_sync(&network_table[i]->async_put_intf);
3121 			cancel_work_sync(&network_table[i]->async_get_intf);
3122 			if (rfk) {
3123 				rfkill_unregister(rfk);
3124 				rfkill_destroy(rfk);
3125 			}
3126 			hso_free_net_device(network_table[i]);
3127 		}
3128 	}
3129 }
3130 
3131 /* Helper functions */
3132 
3133 /* Get the endpoint ! */
3134 static struct usb_endpoint_descriptor *hso_get_ep(struct usb_interface *intf,
3135 						  int type, int dir)
3136 {
3137 	int i;
3138 	struct usb_host_interface *iface = intf->cur_altsetting;
3139 	struct usb_endpoint_descriptor *endp;
3140 
3141 	for (i = 0; i < iface->desc.bNumEndpoints; i++) {
3142 		endp = &iface->endpoint[i].desc;
3143 		if (((endp->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == dir) &&
3144 		    (usb_endpoint_type(endp) == type))
3145 			return endp;
3146 	}
3147 
3148 	return NULL;
3149 }
3150 
3151 /* Get the byte that describes which ports are enabled */
3152 static int hso_get_mux_ports(struct usb_interface *intf, unsigned char *ports)
3153 {
3154 	int i;
3155 	struct usb_host_interface *iface = intf->cur_altsetting;
3156 
3157 	if (iface->extralen == 3) {
3158 		*ports = iface->extra[2];
3159 		return 0;
3160 	}
3161 
3162 	for (i = 0; i < iface->desc.bNumEndpoints; i++) {
3163 		if (iface->endpoint[i].extralen == 3) {
3164 			*ports = iface->endpoint[i].extra[2];
3165 			return 0;
3166 		}
3167 	}
3168 
3169 	return -1;
3170 }
3171 
3172 /* interrupt urb needs to be submitted, used for serial read of muxed port */
3173 static int hso_mux_submit_intr_urb(struct hso_shared_int *shared_int,
3174 				   struct usb_device *usb, gfp_t gfp)
3175 {
3176 	int result;
3177 
3178 	usb_fill_int_urb(shared_int->shared_intr_urb, usb,
3179 			 usb_rcvintpipe(usb,
3180 				shared_int->intr_endp->bEndpointAddress & 0x7F),
3181 			 shared_int->shared_intr_buf,
3182 			 1,
3183 			 intr_callback, shared_int,
3184 			 shared_int->intr_endp->bInterval);
3185 
3186 	result = usb_submit_urb(shared_int->shared_intr_urb, gfp);
3187 	if (result)
3188 		dev_warn(&usb->dev, "%s failed mux_intr_urb %d\n", __func__,
3189 			result);
3190 
3191 	return result;
3192 }
3193 
3194 /* operations setup of the serial interface */
3195 static const struct tty_operations hso_serial_ops = {
3196 	.open = hso_serial_open,
3197 	.close = hso_serial_close,
3198 	.write = hso_serial_write,
3199 	.write_room = hso_serial_write_room,
3200 	.cleanup = hso_serial_cleanup,
3201 	.ioctl = hso_serial_ioctl,
3202 	.set_termios = hso_serial_set_termios,
3203 	.chars_in_buffer = hso_serial_chars_in_buffer,
3204 	.tiocmget = hso_serial_tiocmget,
3205 	.tiocmset = hso_serial_tiocmset,
3206 	.get_icount = hso_get_count,
3207 	.unthrottle = hso_unthrottle
3208 };
3209 
3210 static struct usb_driver hso_driver = {
3211 	.name = driver_name,
3212 	.probe = hso_probe,
3213 	.disconnect = hso_disconnect,
3214 	.id_table = hso_ids,
3215 	.suspend = hso_suspend,
3216 	.resume = hso_resume,
3217 	.reset_resume = hso_resume,
3218 	.supports_autosuspend = 1,
3219 	.disable_hub_initiated_lpm = 1,
3220 };
3221 
3222 static int __init hso_init(void)
3223 {
3224 	int i;
3225 	int result;
3226 
3227 	/* put it in the log */
3228 	pr_info("%s\n", version);
3229 
3230 	/* Initialise the serial table semaphore and table */
3231 	spin_lock_init(&serial_table_lock);
3232 	for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++)
3233 		serial_table[i] = NULL;
3234 
3235 	/* allocate our driver using the proper amount of supported minors */
3236 	tty_drv = alloc_tty_driver(HSO_SERIAL_TTY_MINORS);
3237 	if (!tty_drv)
3238 		return -ENOMEM;
3239 
3240 	/* fill in all needed values */
3241 	tty_drv->driver_name = driver_name;
3242 	tty_drv->name = tty_filename;
3243 
3244 	/* if major number is provided as parameter, use that one */
3245 	if (tty_major)
3246 		tty_drv->major = tty_major;
3247 
3248 	tty_drv->minor_start = 0;
3249 	tty_drv->type = TTY_DRIVER_TYPE_SERIAL;
3250 	tty_drv->subtype = SERIAL_TYPE_NORMAL;
3251 	tty_drv->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
3252 	tty_drv->init_termios = tty_std_termios;
3253 	hso_init_termios(&tty_drv->init_termios);
3254 	tty_set_operations(tty_drv, &hso_serial_ops);
3255 
3256 	/* register the tty driver */
3257 	result = tty_register_driver(tty_drv);
3258 	if (result) {
3259 		pr_err("%s - tty_register_driver failed(%d)\n",
3260 		       __func__, result);
3261 		goto err_free_tty;
3262 	}
3263 
3264 	/* register this module as an usb driver */
3265 	result = usb_register(&hso_driver);
3266 	if (result) {
3267 		pr_err("Could not register hso driver - error: %d\n", result);
3268 		goto err_unreg_tty;
3269 	}
3270 
3271 	/* done */
3272 	return 0;
3273 err_unreg_tty:
3274 	tty_unregister_driver(tty_drv);
3275 err_free_tty:
3276 	put_tty_driver(tty_drv);
3277 	return result;
3278 }
3279 
3280 static void __exit hso_exit(void)
3281 {
3282 	pr_info("unloaded\n");
3283 
3284 	tty_unregister_driver(tty_drv);
3285 	/* deregister the usb driver */
3286 	usb_deregister(&hso_driver);
3287 	put_tty_driver(tty_drv);
3288 }
3289 
3290 /* Module definitions */
3291 module_init(hso_init);
3292 module_exit(hso_exit);
3293 
3294 MODULE_AUTHOR(MOD_AUTHOR);
3295 MODULE_DESCRIPTION(MOD_DESCRIPTION);
3296 MODULE_LICENSE("GPL");
3297 
3298 /* change the debug level (eg: insmod hso.ko debug=0x04) */
3299 MODULE_PARM_DESC(debug, "debug level mask [0x01 | 0x02 | 0x04 | 0x08 | 0x10]");
3300 module_param(debug, int, 0644);
3301 
3302 /* set the major tty number (eg: insmod hso.ko tty_major=245) */
3303 MODULE_PARM_DESC(tty_major, "Set the major tty number");
3304 module_param(tty_major, int, 0644);
3305 
3306 /* disable network interface (eg: insmod hso.ko disable_net=1) */
3307 MODULE_PARM_DESC(disable_net, "Disable the network interface");
3308 module_param(disable_net, int, 0644);
3309