1 // SPDX-License-Identifier: GPL-2.0-only
2 /******************************************************************************
4 * Driver for Option High Speed Mobile Devices.
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.
15 *****************************************************************************/
17 /******************************************************************************
19 * Description of the device:
21 * Interface 0: Contains the IP network interface on the bulk end points.
22 * The multiplexed serial ports are using the interrupt and
24 * Interrupt contains a bitmap telling which multiplexed
25 * serialport needs servicing.
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
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.
37 *****************************************************************************/
39 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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>
55 #include <linux/uaccess.h>
56 #include <linux/usb/cdc.h>
58 #include <asm/byteorder.h>
59 #include <linux/serial_core.h>
60 #include <linux/serial.h>
63 #define MOD_AUTHOR "Option Wireless"
64 #define MOD_DESCRIPTION "USB High Speed Option driver"
66 #define HSO_MAX_NET_DEVICES 10
67 #define HSO__MAX_MTU 2048
68 #define DEFAULT_MTU 1500
69 #define DEFAULT_MRU 1500
71 #define CTRL_URB_RX_SIZE 1024
72 #define CTRL_URB_TX_SIZE 64
74 #define BULK_URB_RX_SIZE 4096
75 #define BULK_URB_TX_SIZE 8192
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
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
86 #define HSO_NET_TX_TIMEOUT (HZ*10)
88 #define HSO_SERIAL_MAGIC 0x48534f31
90 /* Number of ttys to handle */
91 #define HSO_SERIAL_TTY_MINORS 256
95 /*****************************************************************************/
96 /* Debugging functions */
97 /*****************************************************************************/
98 #define hso_dbg(lvl, fmt, ...) \
101 pr_info("[%d:%s] " fmt, \
102 __LINE__, __func__, ##__VA_ARGS__); \
105 /*****************************************************************************/
107 /*****************************************************************************/
108 enum pkt_parse_state
{
114 /*****************************************************************************/
116 /*****************************************************************************/
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
;
125 struct mutex shared_int_lock
;
129 struct hso_device
*parent
;
130 struct net_device
*net
;
131 struct rfkill
*rfkill
;
134 struct usb_endpoint_descriptor
*in_endp
;
135 struct usb_endpoint_descriptor
*out_endp
;
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
;
142 struct sk_buff
*skb_rx_buf
;
143 struct sk_buff
*skb_tx_buf
;
145 enum pkt_parse_state rx_parse_state
;
148 unsigned short rx_buf_size
;
149 unsigned short rx_buf_missing
;
150 struct iphdr rx_ip_hdr
;
161 #define BM_REQUEST_TYPE (0xa1)
162 #define B_NOTIFICATION (0x20)
163 #define W_VALUE (0x0)
164 #define W_LENGTH (0x2)
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)
174 struct hso_serial_state_notification
{
180 u16 UART_state_bitmap
;
183 struct hso_tiocmget
{
185 wait_queue_head_t waitq
;
187 struct usb_endpoint_descriptor
*endp
;
189 struct hso_serial_state_notification serial_state_notification
;
190 u16 prev_UART_state_bitmap
;
191 struct uart_icount icount
;
196 struct hso_device
*parent
;
200 struct hso_shared_int
*shared_int
;
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
];
206 u8
*rx_data
[MAX_RX_URBS
];
207 u16 rx_data_length
; /* should contain allocated length */
212 u16 tx_data_length
; /* should contain allocated length */
215 struct usb_ctrlrequest ctrl_req_tx
;
216 struct usb_ctrlrequest ctrl_req_rx
;
218 struct usb_endpoint_descriptor
*in_endp
;
219 struct usb_endpoint_descriptor
*out_endp
;
221 enum rx_ctrl_state rx_state
;
224 unsigned tx_urb_used
:1;
226 struct tty_port port
;
227 /* from usb_serial_port */
228 spinlock_t serial_lock
;
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.
237 u8 rx_urb_filled
[MAX_RX_URBS
];
238 struct tasklet_struct unthrottle_tasklet
;
243 struct hso_serial
*dev_serial
;
244 struct hso_net
*dev_net
;
251 struct work_struct async_get_intf
;
252 struct work_struct async_put_intf
;
254 struct usb_device
*usb
;
255 struct usb_interface
*interface
;
262 /* Type of interface */
263 #define HSO_INTF_MASK 0xFF00
264 #define HSO_INTF_MUX 0x0100
265 #define HSO_INTF_BULK 0x0200
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
283 /* Additional device info */
284 #define HSO_INFO_MASK 0xFF000000
285 #define HSO_INFO_CRC_BUG 0x01000000
287 /*****************************************************************************/
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
,
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 /*****************************************************************************/
324 static inline struct hso_net
*dev2net(struct hso_device
*hso_dev
)
326 return hso_dev
->port_data
.dev_net
;
329 static inline struct hso_serial
*dev2ser(struct hso_device
*hso_dev
)
331 return hso_dev
->port_data
.dev_serial
;
334 /* Debugging functions */
336 static void dbg_dump(int line_count
, const char *func_name
, unsigned char *buf
,
339 static char name
[255];
341 sprintf(name
, "hso[%d:%s]", line_count
, func_name
);
342 print_hex_dump_bytes(name
, DUMP_PREFIX_NONE
, buf
, len
);
345 #define DUMP(buf_, len_) \
346 dbg_dump(__LINE__, __func__, (unsigned char *)buf_, len_)
348 #define DUMP1(buf_, len_) \
354 #define DUMP(buf_, len_)
355 #define DUMP1(buf_, len_)
358 /* module parameters */
360 static int tty_major
;
361 static int disable_net
;
364 static const char driver_name
[] = "hso";
365 static const char tty_filename
[] = "ttyHS";
366 static const char *version
= __FILE__
": " MOD_AUTHOR
;
367 /* the usb driver itself (registered in hso_init) */
368 static struct usb_driver hso_driver
;
369 /* serial structures */
370 static struct tty_driver
*tty_drv
;
371 static struct hso_device
*serial_table
[HSO_SERIAL_TTY_MINORS
];
372 static struct hso_device
*network_table
[HSO_MAX_NET_DEVICES
];
373 static spinlock_t serial_table_lock
;
375 static const s32 default_port_spec
[] = {
376 HSO_INTF_MUX
| HSO_PORT_NETWORK
,
377 HSO_INTF_BULK
| HSO_PORT_DIAG
,
378 HSO_INTF_BULK
| HSO_PORT_MODEM
,
382 static const s32 icon321_port_spec
[] = {
383 HSO_INTF_MUX
| HSO_PORT_NETWORK
,
384 HSO_INTF_BULK
| HSO_PORT_DIAG2
,
385 HSO_INTF_BULK
| HSO_PORT_MODEM
,
386 HSO_INTF_BULK
| HSO_PORT_DIAG
,
390 #define default_port_device(vendor, product) \
391 USB_DEVICE(vendor, product), \
392 .driver_info = (kernel_ulong_t)default_port_spec
394 #define icon321_port_device(vendor, product) \
395 USB_DEVICE(vendor, product), \
396 .driver_info = (kernel_ulong_t)icon321_port_spec
398 /* list of devices we support */
399 static const struct usb_device_id hso_ids
[] = {
400 {default_port_device(0x0af0, 0x6711)},
401 {default_port_device(0x0af0, 0x6731)},
402 {default_port_device(0x0af0, 0x6751)},
403 {default_port_device(0x0af0, 0x6771)},
404 {default_port_device(0x0af0, 0x6791)},
405 {default_port_device(0x0af0, 0x6811)},
406 {default_port_device(0x0af0, 0x6911)},
407 {default_port_device(0x0af0, 0x6951)},
408 {default_port_device(0x0af0, 0x6971)},
409 {default_port_device(0x0af0, 0x7011)},
410 {default_port_device(0x0af0, 0x7031)},
411 {default_port_device(0x0af0, 0x7051)},
412 {default_port_device(0x0af0, 0x7071)},
413 {default_port_device(0x0af0, 0x7111)},
414 {default_port_device(0x0af0, 0x7211)},
415 {default_port_device(0x0af0, 0x7251)},
416 {default_port_device(0x0af0, 0x7271)},
417 {default_port_device(0x0af0, 0x7311)},
418 {default_port_device(0x0af0, 0xc031)}, /* Icon-Edge */
419 {icon321_port_device(0x0af0, 0xd013)}, /* Module HSxPA */
420 {icon321_port_device(0x0af0, 0xd031)}, /* Icon-321 */
421 {icon321_port_device(0x0af0, 0xd033)}, /* Icon-322 */
422 {USB_DEVICE(0x0af0, 0x7301)}, /* GE40x */
423 {USB_DEVICE(0x0af0, 0x7361)}, /* GE40x */
424 {USB_DEVICE(0x0af0, 0x7381)}, /* GE40x */
425 {USB_DEVICE(0x0af0, 0x7401)}, /* GI 0401 */
426 {USB_DEVICE(0x0af0, 0x7501)}, /* GTM 382 */
427 {USB_DEVICE(0x0af0, 0x7601)}, /* GE40x */
428 {USB_DEVICE(0x0af0, 0x7701)},
429 {USB_DEVICE(0x0af0, 0x7706)},
430 {USB_DEVICE(0x0af0, 0x7801)},
431 {USB_DEVICE(0x0af0, 0x7901)},
432 {USB_DEVICE(0x0af0, 0x7A01)},
433 {USB_DEVICE(0x0af0, 0x7A05)},
434 {USB_DEVICE(0x0af0, 0x8200)},
435 {USB_DEVICE(0x0af0, 0x8201)},
436 {USB_DEVICE(0x0af0, 0x8300)},
437 {USB_DEVICE(0x0af0, 0x8302)},
438 {USB_DEVICE(0x0af0, 0x8304)},
439 {USB_DEVICE(0x0af0, 0x8400)},
440 {USB_DEVICE(0x0af0, 0x8600)},
441 {USB_DEVICE(0x0af0, 0x8800)},
442 {USB_DEVICE(0x0af0, 0x8900)},
443 {USB_DEVICE(0x0af0, 0x9000)},
444 {USB_DEVICE(0x0af0, 0x9200)}, /* Option GTM671WFS */
445 {USB_DEVICE(0x0af0, 0xd035)},
446 {USB_DEVICE(0x0af0, 0xd055)},
447 {USB_DEVICE(0x0af0, 0xd155)},
448 {USB_DEVICE(0x0af0, 0xd255)},
449 {USB_DEVICE(0x0af0, 0xd057)},
450 {USB_DEVICE(0x0af0, 0xd157)},
451 {USB_DEVICE(0x0af0, 0xd257)},
452 {USB_DEVICE(0x0af0, 0xd357)},
453 {USB_DEVICE(0x0af0, 0xd058)},
454 {USB_DEVICE(0x0af0, 0xc100)},
457 MODULE_DEVICE_TABLE(usb
, hso_ids
);
459 /* Sysfs attribute */
460 static ssize_t
hso_sysfs_show_porttype(struct device
*dev
,
461 struct device_attribute
*attr
,
464 struct hso_device
*hso_dev
= dev_get_drvdata(dev
);
470 switch (hso_dev
->port_spec
& HSO_PORT_MASK
) {
471 case HSO_PORT_CONTROL
:
472 port_name
= "Control";
475 port_name
= "Application";
478 port_name
= "Application2";
483 case HSO_PORT_GPS_CONTROL
:
484 port_name
= "GPS Control";
490 port_name
= "Diagnostic";
493 port_name
= "Diagnostic2";
498 case HSO_PORT_NETWORK
:
499 port_name
= "Network";
502 port_name
= "Unknown";
506 return sprintf(buf
, "%s\n", port_name
);
508 static DEVICE_ATTR(hsotype
, 0444, hso_sysfs_show_porttype
, NULL
);
510 static struct attribute
*hso_serial_dev_attrs
[] = {
511 &dev_attr_hsotype
.attr
,
515 ATTRIBUTE_GROUPS(hso_serial_dev
);
517 static int hso_urb_to_index(struct hso_serial
*serial
, struct urb
*urb
)
521 for (idx
= 0; idx
< serial
->num_rx_urbs
; idx
++)
522 if (serial
->rx_urb
[idx
] == urb
)
524 dev_err(serial
->parent
->dev
, "hso_urb_to_index failed\n");
528 /* converts mux value to a port spec value */
529 static u32
hso_mux_to_port(int mux
)
535 result
= HSO_PORT_CONTROL
;
538 result
= HSO_PORT_APP
;
541 result
= HSO_PORT_PCSC
;
544 result
= HSO_PORT_GPS
;
547 result
= HSO_PORT_APP2
;
550 result
= HSO_PORT_NO_PORT
;
555 /* converts port spec value to a mux value */
556 static u32
hso_port_to_mux(int port
)
560 switch (port
& HSO_PORT_MASK
) {
561 case HSO_PORT_CONTROL
:
582 static struct hso_serial
*get_serial_by_shared_int_and_type(
583 struct hso_shared_int
*shared_int
,
588 port
= hso_mux_to_port(mux
);
590 for (i
= 0; i
< HSO_SERIAL_TTY_MINORS
; i
++) {
591 if (serial_table
[i
] &&
592 (dev2ser(serial_table
[i
])->shared_int
== shared_int
) &&
593 ((serial_table
[i
]->port_spec
& HSO_PORT_MASK
) == port
)) {
594 return dev2ser(serial_table
[i
]);
601 static struct hso_serial
*get_serial_by_index(unsigned index
)
603 struct hso_serial
*serial
= NULL
;
606 spin_lock_irqsave(&serial_table_lock
, flags
);
607 if (serial_table
[index
])
608 serial
= dev2ser(serial_table
[index
]);
609 spin_unlock_irqrestore(&serial_table_lock
, flags
);
614 static int get_free_serial_index(void)
619 spin_lock_irqsave(&serial_table_lock
, flags
);
620 for (index
= 0; index
< HSO_SERIAL_TTY_MINORS
; index
++) {
621 if (serial_table
[index
] == NULL
) {
622 spin_unlock_irqrestore(&serial_table_lock
, flags
);
626 spin_unlock_irqrestore(&serial_table_lock
, flags
);
628 pr_err("%s: no free serial devices in table\n", __func__
);
632 static void set_serial_by_index(unsigned index
, struct hso_serial
*serial
)
636 spin_lock_irqsave(&serial_table_lock
, flags
);
638 serial_table
[index
] = serial
->parent
;
640 serial_table
[index
] = NULL
;
641 spin_unlock_irqrestore(&serial_table_lock
, flags
);
644 static void handle_usb_error(int status
, const char *function
,
645 struct hso_device
*hso_dev
)
651 explanation
= "no device";
654 explanation
= "endpoint not enabled";
657 explanation
= "endpoint stalled";
660 explanation
= "not enough bandwidth";
663 explanation
= "device disabled";
666 explanation
= "device suspended";
672 explanation
= "internal error";
678 explanation
= "protocol error";
680 usb_queue_reset_device(hso_dev
->interface
);
683 explanation
= "unknown status";
687 /* log a meaningful explanation of an USB status */
688 hso_dbg(0x1, "%s: received USB status - %s (%d)\n",
689 function
, explanation
, status
);
692 /* Network interface functions */
694 /* called when net interface is brought up by ifconfig */
695 static int hso_net_open(struct net_device
*net
)
697 struct hso_net
*odev
= netdev_priv(net
);
698 unsigned long flags
= 0;
701 dev_err(&net
->dev
, "No net device !\n");
705 odev
->skb_tx_buf
= NULL
;
707 /* setup environment */
708 spin_lock_irqsave(&odev
->net_lock
, flags
);
709 odev
->rx_parse_state
= WAIT_IP
;
710 odev
->rx_buf_size
= 0;
711 odev
->rx_buf_missing
= sizeof(struct iphdr
);
712 spin_unlock_irqrestore(&odev
->net_lock
, flags
);
714 /* We are up and running. */
715 set_bit(HSO_NET_RUNNING
, &odev
->flags
);
716 hso_start_net_device(odev
->parent
);
718 /* Tell the kernel we are ready to start receiving from it */
719 netif_start_queue(net
);
724 /* called when interface is brought down by ifconfig */
725 static int hso_net_close(struct net_device
*net
)
727 struct hso_net
*odev
= netdev_priv(net
);
729 /* we don't need the queue anymore */
730 netif_stop_queue(net
);
731 /* no longer running */
732 clear_bit(HSO_NET_RUNNING
, &odev
->flags
);
734 hso_stop_net_device(odev
->parent
);
740 /* USB tells is xmit done, we should start the netqueue again */
741 static void write_bulk_callback(struct urb
*urb
)
743 struct hso_net
*odev
= urb
->context
;
744 int status
= urb
->status
;
747 if (!odev
|| !test_bit(HSO_NET_RUNNING
, &odev
->flags
)) {
748 dev_err(&urb
->dev
->dev
, "%s: device not running\n", __func__
);
752 /* Do we still have a valid kernel network device? */
753 if (!netif_device_present(odev
->net
)) {
754 dev_err(&urb
->dev
->dev
, "%s: net device not present\n",
759 /* log status, but don't act on it, we don't need to resubmit anything
762 handle_usb_error(status
, __func__
, odev
->parent
);
764 hso_put_activity(odev
->parent
);
766 /* Tell the network interface we are ready for another frame */
767 netif_wake_queue(odev
->net
);
770 /* called by kernel when we need to transmit a packet */
771 static netdev_tx_t
hso_net_start_xmit(struct sk_buff
*skb
,
772 struct net_device
*net
)
774 struct hso_net
*odev
= netdev_priv(net
);
777 /* Tell the kernel, "No more frames 'til we are done with this one." */
778 netif_stop_queue(net
);
779 if (hso_get_activity(odev
->parent
) == -EAGAIN
) {
780 odev
->skb_tx_buf
= skb
;
785 DUMP1(skb
->data
, skb
->len
);
786 /* Copy it from kernel memory to OUR memory */
787 memcpy(odev
->mux_bulk_tx_buf
, skb
->data
, skb
->len
);
788 hso_dbg(0x1, "len: %d/%d\n", skb
->len
, MUX_BULK_TX_BUF_SIZE
);
790 /* Fill in the URB for shipping it out. */
791 usb_fill_bulk_urb(odev
->mux_bulk_tx_urb
,
793 usb_sndbulkpipe(odev
->parent
->usb
,
795 bEndpointAddress
& 0x7F),
796 odev
->mux_bulk_tx_buf
, skb
->len
, write_bulk_callback
,
799 /* Deal with the Zero Length packet problem, I hope */
800 odev
->mux_bulk_tx_urb
->transfer_flags
|= URB_ZERO_PACKET
;
802 /* Send the URB on its merry way. */
803 result
= usb_submit_urb(odev
->mux_bulk_tx_urb
, GFP_ATOMIC
);
805 dev_warn(&odev
->parent
->interface
->dev
,
806 "failed mux_bulk_tx_urb %d\n", result
);
807 net
->stats
.tx_errors
++;
808 netif_start_queue(net
);
810 net
->stats
.tx_packets
++;
811 net
->stats
.tx_bytes
+= skb
->len
;
818 static const struct ethtool_ops ops
= {
819 .get_link
= ethtool_op_get_link
822 /* called when a packet did not ack after watchdogtimeout */
823 static void hso_net_tx_timeout(struct net_device
*net
)
825 struct hso_net
*odev
= netdev_priv(net
);
830 /* Tell syslog we are hosed. */
831 dev_warn(&net
->dev
, "Tx timed out.\n");
833 /* Tear the waiting frame off the list */
834 if (odev
->mux_bulk_tx_urb
&&
835 (odev
->mux_bulk_tx_urb
->status
== -EINPROGRESS
))
836 usb_unlink_urb(odev
->mux_bulk_tx_urb
);
838 /* Update statistics */
839 net
->stats
.tx_errors
++;
842 /* make a real packet from the received USB buffer */
843 static void packetizeRx(struct hso_net
*odev
, unsigned char *ip_pkt
,
844 unsigned int count
, unsigned char is_eop
)
846 unsigned short temp_bytes
;
847 unsigned short buffer_offset
= 0;
848 unsigned short frame_len
;
851 hso_dbg(0x1, "Rx %d bytes\n", count
);
852 DUMP(ip_pkt
, min(128, (int)count
));
855 switch (odev
->rx_parse_state
) {
857 /* waiting for IP header. */
858 /* wanted bytes - size of ip header */
861 odev
->rx_buf_missing
) ? count
: odev
->
864 memcpy(((unsigned char *)(&odev
->rx_ip_hdr
)) +
865 odev
->rx_buf_size
, ip_pkt
+ buffer_offset
,
868 odev
->rx_buf_size
+= temp_bytes
;
869 buffer_offset
+= temp_bytes
;
870 odev
->rx_buf_missing
-= temp_bytes
;
873 if (!odev
->rx_buf_missing
) {
874 /* header is complete allocate an sk_buffer and
875 * continue to WAIT_DATA */
876 frame_len
= ntohs(odev
->rx_ip_hdr
.tot_len
);
878 if ((frame_len
> DEFAULT_MRU
) ||
879 (frame_len
< sizeof(struct iphdr
))) {
880 dev_err(&odev
->net
->dev
,
881 "Invalid frame (%d) length\n",
883 odev
->rx_parse_state
= WAIT_SYNC
;
886 /* Allocate an sk_buff */
887 odev
->skb_rx_buf
= netdev_alloc_skb(odev
->net
,
889 if (!odev
->skb_rx_buf
) {
890 /* We got no receive buffer. */
891 hso_dbg(0x1, "could not allocate memory\n");
892 odev
->rx_parse_state
= WAIT_SYNC
;
896 /* Copy what we got so far. make room for iphdr
898 skb_put_data(odev
->skb_rx_buf
,
899 (char *)&(odev
->rx_ip_hdr
),
900 sizeof(struct iphdr
));
903 odev
->rx_buf_size
= sizeof(struct iphdr
);
905 /* Filip actually use .tot_len */
906 odev
->rx_buf_missing
=
907 frame_len
- sizeof(struct iphdr
);
908 odev
->rx_parse_state
= WAIT_DATA
;
913 temp_bytes
= (count
< odev
->rx_buf_missing
)
914 ? count
: odev
->rx_buf_missing
;
916 /* Copy the rest of the bytes that are left in the
917 * buffer into the waiting sk_buf. */
918 /* Make room for temp_bytes after tail. */
919 skb_put_data(odev
->skb_rx_buf
,
920 ip_pkt
+ buffer_offset
,
923 odev
->rx_buf_missing
-= temp_bytes
;
925 buffer_offset
+= temp_bytes
;
926 odev
->rx_buf_size
+= temp_bytes
;
927 if (!odev
->rx_buf_missing
) {
928 /* Packet is complete. Inject into stack. */
929 /* We have IP packet here */
930 odev
->skb_rx_buf
->protocol
= cpu_to_be16(ETH_P_IP
);
931 skb_reset_mac_header(odev
->skb_rx_buf
);
933 /* Ship it off to the kernel */
934 netif_rx(odev
->skb_rx_buf
);
935 /* No longer our buffer. */
936 odev
->skb_rx_buf
= NULL
;
938 /* update out statistics */
939 odev
->net
->stats
.rx_packets
++;
941 odev
->net
->stats
.rx_bytes
+= odev
->rx_buf_size
;
943 odev
->rx_buf_size
= 0;
944 odev
->rx_buf_missing
= sizeof(struct iphdr
);
945 odev
->rx_parse_state
= WAIT_IP
;
950 hso_dbg(0x1, " W_S\n");
960 /* Recovery mechanism for WAIT_SYNC state. */
962 if (odev
->rx_parse_state
== WAIT_SYNC
) {
963 odev
->rx_parse_state
= WAIT_IP
;
964 odev
->rx_buf_size
= 0;
965 odev
->rx_buf_missing
= sizeof(struct iphdr
);
970 static void fix_crc_bug(struct urb
*urb
, __le16 max_packet_size
)
972 static const u8 crc_check
[4] = { 0xDE, 0xAD, 0xBE, 0xEF };
973 u32 rest
= urb
->actual_length
% le16_to_cpu(max_packet_size
);
975 if (((rest
== 5) || (rest
== 6)) &&
976 !memcmp(((u8
*)urb
->transfer_buffer
) + urb
->actual_length
- 4,
978 urb
->actual_length
-= 4;
982 /* Moving data from usb to kernel (in interrupt state) */
983 static void read_bulk_callback(struct urb
*urb
)
985 struct hso_net
*odev
= urb
->context
;
986 struct net_device
*net
;
989 int status
= urb
->status
;
991 /* is al ok? (Filip: Who's Al ?) */
993 handle_usb_error(status
, __func__
, odev
->parent
);
998 if (!odev
|| !test_bit(HSO_NET_RUNNING
, &odev
->flags
)) {
999 hso_dbg(0x1, "BULK IN callback but driver is not active!\n");
1002 usb_mark_last_busy(urb
->dev
);
1006 if (!netif_device_present(net
)) {
1007 /* Somebody killed our network interface... */
1011 if (odev
->parent
->port_spec
& HSO_INFO_CRC_BUG
)
1012 fix_crc_bug(urb
, odev
->in_endp
->wMaxPacketSize
);
1014 /* do we even have a packet? */
1015 if (urb
->actual_length
) {
1016 /* Handle the IP stream, add header and push it onto network
1017 * stack if the packet is complete. */
1018 spin_lock_irqsave(&odev
->net_lock
, flags
);
1019 packetizeRx(odev
, urb
->transfer_buffer
, urb
->actual_length
,
1020 (urb
->transfer_buffer_length
>
1021 urb
->actual_length
) ? 1 : 0);
1022 spin_unlock_irqrestore(&odev
->net_lock
, flags
);
1025 /* We are done with this URB, resubmit it. Prep the USB to wait for
1026 * another frame. Reuse same as received. */
1027 usb_fill_bulk_urb(urb
,
1029 usb_rcvbulkpipe(odev
->parent
->usb
,
1031 bEndpointAddress
& 0x7F),
1032 urb
->transfer_buffer
, MUX_BULK_RX_BUF_SIZE
,
1033 read_bulk_callback
, odev
);
1035 /* Give this to the USB subsystem so it can tell us when more data
1037 result
= usb_submit_urb(urb
, GFP_ATOMIC
);
1039 dev_warn(&odev
->parent
->interface
->dev
,
1040 "%s failed submit mux_bulk_rx_urb %d\n", __func__
,
1044 /* Serial driver functions */
1046 static void hso_init_termios(struct ktermios
*termios
)
1049 * The default requirements for this device are:
1052 ~(IGNBRK
/* disable ignore break */
1053 | BRKINT
/* disable break causes interrupt */
1054 | PARMRK
/* disable mark parity errors */
1055 | ISTRIP
/* disable clear high bit of input characters */
1056 | INLCR
/* disable translate NL to CR */
1057 | IGNCR
/* disable ignore CR */
1058 | ICRNL
/* disable translate CR to NL */
1059 | IXON
); /* disable enable XON/XOFF flow control */
1061 /* disable postprocess output characters */
1062 termios
->c_oflag
&= ~OPOST
;
1065 ~(ECHO
/* disable echo input characters */
1066 | ECHONL
/* disable echo new line */
1067 | ICANON
/* disable erase, kill, werase, and rprnt
1068 special characters */
1069 | ISIG
/* disable interrupt, quit, and suspend special
1071 | IEXTEN
); /* disable non-POSIX special characters */
1074 ~(CSIZE
/* no size */
1075 | PARENB
/* disable parity bit */
1076 | CBAUD
/* clear current baud rate */
1077 | CBAUDEX
); /* clear current buad rate */
1079 termios
->c_cflag
|= CS8
; /* character size 8 bits */
1081 /* baud rate 115200 */
1082 tty_termios_encode_baud_rate(termios
, 115200, 115200);
1085 static void _hso_serial_set_termios(struct tty_struct
*tty
,
1086 struct ktermios
*old
)
1088 struct hso_serial
*serial
= tty
->driver_data
;
1091 pr_err("%s: no tty structures", __func__
);
1095 hso_dbg(0x8, "port %d\n", serial
->minor
);
1098 * Fix up unsupported bits
1100 tty
->termios
.c_iflag
&= ~IXON
; /* disable enable XON/XOFF flow control */
1102 tty
->termios
.c_cflag
&=
1103 ~(CSIZE
/* no size */
1104 | PARENB
/* disable parity bit */
1105 | CBAUD
/* clear current baud rate */
1106 | CBAUDEX
); /* clear current buad rate */
1108 tty
->termios
.c_cflag
|= CS8
; /* character size 8 bits */
1110 /* baud rate 115200 */
1111 tty_encode_baud_rate(tty
, 115200, 115200);
1114 static void hso_resubmit_rx_bulk_urb(struct hso_serial
*serial
, struct urb
*urb
)
1117 /* We are done with this URB, resubmit it. Prep the USB to wait for
1119 usb_fill_bulk_urb(urb
, serial
->parent
->usb
,
1120 usb_rcvbulkpipe(serial
->parent
->usb
,
1122 bEndpointAddress
& 0x7F),
1123 urb
->transfer_buffer
, serial
->rx_data_length
,
1124 hso_std_serial_read_bulk_callback
, serial
);
1125 /* Give this to the USB subsystem so it can tell us when more data
1127 result
= usb_submit_urb(urb
, GFP_ATOMIC
);
1129 dev_err(&urb
->dev
->dev
, "%s failed submit serial rx_urb %d\n",
1137 static void put_rxbuf_data_and_resubmit_bulk_urb(struct hso_serial
*serial
)
1140 struct urb
*curr_urb
;
1142 while (serial
->rx_urb_filled
[serial
->curr_rx_urb_idx
]) {
1143 curr_urb
= serial
->rx_urb
[serial
->curr_rx_urb_idx
];
1144 count
= put_rxbuf_data(curr_urb
, serial
);
1148 serial
->curr_rx_urb_idx
++;
1149 if (serial
->curr_rx_urb_idx
>= serial
->num_rx_urbs
)
1150 serial
->curr_rx_urb_idx
= 0;
1151 hso_resubmit_rx_bulk_urb(serial
, curr_urb
);
1156 static void put_rxbuf_data_and_resubmit_ctrl_urb(struct hso_serial
*serial
)
1161 urb
= serial
->rx_urb
[0];
1162 if (serial
->port
.count
> 0) {
1163 count
= put_rxbuf_data(urb
, serial
);
1167 /* Re issue a read as long as we receive data. */
1169 if (count
== 0 && ((urb
->actual_length
!= 0) ||
1170 (serial
->rx_state
== RX_PENDING
))) {
1171 serial
->rx_state
= RX_SENT
;
1172 hso_mux_serial_read(serial
);
1174 serial
->rx_state
= RX_IDLE
;
1178 /* read callback for Diag and CS port */
1179 static void hso_std_serial_read_bulk_callback(struct urb
*urb
)
1181 struct hso_serial
*serial
= urb
->context
;
1182 int status
= urb
->status
;
1183 unsigned long flags
;
1185 hso_dbg(0x8, "--- Got serial_read_bulk callback %02x ---\n", status
);
1189 hso_dbg(0x1, "serial == NULL\n");
1193 handle_usb_error(status
, __func__
, serial
->parent
);
1197 hso_dbg(0x1, "Actual length = %d\n", urb
->actual_length
);
1198 DUMP1(urb
->transfer_buffer
, urb
->actual_length
);
1200 /* Anyone listening? */
1201 if (serial
->port
.count
== 0)
1204 if (serial
->parent
->port_spec
& HSO_INFO_CRC_BUG
)
1205 fix_crc_bug(urb
, serial
->in_endp
->wMaxPacketSize
);
1206 /* Valid data, handle RX data */
1207 spin_lock_irqsave(&serial
->serial_lock
, flags
);
1208 serial
->rx_urb_filled
[hso_urb_to_index(serial
, urb
)] = 1;
1209 put_rxbuf_data_and_resubmit_bulk_urb(serial
);
1210 spin_unlock_irqrestore(&serial
->serial_lock
, flags
);
1214 * This needs to be a tasklet otherwise we will
1215 * end up recursively calling this function.
1217 static void hso_unthrottle_tasklet(struct hso_serial
*serial
)
1219 unsigned long flags
;
1221 spin_lock_irqsave(&serial
->serial_lock
, flags
);
1222 if ((serial
->parent
->port_spec
& HSO_INTF_MUX
))
1223 put_rxbuf_data_and_resubmit_ctrl_urb(serial
);
1225 put_rxbuf_data_and_resubmit_bulk_urb(serial
);
1226 spin_unlock_irqrestore(&serial
->serial_lock
, flags
);
1229 static void hso_unthrottle(struct tty_struct
*tty
)
1231 struct hso_serial
*serial
= tty
->driver_data
;
1233 tasklet_hi_schedule(&serial
->unthrottle_tasklet
);
1236 /* open the requested serial port */
1237 static int hso_serial_open(struct tty_struct
*tty
, struct file
*filp
)
1239 struct hso_serial
*serial
= get_serial_by_index(tty
->index
);
1243 if (serial
== NULL
|| serial
->magic
!= HSO_SERIAL_MAGIC
) {
1245 tty
->driver_data
= NULL
;
1246 hso_dbg(0x1, "Failed to open port\n");
1250 mutex_lock(&serial
->parent
->mutex
);
1251 result
= usb_autopm_get_interface(serial
->parent
->interface
);
1255 hso_dbg(0x1, "Opening %d\n", serial
->minor
);
1258 tty
->driver_data
= serial
;
1259 tty_port_tty_set(&serial
->port
, tty
);
1261 /* check for port already opened, if not set the termios */
1262 serial
->port
.count
++;
1263 if (serial
->port
.count
== 1) {
1264 serial
->rx_state
= RX_IDLE
;
1265 /* Force default termio settings */
1266 _hso_serial_set_termios(tty
, NULL
);
1267 tasklet_init(&serial
->unthrottle_tasklet
,
1268 (void (*)(unsigned long))hso_unthrottle_tasklet
,
1269 (unsigned long)serial
);
1270 result
= hso_start_serial_device(serial
->parent
, GFP_KERNEL
);
1272 hso_stop_serial_device(serial
->parent
);
1273 serial
->port
.count
--;
1275 kref_get(&serial
->parent
->ref
);
1278 hso_dbg(0x1, "Port was already open\n");
1281 usb_autopm_put_interface(serial
->parent
->interface
);
1285 hso_serial_tiocmset(tty
, TIOCM_RTS
| TIOCM_DTR
, 0);
1287 mutex_unlock(&serial
->parent
->mutex
);
1291 /* close the requested serial port */
1292 static void hso_serial_close(struct tty_struct
*tty
, struct file
*filp
)
1294 struct hso_serial
*serial
= tty
->driver_data
;
1297 hso_dbg(0x1, "Closing serial port\n");
1299 /* Open failed, no close cleanup required */
1303 mutex_lock(&serial
->parent
->mutex
);
1304 usb_gone
= serial
->parent
->usb_gone
;
1307 usb_autopm_get_interface(serial
->parent
->interface
);
1309 /* reset the rts and dtr */
1310 /* do the actual close */
1311 serial
->port
.count
--;
1313 if (serial
->port
.count
<= 0) {
1314 serial
->port
.count
= 0;
1315 tty_port_tty_set(&serial
->port
, NULL
);
1317 hso_stop_serial_device(serial
->parent
);
1318 tasklet_kill(&serial
->unthrottle_tasklet
);
1322 usb_autopm_put_interface(serial
->parent
->interface
);
1324 mutex_unlock(&serial
->parent
->mutex
);
1327 /* close the requested serial port */
1328 static int hso_serial_write(struct tty_struct
*tty
, const unsigned char *buf
,
1331 struct hso_serial
*serial
= tty
->driver_data
;
1332 int space
, tx_bytes
;
1333 unsigned long flags
;
1336 if (serial
== NULL
) {
1337 pr_err("%s: serial is NULL\n", __func__
);
1341 spin_lock_irqsave(&serial
->serial_lock
, flags
);
1343 space
= serial
->tx_data_length
- serial
->tx_buffer_count
;
1344 tx_bytes
= (count
< space
) ? count
: space
;
1349 memcpy(serial
->tx_buffer
+ serial
->tx_buffer_count
, buf
, tx_bytes
);
1350 serial
->tx_buffer_count
+= tx_bytes
;
1353 spin_unlock_irqrestore(&serial
->serial_lock
, flags
);
1355 hso_kick_transmit(serial
);
1360 /* how much room is there for writing */
1361 static int hso_serial_write_room(struct tty_struct
*tty
)
1363 struct hso_serial
*serial
= tty
->driver_data
;
1365 unsigned long flags
;
1367 spin_lock_irqsave(&serial
->serial_lock
, flags
);
1368 room
= serial
->tx_data_length
- serial
->tx_buffer_count
;
1369 spin_unlock_irqrestore(&serial
->serial_lock
, flags
);
1371 /* return free room */
1375 static void hso_serial_cleanup(struct tty_struct
*tty
)
1377 struct hso_serial
*serial
= tty
->driver_data
;
1382 kref_put(&serial
->parent
->ref
, hso_serial_ref_free
);
1385 /* setup the term */
1386 static void hso_serial_set_termios(struct tty_struct
*tty
, struct ktermios
*old
)
1388 struct hso_serial
*serial
= tty
->driver_data
;
1389 unsigned long flags
;
1392 hso_dbg(0x16, "Termios called with: cflags new[%d] - old[%d]\n",
1393 tty
->termios
.c_cflag
, old
->c_cflag
);
1395 /* the actual setup */
1396 spin_lock_irqsave(&serial
->serial_lock
, flags
);
1397 if (serial
->port
.count
)
1398 _hso_serial_set_termios(tty
, old
);
1400 tty
->termios
= *old
;
1401 spin_unlock_irqrestore(&serial
->serial_lock
, flags
);
1406 /* how many characters in the buffer */
1407 static int hso_serial_chars_in_buffer(struct tty_struct
*tty
)
1409 struct hso_serial
*serial
= tty
->driver_data
;
1411 unsigned long flags
;
1417 spin_lock_irqsave(&serial
->serial_lock
, flags
);
1418 chars
= serial
->tx_buffer_count
;
1419 spin_unlock_irqrestore(&serial
->serial_lock
, flags
);
1423 static int tiocmget_submit_urb(struct hso_serial
*serial
,
1424 struct hso_tiocmget
*tiocmget
,
1425 struct usb_device
*usb
)
1429 if (serial
->parent
->usb_gone
)
1431 usb_fill_int_urb(tiocmget
->urb
, usb
,
1434 bEndpointAddress
& 0x7F),
1435 &tiocmget
->serial_state_notification
,
1436 sizeof(struct hso_serial_state_notification
),
1437 tiocmget_intr_callback
, serial
,
1438 tiocmget
->endp
->bInterval
);
1439 result
= usb_submit_urb(tiocmget
->urb
, GFP_ATOMIC
);
1441 dev_warn(&usb
->dev
, "%s usb_submit_urb failed %d\n", __func__
,
1448 static void tiocmget_intr_callback(struct urb
*urb
)
1450 struct hso_serial
*serial
= urb
->context
;
1451 struct hso_tiocmget
*tiocmget
;
1452 int status
= urb
->status
;
1453 u16 UART_state_bitmap
, prev_UART_state_bitmap
;
1454 struct uart_icount
*icount
;
1455 struct hso_serial_state_notification
*serial_state_notification
;
1456 struct usb_device
*usb
;
1457 struct usb_interface
*interface
;
1464 handle_usb_error(status
, __func__
, serial
->parent
);
1468 /* tiocmget is only supported on HSO_PORT_MODEM */
1469 tiocmget
= serial
->tiocmget
;
1472 BUG_ON((serial
->parent
->port_spec
& HSO_PORT_MASK
) != HSO_PORT_MODEM
);
1474 usb
= serial
->parent
->usb
;
1475 interface
= serial
->parent
->interface
;
1477 if_num
= interface
->cur_altsetting
->desc
.bInterfaceNumber
;
1479 /* wIndex should be the USB interface number of the port to which the
1480 * notification applies, which should always be the Modem port.
1482 serial_state_notification
= &tiocmget
->serial_state_notification
;
1483 if (serial_state_notification
->bmRequestType
!= BM_REQUEST_TYPE
||
1484 serial_state_notification
->bNotification
!= B_NOTIFICATION
||
1485 le16_to_cpu(serial_state_notification
->wValue
) != W_VALUE
||
1486 le16_to_cpu(serial_state_notification
->wIndex
) != if_num
||
1487 le16_to_cpu(serial_state_notification
->wLength
) != W_LENGTH
) {
1489 "hso received invalid serial state notification\n");
1490 DUMP(serial_state_notification
,
1491 sizeof(struct hso_serial_state_notification
));
1493 unsigned long flags
;
1495 UART_state_bitmap
= le16_to_cpu(serial_state_notification
->
1497 prev_UART_state_bitmap
= tiocmget
->prev_UART_state_bitmap
;
1498 icount
= &tiocmget
->icount
;
1499 spin_lock_irqsave(&serial
->serial_lock
, flags
);
1500 if ((UART_state_bitmap
& B_OVERRUN
) !=
1501 (prev_UART_state_bitmap
& B_OVERRUN
))
1503 if ((UART_state_bitmap
& B_PARITY
) !=
1504 (prev_UART_state_bitmap
& B_PARITY
))
1506 if ((UART_state_bitmap
& B_FRAMING
) !=
1507 (prev_UART_state_bitmap
& B_FRAMING
))
1509 if ((UART_state_bitmap
& B_RING_SIGNAL
) &&
1510 !(prev_UART_state_bitmap
& B_RING_SIGNAL
))
1512 if ((UART_state_bitmap
& B_BREAK
) !=
1513 (prev_UART_state_bitmap
& B_BREAK
))
1515 if ((UART_state_bitmap
& B_TX_CARRIER
) !=
1516 (prev_UART_state_bitmap
& B_TX_CARRIER
))
1518 if ((UART_state_bitmap
& B_RX_CARRIER
) !=
1519 (prev_UART_state_bitmap
& B_RX_CARRIER
))
1521 tiocmget
->prev_UART_state_bitmap
= UART_state_bitmap
;
1522 spin_unlock_irqrestore(&serial
->serial_lock
, flags
);
1523 tiocmget
->intr_completed
= 1;
1524 wake_up_interruptible(&tiocmget
->waitq
);
1526 memset(serial_state_notification
, 0,
1527 sizeof(struct hso_serial_state_notification
));
1528 tiocmget_submit_urb(serial
,
1530 serial
->parent
->usb
);
1534 * next few functions largely stolen from drivers/serial/serial_core.c
1536 /* Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
1537 * - mask passed in arg for lines of interest
1538 * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
1539 * Caller should use TIOCGICOUNT to see which one it was
1542 hso_wait_modem_status(struct hso_serial
*serial
, unsigned long arg
)
1544 DECLARE_WAITQUEUE(wait
, current
);
1545 struct uart_icount cprev
, cnow
;
1546 struct hso_tiocmget
*tiocmget
;
1549 tiocmget
= serial
->tiocmget
;
1553 * note the counters on entry
1555 spin_lock_irq(&serial
->serial_lock
);
1556 memcpy(&cprev
, &tiocmget
->icount
, sizeof(struct uart_icount
));
1557 spin_unlock_irq(&serial
->serial_lock
);
1558 add_wait_queue(&tiocmget
->waitq
, &wait
);
1560 spin_lock_irq(&serial
->serial_lock
);
1561 memcpy(&cnow
, &tiocmget
->icount
, sizeof(struct uart_icount
));
1562 spin_unlock_irq(&serial
->serial_lock
);
1563 set_current_state(TASK_INTERRUPTIBLE
);
1564 if (((arg
& TIOCM_RNG
) && (cnow
.rng
!= cprev
.rng
)) ||
1565 ((arg
& TIOCM_DSR
) && (cnow
.dsr
!= cprev
.dsr
)) ||
1566 ((arg
& TIOCM_CD
) && (cnow
.dcd
!= cprev
.dcd
))) {
1571 /* see if a signal did it */
1572 if (signal_pending(current
)) {
1578 __set_current_state(TASK_RUNNING
);
1579 remove_wait_queue(&tiocmget
->waitq
, &wait
);
1585 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
1586 * Return: write counters to the user passed counter struct
1587 * NB: both 1->0 and 0->1 transitions are counted except for
1588 * RI where only 0->1 is counted.
1590 static int hso_get_count(struct tty_struct
*tty
,
1591 struct serial_icounter_struct
*icount
)
1593 struct uart_icount cnow
;
1594 struct hso_serial
*serial
= tty
->driver_data
;
1595 struct hso_tiocmget
*tiocmget
= serial
->tiocmget
;
1597 memset(icount
, 0, sizeof(struct serial_icounter_struct
));
1601 spin_lock_irq(&serial
->serial_lock
);
1602 memcpy(&cnow
, &tiocmget
->icount
, sizeof(struct uart_icount
));
1603 spin_unlock_irq(&serial
->serial_lock
);
1605 icount
->cts
= cnow
.cts
;
1606 icount
->dsr
= cnow
.dsr
;
1607 icount
->rng
= cnow
.rng
;
1608 icount
->dcd
= cnow
.dcd
;
1609 icount
->rx
= cnow
.rx
;
1610 icount
->tx
= cnow
.tx
;
1611 icount
->frame
= cnow
.frame
;
1612 icount
->overrun
= cnow
.overrun
;
1613 icount
->parity
= cnow
.parity
;
1614 icount
->brk
= cnow
.brk
;
1615 icount
->buf_overrun
= cnow
.buf_overrun
;
1621 static int hso_serial_tiocmget(struct tty_struct
*tty
)
1624 struct hso_serial
*serial
= tty
->driver_data
;
1625 struct hso_tiocmget
*tiocmget
;
1626 u16 UART_state_bitmap
;
1630 hso_dbg(0x1, "no tty structures\n");
1633 spin_lock_irq(&serial
->serial_lock
);
1634 retval
= ((serial
->rts_state
) ? TIOCM_RTS
: 0) |
1635 ((serial
->dtr_state
) ? TIOCM_DTR
: 0);
1636 tiocmget
= serial
->tiocmget
;
1639 UART_state_bitmap
= le16_to_cpu(
1640 tiocmget
->prev_UART_state_bitmap
);
1641 if (UART_state_bitmap
& B_RING_SIGNAL
)
1642 retval
|= TIOCM_RNG
;
1643 if (UART_state_bitmap
& B_RX_CARRIER
)
1645 if (UART_state_bitmap
& B_TX_CARRIER
)
1646 retval
|= TIOCM_DSR
;
1648 spin_unlock_irq(&serial
->serial_lock
);
1652 static int hso_serial_tiocmset(struct tty_struct
*tty
,
1653 unsigned int set
, unsigned int clear
)
1656 unsigned long flags
;
1658 struct hso_serial
*serial
= tty
->driver_data
;
1659 struct usb_interface
*interface
;
1663 hso_dbg(0x1, "no tty structures\n");
1667 if ((serial
->parent
->port_spec
& HSO_PORT_MASK
) != HSO_PORT_MODEM
)
1670 interface
= serial
->parent
->interface
;
1671 if_num
= interface
->cur_altsetting
->desc
.bInterfaceNumber
;
1673 spin_lock_irqsave(&serial
->serial_lock
, flags
);
1674 if (set
& TIOCM_RTS
)
1675 serial
->rts_state
= 1;
1676 if (set
& TIOCM_DTR
)
1677 serial
->dtr_state
= 1;
1679 if (clear
& TIOCM_RTS
)
1680 serial
->rts_state
= 0;
1681 if (clear
& TIOCM_DTR
)
1682 serial
->dtr_state
= 0;
1684 if (serial
->dtr_state
)
1686 if (serial
->rts_state
)
1689 spin_unlock_irqrestore(&serial
->serial_lock
, flags
);
1691 return usb_control_msg(serial
->parent
->usb
,
1692 usb_rcvctrlpipe(serial
->parent
->usb
, 0), 0x22,
1693 0x21, val
, if_num
, NULL
, 0,
1694 USB_CTRL_SET_TIMEOUT
);
1697 static int hso_serial_ioctl(struct tty_struct
*tty
,
1698 unsigned int cmd
, unsigned long arg
)
1700 struct hso_serial
*serial
= tty
->driver_data
;
1702 hso_dbg(0x8, "IOCTL cmd: %d, arg: %ld\n", cmd
, arg
);
1708 ret
= hso_wait_modem_status(serial
, arg
);
1718 /* starts a transmit */
1719 static void hso_kick_transmit(struct hso_serial
*serial
)
1721 unsigned long flags
;
1724 spin_lock_irqsave(&serial
->serial_lock
, flags
);
1725 if (!serial
->tx_buffer_count
)
1728 if (serial
->tx_urb_used
)
1731 /* Wakeup USB interface if necessary */
1732 if (hso_get_activity(serial
->parent
) == -EAGAIN
)
1735 /* Switch pointers around to avoid memcpy */
1736 swap(serial
->tx_buffer
, serial
->tx_data
);
1737 serial
->tx_data_count
= serial
->tx_buffer_count
;
1738 serial
->tx_buffer_count
= 0;
1740 /* If serial->tx_data is set, it means we switched buffers */
1741 if (serial
->tx_data
&& serial
->write_data
) {
1742 res
= serial
->write_data(serial
);
1744 serial
->tx_urb_used
= 1;
1747 spin_unlock_irqrestore(&serial
->serial_lock
, flags
);
1750 /* make a request (for reading and writing data to muxed serial port) */
1751 static int mux_device_request(struct hso_serial
*serial
, u8 type
, u16 port
,
1752 struct urb
*ctrl_urb
,
1753 struct usb_ctrlrequest
*ctrl_req
,
1754 u8
*ctrl_urb_data
, u32 size
)
1760 if (!serial
|| !ctrl_urb
|| !ctrl_req
) {
1761 pr_err("%s: Wrong arguments\n", __func__
);
1766 ctrl_req
->wValue
= 0;
1767 ctrl_req
->wIndex
= cpu_to_le16(hso_port_to_mux(port
));
1768 ctrl_req
->wLength
= cpu_to_le16(size
);
1770 if (type
== USB_CDC_GET_ENCAPSULATED_RESPONSE
) {
1771 /* Reading command */
1772 ctrl_req
->bRequestType
= USB_DIR_IN
|
1773 USB_TYPE_OPTION_VENDOR
|
1774 USB_RECIP_INTERFACE
;
1775 ctrl_req
->bRequest
= USB_CDC_GET_ENCAPSULATED_RESPONSE
;
1776 pipe
= usb_rcvctrlpipe(serial
->parent
->usb
, 0);
1778 /* Writing command */
1779 ctrl_req
->bRequestType
= USB_DIR_OUT
|
1780 USB_TYPE_OPTION_VENDOR
|
1781 USB_RECIP_INTERFACE
;
1782 ctrl_req
->bRequest
= USB_CDC_SEND_ENCAPSULATED_COMMAND
;
1783 pipe
= usb_sndctrlpipe(serial
->parent
->usb
, 0);
1786 hso_dbg(0x2, "%s command (%02x) len: %d, port: %d\n",
1787 type
== USB_CDC_GET_ENCAPSULATED_RESPONSE
? "Read" : "Write",
1788 ctrl_req
->bRequestType
, ctrl_req
->wLength
, port
);
1791 ctrl_urb
->transfer_flags
= 0;
1792 usb_fill_control_urb(ctrl_urb
,
1793 serial
->parent
->usb
,
1796 ctrl_urb_data
, size
, ctrl_callback
, serial
);
1797 /* Send it on merry way */
1798 result
= usb_submit_urb(ctrl_urb
, GFP_ATOMIC
);
1800 dev_err(&ctrl_urb
->dev
->dev
,
1801 "%s failed submit ctrl_urb %d type %d\n", __func__
,
1810 /* called by intr_callback when read occurs */
1811 static int hso_mux_serial_read(struct hso_serial
*serial
)
1817 memset(serial
->rx_data
[0], 0, CTRL_URB_RX_SIZE
);
1818 /* make the request */
1820 if (serial
->num_rx_urbs
!= 1) {
1821 dev_err(&serial
->parent
->interface
->dev
,
1822 "ERROR: mux'd reads with multiple buffers "
1826 return mux_device_request(serial
,
1827 USB_CDC_GET_ENCAPSULATED_RESPONSE
,
1828 serial
->parent
->port_spec
& HSO_PORT_MASK
,
1830 &serial
->ctrl_req_rx
,
1831 serial
->rx_data
[0], serial
->rx_data_length
);
1834 /* used for muxed serial port callback (muxed serial read) */
1835 static void intr_callback(struct urb
*urb
)
1837 struct hso_shared_int
*shared_int
= urb
->context
;
1838 struct hso_serial
*serial
;
1839 unsigned char *port_req
;
1840 int status
= urb
->status
;
1841 unsigned long flags
;
1844 usb_mark_last_busy(urb
->dev
);
1852 handle_usb_error(status
, __func__
, NULL
);
1855 hso_dbg(0x8, "--- Got intr callback 0x%02X ---\n", status
);
1858 port_req
= urb
->transfer_buffer
;
1859 hso_dbg(0x8, "port_req = 0x%.2X\n", *port_req
);
1860 /* loop over all muxed ports to find the one sending this */
1861 for (i
= 0; i
< 8; i
++) {
1862 /* max 8 channels on MUX */
1863 if (*port_req
& (1 << i
)) {
1864 serial
= get_serial_by_shared_int_and_type(shared_int
,
1866 if (serial
!= NULL
) {
1867 hso_dbg(0x1, "Pending read interrupt on port %d\n",
1869 spin_lock_irqsave(&serial
->serial_lock
, flags
);
1870 if (serial
->rx_state
== RX_IDLE
&&
1871 serial
->port
.count
> 0) {
1872 /* Setup and send a ctrl req read on
1874 if (!serial
->rx_urb_filled
[0]) {
1875 serial
->rx_state
= RX_SENT
;
1876 hso_mux_serial_read(serial
);
1878 serial
->rx_state
= RX_PENDING
;
1880 hso_dbg(0x1, "Already a read pending on port %d or port not open\n",
1883 spin_unlock_irqrestore(&serial
->serial_lock
,
1888 /* Resubmit interrupt urb */
1889 hso_mux_submit_intr_urb(shared_int
, urb
->dev
, GFP_ATOMIC
);
1892 /* called for writing to muxed serial port */
1893 static int hso_mux_serial_write_data(struct hso_serial
*serial
)
1898 return mux_device_request(serial
,
1899 USB_CDC_SEND_ENCAPSULATED_COMMAND
,
1900 serial
->parent
->port_spec
& HSO_PORT_MASK
,
1902 &serial
->ctrl_req_tx
,
1903 serial
->tx_data
, serial
->tx_data_count
);
1906 /* write callback for Diag and CS port */
1907 static void hso_std_serial_write_bulk_callback(struct urb
*urb
)
1909 struct hso_serial
*serial
= urb
->context
;
1910 int status
= urb
->status
;
1911 unsigned long flags
;
1915 hso_dbg(0x1, "serial == NULL\n");
1919 spin_lock_irqsave(&serial
->serial_lock
, flags
);
1920 serial
->tx_urb_used
= 0;
1921 spin_unlock_irqrestore(&serial
->serial_lock
, flags
);
1923 handle_usb_error(status
, __func__
, serial
->parent
);
1926 hso_put_activity(serial
->parent
);
1927 tty_port_tty_wakeup(&serial
->port
);
1928 hso_kick_transmit(serial
);
1933 /* called for writing diag or CS serial port */
1934 static int hso_std_serial_write_data(struct hso_serial
*serial
)
1936 int count
= serial
->tx_data_count
;
1939 usb_fill_bulk_urb(serial
->tx_urb
,
1940 serial
->parent
->usb
,
1941 usb_sndbulkpipe(serial
->parent
->usb
,
1943 bEndpointAddress
& 0x7F),
1944 serial
->tx_data
, serial
->tx_data_count
,
1945 hso_std_serial_write_bulk_callback
, serial
);
1947 result
= usb_submit_urb(serial
->tx_urb
, GFP_ATOMIC
);
1949 dev_warn(&serial
->parent
->usb
->dev
,
1950 "Failed to submit urb - res %d\n", result
);
1957 /* callback after read or write on muxed serial port */
1958 static void ctrl_callback(struct urb
*urb
)
1960 struct hso_serial
*serial
= urb
->context
;
1961 struct usb_ctrlrequest
*req
;
1962 int status
= urb
->status
;
1963 unsigned long flags
;
1969 spin_lock_irqsave(&serial
->serial_lock
, flags
);
1970 serial
->tx_urb_used
= 0;
1971 spin_unlock_irqrestore(&serial
->serial_lock
, flags
);
1973 handle_usb_error(status
, __func__
, serial
->parent
);
1978 req
= (struct usb_ctrlrequest
*)(urb
->setup_packet
);
1979 hso_dbg(0x8, "--- Got muxed ctrl callback 0x%02X ---\n", status
);
1980 hso_dbg(0x8, "Actual length of urb = %d\n", urb
->actual_length
);
1981 DUMP1(urb
->transfer_buffer
, urb
->actual_length
);
1983 if (req
->bRequestType
==
1984 (USB_DIR_IN
| USB_TYPE_OPTION_VENDOR
| USB_RECIP_INTERFACE
)) {
1985 /* response to a read command */
1986 serial
->rx_urb_filled
[0] = 1;
1987 spin_lock_irqsave(&serial
->serial_lock
, flags
);
1988 put_rxbuf_data_and_resubmit_ctrl_urb(serial
);
1989 spin_unlock_irqrestore(&serial
->serial_lock
, flags
);
1991 hso_put_activity(serial
->parent
);
1992 tty_port_tty_wakeup(&serial
->port
);
1993 /* response to a write command */
1994 hso_kick_transmit(serial
);
1998 /* handle RX data for serial port */
1999 static int put_rxbuf_data(struct urb
*urb
, struct hso_serial
*serial
)
2001 struct tty_struct
*tty
;
2005 if (urb
== NULL
|| serial
== NULL
) {
2006 hso_dbg(0x1, "serial = NULL\n");
2010 tty
= tty_port_tty_get(&serial
->port
);
2012 if (tty
&& tty_throttled(tty
)) {
2017 /* Push data to tty */
2018 hso_dbg(0x1, "data to push to tty\n");
2019 count
= tty_buffer_request_room(&serial
->port
, urb
->actual_length
);
2020 if (count
>= urb
->actual_length
) {
2021 tty_insert_flip_string(&serial
->port
, urb
->transfer_buffer
,
2022 urb
->actual_length
);
2023 tty_flip_buffer_push(&serial
->port
);
2025 dev_warn(&serial
->parent
->usb
->dev
,
2026 "dropping data, %d bytes lost\n", urb
->actual_length
);
2031 serial
->rx_urb_filled
[hso_urb_to_index(serial
, urb
)] = 0;
2037 /* Base driver functions */
2039 static void hso_log_port(struct hso_device
*hso_dev
)
2044 switch (hso_dev
->port_spec
& HSO_PORT_MASK
) {
2045 case HSO_PORT_CONTROL
:
2046 port_type
= "Control";
2049 port_type
= "Application";
2054 case HSO_PORT_GPS_CONTROL
:
2055 port_type
= "GPS control";
2058 port_type
= "Application2";
2064 port_type
= "Diagnostic";
2066 case HSO_PORT_DIAG2
:
2067 port_type
= "Diagnostic2";
2069 case HSO_PORT_MODEM
:
2070 port_type
= "Modem";
2072 case HSO_PORT_NETWORK
:
2073 port_type
= "Network";
2076 port_type
= "Unknown";
2079 if ((hso_dev
->port_spec
& HSO_PORT_MASK
) == HSO_PORT_NETWORK
) {
2080 sprintf(port_dev
, "%s", dev2net(hso_dev
)->net
->name
);
2082 sprintf(port_dev
, "/dev/%s%d", tty_filename
,
2083 dev2ser(hso_dev
)->minor
);
2085 dev_dbg(&hso_dev
->interface
->dev
, "HSO: Found %s port %s\n",
2086 port_type
, port_dev
);
2089 static int hso_start_net_device(struct hso_device
*hso_dev
)
2092 struct hso_net
*hso_net
= dev2net(hso_dev
);
2097 /* send URBs for all read buffers */
2098 for (i
= 0; i
< MUX_BULK_RX_BUF_COUNT
; i
++) {
2100 /* Prep a receive URB */
2101 usb_fill_bulk_urb(hso_net
->mux_bulk_rx_urb_pool
[i
],
2103 usb_rcvbulkpipe(hso_dev
->usb
,
2105 bEndpointAddress
& 0x7F),
2106 hso_net
->mux_bulk_rx_buf_pool
[i
],
2107 MUX_BULK_RX_BUF_SIZE
, read_bulk_callback
,
2110 /* Put it out there so the device can send us stuff */
2111 result
= usb_submit_urb(hso_net
->mux_bulk_rx_urb_pool
[i
],
2114 dev_warn(&hso_dev
->usb
->dev
,
2115 "%s failed mux_bulk_rx_urb[%d] %d\n", __func__
,
2122 static int hso_stop_net_device(struct hso_device
*hso_dev
)
2125 struct hso_net
*hso_net
= dev2net(hso_dev
);
2130 for (i
= 0; i
< MUX_BULK_RX_BUF_COUNT
; i
++) {
2131 if (hso_net
->mux_bulk_rx_urb_pool
[i
])
2132 usb_kill_urb(hso_net
->mux_bulk_rx_urb_pool
[i
]);
2135 if (hso_net
->mux_bulk_tx_urb
)
2136 usb_kill_urb(hso_net
->mux_bulk_tx_urb
);
2141 static int hso_start_serial_device(struct hso_device
*hso_dev
, gfp_t flags
)
2144 struct hso_serial
*serial
= dev2ser(hso_dev
);
2149 /* If it is not the MUX port fill in and submit a bulk urb (already
2150 * allocated in hso_serial_start) */
2151 if (!(serial
->parent
->port_spec
& HSO_INTF_MUX
)) {
2152 for (i
= 0; i
< serial
->num_rx_urbs
; i
++) {
2153 usb_fill_bulk_urb(serial
->rx_urb
[i
],
2154 serial
->parent
->usb
,
2155 usb_rcvbulkpipe(serial
->parent
->usb
,
2160 serial
->rx_data_length
,
2161 hso_std_serial_read_bulk_callback
,
2163 result
= usb_submit_urb(serial
->rx_urb
[i
], flags
);
2165 dev_warn(&serial
->parent
->usb
->dev
,
2166 "Failed to submit urb - res %d\n",
2172 mutex_lock(&serial
->shared_int
->shared_int_lock
);
2173 if (!serial
->shared_int
->use_count
) {
2175 hso_mux_submit_intr_urb(serial
->shared_int
,
2176 hso_dev
->usb
, flags
);
2178 serial
->shared_int
->use_count
++;
2179 mutex_unlock(&serial
->shared_int
->shared_int_lock
);
2181 if (serial
->tiocmget
)
2182 tiocmget_submit_urb(serial
,
2184 serial
->parent
->usb
);
2188 static int hso_stop_serial_device(struct hso_device
*hso_dev
)
2191 struct hso_serial
*serial
= dev2ser(hso_dev
);
2192 struct hso_tiocmget
*tiocmget
;
2197 for (i
= 0; i
< serial
->num_rx_urbs
; i
++) {
2198 if (serial
->rx_urb
[i
]) {
2199 usb_kill_urb(serial
->rx_urb
[i
]);
2200 serial
->rx_urb_filled
[i
] = 0;
2203 serial
->curr_rx_urb_idx
= 0;
2206 usb_kill_urb(serial
->tx_urb
);
2208 if (serial
->shared_int
) {
2209 mutex_lock(&serial
->shared_int
->shared_int_lock
);
2210 if (serial
->shared_int
->use_count
&&
2211 (--serial
->shared_int
->use_count
== 0)) {
2214 urb
= serial
->shared_int
->shared_intr_urb
;
2218 mutex_unlock(&serial
->shared_int
->shared_int_lock
);
2220 tiocmget
= serial
->tiocmget
;
2222 wake_up_interruptible(&tiocmget
->waitq
);
2223 usb_kill_urb(tiocmget
->urb
);
2229 static void hso_serial_tty_unregister(struct hso_serial
*serial
)
2231 tty_unregister_device(tty_drv
, serial
->minor
);
2234 static void hso_serial_common_free(struct hso_serial
*serial
)
2238 for (i
= 0; i
< serial
->num_rx_urbs
; i
++) {
2239 /* unlink and free RX URB */
2240 usb_free_urb(serial
->rx_urb
[i
]);
2241 /* free the RX buffer */
2242 kfree(serial
->rx_data
[i
]);
2245 /* unlink and free TX URB */
2246 usb_free_urb(serial
->tx_urb
);
2247 kfree(serial
->tx_buffer
);
2248 kfree(serial
->tx_data
);
2249 tty_port_destroy(&serial
->port
);
2252 static int hso_serial_common_create(struct hso_serial
*serial
, int num_urbs
,
2253 int rx_size
, int tx_size
)
2258 tty_port_init(&serial
->port
);
2260 minor
= get_free_serial_index();
2264 /* register our minor number */
2265 serial
->parent
->dev
= tty_port_register_device_attr(&serial
->port
,
2266 tty_drv
, minor
, &serial
->parent
->interface
->dev
,
2267 serial
->parent
, hso_serial_dev_groups
);
2269 /* fill in specific data for later use */
2270 serial
->minor
= minor
;
2271 serial
->magic
= HSO_SERIAL_MAGIC
;
2272 spin_lock_init(&serial
->serial_lock
);
2273 serial
->num_rx_urbs
= num_urbs
;
2275 /* RX, allocate urb and initialize */
2277 /* prepare our RX buffer */
2278 serial
->rx_data_length
= rx_size
;
2279 for (i
= 0; i
< serial
->num_rx_urbs
; i
++) {
2280 serial
->rx_urb
[i
] = usb_alloc_urb(0, GFP_KERNEL
);
2281 if (!serial
->rx_urb
[i
])
2283 serial
->rx_urb
[i
]->transfer_buffer
= NULL
;
2284 serial
->rx_urb
[i
]->transfer_buffer_length
= 0;
2285 serial
->rx_data
[i
] = kzalloc(serial
->rx_data_length
,
2287 if (!serial
->rx_data
[i
])
2291 /* TX, allocate urb and initialize */
2292 serial
->tx_urb
= usb_alloc_urb(0, GFP_KERNEL
);
2293 if (!serial
->tx_urb
)
2295 serial
->tx_urb
->transfer_buffer
= NULL
;
2296 serial
->tx_urb
->transfer_buffer_length
= 0;
2297 /* prepare our TX buffer */
2298 serial
->tx_data_count
= 0;
2299 serial
->tx_buffer_count
= 0;
2300 serial
->tx_data_length
= tx_size
;
2301 serial
->tx_data
= kzalloc(serial
->tx_data_length
, GFP_KERNEL
);
2302 if (!serial
->tx_data
)
2305 serial
->tx_buffer
= kzalloc(serial
->tx_data_length
, GFP_KERNEL
);
2306 if (!serial
->tx_buffer
)
2311 hso_serial_tty_unregister(serial
);
2312 hso_serial_common_free(serial
);
2316 /* Creates a general hso device */
2317 static struct hso_device
*hso_create_device(struct usb_interface
*intf
,
2320 struct hso_device
*hso_dev
;
2322 hso_dev
= kzalloc(sizeof(*hso_dev
), GFP_ATOMIC
);
2326 hso_dev
->port_spec
= port_spec
;
2327 hso_dev
->usb
= interface_to_usbdev(intf
);
2328 hso_dev
->interface
= intf
;
2329 kref_init(&hso_dev
->ref
);
2330 mutex_init(&hso_dev
->mutex
);
2332 INIT_WORK(&hso_dev
->async_get_intf
, async_get_intf
);
2333 INIT_WORK(&hso_dev
->async_put_intf
, async_put_intf
);
2338 /* Removes a network device in the network device table */
2339 static int remove_net_device(struct hso_device
*hso_dev
)
2343 for (i
= 0; i
< HSO_MAX_NET_DEVICES
; i
++) {
2344 if (network_table
[i
] == hso_dev
) {
2345 network_table
[i
] = NULL
;
2349 if (i
== HSO_MAX_NET_DEVICES
)
2354 /* Frees our network device */
2355 static void hso_free_net_device(struct hso_device
*hso_dev
)
2358 struct hso_net
*hso_net
= dev2net(hso_dev
);
2363 remove_net_device(hso_net
->parent
);
2366 unregister_netdev(hso_net
->net
);
2369 for (i
= 0; i
< MUX_BULK_RX_BUF_COUNT
; i
++) {
2370 usb_free_urb(hso_net
->mux_bulk_rx_urb_pool
[i
]);
2371 kfree(hso_net
->mux_bulk_rx_buf_pool
[i
]);
2372 hso_net
->mux_bulk_rx_buf_pool
[i
] = NULL
;
2374 usb_free_urb(hso_net
->mux_bulk_tx_urb
);
2375 kfree(hso_net
->mux_bulk_tx_buf
);
2376 hso_net
->mux_bulk_tx_buf
= NULL
;
2379 free_netdev(hso_net
->net
);
2384 static const struct net_device_ops hso_netdev_ops
= {
2385 .ndo_open
= hso_net_open
,
2386 .ndo_stop
= hso_net_close
,
2387 .ndo_start_xmit
= hso_net_start_xmit
,
2388 .ndo_tx_timeout
= hso_net_tx_timeout
,
2391 /* initialize the network interface */
2392 static void hso_net_init(struct net_device
*net
)
2394 struct hso_net
*hso_net
= netdev_priv(net
);
2396 hso_dbg(0x1, "sizeof hso_net is %zu\n", sizeof(*hso_net
));
2398 /* fill in the other fields */
2399 net
->netdev_ops
= &hso_netdev_ops
;
2400 net
->watchdog_timeo
= HSO_NET_TX_TIMEOUT
;
2401 net
->flags
= IFF_POINTOPOINT
| IFF_NOARP
| IFF_MULTICAST
;
2402 net
->type
= ARPHRD_NONE
;
2403 net
->mtu
= DEFAULT_MTU
- 14;
2404 net
->tx_queue_len
= 10;
2405 net
->ethtool_ops
= &ops
;
2407 /* and initialize the semaphore */
2408 spin_lock_init(&hso_net
->net_lock
);
2411 /* Adds a network device in the network device table */
2412 static int add_net_device(struct hso_device
*hso_dev
)
2416 for (i
= 0; i
< HSO_MAX_NET_DEVICES
; i
++) {
2417 if (network_table
[i
] == NULL
) {
2418 network_table
[i
] = hso_dev
;
2422 if (i
== HSO_MAX_NET_DEVICES
)
2427 static int hso_rfkill_set_block(void *data
, bool blocked
)
2429 struct hso_device
*hso_dev
= data
;
2430 int enabled
= !blocked
;
2433 mutex_lock(&hso_dev
->mutex
);
2434 if (hso_dev
->usb_gone
)
2437 rv
= usb_control_msg(hso_dev
->usb
, usb_rcvctrlpipe(hso_dev
->usb
, 0),
2438 enabled
? 0x82 : 0x81, 0x40, 0, 0, NULL
, 0,
2439 USB_CTRL_SET_TIMEOUT
);
2440 mutex_unlock(&hso_dev
->mutex
);
2444 static const struct rfkill_ops hso_rfkill_ops
= {
2445 .set_block
= hso_rfkill_set_block
,
2448 /* Creates and sets up everything for rfkill */
2449 static void hso_create_rfkill(struct hso_device
*hso_dev
,
2450 struct usb_interface
*interface
)
2452 struct hso_net
*hso_net
= dev2net(hso_dev
);
2453 struct device
*dev
= &hso_net
->net
->dev
;
2454 static u32 rfkill_counter
;
2456 snprintf(hso_net
->name
, sizeof(hso_net
->name
), "hso-%d",
2459 hso_net
->rfkill
= rfkill_alloc(hso_net
->name
,
2460 &interface_to_usbdev(interface
)->dev
,
2462 &hso_rfkill_ops
, hso_dev
);
2463 if (!hso_net
->rfkill
) {
2464 dev_err(dev
, "%s - Out of memory\n", __func__
);
2467 if (rfkill_register(hso_net
->rfkill
) < 0) {
2468 rfkill_destroy(hso_net
->rfkill
);
2469 hso_net
->rfkill
= NULL
;
2470 dev_err(dev
, "%s - Failed to register rfkill\n", __func__
);
2475 static struct device_type hso_type
= {
2479 /* Creates our network device */
2480 static struct hso_device
*hso_create_net_device(struct usb_interface
*interface
,
2484 struct net_device
*net
;
2485 struct hso_net
*hso_net
;
2486 struct hso_device
*hso_dev
;
2488 hso_dev
= hso_create_device(interface
, port_spec
);
2492 /* allocate our network device, then we can put in our private data */
2493 /* call hso_net_init to do the basic initialization */
2494 net
= alloc_netdev(sizeof(struct hso_net
), "hso%d", NET_NAME_UNKNOWN
,
2497 dev_err(&interface
->dev
, "Unable to create ethernet device\n");
2501 hso_net
= netdev_priv(net
);
2503 hso_dev
->port_data
.dev_net
= hso_net
;
2505 hso_net
->parent
= hso_dev
;
2507 hso_net
->in_endp
= hso_get_ep(interface
, USB_ENDPOINT_XFER_BULK
,
2509 if (!hso_net
->in_endp
) {
2510 dev_err(&interface
->dev
, "Can't find BULK IN endpoint\n");
2513 hso_net
->out_endp
= hso_get_ep(interface
, USB_ENDPOINT_XFER_BULK
,
2515 if (!hso_net
->out_endp
) {
2516 dev_err(&interface
->dev
, "Can't find BULK OUT endpoint\n");
2519 SET_NETDEV_DEV(net
, &interface
->dev
);
2520 SET_NETDEV_DEVTYPE(net
, &hso_type
);
2522 /* start allocating */
2523 for (i
= 0; i
< MUX_BULK_RX_BUF_COUNT
; i
++) {
2524 hso_net
->mux_bulk_rx_urb_pool
[i
] = usb_alloc_urb(0, GFP_KERNEL
);
2525 if (!hso_net
->mux_bulk_rx_urb_pool
[i
])
2527 hso_net
->mux_bulk_rx_buf_pool
[i
] = kzalloc(MUX_BULK_RX_BUF_SIZE
,
2529 if (!hso_net
->mux_bulk_rx_buf_pool
[i
])
2532 hso_net
->mux_bulk_tx_urb
= usb_alloc_urb(0, GFP_KERNEL
);
2533 if (!hso_net
->mux_bulk_tx_urb
)
2535 hso_net
->mux_bulk_tx_buf
= kzalloc(MUX_BULK_TX_BUF_SIZE
, GFP_KERNEL
);
2536 if (!hso_net
->mux_bulk_tx_buf
)
2539 add_net_device(hso_dev
);
2541 /* registering our net device */
2542 result
= register_netdev(net
);
2544 dev_err(&interface
->dev
, "Failed to register device\n");
2548 hso_log_port(hso_dev
);
2550 hso_create_rfkill(hso_dev
, interface
);
2554 hso_free_net_device(hso_dev
);
2558 static void hso_free_tiomget(struct hso_serial
*serial
)
2560 struct hso_tiocmget
*tiocmget
;
2563 tiocmget
= serial
->tiocmget
;
2565 usb_free_urb(tiocmget
->urb
);
2566 tiocmget
->urb
= NULL
;
2567 serial
->tiocmget
= NULL
;
2572 /* Frees an AT channel ( goes for both mux and non-mux ) */
2573 static void hso_free_serial_device(struct hso_device
*hso_dev
)
2575 struct hso_serial
*serial
= dev2ser(hso_dev
);
2580 hso_serial_common_free(serial
);
2582 if (serial
->shared_int
) {
2583 mutex_lock(&serial
->shared_int
->shared_int_lock
);
2584 if (--serial
->shared_int
->ref_count
== 0)
2585 hso_free_shared_int(serial
->shared_int
);
2587 mutex_unlock(&serial
->shared_int
->shared_int_lock
);
2589 hso_free_tiomget(serial
);
2594 /* Creates a bulk AT channel */
2595 static struct hso_device
*hso_create_bulk_serial_device(
2596 struct usb_interface
*interface
, int port
)
2598 struct hso_device
*hso_dev
;
2599 struct hso_serial
*serial
;
2601 struct hso_tiocmget
*tiocmget
;
2603 hso_dev
= hso_create_device(interface
, port
);
2607 serial
= kzalloc(sizeof(*serial
), GFP_KERNEL
);
2611 serial
->parent
= hso_dev
;
2612 hso_dev
->port_data
.dev_serial
= serial
;
2614 if ((port
& HSO_PORT_MASK
) == HSO_PORT_MODEM
) {
2616 serial
->tiocmget
= kzalloc(sizeof(struct hso_tiocmget
),
2618 /* it isn't going to break our heart if serial->tiocmget
2619 * allocation fails don't bother checking this.
2621 if (serial
->tiocmget
) {
2622 tiocmget
= serial
->tiocmget
;
2623 tiocmget
->urb
= usb_alloc_urb(0, GFP_KERNEL
);
2624 if (tiocmget
->urb
) {
2625 mutex_init(&tiocmget
->mutex
);
2626 init_waitqueue_head(&tiocmget
->waitq
);
2627 tiocmget
->endp
= hso_get_ep(
2629 USB_ENDPOINT_XFER_INT
,
2632 hso_free_tiomget(serial
);
2638 if (hso_serial_common_create(serial
, num_urbs
, BULK_URB_RX_SIZE
,
2642 serial
->in_endp
= hso_get_ep(interface
, USB_ENDPOINT_XFER_BULK
,
2644 if (!serial
->in_endp
) {
2645 dev_err(&interface
->dev
, "Failed to find BULK IN ep\n");
2651 hso_get_ep(interface
, USB_ENDPOINT_XFER_BULK
, USB_DIR_OUT
))) {
2652 dev_err(&interface
->dev
, "Failed to find BULK IN ep\n");
2656 serial
->write_data
= hso_std_serial_write_data
;
2658 /* and record this serial */
2659 set_serial_by_index(serial
->minor
, serial
);
2661 /* setup the proc dirs and files if needed */
2662 hso_log_port(hso_dev
);
2664 /* done, return it */
2668 hso_serial_tty_unregister(serial
);
2669 hso_serial_common_free(serial
);
2671 hso_free_tiomget(serial
);
2677 /* Creates a multiplexed AT channel */
2679 struct hso_device
*hso_create_mux_serial_device(struct usb_interface
*interface
,
2681 struct hso_shared_int
*mux
)
2683 struct hso_device
*hso_dev
;
2684 struct hso_serial
*serial
;
2687 port_spec
= HSO_INTF_MUX
;
2688 port_spec
&= ~HSO_PORT_MASK
;
2690 port_spec
|= hso_mux_to_port(port
);
2691 if ((port_spec
& HSO_PORT_MASK
) == HSO_PORT_NO_PORT
)
2694 hso_dev
= hso_create_device(interface
, port_spec
);
2698 serial
= kzalloc(sizeof(*serial
), GFP_KERNEL
);
2702 hso_dev
->port_data
.dev_serial
= serial
;
2703 serial
->parent
= hso_dev
;
2705 if (hso_serial_common_create
2706 (serial
, 1, CTRL_URB_RX_SIZE
, CTRL_URB_TX_SIZE
))
2709 serial
->tx_data_length
--;
2710 serial
->write_data
= hso_mux_serial_write_data
;
2712 serial
->shared_int
= mux
;
2713 mutex_lock(&serial
->shared_int
->shared_int_lock
);
2714 serial
->shared_int
->ref_count
++;
2715 mutex_unlock(&serial
->shared_int
->shared_int_lock
);
2717 /* and record this serial */
2718 set_serial_by_index(serial
->minor
, serial
);
2720 /* setup the proc dirs and files if needed */
2721 hso_log_port(hso_dev
);
2723 /* done, return it */
2728 tty_unregister_device(tty_drv
, serial
->minor
);
2736 static void hso_free_shared_int(struct hso_shared_int
*mux
)
2738 usb_free_urb(mux
->shared_intr_urb
);
2739 kfree(mux
->shared_intr_buf
);
2740 mutex_unlock(&mux
->shared_int_lock
);
2745 struct hso_shared_int
*hso_create_shared_int(struct usb_interface
*interface
)
2747 struct hso_shared_int
*mux
= kzalloc(sizeof(*mux
), GFP_KERNEL
);
2752 mux
->intr_endp
= hso_get_ep(interface
, USB_ENDPOINT_XFER_INT
,
2754 if (!mux
->intr_endp
) {
2755 dev_err(&interface
->dev
, "Can't find INT IN endpoint\n");
2759 mux
->shared_intr_urb
= usb_alloc_urb(0, GFP_KERNEL
);
2760 if (!mux
->shared_intr_urb
)
2762 mux
->shared_intr_buf
=
2763 kzalloc(le16_to_cpu(mux
->intr_endp
->wMaxPacketSize
),
2765 if (!mux
->shared_intr_buf
)
2768 mutex_init(&mux
->shared_int_lock
);
2773 kfree(mux
->shared_intr_buf
);
2774 usb_free_urb(mux
->shared_intr_urb
);
2779 /* Gets the port spec for a certain interface */
2780 static int hso_get_config_data(struct usb_interface
*interface
)
2782 struct usb_device
*usbdev
= interface_to_usbdev(interface
);
2783 u8
*config_data
= kmalloc(17, GFP_KERNEL
);
2784 u32 if_num
= interface
->cur_altsetting
->desc
.bInterfaceNumber
;
2789 if (usb_control_msg(usbdev
, usb_rcvctrlpipe(usbdev
, 0),
2790 0x86, 0xC0, 0, 0, config_data
, 17,
2791 USB_CTRL_SET_TIMEOUT
) != 0x11) {
2796 /* check if we have a valid interface */
2802 switch (config_data
[if_num
]) {
2807 result
= HSO_PORT_DIAG
;
2810 result
= HSO_PORT_GPS
;
2813 result
= HSO_PORT_GPS_CONTROL
;
2816 result
= HSO_PORT_APP
;
2819 result
= HSO_PORT_APP2
;
2822 result
= HSO_PORT_CONTROL
;
2825 result
= HSO_PORT_NETWORK
;
2828 result
= HSO_PORT_MODEM
;
2831 result
= HSO_PORT_MSD
;
2834 result
= HSO_PORT_PCSC
;
2837 result
= HSO_PORT_VOICE
;
2844 result
|= HSO_INTF_BULK
;
2846 if (config_data
[16] & 0x1)
2847 result
|= HSO_INFO_CRC_BUG
;
2853 /* called once for each interface upon device insertion */
2854 static int hso_probe(struct usb_interface
*interface
,
2855 const struct usb_device_id
*id
)
2857 int mux
, i
, if_num
, port_spec
;
2858 unsigned char port_mask
;
2859 struct hso_device
*hso_dev
= NULL
;
2860 struct hso_shared_int
*shared_int
;
2861 struct hso_device
*tmp_dev
= NULL
;
2863 if (interface
->cur_altsetting
->desc
.bInterfaceClass
!= 0xFF) {
2864 dev_err(&interface
->dev
, "Not our interface\n");
2868 if_num
= interface
->cur_altsetting
->desc
.bInterfaceNumber
;
2870 /* Get the interface/port specification from either driver_info or from
2871 * the device itself */
2872 if (id
->driver_info
) {
2873 /* if_num is controlled by the device, driver_info is a 0 terminated
2874 * array. Make sure, the access is in bounds! */
2875 for (i
= 0; i
<= if_num
; ++i
)
2876 if (((u32
*)(id
->driver_info
))[i
] == 0)
2878 port_spec
= ((u32
*)(id
->driver_info
))[if_num
];
2880 port_spec
= hso_get_config_data(interface
);
2885 /* Check if we need to switch to alt interfaces prior to port
2887 if (interface
->num_altsetting
> 1)
2888 usb_set_interface(interface_to_usbdev(interface
), if_num
, 1);
2889 interface
->needs_remote_wakeup
= 1;
2891 /* Allocate new hso device(s) */
2892 switch (port_spec
& HSO_INTF_MASK
) {
2894 if ((port_spec
& HSO_PORT_MASK
) == HSO_PORT_NETWORK
) {
2895 /* Create the network device */
2897 hso_dev
= hso_create_net_device(interface
,
2905 if (hso_get_mux_ports(interface
, &port_mask
))
2906 /* TODO: de-allocate everything */
2909 shared_int
= hso_create_shared_int(interface
);
2913 for (i
= 1, mux
= 0; i
< 0x100; i
= i
<< 1, mux
++) {
2914 if (port_mask
& i
) {
2915 hso_dev
= hso_create_mux_serial_device(
2916 interface
, i
, shared_int
);
2927 /* It's a regular bulk interface */
2928 if ((port_spec
& HSO_PORT_MASK
) == HSO_PORT_NETWORK
) {
2931 hso_create_net_device(interface
, port_spec
);
2934 hso_create_bulk_serial_device(interface
, port_spec
);
2943 /* save our data pointer in this device */
2944 usb_set_intfdata(interface
, hso_dev
);
2949 hso_free_interface(interface
);
2953 /* device removed, cleaning up */
2954 static void hso_disconnect(struct usb_interface
*interface
)
2956 hso_free_interface(interface
);
2958 /* remove reference of our private data */
2959 usb_set_intfdata(interface
, NULL
);
2962 static void async_get_intf(struct work_struct
*data
)
2964 struct hso_device
*hso_dev
=
2965 container_of(data
, struct hso_device
, async_get_intf
);
2966 usb_autopm_get_interface(hso_dev
->interface
);
2969 static void async_put_intf(struct work_struct
*data
)
2971 struct hso_device
*hso_dev
=
2972 container_of(data
, struct hso_device
, async_put_intf
);
2973 usb_autopm_put_interface(hso_dev
->interface
);
2976 static int hso_get_activity(struct hso_device
*hso_dev
)
2978 if (hso_dev
->usb
->state
== USB_STATE_SUSPENDED
) {
2979 if (!hso_dev
->is_active
) {
2980 hso_dev
->is_active
= 1;
2981 schedule_work(&hso_dev
->async_get_intf
);
2985 if (hso_dev
->usb
->state
!= USB_STATE_CONFIGURED
)
2988 usb_mark_last_busy(hso_dev
->usb
);
2993 static int hso_put_activity(struct hso_device
*hso_dev
)
2995 if (hso_dev
->usb
->state
!= USB_STATE_SUSPENDED
) {
2996 if (hso_dev
->is_active
) {
2997 hso_dev
->is_active
= 0;
2998 schedule_work(&hso_dev
->async_put_intf
);
3002 hso_dev
->is_active
= 0;
3006 /* called by kernel when we need to suspend device */
3007 static int hso_suspend(struct usb_interface
*iface
, pm_message_t message
)
3011 /* Stop all serial ports */
3012 for (i
= 0; i
< HSO_SERIAL_TTY_MINORS
; i
++) {
3013 if (serial_table
[i
] && (serial_table
[i
]->interface
== iface
)) {
3014 result
= hso_stop_serial_device(serial_table
[i
]);
3020 /* Stop all network ports */
3021 for (i
= 0; i
< HSO_MAX_NET_DEVICES
; i
++) {
3022 if (network_table
[i
] &&
3023 (network_table
[i
]->interface
== iface
)) {
3024 result
= hso_stop_net_device(network_table
[i
]);
3034 /* called by kernel when we need to resume device */
3035 static int hso_resume(struct usb_interface
*iface
)
3038 struct hso_net
*hso_net
;
3040 /* Start all serial ports */
3041 for (i
= 0; i
< HSO_SERIAL_TTY_MINORS
; i
++) {
3042 if (serial_table
[i
] && (serial_table
[i
]->interface
== iface
)) {
3043 if (dev2ser(serial_table
[i
])->port
.count
) {
3045 hso_start_serial_device(serial_table
[i
], GFP_NOIO
);
3046 hso_kick_transmit(dev2ser(serial_table
[i
]));
3053 /* Start all network ports */
3054 for (i
= 0; i
< HSO_MAX_NET_DEVICES
; i
++) {
3055 if (network_table
[i
] &&
3056 (network_table
[i
]->interface
== iface
)) {
3057 hso_net
= dev2net(network_table
[i
]);
3058 if (hso_net
->flags
& IFF_UP
) {
3059 /* First transmit any lingering data,
3060 then restart the device. */
3061 if (hso_net
->skb_tx_buf
) {
3062 dev_dbg(&iface
->dev
,
3064 " lingering data\n");
3065 hso_net_start_xmit(hso_net
->skb_tx_buf
,
3067 hso_net
->skb_tx_buf
= NULL
;
3069 result
= hso_start_net_device(network_table
[i
]);
3080 static void hso_serial_ref_free(struct kref
*ref
)
3082 struct hso_device
*hso_dev
= container_of(ref
, struct hso_device
, ref
);
3084 hso_free_serial_device(hso_dev
);
3087 static void hso_free_interface(struct usb_interface
*interface
)
3089 struct hso_serial
*serial
;
3092 for (i
= 0; i
< HSO_SERIAL_TTY_MINORS
; i
++) {
3093 if (serial_table
[i
] &&
3094 (serial_table
[i
]->interface
== interface
)) {
3095 serial
= dev2ser(serial_table
[i
]);
3096 tty_port_tty_hangup(&serial
->port
, false);
3097 mutex_lock(&serial
->parent
->mutex
);
3098 serial
->parent
->usb_gone
= 1;
3099 mutex_unlock(&serial
->parent
->mutex
);
3100 cancel_work_sync(&serial_table
[i
]->async_put_intf
);
3101 cancel_work_sync(&serial_table
[i
]->async_get_intf
);
3102 hso_serial_tty_unregister(serial
);
3103 kref_put(&serial_table
[i
]->ref
, hso_serial_ref_free
);
3104 set_serial_by_index(i
, NULL
);
3108 for (i
= 0; i
< HSO_MAX_NET_DEVICES
; i
++) {
3109 if (network_table
[i
] &&
3110 (network_table
[i
]->interface
== interface
)) {
3111 struct rfkill
*rfk
= dev2net(network_table
[i
])->rfkill
;
3112 /* hso_stop_net_device doesn't stop the net queue since
3113 * traffic needs to start it again when suspended */
3114 netif_stop_queue(dev2net(network_table
[i
])->net
);
3115 hso_stop_net_device(network_table
[i
]);
3116 cancel_work_sync(&network_table
[i
]->async_put_intf
);
3117 cancel_work_sync(&network_table
[i
]->async_get_intf
);
3119 rfkill_unregister(rfk
);
3120 rfkill_destroy(rfk
);
3122 hso_free_net_device(network_table
[i
]);
3127 /* Helper functions */
3129 /* Get the endpoint ! */
3130 static struct usb_endpoint_descriptor
*hso_get_ep(struct usb_interface
*intf
,
3134 struct usb_host_interface
*iface
= intf
->cur_altsetting
;
3135 struct usb_endpoint_descriptor
*endp
;
3137 for (i
= 0; i
< iface
->desc
.bNumEndpoints
; i
++) {
3138 endp
= &iface
->endpoint
[i
].desc
;
3139 if (((endp
->bEndpointAddress
& USB_ENDPOINT_DIR_MASK
) == dir
) &&
3140 (usb_endpoint_type(endp
) == type
))
3147 /* Get the byte that describes which ports are enabled */
3148 static int hso_get_mux_ports(struct usb_interface
*intf
, unsigned char *ports
)
3151 struct usb_host_interface
*iface
= intf
->cur_altsetting
;
3153 if (iface
->extralen
== 3) {
3154 *ports
= iface
->extra
[2];
3158 for (i
= 0; i
< iface
->desc
.bNumEndpoints
; i
++) {
3159 if (iface
->endpoint
[i
].extralen
== 3) {
3160 *ports
= iface
->endpoint
[i
].extra
[2];
3168 /* interrupt urb needs to be submitted, used for serial read of muxed port */
3169 static int hso_mux_submit_intr_urb(struct hso_shared_int
*shared_int
,
3170 struct usb_device
*usb
, gfp_t gfp
)
3174 usb_fill_int_urb(shared_int
->shared_intr_urb
, usb
,
3176 shared_int
->intr_endp
->bEndpointAddress
& 0x7F),
3177 shared_int
->shared_intr_buf
,
3179 intr_callback
, shared_int
,
3180 shared_int
->intr_endp
->bInterval
);
3182 result
= usb_submit_urb(shared_int
->shared_intr_urb
, gfp
);
3184 dev_warn(&usb
->dev
, "%s failed mux_intr_urb %d\n", __func__
,
3190 /* operations setup of the serial interface */
3191 static const struct tty_operations hso_serial_ops
= {
3192 .open
= hso_serial_open
,
3193 .close
= hso_serial_close
,
3194 .write
= hso_serial_write
,
3195 .write_room
= hso_serial_write_room
,
3196 .cleanup
= hso_serial_cleanup
,
3197 .ioctl
= hso_serial_ioctl
,
3198 .set_termios
= hso_serial_set_termios
,
3199 .chars_in_buffer
= hso_serial_chars_in_buffer
,
3200 .tiocmget
= hso_serial_tiocmget
,
3201 .tiocmset
= hso_serial_tiocmset
,
3202 .get_icount
= hso_get_count
,
3203 .unthrottle
= hso_unthrottle
3206 static struct usb_driver hso_driver
= {
3207 .name
= driver_name
,
3209 .disconnect
= hso_disconnect
,
3210 .id_table
= hso_ids
,
3211 .suspend
= hso_suspend
,
3212 .resume
= hso_resume
,
3213 .reset_resume
= hso_resume
,
3214 .supports_autosuspend
= 1,
3215 .disable_hub_initiated_lpm
= 1,
3218 static int __init
hso_init(void)
3223 /* put it in the log */
3224 pr_info("%s\n", version
);
3226 /* Initialise the serial table semaphore and table */
3227 spin_lock_init(&serial_table_lock
);
3228 for (i
= 0; i
< HSO_SERIAL_TTY_MINORS
; i
++)
3229 serial_table
[i
] = NULL
;
3231 /* allocate our driver using the proper amount of supported minors */
3232 tty_drv
= alloc_tty_driver(HSO_SERIAL_TTY_MINORS
);
3236 /* fill in all needed values */
3237 tty_drv
->driver_name
= driver_name
;
3238 tty_drv
->name
= tty_filename
;
3240 /* if major number is provided as parameter, use that one */
3242 tty_drv
->major
= tty_major
;
3244 tty_drv
->minor_start
= 0;
3245 tty_drv
->type
= TTY_DRIVER_TYPE_SERIAL
;
3246 tty_drv
->subtype
= SERIAL_TYPE_NORMAL
;
3247 tty_drv
->flags
= TTY_DRIVER_REAL_RAW
| TTY_DRIVER_DYNAMIC_DEV
;
3248 tty_drv
->init_termios
= tty_std_termios
;
3249 hso_init_termios(&tty_drv
->init_termios
);
3250 tty_set_operations(tty_drv
, &hso_serial_ops
);
3252 /* register the tty driver */
3253 result
= tty_register_driver(tty_drv
);
3255 pr_err("%s - tty_register_driver failed(%d)\n",
3260 /* register this module as an usb driver */
3261 result
= usb_register(&hso_driver
);
3263 pr_err("Could not register hso driver - error: %d\n", result
);
3270 tty_unregister_driver(tty_drv
);
3272 put_tty_driver(tty_drv
);
3276 static void __exit
hso_exit(void)
3278 pr_info("unloaded\n");
3280 tty_unregister_driver(tty_drv
);
3281 /* deregister the usb driver */
3282 usb_deregister(&hso_driver
);
3283 put_tty_driver(tty_drv
);
3286 /* Module definitions */
3287 module_init(hso_init
);
3288 module_exit(hso_exit
);
3290 MODULE_AUTHOR(MOD_AUTHOR
);
3291 MODULE_DESCRIPTION(MOD_DESCRIPTION
);
3292 MODULE_LICENSE("GPL");
3294 /* change the debug level (eg: insmod hso.ko debug=0x04) */
3295 MODULE_PARM_DESC(debug
, "debug level mask [0x01 | 0x02 | 0x04 | 0x08 | 0x10]");
3296 module_param(debug
, int, 0644);
3298 /* set the major tty number (eg: insmod hso.ko tty_major=245) */
3299 MODULE_PARM_DESC(tty_major
, "Set the major tty number");
3300 module_param(tty_major
, int, 0644);
3302 /* disable network interface (eg: insmod hso.ko disable_net=1) */
3303 MODULE_PARM_DESC(disable_net
, "Disable the network interface");
3304 module_param(disable_net
, int, 0644);