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