Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland...
[linux-2.6] / drivers / isdn / gigaset / interface.c
1 /*
2  * interface to user space for the gigaset driver
3  *
4  * Copyright (c) 2004 by Hansjoerg Lipp <hjlipp@web.de>
5  *
6  * =====================================================================
7  *    This program is free software; you can redistribute it and/or
8  *    modify it under the terms of the GNU General Public License as
9  *    published by the Free Software Foundation; either version 2 of
10  *    the License, or (at your option) any later version.
11  * =====================================================================
12  */
13
14 #include "gigaset.h"
15 #include <linux/gigaset_dev.h>
16 #include <linux/tty.h>
17 #include <linux/tty_flip.h>
18
19 /*** our ioctls ***/
20
21 static int if_lock(struct cardstate *cs, int *arg)
22 {
23         int cmd = *arg;
24
25         gig_dbg(DEBUG_IF, "%u: if_lock (%d)", cs->minor_index, cmd);
26
27         if (cmd > 1)
28                 return -EINVAL;
29
30         if (cmd < 0) {
31                 *arg = cs->mstate == MS_LOCKED;
32                 return 0;
33         }
34
35         if (!cmd && cs->mstate == MS_LOCKED && cs->connected) {
36                 cs->ops->set_modem_ctrl(cs, 0, TIOCM_DTR|TIOCM_RTS);
37                 cs->ops->baud_rate(cs, B115200);
38                 cs->ops->set_line_ctrl(cs, CS8);
39                 cs->control_state = TIOCM_DTR|TIOCM_RTS;
40         }
41
42         cs->waiting = 1;
43         if (!gigaset_add_event(cs, &cs->at_state, EV_IF_LOCK,
44                                NULL, cmd, NULL)) {
45                 cs->waiting = 0;
46                 return -ENOMEM;
47         }
48
49         gig_dbg(DEBUG_CMD, "scheduling IF_LOCK");
50         gigaset_schedule_event(cs);
51
52         wait_event(cs->waitqueue, !cs->waiting);
53
54         if (cs->cmd_result >= 0) {
55                 *arg = cs->cmd_result;
56                 return 0;
57         }
58
59         return cs->cmd_result;
60 }
61
62 static int if_version(struct cardstate *cs, unsigned arg[4])
63 {
64         static const unsigned version[4] = GIG_VERSION;
65         static const unsigned compat[4] = GIG_COMPAT;
66         unsigned cmd = arg[0];
67
68         gig_dbg(DEBUG_IF, "%u: if_version (%d)", cs->minor_index, cmd);
69
70         switch (cmd) {
71         case GIGVER_DRIVER:
72                 memcpy(arg, version, sizeof version);
73                 return 0;
74         case GIGVER_COMPAT:
75                 memcpy(arg, compat, sizeof compat);
76                 return 0;
77         case GIGVER_FWBASE:
78                 cs->waiting = 1;
79                 if (!gigaset_add_event(cs, &cs->at_state, EV_IF_VER,
80                                        NULL, 0, arg)) {
81                         cs->waiting = 0;
82                         return -ENOMEM;
83                 }
84
85                 gig_dbg(DEBUG_CMD, "scheduling IF_VER");
86                 gigaset_schedule_event(cs);
87
88                 wait_event(cs->waitqueue, !cs->waiting);
89
90                 if (cs->cmd_result >= 0)
91                         return 0;
92
93                 return cs->cmd_result;
94         default:
95                 return -EINVAL;
96         }
97 }
98
99 static int if_config(struct cardstate *cs, int *arg)
100 {
101         gig_dbg(DEBUG_IF, "%u: if_config (%d)", cs->minor_index, *arg);
102
103         if (*arg != 1)
104                 return -EINVAL;
105
106         if (cs->mstate != MS_LOCKED)
107                 return -EBUSY;
108
109         if (!cs->connected) {
110                 pr_err("%s: not connected\n", __func__);
111                 return -ENODEV;
112         }
113
114         *arg = 0;
115         return gigaset_enterconfigmode(cs);
116 }
117
118 /*** the terminal driver ***/
119 /* stolen from usbserial and some other tty drivers */
120
121 static int  if_open(struct tty_struct *tty, struct file *filp);
122 static void if_close(struct tty_struct *tty, struct file *filp);
123 static int  if_ioctl(struct tty_struct *tty, struct file *file,
124                      unsigned int cmd, unsigned long arg);
125 static int  if_write_room(struct tty_struct *tty);
126 static int  if_chars_in_buffer(struct tty_struct *tty);
127 static void if_throttle(struct tty_struct *tty);
128 static void if_unthrottle(struct tty_struct *tty);
129 static void if_set_termios(struct tty_struct *tty, struct ktermios *old);
130 static int  if_tiocmget(struct tty_struct *tty, struct file *file);
131 static int  if_tiocmset(struct tty_struct *tty, struct file *file,
132                         unsigned int set, unsigned int clear);
133 static int  if_write(struct tty_struct *tty,
134                      const unsigned char *buf, int count);
135
136 static const struct tty_operations if_ops = {
137         .open =                 if_open,
138         .close =                if_close,
139         .ioctl =                if_ioctl,
140         .write =                if_write,
141         .write_room =           if_write_room,
142         .chars_in_buffer =      if_chars_in_buffer,
143         .set_termios =          if_set_termios,
144         .throttle =             if_throttle,
145         .unthrottle =           if_unthrottle,
146         .tiocmget =             if_tiocmget,
147         .tiocmset =             if_tiocmset,
148 };
149
150 static int if_open(struct tty_struct *tty, struct file *filp)
151 {
152         struct cardstate *cs;
153         unsigned long flags;
154
155         gig_dbg(DEBUG_IF, "%d+%d: %s()",
156                 tty->driver->minor_start, tty->index, __func__);
157
158         tty->driver_data = NULL;
159
160         cs = gigaset_get_cs_by_tty(tty);
161         if (!cs || !try_module_get(cs->driver->owner))
162                 return -ENODEV;
163
164         if (mutex_lock_interruptible(&cs->mutex))
165                 return -ERESTARTSYS; // FIXME -EINTR?
166         tty->driver_data = cs;
167
168         ++cs->open_count;
169
170         if (cs->open_count == 1) {
171                 spin_lock_irqsave(&cs->lock, flags);
172                 cs->tty = tty;
173                 spin_unlock_irqrestore(&cs->lock, flags);
174                 tty->low_latency = 1; //FIXME test
175         }
176
177         mutex_unlock(&cs->mutex);
178         return 0;
179 }
180
181 static void if_close(struct tty_struct *tty, struct file *filp)
182 {
183         struct cardstate *cs;
184         unsigned long flags;
185
186         cs = (struct cardstate *) tty->driver_data;
187         if (!cs) {
188                 pr_err("%s: no cardstate\n", __func__);
189                 return;
190         }
191
192         gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
193
194         mutex_lock(&cs->mutex);
195
196         if (!cs->connected)
197                 gig_dbg(DEBUG_IF, "not connected");     /* nothing to do */
198         else if (!cs->open_count)
199                 dev_warn(cs->dev, "%s: device not opened\n", __func__);
200         else {
201                 if (!--cs->open_count) {
202                         spin_lock_irqsave(&cs->lock, flags);
203                         cs->tty = NULL;
204                         spin_unlock_irqrestore(&cs->lock, flags);
205                 }
206         }
207
208         mutex_unlock(&cs->mutex);
209
210         module_put(cs->driver->owner);
211 }
212
213 static int if_ioctl(struct tty_struct *tty, struct file *file,
214                     unsigned int cmd, unsigned long arg)
215 {
216         struct cardstate *cs;
217         int retval = -ENODEV;
218         int int_arg;
219         unsigned char buf[6];
220         unsigned version[4];
221
222         cs = (struct cardstate *) tty->driver_data;
223         if (!cs) {
224                 pr_err("%s: no cardstate\n", __func__);
225                 return -ENODEV;
226         }
227
228         gig_dbg(DEBUG_IF, "%u: %s(0x%x)", cs->minor_index, __func__, cmd);
229
230         if (mutex_lock_interruptible(&cs->mutex))
231                 return -ERESTARTSYS; // FIXME -EINTR?
232
233         if (!cs->connected) {
234                 gig_dbg(DEBUG_IF, "not connected");
235                 retval = -ENODEV;
236         } else if (!cs->open_count)
237                 dev_warn(cs->dev, "%s: device not opened\n", __func__);
238         else {
239                 retval = 0;
240                 switch (cmd) {
241                 case GIGASET_REDIR:
242                         retval = get_user(int_arg, (int __user *) arg);
243                         if (retval >= 0)
244                                 retval = if_lock(cs, &int_arg);
245                         if (retval >= 0)
246                                 retval = put_user(int_arg, (int __user *) arg);
247                         break;
248                 case GIGASET_CONFIG:
249                         retval = get_user(int_arg, (int __user *) arg);
250                         if (retval >= 0)
251                                 retval = if_config(cs, &int_arg);
252                         if (retval >= 0)
253                                 retval = put_user(int_arg, (int __user *) arg);
254                         break;
255                 case GIGASET_BRKCHARS:
256                         retval = copy_from_user(&buf,
257                                         (const unsigned char __user *) arg, 6)
258                                 ? -EFAULT : 0;
259                         if (retval >= 0) {
260                                 gigaset_dbg_buffer(DEBUG_IF, "GIGASET_BRKCHARS",
261                                                 6, (const unsigned char *) arg);
262                                 retval = cs->ops->brkchars(cs, buf);
263                         }
264                         break;
265                 case GIGASET_VERSION:
266                         retval = copy_from_user(version,
267                                         (unsigned __user *) arg, sizeof version)
268                                 ? -EFAULT : 0;
269                         if (retval >= 0)
270                                 retval = if_version(cs, version);
271                         if (retval >= 0)
272                                 retval = copy_to_user((unsigned __user *) arg,
273                                                       version, sizeof version)
274                                         ? -EFAULT : 0;
275                         break;
276                 default:
277                         gig_dbg(DEBUG_ANY, "%s: arg not supported - 0x%04x",
278                                 __func__, cmd);
279                         retval = -ENOIOCTLCMD;
280                 }
281         }
282
283         mutex_unlock(&cs->mutex);
284
285         return retval;
286 }
287
288 static int if_tiocmget(struct tty_struct *tty, struct file *file)
289 {
290         struct cardstate *cs;
291         int retval;
292
293         cs = (struct cardstate *) tty->driver_data;
294         if (!cs) {
295                 pr_err("%s: no cardstate\n", __func__);
296                 return -ENODEV;
297         }
298
299         gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
300
301         if (mutex_lock_interruptible(&cs->mutex))
302                 return -ERESTARTSYS; // FIXME -EINTR?
303
304         // FIXME read from device?
305         retval = cs->control_state & (TIOCM_RTS|TIOCM_DTR);
306
307         mutex_unlock(&cs->mutex);
308
309         return retval;
310 }
311
312 static int if_tiocmset(struct tty_struct *tty, struct file *file,
313                        unsigned int set, unsigned int clear)
314 {
315         struct cardstate *cs;
316         int retval;
317         unsigned mc;
318
319         cs = (struct cardstate *) tty->driver_data;
320         if (!cs) {
321                 pr_err("%s: no cardstate\n", __func__);
322                 return -ENODEV;
323         }
324
325         gig_dbg(DEBUG_IF, "%u: %s(0x%x, 0x%x)",
326                 cs->minor_index, __func__, set, clear);
327
328         if (mutex_lock_interruptible(&cs->mutex))
329                 return -ERESTARTSYS; // FIXME -EINTR?
330
331         if (!cs->connected) {
332                 gig_dbg(DEBUG_IF, "not connected");
333                 retval = -ENODEV;
334         } else {
335                 mc = (cs->control_state | set) & ~clear & (TIOCM_RTS|TIOCM_DTR);
336                 retval = cs->ops->set_modem_ctrl(cs, cs->control_state, mc);
337                 cs->control_state = mc;
338         }
339
340         mutex_unlock(&cs->mutex);
341
342         return retval;
343 }
344
345 static int if_write(struct tty_struct *tty, const unsigned char *buf, int count)
346 {
347         struct cardstate *cs;
348         int retval = -ENODEV;
349
350         cs = (struct cardstate *) tty->driver_data;
351         if (!cs) {
352                 pr_err("%s: no cardstate\n", __func__);
353                 return -ENODEV;
354         }
355
356         gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
357
358         if (mutex_lock_interruptible(&cs->mutex))
359                 return -ERESTARTSYS; // FIXME -EINTR?
360
361         if (!cs->connected) {
362                 gig_dbg(DEBUG_IF, "not connected");
363                 retval = -ENODEV;
364         } else if (!cs->open_count)
365                 dev_warn(cs->dev, "%s: device not opened\n", __func__);
366         else if (cs->mstate != MS_LOCKED) {
367                 dev_warn(cs->dev, "can't write to unlocked device\n");
368                 retval = -EBUSY;
369         } else {
370                 retval = cs->ops->write_cmd(cs, buf, count,
371                                             &cs->if_wake_tasklet);
372         }
373
374         mutex_unlock(&cs->mutex);
375
376         return retval;
377 }
378
379 static int if_write_room(struct tty_struct *tty)
380 {
381         struct cardstate *cs;
382         int retval = -ENODEV;
383
384         cs = (struct cardstate *) tty->driver_data;
385         if (!cs) {
386                 pr_err("%s: no cardstate\n", __func__);
387                 return -ENODEV;
388         }
389
390         gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
391
392         if (mutex_lock_interruptible(&cs->mutex))
393                 return -ERESTARTSYS; // FIXME -EINTR?
394
395         if (!cs->connected) {
396                 gig_dbg(DEBUG_IF, "not connected");
397                 retval = -ENODEV;
398         } else if (!cs->open_count)
399                 dev_warn(cs->dev, "%s: device not opened\n", __func__);
400         else if (cs->mstate != MS_LOCKED) {
401                 dev_warn(cs->dev, "can't write to unlocked device\n");
402                 retval = -EBUSY;
403         } else
404                 retval = cs->ops->write_room(cs);
405
406         mutex_unlock(&cs->mutex);
407
408         return retval;
409 }
410
411 static int if_chars_in_buffer(struct tty_struct *tty)
412 {
413         struct cardstate *cs;
414         int retval = -ENODEV;
415
416         cs = (struct cardstate *) tty->driver_data;
417         if (!cs) {
418                 pr_err("%s: no cardstate\n", __func__);
419                 return -ENODEV;
420         }
421
422         gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
423
424         if (mutex_lock_interruptible(&cs->mutex))
425                 return -ERESTARTSYS; // FIXME -EINTR?
426
427         if (!cs->connected) {
428                 gig_dbg(DEBUG_IF, "not connected");
429                 retval = -ENODEV;
430         } else if (!cs->open_count)
431                 dev_warn(cs->dev, "%s: device not opened\n", __func__);
432         else if (cs->mstate != MS_LOCKED) {
433                 dev_warn(cs->dev, "can't write to unlocked device\n");
434                 retval = -EBUSY;
435         } else
436                 retval = cs->ops->chars_in_buffer(cs);
437
438         mutex_unlock(&cs->mutex);
439
440         return retval;
441 }
442
443 static void if_throttle(struct tty_struct *tty)
444 {
445         struct cardstate *cs;
446
447         cs = (struct cardstate *) tty->driver_data;
448         if (!cs) {
449                 pr_err("%s: no cardstate\n", __func__);
450                 return;
451         }
452
453         gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
454
455         mutex_lock(&cs->mutex);
456
457         if (!cs->connected)
458                 gig_dbg(DEBUG_IF, "not connected");     /* nothing to do */
459         else if (!cs->open_count)
460                 dev_warn(cs->dev, "%s: device not opened\n", __func__);
461         else {
462                 //FIXME
463         }
464
465         mutex_unlock(&cs->mutex);
466 }
467
468 static void if_unthrottle(struct tty_struct *tty)
469 {
470         struct cardstate *cs;
471
472         cs = (struct cardstate *) tty->driver_data;
473         if (!cs) {
474                 pr_err("%s: no cardstate\n", __func__);
475                 return;
476         }
477
478         gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
479
480         mutex_lock(&cs->mutex);
481
482         if (!cs->connected)
483                 gig_dbg(DEBUG_IF, "not connected");     /* nothing to do */
484         else if (!cs->open_count)
485                 dev_warn(cs->dev, "%s: device not opened\n", __func__);
486         else {
487                 //FIXME
488         }
489
490         mutex_unlock(&cs->mutex);
491 }
492
493 static void if_set_termios(struct tty_struct *tty, struct ktermios *old)
494 {
495         struct cardstate *cs;
496         unsigned int iflag;
497         unsigned int cflag;
498         unsigned int old_cflag;
499         unsigned int control_state, new_state;
500
501         cs = (struct cardstate *) tty->driver_data;
502         if (!cs) {
503                 pr_err("%s: no cardstate\n", __func__);
504                 return;
505         }
506
507         gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
508
509         mutex_lock(&cs->mutex);
510
511         if (!cs->connected) {
512                 gig_dbg(DEBUG_IF, "not connected");
513                 goto out;
514         }
515
516         if (!cs->open_count) {
517                 dev_warn(cs->dev, "%s: device not opened\n", __func__);
518                 goto out;
519         }
520
521         // stolen from mct_u232.c
522         iflag = tty->termios->c_iflag;
523         cflag = tty->termios->c_cflag;
524         old_cflag = old ? old->c_cflag : cflag; //FIXME?
525         gig_dbg(DEBUG_IF, "%u: iflag %x cflag %x old %x",
526                 cs->minor_index, iflag, cflag, old_cflag);
527
528         /* get a local copy of the current port settings */
529         control_state = cs->control_state;
530
531         /*
532          * Update baud rate.
533          * Do not attempt to cache old rates and skip settings,
534          * disconnects screw such tricks up completely.
535          * Premature optimization is the root of all evil.
536          */
537
538         /* reassert DTR and (maybe) RTS on transition from B0 */
539         if ((old_cflag & CBAUD) == B0) {
540                 new_state = control_state | TIOCM_DTR;
541                 /* don't set RTS if using hardware flow control */
542                 if (!(old_cflag & CRTSCTS))
543                         new_state |= TIOCM_RTS;
544                 gig_dbg(DEBUG_IF, "%u: from B0 - set DTR%s",
545                         cs->minor_index,
546                         (new_state & TIOCM_RTS) ? " only" : "/RTS");
547                 cs->ops->set_modem_ctrl(cs, control_state, new_state);
548                 control_state = new_state;
549         }
550
551         cs->ops->baud_rate(cs, cflag & CBAUD);
552
553         if ((cflag & CBAUD) == B0) {
554                 /* Drop RTS and DTR */
555                 gig_dbg(DEBUG_IF, "%u: to B0 - drop DTR/RTS", cs->minor_index);
556                 new_state = control_state & ~(TIOCM_DTR | TIOCM_RTS);
557                 cs->ops->set_modem_ctrl(cs, control_state, new_state);
558                 control_state = new_state;
559         }
560
561         /*
562          * Update line control register (LCR)
563          */
564
565         cs->ops->set_line_ctrl(cs, cflag);
566
567         /* save off the modified port settings */
568         cs->control_state = control_state;
569
570 out:
571         mutex_unlock(&cs->mutex);
572 }
573
574
575 /* wakeup tasklet for the write operation */
576 static void if_wake(unsigned long data)
577 {
578         struct cardstate *cs = (struct cardstate *) data;
579
580         if (cs->tty)
581                 tty_wakeup(cs->tty);
582 }
583
584 /*** interface to common ***/
585
586 void gigaset_if_init(struct cardstate *cs)
587 {
588         struct gigaset_driver *drv;
589
590         drv = cs->driver;
591         if (!drv->have_tty)
592                 return;
593
594         tasklet_init(&cs->if_wake_tasklet, &if_wake, (unsigned long) cs);
595
596         mutex_lock(&cs->mutex);
597         cs->tty_dev = tty_register_device(drv->tty, cs->minor_index, NULL);
598
599         if (!IS_ERR(cs->tty_dev))
600                 dev_set_drvdata(cs->tty_dev, cs);
601         else {
602                 dev_warn(cs->dev,
603                          "could not register device to the tty subsystem\n");
604                 cs->tty_dev = NULL;
605         }
606         mutex_unlock(&cs->mutex);
607 }
608
609 void gigaset_if_free(struct cardstate *cs)
610 {
611         struct gigaset_driver *drv;
612
613         drv = cs->driver;
614         if (!drv->have_tty)
615                 return;
616
617         tasklet_disable(&cs->if_wake_tasklet);
618         tasklet_kill(&cs->if_wake_tasklet);
619         cs->tty_dev = NULL;
620         tty_unregister_device(drv->tty, cs->minor_index);
621 }
622
623 void gigaset_if_receive(struct cardstate *cs,
624                         unsigned char *buffer, size_t len)
625 {
626         unsigned long flags;
627         struct tty_struct *tty;
628
629         spin_lock_irqsave(&cs->lock, flags);
630         if ((tty = cs->tty) == NULL)
631                 gig_dbg(DEBUG_ANY, "receive on closed device");
632         else {
633                 tty_buffer_request_room(tty, len);
634                 tty_insert_flip_string(tty, buffer, len);
635                 tty_flip_buffer_push(tty);
636         }
637         spin_unlock_irqrestore(&cs->lock, flags);
638 }
639 EXPORT_SYMBOL_GPL(gigaset_if_receive);
640
641 /* gigaset_if_initdriver
642  * Initialize tty interface.
643  * parameters:
644  *      drv             Driver
645  *      procname        Name of the driver (e.g. for /proc/tty/drivers)
646  *      devname         Name of the device files (prefix without minor number)
647  */
648 void gigaset_if_initdriver(struct gigaset_driver *drv, const char *procname,
649                            const char *devname)
650 {
651         unsigned minors = drv->minors;
652         int ret;
653         struct tty_driver *tty;
654
655         drv->have_tty = 0;
656
657         if ((drv->tty = alloc_tty_driver(minors)) == NULL)
658                 goto enomem;
659         tty = drv->tty;
660
661         tty->magic =            TTY_DRIVER_MAGIC,
662         tty->major =            GIG_MAJOR,
663         tty->type =             TTY_DRIVER_TYPE_SERIAL,
664         tty->subtype =          SERIAL_TYPE_NORMAL,
665         tty->flags =            TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
666
667         tty->driver_name =      procname;
668         tty->name =             devname;
669         tty->minor_start =      drv->minor;
670         tty->num =              drv->minors;
671
672         tty->owner =            THIS_MODULE;
673
674         tty->init_termios          = tty_std_termios; //FIXME
675         tty->init_termios.c_cflag  = B9600 | CS8 | CREAD | HUPCL | CLOCAL; //FIXME
676         tty_set_operations(tty, &if_ops);
677
678         ret = tty_register_driver(tty);
679         if (ret < 0) {
680                 pr_err("error %d registering tty driver\n", ret);
681                 goto error;
682         }
683         gig_dbg(DEBUG_IF, "tty driver initialized");
684         drv->have_tty = 1;
685         return;
686
687 enomem:
688         pr_err("out of memory\n");
689 error:
690         if (drv->tty)
691                 put_tty_driver(drv->tty);
692 }
693
694 void gigaset_if_freedriver(struct gigaset_driver *drv)
695 {
696         if (!drv->have_tty)
697                 return;
698
699         drv->have_tty = 0;
700         tty_unregister_driver(drv->tty);
701         put_tty_driver(drv->tty);
702 }