1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * IPWireless 3G PCMCIA Network Driver
4 *
5 * Original code
6 * by Stephen Blackheath <stephen@blacksapphire.com>,
7 * Ben Martel <benm@symmetric.co.nz>
8 *
9 * Copyrighted as follows:
10 * Copyright (C) 2004 by Symmetric Systems Ltd (NZ)
11 *
12 * Various driver changes and rewrites, port to new kernels
13 * Copyright (C) 2006-2007 Jiri Kosina
14 *
15 * Misc code cleanups and updates
16 * Copyright (C) 2007 David Sterba
17 */
18
19 #include <linux/kernel.h>
20 #include <linux/module.h>
21 #include <linux/mutex.h>
22 #include <linux/ppp_defs.h>
23 #include <linux/if.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>
32
33 #include "tty.h"
34 #include "network.h"
35 #include "hardware.h"
36 #include "main.h"
37
38 #define IPWIRELESS_PCMCIA_START (0)
39 #define IPWIRELESS_PCMCIA_MINORS (24)
40 #define IPWIRELESS_PCMCIA_MINOR_RANGE (8)
41
42 #define TTYTYPE_MODEM (0)
43 #define TTYTYPE_MONITOR (1)
44 #define TTYTYPE_RAS_RAW (2)
45
46 struct ipw_tty {
47 struct tty_port port;
48 int index;
49 struct ipw_hardware *hardware;
50 unsigned int channel_idx;
51 unsigned int secondary_channel_idx;
52 int tty_type;
53 struct ipw_network *network;
54 unsigned int control_lines;
55 struct mutex ipw_tty_mutex;
56 int tx_bytes_queued;
57 };
58
59 static struct ipw_tty *ttys[IPWIRELESS_PCMCIA_MINORS];
60
61 static struct tty_driver *ipw_tty_driver;
62
tty_type_name(int tty_type)63 static char *tty_type_name(int tty_type)
64 {
65 static char *channel_names[] = {
66 "modem",
67 "monitor",
68 "RAS-raw"
69 };
70
71 return channel_names[tty_type];
72 }
73
get_tty(int index)74 static struct ipw_tty *get_tty(int index)
75 {
76 /*
77 * The 'ras_raw' channel is only available when 'loopback' mode
78 * is enabled.
79 * Number of minor starts with 16 (_RANGE * _RAS_RAW).
80 */
81 if (!ipwireless_loopback && index >=
82 IPWIRELESS_PCMCIA_MINOR_RANGE * TTYTYPE_RAS_RAW)
83 return NULL;
84
85 return ttys[index];
86 }
87
ipw_open(struct tty_struct * linux_tty,struct file * filp)88 static int ipw_open(struct tty_struct *linux_tty, struct file *filp)
89 {
90 struct ipw_tty *tty = get_tty(linux_tty->index);
91
92 if (!tty)
93 return -ENODEV;
94
95 mutex_lock(&tty->ipw_tty_mutex);
96 if (tty->port.count == 0)
97 tty->tx_bytes_queued = 0;
98
99 tty->port.count++;
100
101 tty->port.tty = linux_tty;
102 linux_tty->driver_data = tty;
103
104 if (tty->tty_type == TTYTYPE_MODEM)
105 ipwireless_ppp_open(tty->network);
106
107 mutex_unlock(&tty->ipw_tty_mutex);
108
109 return 0;
110 }
111
do_ipw_close(struct ipw_tty * tty)112 static void do_ipw_close(struct ipw_tty *tty)
113 {
114 tty->port.count--;
115
116 if (tty->port.count == 0) {
117 struct tty_struct *linux_tty = tty->port.tty;
118
119 if (linux_tty != NULL) {
120 tty->port.tty = NULL;
121 linux_tty->driver_data = NULL;
122
123 if (tty->tty_type == TTYTYPE_MODEM)
124 ipwireless_ppp_close(tty->network);
125 }
126 }
127 }
128
ipw_hangup(struct tty_struct * linux_tty)129 static void ipw_hangup(struct tty_struct *linux_tty)
130 {
131 struct ipw_tty *tty = linux_tty->driver_data;
132
133 if (!tty)
134 return;
135
136 mutex_lock(&tty->ipw_tty_mutex);
137 if (tty->port.count == 0) {
138 mutex_unlock(&tty->ipw_tty_mutex);
139 return;
140 }
141
142 do_ipw_close(tty);
143
144 mutex_unlock(&tty->ipw_tty_mutex);
145 }
146
ipw_close(struct tty_struct * linux_tty,struct file * filp)147 static void ipw_close(struct tty_struct *linux_tty, struct file *filp)
148 {
149 ipw_hangup(linux_tty);
150 }
151
152 /* Take data received from hardware, and send it out the tty */
ipwireless_tty_received(struct ipw_tty * tty,unsigned char * data,unsigned int length)153 void ipwireless_tty_received(struct ipw_tty *tty, unsigned char *data,
154 unsigned int length)
155 {
156 int work = 0;
157
158 mutex_lock(&tty->ipw_tty_mutex);
159
160 if (!tty->port.count) {
161 mutex_unlock(&tty->ipw_tty_mutex);
162 return;
163 }
164 mutex_unlock(&tty->ipw_tty_mutex);
165
166 work = tty_insert_flip_string(&tty->port, data, length);
167
168 if (work != length)
169 printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME
170 ": %d chars not inserted to flip buffer!\n",
171 length - work);
172
173 if (work)
174 tty_flip_buffer_push(&tty->port);
175 }
176
ipw_write_packet_sent_callback(void * callback_data,unsigned int packet_length)177 static void ipw_write_packet_sent_callback(void *callback_data,
178 unsigned int packet_length)
179 {
180 struct ipw_tty *tty = callback_data;
181
182 /*
183 * Packet has been sent, so we subtract the number of bytes from our
184 * tally of outstanding TX bytes.
185 */
186 tty->tx_bytes_queued -= packet_length;
187 }
188
ipw_write(struct tty_struct * linux_tty,const unsigned char * buf,int count)189 static int ipw_write(struct tty_struct *linux_tty,
190 const unsigned char *buf, int count)
191 {
192 struct ipw_tty *tty = linux_tty->driver_data;
193 int room, ret;
194
195 if (!tty)
196 return -ENODEV;
197
198 mutex_lock(&tty->ipw_tty_mutex);
199 if (!tty->port.count) {
200 mutex_unlock(&tty->ipw_tty_mutex);
201 return -EINVAL;
202 }
203
204 room = IPWIRELESS_TX_QUEUE_SIZE - tty->tx_bytes_queued;
205 if (room < 0)
206 room = 0;
207 /* Don't allow caller to write any more than we have room for */
208 if (count > room)
209 count = room;
210
211 if (count == 0) {
212 mutex_unlock(&tty->ipw_tty_mutex);
213 return 0;
214 }
215
216 ret = ipwireless_send_packet(tty->hardware, IPW_CHANNEL_RAS,
217 buf, count,
218 ipw_write_packet_sent_callback, tty);
219 if (ret < 0) {
220 mutex_unlock(&tty->ipw_tty_mutex);
221 return 0;
222 }
223
224 tty->tx_bytes_queued += count;
225 mutex_unlock(&tty->ipw_tty_mutex);
226
227 return count;
228 }
229
ipw_write_room(struct tty_struct * linux_tty)230 static unsigned int ipw_write_room(struct tty_struct *linux_tty)
231 {
232 struct ipw_tty *tty = linux_tty->driver_data;
233 int room;
234
235 /* FIXME: Exactly how is the tty object locked here .. */
236 if (!tty)
237 return 0;
238
239 if (!tty->port.count)
240 return 0;
241
242 room = IPWIRELESS_TX_QUEUE_SIZE - tty->tx_bytes_queued;
243 if (room < 0)
244 room = 0;
245
246 return room;
247 }
248
ipwireless_get_serial_info(struct tty_struct * linux_tty,struct serial_struct * ss)249 static int ipwireless_get_serial_info(struct tty_struct *linux_tty,
250 struct serial_struct *ss)
251 {
252 struct ipw_tty *tty = linux_tty->driver_data;
253
254 if (!tty)
255 return -ENODEV;
256
257 if (!tty->port.count)
258 return -EINVAL;
259
260 ss->type = PORT_UNKNOWN;
261 ss->line = tty->index;
262 ss->baud_base = 115200;
263 return 0;
264 }
265
ipwireless_set_serial_info(struct tty_struct * linux_tty,struct serial_struct * ss)266 static int ipwireless_set_serial_info(struct tty_struct *linux_tty,
267 struct serial_struct *ss)
268 {
269 return 0; /* Keeps the PCMCIA scripts happy. */
270 }
271
ipw_chars_in_buffer(struct tty_struct * linux_tty)272 static unsigned int ipw_chars_in_buffer(struct tty_struct *linux_tty)
273 {
274 struct ipw_tty *tty = linux_tty->driver_data;
275
276 if (!tty)
277 return 0;
278
279 if (!tty->port.count)
280 return 0;
281
282 return tty->tx_bytes_queued;
283 }
284
get_control_lines(struct ipw_tty * tty)285 static int get_control_lines(struct ipw_tty *tty)
286 {
287 unsigned int my = tty->control_lines;
288 unsigned int out = 0;
289
290 if (my & IPW_CONTROL_LINE_RTS)
291 out |= TIOCM_RTS;
292 if (my & IPW_CONTROL_LINE_DTR)
293 out |= TIOCM_DTR;
294 if (my & IPW_CONTROL_LINE_CTS)
295 out |= TIOCM_CTS;
296 if (my & IPW_CONTROL_LINE_DSR)
297 out |= TIOCM_DSR;
298 if (my & IPW_CONTROL_LINE_DCD)
299 out |= TIOCM_CD;
300
301 return out;
302 }
303
set_control_lines(struct ipw_tty * tty,unsigned int set,unsigned int clear)304 static int set_control_lines(struct ipw_tty *tty, unsigned int set,
305 unsigned int clear)
306 {
307 int ret;
308
309 if (set & TIOCM_RTS) {
310 ret = ipwireless_set_RTS(tty->hardware, tty->channel_idx, 1);
311 if (ret)
312 return ret;
313 if (tty->secondary_channel_idx != -1) {
314 ret = ipwireless_set_RTS(tty->hardware,
315 tty->secondary_channel_idx, 1);
316 if (ret)
317 return ret;
318 }
319 }
320 if (set & TIOCM_DTR) {
321 ret = ipwireless_set_DTR(tty->hardware, tty->channel_idx, 1);
322 if (ret)
323 return ret;
324 if (tty->secondary_channel_idx != -1) {
325 ret = ipwireless_set_DTR(tty->hardware,
326 tty->secondary_channel_idx, 1);
327 if (ret)
328 return ret;
329 }
330 }
331 if (clear & TIOCM_RTS) {
332 ret = ipwireless_set_RTS(tty->hardware, tty->channel_idx, 0);
333 if (tty->secondary_channel_idx != -1) {
334 ret = ipwireless_set_RTS(tty->hardware,
335 tty->secondary_channel_idx, 0);
336 if (ret)
337 return ret;
338 }
339 }
340 if (clear & TIOCM_DTR) {
341 ret = ipwireless_set_DTR(tty->hardware, tty->channel_idx, 0);
342 if (tty->secondary_channel_idx != -1) {
343 ret = ipwireless_set_DTR(tty->hardware,
344 tty->secondary_channel_idx, 0);
345 if (ret)
346 return ret;
347 }
348 }
349 return 0;
350 }
351
ipw_tiocmget(struct tty_struct * linux_tty)352 static int ipw_tiocmget(struct tty_struct *linux_tty)
353 {
354 struct ipw_tty *tty = linux_tty->driver_data;
355 /* FIXME: Exactly how is the tty object locked here .. */
356
357 if (!tty)
358 return -ENODEV;
359
360 if (!tty->port.count)
361 return -EINVAL;
362
363 return get_control_lines(tty);
364 }
365
366 static int
ipw_tiocmset(struct tty_struct * linux_tty,unsigned int set,unsigned int clear)367 ipw_tiocmset(struct tty_struct *linux_tty,
368 unsigned int set, unsigned int clear)
369 {
370 struct ipw_tty *tty = linux_tty->driver_data;
371 /* FIXME: Exactly how is the tty object locked here .. */
372
373 if (!tty)
374 return -ENODEV;
375
376 if (!tty->port.count)
377 return -EINVAL;
378
379 return set_control_lines(tty, set, clear);
380 }
381
ipw_ioctl(struct tty_struct * linux_tty,unsigned int cmd,unsigned long arg)382 static int ipw_ioctl(struct tty_struct *linux_tty,
383 unsigned int cmd, unsigned long arg)
384 {
385 struct ipw_tty *tty = linux_tty->driver_data;
386
387 if (!tty)
388 return -ENODEV;
389
390 if (!tty->port.count)
391 return -EINVAL;
392
393 /* FIXME: Exactly how is the tty object locked here .. */
394 if (tty->tty_type == TTYTYPE_MODEM) {
395 switch (cmd) {
396 case PPPIOCGCHAN:
397 {
398 int chan = ipwireless_ppp_channel_index(
399 tty->network);
400
401 if (chan < 0)
402 return -ENODEV;
403 if (put_user(chan, (int __user *) arg))
404 return -EFAULT;
405 }
406 return 0;
407
408 case PPPIOCGUNIT:
409 {
410 int unit = ipwireless_ppp_unit_number(
411 tty->network);
412
413 if (unit < 0)
414 return -ENODEV;
415 if (put_user(unit, (int __user *) arg))
416 return -EFAULT;
417 }
418 return 0;
419
420 case FIONREAD:
421 {
422 int val = 0;
423
424 if (put_user(val, (int __user *) arg))
425 return -EFAULT;
426 }
427 return 0;
428 case TCFLSH:
429 return tty_perform_flush(linux_tty, arg);
430 }
431 }
432 return -ENOIOCTLCMD;
433 }
434
add_tty(int j,struct ipw_hardware * hardware,struct ipw_network * network,int channel_idx,int secondary_channel_idx,int tty_type)435 static int add_tty(int j,
436 struct ipw_hardware *hardware,
437 struct ipw_network *network, int channel_idx,
438 int secondary_channel_idx, int tty_type)
439 {
440 ttys[j] = kzalloc(sizeof(struct ipw_tty), GFP_KERNEL);
441 if (!ttys[j])
442 return -ENOMEM;
443 ttys[j]->index = j;
444 ttys[j]->hardware = hardware;
445 ttys[j]->channel_idx = channel_idx;
446 ttys[j]->secondary_channel_idx = secondary_channel_idx;
447 ttys[j]->network = network;
448 ttys[j]->tty_type = tty_type;
449 mutex_init(&ttys[j]->ipw_tty_mutex);
450 tty_port_init(&ttys[j]->port);
451
452 tty_port_register_device(&ttys[j]->port, ipw_tty_driver, j, NULL);
453 ipwireless_associate_network_tty(network, channel_idx, ttys[j]);
454
455 if (secondary_channel_idx != -1)
456 ipwireless_associate_network_tty(network,
457 secondary_channel_idx,
458 ttys[j]);
459 /* check if we provide raw device (if loopback is enabled) */
460 if (get_tty(j))
461 printk(KERN_INFO IPWIRELESS_PCCARD_NAME
462 ": registering %s device ttyIPWp%d\n",
463 tty_type_name(tty_type), j);
464
465 return 0;
466 }
467
ipwireless_tty_create(struct ipw_hardware * hardware,struct ipw_network * network)468 struct ipw_tty *ipwireless_tty_create(struct ipw_hardware *hardware,
469 struct ipw_network *network)
470 {
471 int i, j;
472
473 for (i = 0; i < IPWIRELESS_PCMCIA_MINOR_RANGE; i++) {
474 int allfree = 1;
475
476 for (j = i; j < IPWIRELESS_PCMCIA_MINORS;
477 j += IPWIRELESS_PCMCIA_MINOR_RANGE)
478 if (ttys[j] != NULL) {
479 allfree = 0;
480 break;
481 }
482
483 if (allfree) {
484 j = i;
485
486 if (add_tty(j, hardware, network,
487 IPW_CHANNEL_DIALLER, IPW_CHANNEL_RAS,
488 TTYTYPE_MODEM))
489 return NULL;
490
491 j += IPWIRELESS_PCMCIA_MINOR_RANGE;
492 if (add_tty(j, hardware, network,
493 IPW_CHANNEL_DIALLER, -1,
494 TTYTYPE_MONITOR))
495 return NULL;
496
497 j += IPWIRELESS_PCMCIA_MINOR_RANGE;
498 if (add_tty(j, hardware, network,
499 IPW_CHANNEL_RAS, -1,
500 TTYTYPE_RAS_RAW))
501 return NULL;
502
503 return ttys[i];
504 }
505 }
506 return NULL;
507 }
508
509 /*
510 * Must be called before ipwireless_network_free().
511 */
ipwireless_tty_free(struct ipw_tty * tty)512 void ipwireless_tty_free(struct ipw_tty *tty)
513 {
514 int j;
515 struct ipw_network *network = ttys[tty->index]->network;
516
517 for (j = tty->index; j < IPWIRELESS_PCMCIA_MINORS;
518 j += IPWIRELESS_PCMCIA_MINOR_RANGE) {
519 struct ipw_tty *ttyj = ttys[j];
520
521 if (ttyj) {
522 mutex_lock(&ttyj->ipw_tty_mutex);
523 if (get_tty(j))
524 printk(KERN_INFO IPWIRELESS_PCCARD_NAME
525 ": deregistering %s device ttyIPWp%d\n",
526 tty_type_name(ttyj->tty_type), j);
527 if (ttyj->port.tty != NULL) {
528 mutex_unlock(&ttyj->ipw_tty_mutex);
529 tty_vhangup(ttyj->port.tty);
530 /* FIXME: Exactly how is the tty object locked here
531 against a parallel ioctl etc */
532 /* FIXME2: hangup does not mean all processes
533 * are gone */
534 mutex_lock(&ttyj->ipw_tty_mutex);
535 }
536 while (ttyj->port.count)
537 do_ipw_close(ttyj);
538 ipwireless_disassociate_network_ttys(network,
539 ttyj->channel_idx);
540 tty_unregister_device(ipw_tty_driver, j);
541 tty_port_destroy(&ttyj->port);
542 ttys[j] = NULL;
543 mutex_unlock(&ttyj->ipw_tty_mutex);
544 kfree(ttyj);
545 }
546 }
547 }
548
549 static const struct tty_operations tty_ops = {
550 .open = ipw_open,
551 .close = ipw_close,
552 .hangup = ipw_hangup,
553 .write = ipw_write,
554 .write_room = ipw_write_room,
555 .ioctl = ipw_ioctl,
556 .chars_in_buffer = ipw_chars_in_buffer,
557 .tiocmget = ipw_tiocmget,
558 .tiocmset = ipw_tiocmset,
559 .set_serial = ipwireless_set_serial_info,
560 .get_serial = ipwireless_get_serial_info,
561 };
562
ipwireless_tty_init(void)563 int ipwireless_tty_init(void)
564 {
565 int result;
566
567 ipw_tty_driver = tty_alloc_driver(IPWIRELESS_PCMCIA_MINORS,
568 TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV);
569 if (IS_ERR(ipw_tty_driver))
570 return PTR_ERR(ipw_tty_driver);
571
572 ipw_tty_driver->driver_name = IPWIRELESS_PCCARD_NAME;
573 ipw_tty_driver->name = "ttyIPWp";
574 ipw_tty_driver->major = 0;
575 ipw_tty_driver->minor_start = IPWIRELESS_PCMCIA_START;
576 ipw_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
577 ipw_tty_driver->subtype = SERIAL_TYPE_NORMAL;
578 ipw_tty_driver->init_termios = tty_std_termios;
579 ipw_tty_driver->init_termios.c_cflag =
580 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
581 ipw_tty_driver->init_termios.c_ispeed = 9600;
582 ipw_tty_driver->init_termios.c_ospeed = 9600;
583 tty_set_operations(ipw_tty_driver, &tty_ops);
584 result = tty_register_driver(ipw_tty_driver);
585 if (result) {
586 printk(KERN_ERR IPWIRELESS_PCCARD_NAME
587 ": failed to register tty driver\n");
588 tty_driver_kref_put(ipw_tty_driver);
589 return result;
590 }
591
592 return 0;
593 }
594
ipwireless_tty_release(void)595 void ipwireless_tty_release(void)
596 {
597 tty_unregister_driver(ipw_tty_driver);
598 tty_driver_kref_put(ipw_tty_driver);
599 }
600
ipwireless_tty_is_modem(struct ipw_tty * tty)601 int ipwireless_tty_is_modem(struct ipw_tty *tty)
602 {
603 return tty->tty_type == TTYTYPE_MODEM;
604 }
605
606 void
ipwireless_tty_notify_control_line_change(struct ipw_tty * tty,unsigned int channel_idx,unsigned int control_lines,unsigned int changed_mask)607 ipwireless_tty_notify_control_line_change(struct ipw_tty *tty,
608 unsigned int channel_idx,
609 unsigned int control_lines,
610 unsigned int changed_mask)
611 {
612 unsigned int old_control_lines = tty->control_lines;
613
614 tty->control_lines = (tty->control_lines & ~changed_mask)
615 | (control_lines & changed_mask);
616
617 /*
618 * If DCD is de-asserted, we close the tty so pppd can tell that we
619 * have gone offline.
620 */
621 if ((old_control_lines & IPW_CONTROL_LINE_DCD)
622 && !(tty->control_lines & IPW_CONTROL_LINE_DCD)
623 && tty->port.tty) {
624 tty_hangup(tty->port.tty);
625 }
626 }
627
628