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