1 // SPDX-License-Identifier: GPL-2.0
3 * IPWireless 3G PCMCIA Network Driver
6 * by Stephen Blackheath <stephen@blacksapphire.com>,
7 * Ben Martel <benm@symmetric.co.nz>
9 * Copyrighted as follows:
10 * Copyright (C) 2004 by Symmetric Systems Ltd (NZ)
12 * Various driver changes and rewrites, port to new kernels
13 * Copyright (C) 2006-2007 Jiri Kosina
15 * Misc code cleanups and updates
16 * Copyright (C) 2007 David Sterba
19 #include <linux/kernel.h>
20 #include <linux/module.h>
21 #include <linux/mutex.h>
22 #include <linux/ppp_defs.h>
24 #include <linux/ppp-ioctl.h>
25 #include <linux/sched.h>
26 #include <linux/serial.h>
27 #include <linux/slab.h>
28 #include <linux/tty.h>
29 #include <linux/tty_driver.h>
30 #include <linux/tty_flip.h>
31 #include <linux/uaccess.h>
38 #define IPWIRELESS_PCMCIA_START (0)
39 #define IPWIRELESS_PCMCIA_MINORS (24)
40 #define IPWIRELESS_PCMCIA_MINOR_RANGE (8)
42 #define TTYTYPE_MODEM (0)
43 #define TTYTYPE_MONITOR (1)
44 #define TTYTYPE_RAS_RAW (2)
49 struct ipw_hardware *hardware;
50 unsigned int channel_idx;
51 unsigned int secondary_channel_idx;
53 struct ipw_network *network;
54 unsigned int control_lines;
55 struct mutex ipw_tty_mutex;
60 static struct ipw_tty *ttys[IPWIRELESS_PCMCIA_MINORS];
62 static struct tty_driver *ipw_tty_driver;
64 static char *tty_type_name(int tty_type)
66 static char *channel_names[] = {
72 return channel_names[tty_type];
75 static struct ipw_tty *get_tty(int index)
78 * The 'ras_raw' channel is only available when 'loopback' mode
80 * Number of minor starts with 16 (_RANGE * _RAS_RAW).
82 if (!ipwireless_loopback && index >=
83 IPWIRELESS_PCMCIA_MINOR_RANGE * TTYTYPE_RAS_RAW)
89 static int ipw_open(struct tty_struct *linux_tty, struct file *filp)
91 struct ipw_tty *tty = get_tty(linux_tty->index);
96 mutex_lock(&tty->ipw_tty_mutex);
97 if (tty->port.count == 0)
98 tty->tx_bytes_queued = 0;
102 tty->port.tty = linux_tty;
103 linux_tty->driver_data = tty;
105 if (tty->tty_type == TTYTYPE_MODEM)
106 ipwireless_ppp_open(tty->network);
108 mutex_unlock(&tty->ipw_tty_mutex);
113 static void do_ipw_close(struct ipw_tty *tty)
117 if (tty->port.count == 0) {
118 struct tty_struct *linux_tty = tty->port.tty;
120 if (linux_tty != NULL) {
121 tty->port.tty = NULL;
122 linux_tty->driver_data = NULL;
124 if (tty->tty_type == TTYTYPE_MODEM)
125 ipwireless_ppp_close(tty->network);
130 static void ipw_hangup(struct tty_struct *linux_tty)
132 struct ipw_tty *tty = linux_tty->driver_data;
137 mutex_lock(&tty->ipw_tty_mutex);
138 if (tty->port.count == 0) {
139 mutex_unlock(&tty->ipw_tty_mutex);
145 mutex_unlock(&tty->ipw_tty_mutex);
148 static void ipw_close(struct tty_struct *linux_tty, struct file *filp)
150 ipw_hangup(linux_tty);
153 /* Take data received from hardware, and send it out the tty */
154 void ipwireless_tty_received(struct ipw_tty *tty, unsigned char *data,
159 mutex_lock(&tty->ipw_tty_mutex);
161 if (!tty->port.count) {
162 mutex_unlock(&tty->ipw_tty_mutex);
165 mutex_unlock(&tty->ipw_tty_mutex);
167 work = tty_insert_flip_string(&tty->port, data, length);
170 printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME
171 ": %d chars not inserted to flip buffer!\n",
175 tty_flip_buffer_push(&tty->port);
178 static void ipw_write_packet_sent_callback(void *callback_data,
179 unsigned int packet_length)
181 struct ipw_tty *tty = callback_data;
184 * Packet has been sent, so we subtract the number of bytes from our
185 * tally of outstanding TX bytes.
187 tty->tx_bytes_queued -= packet_length;
190 static int ipw_write(struct tty_struct *linux_tty,
191 const unsigned char *buf, int count)
193 struct ipw_tty *tty = linux_tty->driver_data;
199 mutex_lock(&tty->ipw_tty_mutex);
200 if (!tty->port.count) {
201 mutex_unlock(&tty->ipw_tty_mutex);
205 room = IPWIRELESS_TX_QUEUE_SIZE - tty->tx_bytes_queued;
208 /* Don't allow caller to write any more than we have room for */
213 mutex_unlock(&tty->ipw_tty_mutex);
217 ret = ipwireless_send_packet(tty->hardware, IPW_CHANNEL_RAS,
219 ipw_write_packet_sent_callback, tty);
221 mutex_unlock(&tty->ipw_tty_mutex);
225 tty->tx_bytes_queued += count;
226 mutex_unlock(&tty->ipw_tty_mutex);
231 static int ipw_write_room(struct tty_struct *linux_tty)
233 struct ipw_tty *tty = linux_tty->driver_data;
236 /* FIXME: Exactly how is the tty object locked here .. */
240 if (!tty->port.count)
243 room = IPWIRELESS_TX_QUEUE_SIZE - tty->tx_bytes_queued;
250 static int ipwireless_get_serial_info(struct tty_struct *linux_tty,
251 struct serial_struct *ss)
253 struct ipw_tty *tty = linux_tty->driver_data;
258 if (!tty->port.count)
261 ss->type = PORT_UNKNOWN;
262 ss->line = tty->index;
263 ss->baud_base = 115200;
267 static int ipwireless_set_serial_info(struct tty_struct *linux_tty,
268 struct serial_struct *ss)
270 return 0; /* Keeps the PCMCIA scripts happy. */
273 static int ipw_chars_in_buffer(struct tty_struct *linux_tty)
275 struct ipw_tty *tty = linux_tty->driver_data;
280 if (!tty->port.count)
283 return tty->tx_bytes_queued;
286 static int get_control_lines(struct ipw_tty *tty)
288 unsigned int my = tty->control_lines;
289 unsigned int out = 0;
291 if (my & IPW_CONTROL_LINE_RTS)
293 if (my & IPW_CONTROL_LINE_DTR)
295 if (my & IPW_CONTROL_LINE_CTS)
297 if (my & IPW_CONTROL_LINE_DSR)
299 if (my & IPW_CONTROL_LINE_DCD)
305 static int set_control_lines(struct ipw_tty *tty, unsigned int set,
310 if (set & TIOCM_RTS) {
311 ret = ipwireless_set_RTS(tty->hardware, tty->channel_idx, 1);
314 if (tty->secondary_channel_idx != -1) {
315 ret = ipwireless_set_RTS(tty->hardware,
316 tty->secondary_channel_idx, 1);
321 if (set & TIOCM_DTR) {
322 ret = ipwireless_set_DTR(tty->hardware, tty->channel_idx, 1);
325 if (tty->secondary_channel_idx != -1) {
326 ret = ipwireless_set_DTR(tty->hardware,
327 tty->secondary_channel_idx, 1);
332 if (clear & TIOCM_RTS) {
333 ret = ipwireless_set_RTS(tty->hardware, tty->channel_idx, 0);
334 if (tty->secondary_channel_idx != -1) {
335 ret = ipwireless_set_RTS(tty->hardware,
336 tty->secondary_channel_idx, 0);
341 if (clear & TIOCM_DTR) {
342 ret = ipwireless_set_DTR(tty->hardware, tty->channel_idx, 0);
343 if (tty->secondary_channel_idx != -1) {
344 ret = ipwireless_set_DTR(tty->hardware,
345 tty->secondary_channel_idx, 0);
353 static int ipw_tiocmget(struct tty_struct *linux_tty)
355 struct ipw_tty *tty = linux_tty->driver_data;
356 /* FIXME: Exactly how is the tty object locked here .. */
361 if (!tty->port.count)
364 return get_control_lines(tty);
368 ipw_tiocmset(struct tty_struct *linux_tty,
369 unsigned int set, unsigned int clear)
371 struct ipw_tty *tty = linux_tty->driver_data;
372 /* FIXME: Exactly how is the tty object locked here .. */
377 if (!tty->port.count)
380 return set_control_lines(tty, set, clear);
383 static int ipw_ioctl(struct tty_struct *linux_tty,
384 unsigned int cmd, unsigned long arg)
386 struct ipw_tty *tty = linux_tty->driver_data;
391 if (!tty->port.count)
394 /* FIXME: Exactly how is the tty object locked here .. */
395 if (tty->tty_type == TTYTYPE_MODEM) {
399 int chan = ipwireless_ppp_channel_index(
404 if (put_user(chan, (int __user *) arg))
411 int unit = ipwireless_ppp_unit_number(
416 if (put_user(unit, (int __user *) arg))
425 if (put_user(val, (int __user *) arg))
430 return tty_perform_flush(linux_tty, arg);
436 static int add_tty(int j,
437 struct ipw_hardware *hardware,
438 struct ipw_network *network, int channel_idx,
439 int secondary_channel_idx, int tty_type)
441 ttys[j] = kzalloc(sizeof(struct ipw_tty), GFP_KERNEL);
445 ttys[j]->hardware = hardware;
446 ttys[j]->channel_idx = channel_idx;
447 ttys[j]->secondary_channel_idx = secondary_channel_idx;
448 ttys[j]->network = network;
449 ttys[j]->tty_type = tty_type;
450 mutex_init(&ttys[j]->ipw_tty_mutex);
451 tty_port_init(&ttys[j]->port);
453 tty_port_register_device(&ttys[j]->port, ipw_tty_driver, j, NULL);
454 ipwireless_associate_network_tty(network, channel_idx, ttys[j]);
456 if (secondary_channel_idx != -1)
457 ipwireless_associate_network_tty(network,
458 secondary_channel_idx,
460 /* check if we provide raw device (if loopback is enabled) */
462 printk(KERN_INFO IPWIRELESS_PCCARD_NAME
463 ": registering %s device ttyIPWp%d\n",
464 tty_type_name(tty_type), j);
469 struct ipw_tty *ipwireless_tty_create(struct ipw_hardware *hardware,
470 struct ipw_network *network)
474 for (i = 0; i < IPWIRELESS_PCMCIA_MINOR_RANGE; i++) {
477 for (j = i; j < IPWIRELESS_PCMCIA_MINORS;
478 j += IPWIRELESS_PCMCIA_MINOR_RANGE)
479 if (ttys[j] != NULL) {
487 if (add_tty(j, hardware, network,
488 IPW_CHANNEL_DIALLER, IPW_CHANNEL_RAS,
492 j += IPWIRELESS_PCMCIA_MINOR_RANGE;
493 if (add_tty(j, hardware, network,
494 IPW_CHANNEL_DIALLER, -1,
498 j += IPWIRELESS_PCMCIA_MINOR_RANGE;
499 if (add_tty(j, hardware, network,
511 * Must be called before ipwireless_network_free().
513 void ipwireless_tty_free(struct ipw_tty *tty)
516 struct ipw_network *network = ttys[tty->index]->network;
518 for (j = tty->index; j < IPWIRELESS_PCMCIA_MINORS;
519 j += IPWIRELESS_PCMCIA_MINOR_RANGE) {
520 struct ipw_tty *ttyj = ttys[j];
523 mutex_lock(&ttyj->ipw_tty_mutex);
525 printk(KERN_INFO IPWIRELESS_PCCARD_NAME
526 ": deregistering %s device ttyIPWp%d\n",
527 tty_type_name(ttyj->tty_type), j);
529 if (ttyj->port.tty != NULL) {
530 mutex_unlock(&ttyj->ipw_tty_mutex);
531 tty_vhangup(ttyj->port.tty);
532 /* FIXME: Exactly how is the tty object locked here
533 against a parallel ioctl etc */
534 /* FIXME2: hangup does not mean all processes
536 mutex_lock(&ttyj->ipw_tty_mutex);
538 while (ttyj->port.count)
540 ipwireless_disassociate_network_ttys(network,
542 tty_unregister_device(ipw_tty_driver, j);
543 tty_port_destroy(&ttyj->port);
545 mutex_unlock(&ttyj->ipw_tty_mutex);
551 static const struct tty_operations tty_ops = {
554 .hangup = ipw_hangup,
556 .write_room = ipw_write_room,
558 .chars_in_buffer = ipw_chars_in_buffer,
559 .tiocmget = ipw_tiocmget,
560 .tiocmset = ipw_tiocmset,
561 .set_serial = ipwireless_set_serial_info,
562 .get_serial = ipwireless_get_serial_info,
565 int ipwireless_tty_init(void)
569 ipw_tty_driver = alloc_tty_driver(IPWIRELESS_PCMCIA_MINORS);
573 ipw_tty_driver->driver_name = IPWIRELESS_PCCARD_NAME;
574 ipw_tty_driver->name = "ttyIPWp";
575 ipw_tty_driver->major = 0;
576 ipw_tty_driver->minor_start = IPWIRELESS_PCMCIA_START;
577 ipw_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
578 ipw_tty_driver->subtype = SERIAL_TYPE_NORMAL;
579 ipw_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
580 ipw_tty_driver->init_termios = tty_std_termios;
581 ipw_tty_driver->init_termios.c_cflag =
582 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
583 ipw_tty_driver->init_termios.c_ispeed = 9600;
584 ipw_tty_driver->init_termios.c_ospeed = 9600;
585 tty_set_operations(ipw_tty_driver, &tty_ops);
586 result = tty_register_driver(ipw_tty_driver);
588 printk(KERN_ERR IPWIRELESS_PCCARD_NAME
589 ": failed to register tty driver\n");
590 put_tty_driver(ipw_tty_driver);
597 void ipwireless_tty_release(void)
599 tty_unregister_driver(ipw_tty_driver);
600 put_tty_driver(ipw_tty_driver);
603 int ipwireless_tty_is_modem(struct ipw_tty *tty)
605 return tty->tty_type == TTYTYPE_MODEM;
609 ipwireless_tty_notify_control_line_change(struct ipw_tty *tty,
610 unsigned int channel_idx,
611 unsigned int control_lines,
612 unsigned int changed_mask)
614 unsigned int old_control_lines = tty->control_lines;
616 tty->control_lines = (tty->control_lines & ~changed_mask)
617 | (control_lines & changed_mask);
620 * If DCD is de-asserted, we close the tty so pppd can tell that we
623 if ((old_control_lines & IPW_CONTROL_LINE_DCD)
624 && !(tty->control_lines & IPW_CONTROL_LINE_DCD)
626 tty_hangup(tty->port.tty);