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