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