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