gigaset: use pr_err() and pr_info()
[linux-2.6.git] / 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 #if 0
147         .break_ctl =            serial_break,
148 #endif
149         .tiocmget =             if_tiocmget,
150         .tiocmset =             if_tiocmset,
151 };
152
153 static int if_open(struct tty_struct *tty, struct file *filp)
154 {
155         struct cardstate *cs;
156         unsigned long flags;
157
158         gig_dbg(DEBUG_IF, "%d+%d: %s()",
159                 tty->driver->minor_start, tty->index, __func__);
160
161         tty->driver_data = NULL;
162
163         cs = gigaset_get_cs_by_tty(tty);
164         if (!cs || !try_module_get(cs->driver->owner))
165                 return -ENODEV;
166
167         if (mutex_lock_interruptible(&cs->mutex))
168                 return -ERESTARTSYS; // FIXME -EINTR?
169         tty->driver_data = cs;
170
171         ++cs->open_count;
172
173         if (cs->open_count == 1) {
174                 spin_lock_irqsave(&cs->lock, flags);
175                 cs->tty = tty;
176                 spin_unlock_irqrestore(&cs->lock, flags);
177                 tty->low_latency = 1; //FIXME test
178         }
179
180         mutex_unlock(&cs->mutex);
181         return 0;
182 }
183
184 static void if_close(struct tty_struct *tty, struct file *filp)
185 {
186         struct cardstate *cs;
187         unsigned long flags;
188
189         cs = (struct cardstate *) tty->driver_data;
190         if (!cs) {
191                 pr_err("%s: no cardstate\n", __func__);
192                 return;
193         }
194
195         gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
196
197         mutex_lock(&cs->mutex);
198
199         if (!cs->open_count)
200                 dev_warn(cs->dev, "%s: device not opened\n", __func__);
201         else {
202                 if (!--cs->open_count) {
203                         spin_lock_irqsave(&cs->lock, flags);
204                         cs->tty = NULL;
205                         spin_unlock_irqrestore(&cs->lock, flags);
206                 }
207         }
208
209         mutex_unlock(&cs->mutex);
210
211         module_put(cs->driver->owner);
212 }
213
214 static int if_ioctl(struct tty_struct *tty, struct file *file,
215                     unsigned int cmd, unsigned long arg)
216 {
217         struct cardstate *cs;
218         int retval = -ENODEV;
219         int int_arg;
220         unsigned char buf[6];
221         unsigned version[4];
222
223         cs = (struct cardstate *) tty->driver_data;
224         if (!cs) {
225                 pr_err("%s: no cardstate\n", __func__);
226                 return -ENODEV;
227         }
228
229         gig_dbg(DEBUG_IF, "%u: %s(0x%x)", cs->minor_index, __func__, cmd);
230
231         if (mutex_lock_interruptible(&cs->mutex))
232                 return -ERESTARTSYS; // FIXME -EINTR?
233
234         if (!cs->open_count)
235                 dev_warn(cs->dev, "%s: device not opened\n", __func__);
236         else {
237                 retval = 0;
238                 switch (cmd) {
239                 case GIGASET_REDIR:
240                         retval = get_user(int_arg, (int __user *) arg);
241                         if (retval >= 0)
242                                 retval = if_lock(cs, &int_arg);
243                         if (retval >= 0)
244                                 retval = put_user(int_arg, (int __user *) arg);
245                         break;
246                 case GIGASET_CONFIG:
247                         retval = get_user(int_arg, (int __user *) arg);
248                         if (retval >= 0)
249                                 retval = if_config(cs, &int_arg);
250                         if (retval >= 0)
251                                 retval = put_user(int_arg, (int __user *) arg);
252                         break;
253                 case GIGASET_BRKCHARS:
254                         //FIXME test if MS_LOCKED
255                         if (!cs->connected) {
256                                 gig_dbg(DEBUG_ANY,
257                                     "can't communicate with unplugged device");
258                                 retval = -ENODEV;
259                                 break;
260                         }
261                         retval = copy_from_user(&buf,
262                                         (const unsigned char __user *) arg, 6)
263                                 ? -EFAULT : 0;
264                         if (retval >= 0) {
265                                 gigaset_dbg_buffer(DEBUG_IF, "GIGASET_BRKCHARS",
266                                                 6, (const unsigned char *) arg);
267                                 retval = cs->ops->brkchars(cs, buf);
268                         }
269                         break;
270                 case GIGASET_VERSION:
271                         retval = copy_from_user(version,
272                                         (unsigned __user *) arg, sizeof version)
273                                 ? -EFAULT : 0;
274                         if (retval >= 0)
275                                 retval = if_version(cs, version);
276                         if (retval >= 0)
277                                 retval = copy_to_user((unsigned __user *) arg,
278                                                       version, sizeof version)
279                                         ? -EFAULT : 0;
280                         break;
281                 default:
282                         gig_dbg(DEBUG_ANY, "%s: arg not supported - 0x%04x",
283                                 __func__, cmd);
284                         retval = -ENOIOCTLCMD;
285                 }
286         }
287
288         mutex_unlock(&cs->mutex);
289
290         return retval;
291 }
292
293 static int if_tiocmget(struct tty_struct *tty, struct file *file)
294 {
295         struct cardstate *cs;
296         int retval;
297
298         cs = (struct cardstate *) tty->driver_data;
299         if (!cs) {
300                 pr_err("%s: no cardstate\n", __func__);
301                 return -ENODEV;
302         }
303
304         gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
305
306         if (mutex_lock_interruptible(&cs->mutex))
307                 return -ERESTARTSYS; // FIXME -EINTR?
308
309         // FIXME read from device?
310         retval = cs->control_state & (TIOCM_RTS|TIOCM_DTR);
311
312         mutex_unlock(&cs->mutex);
313
314         return retval;
315 }
316
317 static int if_tiocmset(struct tty_struct *tty, struct file *file,
318                        unsigned int set, unsigned int clear)
319 {
320         struct cardstate *cs;
321         int retval;
322         unsigned mc;
323
324         cs = (struct cardstate *) tty->driver_data;
325         if (!cs) {
326                 pr_err("%s: no cardstate\n", __func__);
327                 return -ENODEV;
328         }
329
330         gig_dbg(DEBUG_IF, "%u: %s(0x%x, 0x%x)",
331                 cs->minor_index, __func__, set, clear);
332
333         if (mutex_lock_interruptible(&cs->mutex))
334                 return -ERESTARTSYS; // FIXME -EINTR?
335
336         if (!cs->connected) {
337                 gig_dbg(DEBUG_ANY, "can't communicate with unplugged device");
338                 retval = -ENODEV;
339         } else {
340                 mc = (cs->control_state | set) & ~clear & (TIOCM_RTS|TIOCM_DTR);
341                 retval = cs->ops->set_modem_ctrl(cs, cs->control_state, mc);
342                 cs->control_state = mc;
343         }
344
345         mutex_unlock(&cs->mutex);
346
347         return retval;
348 }
349
350 static int if_write(struct tty_struct *tty, const unsigned char *buf, int count)
351 {
352         struct cardstate *cs;
353         int retval = -ENODEV;
354
355         cs = (struct cardstate *) tty->driver_data;
356         if (!cs) {
357                 pr_err("%s: no cardstate\n", __func__);
358                 return -ENODEV;
359         }
360
361         gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
362
363         if (mutex_lock_interruptible(&cs->mutex))
364                 return -ERESTARTSYS; // FIXME -EINTR?
365
366         if (!cs->open_count)
367                 dev_warn(cs->dev, "%s: device not opened\n", __func__);
368         else if (cs->mstate != MS_LOCKED) {
369                 dev_warn(cs->dev, "can't write to unlocked device\n");
370                 retval = -EBUSY;
371         } else if (!cs->connected) {
372                 gig_dbg(DEBUG_ANY, "can't write to unplugged device");
373                 retval = -EBUSY; //FIXME
374         } else {
375                 retval = cs->ops->write_cmd(cs, buf, count,
376                                             &cs->if_wake_tasklet);
377         }
378
379         mutex_unlock(&cs->mutex);
380
381         return retval;
382 }
383
384 static int if_write_room(struct tty_struct *tty)
385 {
386         struct cardstate *cs;
387         int retval = -ENODEV;
388
389         cs = (struct cardstate *) tty->driver_data;
390         if (!cs) {
391                 pr_err("%s: no cardstate\n", __func__);
392                 return -ENODEV;
393         }
394
395         gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
396
397         if (mutex_lock_interruptible(&cs->mutex))
398                 return -ERESTARTSYS; // FIXME -EINTR?
399
400         if (!cs->open_count)
401                 dev_warn(cs->dev, "%s: device not opened\n", __func__);
402         else if (cs->mstate != MS_LOCKED) {
403                 dev_warn(cs->dev, "can't write to unlocked device\n");
404                 retval = -EBUSY;
405         } else if (!cs->connected) {
406                 gig_dbg(DEBUG_ANY, "can't write to unplugged device");
407                 retval = -EBUSY; //FIXME
408         } else
409                 retval = cs->ops->write_room(cs);
410
411         mutex_unlock(&cs->mutex);
412
413         return retval;
414 }
415
416 static int if_chars_in_buffer(struct tty_struct *tty)
417 {
418         struct cardstate *cs;
419         int retval = -ENODEV;
420
421         cs = (struct cardstate *) tty->driver_data;
422         if (!cs) {
423                 pr_err("%s: no cardstate\n", __func__);
424                 return -ENODEV;
425         }
426
427         gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
428
429         if (mutex_lock_interruptible(&cs->mutex))
430                 return -ERESTARTSYS; // FIXME -EINTR?
431
432         if (!cs->open_count)
433                 dev_warn(cs->dev, "%s: device not opened\n", __func__);
434         else if (cs->mstate != MS_LOCKED) {
435                 dev_warn(cs->dev, "can't write to unlocked device\n");
436                 retval = -EBUSY;
437         } else if (!cs->connected) {
438                 gig_dbg(DEBUG_ANY, "can't write to unplugged device");
439                 retval = -EBUSY; //FIXME
440         } else
441                 retval = cs->ops->chars_in_buffer(cs);
442
443         mutex_unlock(&cs->mutex);
444
445         return retval;
446 }
447
448 static void if_throttle(struct tty_struct *tty)
449 {
450         struct cardstate *cs;
451
452         cs = (struct cardstate *) tty->driver_data;
453         if (!cs) {
454                 pr_err("%s: no cardstate\n", __func__);
455                 return;
456         }
457
458         gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
459
460         mutex_lock(&cs->mutex);
461
462         if (!cs->open_count)
463                 dev_warn(cs->dev, "%s: device not opened\n", __func__);
464         else {
465                 //FIXME
466         }
467
468         mutex_unlock(&cs->mutex);
469 }
470
471 static void if_unthrottle(struct tty_struct *tty)
472 {
473         struct cardstate *cs;
474
475         cs = (struct cardstate *) tty->driver_data;
476         if (!cs) {
477                 pr_err("%s: no cardstate\n", __func__);
478                 return;
479         }
480
481         gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
482
483         mutex_lock(&cs->mutex);
484
485         if (!cs->open_count)
486                 dev_warn(cs->dev, "%s: device not opened\n", __func__);
487         else {
488                 //FIXME
489         }
490
491         mutex_unlock(&cs->mutex);
492 }
493
494 static void if_set_termios(struct tty_struct *tty, struct ktermios *old)
495 {
496         struct cardstate *cs;
497         unsigned int iflag;
498         unsigned int cflag;
499         unsigned int old_cflag;
500         unsigned int control_state, new_state;
501
502         cs = (struct cardstate *) tty->driver_data;
503         if (!cs) {
504                 pr_err("%s: no cardstate\n", __func__);
505                 return;
506         }
507
508         gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
509
510         mutex_lock(&cs->mutex);
511
512         if (!cs->open_count) {
513                 dev_warn(cs->dev, "%s: device not opened\n", __func__);
514                 goto out;
515         }
516
517         if (!cs->connected) {
518                 gig_dbg(DEBUG_ANY, "can't communicate with unplugged device");
519                 goto out;
520         }
521
522         // stolen from mct_u232.c
523         iflag = tty->termios->c_iflag;
524         cflag = tty->termios->c_cflag;
525         old_cflag = old ? old->c_cflag : cflag; //FIXME?
526         gig_dbg(DEBUG_IF, "%u: iflag %x cflag %x old %x",
527                 cs->minor_index, iflag, cflag, old_cflag);
528
529         /* get a local copy of the current port settings */
530         control_state = cs->control_state;
531
532         /*
533          * Update baud rate.
534          * Do not attempt to cache old rates and skip settings,
535          * disconnects screw such tricks up completely.
536          * Premature optimization is the root of all evil.
537          */
538
539         /* reassert DTR and (maybe) RTS on transition from B0 */
540         if ((old_cflag & CBAUD) == B0) {
541                 new_state = control_state | TIOCM_DTR;
542                 /* don't set RTS if using hardware flow control */
543                 if (!(old_cflag & CRTSCTS))
544                         new_state |= TIOCM_RTS;
545                 gig_dbg(DEBUG_IF, "%u: from B0 - set DTR%s",
546                         cs->minor_index,
547                         (new_state & TIOCM_RTS) ? " only" : "/RTS");
548                 cs->ops->set_modem_ctrl(cs, control_state, new_state);
549                 control_state = new_state;
550         }
551
552         cs->ops->baud_rate(cs, cflag & CBAUD);
553
554         if ((cflag & CBAUD) == B0) {
555                 /* Drop RTS and DTR */
556                 gig_dbg(DEBUG_IF, "%u: to B0 - drop DTR/RTS", cs->minor_index);
557                 new_state = control_state & ~(TIOCM_DTR | TIOCM_RTS);
558                 cs->ops->set_modem_ctrl(cs, control_state, new_state);
559                 control_state = new_state;
560         }
561
562         /*
563          * Update line control register (LCR)
564          */
565
566         cs->ops->set_line_ctrl(cs, cflag);
567
568 #if 0
569         //FIXME this hangs M101 [ts 2005-03-09]
570         //FIXME do we need this?
571         /*
572          * Set flow control: well, I do not really now how to handle DTR/RTS.
573          * Just do what we have seen with SniffUSB on Win98.
574          */
575         /* Drop DTR/RTS if no flow control otherwise assert */
576         gig_dbg(DEBUG_IF, "%u: control_state %x",
577                 cs->minor_index, control_state);
578         new_state = control_state;
579         if ((iflag & IXOFF) || (iflag & IXON) || (cflag & CRTSCTS))
580                 new_state |= TIOCM_DTR | TIOCM_RTS;
581         else
582                 new_state &= ~(TIOCM_DTR | TIOCM_RTS);
583         if (new_state != control_state) {
584                 gig_dbg(DEBUG_IF, "%u: new_state %x",
585                         cs->minor_index, new_state);
586                 gigaset_set_modem_ctrl(cs, control_state, new_state);
587                 control_state = new_state;
588         }
589 #endif
590
591         /* save off the modified port settings */
592         cs->control_state = control_state;
593
594 out:
595         mutex_unlock(&cs->mutex);
596 }
597
598
599 /* wakeup tasklet for the write operation */
600 static void if_wake(unsigned long data)
601 {
602         struct cardstate *cs = (struct cardstate *) data;
603
604         if (cs->tty)
605                 tty_wakeup(cs->tty);
606 }
607
608 /*** interface to common ***/
609
610 void gigaset_if_init(struct cardstate *cs)
611 {
612         struct gigaset_driver *drv;
613
614         drv = cs->driver;
615         if (!drv->have_tty)
616                 return;
617
618         tasklet_init(&cs->if_wake_tasklet, &if_wake, (unsigned long) cs);
619
620         mutex_lock(&cs->mutex);
621         cs->tty_dev = tty_register_device(drv->tty, cs->minor_index, NULL);
622
623         if (!IS_ERR(cs->tty_dev))
624                 dev_set_drvdata(cs->tty_dev, cs);
625         else {
626                 dev_warn(cs->dev,
627                          "could not register device to the tty subsystem\n");
628                 cs->tty_dev = NULL;
629         }
630         mutex_unlock(&cs->mutex);
631 }
632
633 void gigaset_if_free(struct cardstate *cs)
634 {
635         struct gigaset_driver *drv;
636
637         drv = cs->driver;
638         if (!drv->have_tty)
639                 return;
640
641         tasklet_disable(&cs->if_wake_tasklet);
642         tasklet_kill(&cs->if_wake_tasklet);
643         cs->tty_dev = NULL;
644         tty_unregister_device(drv->tty, cs->minor_index);
645 }
646
647 void gigaset_if_receive(struct cardstate *cs,
648                         unsigned char *buffer, size_t len)
649 {
650         unsigned long flags;
651         struct tty_struct *tty;
652
653         spin_lock_irqsave(&cs->lock, flags);
654         if ((tty = cs->tty) == NULL)
655                 gig_dbg(DEBUG_ANY, "receive on closed device");
656         else {
657                 tty_buffer_request_room(tty, len);
658                 tty_insert_flip_string(tty, buffer, len);
659                 tty_flip_buffer_push(tty);
660         }
661         spin_unlock_irqrestore(&cs->lock, flags);
662 }
663 EXPORT_SYMBOL_GPL(gigaset_if_receive);
664
665 /* gigaset_if_initdriver
666  * Initialize tty interface.
667  * parameters:
668  *      drv             Driver
669  *      procname        Name of the driver (e.g. for /proc/tty/drivers)
670  *      devname         Name of the device files (prefix without minor number)
671  */
672 void gigaset_if_initdriver(struct gigaset_driver *drv, const char *procname,
673                            const char *devname)
674 {
675         unsigned minors = drv->minors;
676         int ret;
677         struct tty_driver *tty;
678
679         drv->have_tty = 0;
680
681         if ((drv->tty = alloc_tty_driver(minors)) == NULL)
682                 goto enomem;
683         tty = drv->tty;
684
685         tty->magic =            TTY_DRIVER_MAGIC,
686         tty->major =            GIG_MAJOR,
687         tty->type =             TTY_DRIVER_TYPE_SERIAL,
688         tty->subtype =          SERIAL_TYPE_NORMAL,
689         tty->flags =            TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
690
691         tty->driver_name =      procname;
692         tty->name =             devname;
693         tty->minor_start =      drv->minor;
694         tty->num =              drv->minors;
695
696         tty->owner =            THIS_MODULE;
697
698         tty->init_termios          = tty_std_termios; //FIXME
699         tty->init_termios.c_cflag  = B9600 | CS8 | CREAD | HUPCL | CLOCAL; //FIXME
700         tty_set_operations(tty, &if_ops);
701
702         ret = tty_register_driver(tty);
703         if (ret < 0) {
704                 pr_err("error %d registering tty driver\n", ret);
705                 goto error;
706         }
707         gig_dbg(DEBUG_IF, "tty driver initialized");
708         drv->have_tty = 1;
709         return;
710
711 enomem:
712         pr_err("out of memory\n");
713 error:
714         if (drv->tty)
715                 put_tty_driver(drv->tty);
716 }
717
718 void gigaset_if_freedriver(struct gigaset_driver *drv)
719 {
720         if (!drv->have_tty)
721                 return;
722
723         drv->have_tty = 0;
724         tty_unregister_driver(drv->tty);
725         put_tty_driver(drv->tty);
726 }