Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/djbw/async_tx
[linux-2.6] / drivers / isdn / gigaset / ser-gigaset.c
1 /* This is the serial hardware link layer (HLL) for the Gigaset 307x isdn
2  * DECT base (aka Sinus 45 isdn) using the RS232 DECT data module M101,
3  * written as a line discipline.
4  *
5  * =====================================================================
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License as
8  * published by the Free Software Foundation; either version 2 of
9  * the License, or (at your option) any later version.
10  * =====================================================================
11  */
12
13 #include "gigaset.h"
14
15 #include <linux/module.h>
16 #include <linux/moduleparam.h>
17 #include <linux/platform_device.h>
18 #include <linux/tty.h>
19 #include <linux/poll.h>
20 #include <linux/completion.h>
21
22 /* Version Information */
23 #define DRIVER_AUTHOR "Tilman Schmidt"
24 #define DRIVER_DESC "Serial Driver for Gigaset 307x using Siemens M101"
25
26 #define GIGASET_MINORS     1
27 #define GIGASET_MINOR      0
28 #define GIGASET_MODULENAME "ser_gigaset"
29 #define GIGASET_DEVNAME    "ttyGS"
30
31 /* length limit according to Siemens 3070usb-protokoll.doc ch. 2.1 */
32 #define IF_WRITEBUF 264
33
34 MODULE_AUTHOR(DRIVER_AUTHOR);
35 MODULE_DESCRIPTION(DRIVER_DESC);
36 MODULE_LICENSE("GPL");
37 MODULE_ALIAS_LDISC(N_GIGASET_M101);
38
39 static int startmode = SM_ISDN;
40 module_param(startmode, int, S_IRUGO);
41 MODULE_PARM_DESC(startmode, "initial operation mode");
42 static int cidmode = 1;
43 module_param(cidmode, int, S_IRUGO);
44 MODULE_PARM_DESC(cidmode, "stay in CID mode when idle");
45
46 static struct gigaset_driver *driver;
47
48 struct ser_cardstate {
49         struct platform_device  dev;
50         struct tty_struct       *tty;
51         atomic_t                refcnt;
52         struct completion       dead_cmp;
53 };
54
55 static struct platform_driver device_driver = {
56         .driver = {
57                 .name = GIGASET_MODULENAME,
58         },
59 };
60
61 static void flush_send_queue(struct cardstate *);
62
63 /* transmit data from current open skb
64  * result: number of bytes sent or error code < 0
65  */
66 static int write_modem(struct cardstate *cs)
67 {
68         struct tty_struct *tty = cs->hw.ser->tty;
69         struct bc_state *bcs = &cs->bcs[0];     /* only one channel */
70         struct sk_buff *skb = bcs->tx_skb;
71         int sent = -EOPNOTSUPP;
72
73         if (!tty || !tty->driver || !skb)
74                 return -EINVAL;
75
76         if (!skb->len) {
77                 dev_kfree_skb_any(skb);
78                 bcs->tx_skb = NULL;
79                 return -EINVAL;
80         }
81
82         set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
83         if (tty->ops->write)
84                 sent = tty->ops->write(tty, skb->data, skb->len);
85         gig_dbg(DEBUG_OUTPUT, "write_modem: sent %d", sent);
86         if (sent < 0) {
87                 /* error */
88                 flush_send_queue(cs);
89                 return sent;
90         }
91         skb_pull(skb, sent);
92         if (!skb->len) {
93                 /* skb sent completely */
94                 gigaset_skb_sent(bcs, skb);
95
96                 gig_dbg(DEBUG_INTR, "kfree skb (Adr: %lx)!",
97                         (unsigned long) skb);
98                 dev_kfree_skb_any(skb);
99                 bcs->tx_skb = NULL;
100         }
101         return sent;
102 }
103
104 /*
105  * transmit first queued command buffer
106  * result: number of bytes sent or error code < 0
107  */
108 static int send_cb(struct cardstate *cs)
109 {
110         struct tty_struct *tty = cs->hw.ser->tty;
111         struct cmdbuf_t *cb, *tcb;
112         unsigned long flags;
113         int sent = 0;
114
115         if (!tty || !tty->driver)
116                 return -EFAULT;
117
118         cb = cs->cmdbuf;
119         if (!cb)
120                 return 0;       /* nothing to do */
121
122         if (cb->len) {
123                 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
124                 sent = tty->ops->write(tty, cb->buf + cb->offset, cb->len);
125                 if (sent < 0) {
126                         /* error */
127                         gig_dbg(DEBUG_OUTPUT, "send_cb: write error %d", sent);
128                         flush_send_queue(cs);
129                         return sent;
130                 }
131                 cb->offset += sent;
132                 cb->len -= sent;
133                 gig_dbg(DEBUG_OUTPUT, "send_cb: sent %d, left %u, queued %u",
134                         sent, cb->len, cs->cmdbytes);
135         }
136
137         while (cb && !cb->len) {
138                 spin_lock_irqsave(&cs->cmdlock, flags);
139                 cs->cmdbytes -= cs->curlen;
140                 tcb = cb;
141                 cs->cmdbuf = cb = cb->next;
142                 if (cb) {
143                         cb->prev = NULL;
144                         cs->curlen = cb->len;
145                 } else {
146                         cs->lastcmdbuf = NULL;
147                         cs->curlen = 0;
148                 }
149                 spin_unlock_irqrestore(&cs->cmdlock, flags);
150
151                 if (tcb->wake_tasklet)
152                         tasklet_schedule(tcb->wake_tasklet);
153                 kfree(tcb);
154         }
155         return sent;
156 }
157
158 /*
159  * send queue tasklet
160  * If there is already a skb opened, put data to the transfer buffer
161  * by calling "write_modem".
162  * Otherwise take a new skb out of the queue.
163  */
164 static void gigaset_modem_fill(unsigned long data)
165 {
166         struct cardstate *cs = (struct cardstate *) data;
167         struct bc_state *bcs;
168         int sent = 0;
169
170         if (!cs || !(bcs = cs->bcs)) {
171                 gig_dbg(DEBUG_OUTPUT, "%s: no cardstate", __func__);
172                 return;
173         }
174         if (!bcs->tx_skb) {
175                 /* no skb is being sent; send command if any */
176                 sent = send_cb(cs);
177                 gig_dbg(DEBUG_OUTPUT, "%s: send_cb -> %d", __func__, sent);
178                 if (sent)
179                         /* something sent or error */
180                         return;
181
182                 /* no command to send; get skb */
183                 if (!(bcs->tx_skb = skb_dequeue(&bcs->squeue)))
184                         /* no skb either, nothing to do */
185                         return;
186
187                 gig_dbg(DEBUG_INTR, "Dequeued skb (Adr: %lx)",
188                         (unsigned long) bcs->tx_skb);
189         }
190
191         /* send skb */
192         gig_dbg(DEBUG_OUTPUT, "%s: tx_skb", __func__);
193         if (write_modem(cs) < 0)
194                 gig_dbg(DEBUG_OUTPUT, "%s: write_modem failed", __func__);
195 }
196
197 /*
198  * throw away all data queued for sending
199  */
200 static void flush_send_queue(struct cardstate *cs)
201 {
202         struct sk_buff *skb;
203         struct cmdbuf_t *cb;
204         unsigned long flags;
205
206         /* command queue */
207         spin_lock_irqsave(&cs->cmdlock, flags);
208         while ((cb = cs->cmdbuf) != NULL) {
209                 cs->cmdbuf = cb->next;
210                 if (cb->wake_tasklet)
211                         tasklet_schedule(cb->wake_tasklet);
212                 kfree(cb);
213         }
214         cs->cmdbuf = cs->lastcmdbuf = NULL;
215         cs->cmdbytes = cs->curlen = 0;
216         spin_unlock_irqrestore(&cs->cmdlock, flags);
217
218         /* data queue */
219         if (cs->bcs->tx_skb)
220                 dev_kfree_skb_any(cs->bcs->tx_skb);
221         while ((skb = skb_dequeue(&cs->bcs->squeue)) != NULL)
222                 dev_kfree_skb_any(skb);
223 }
224
225
226 /* Gigaset Driver Interface */
227 /* ======================== */
228
229 /*
230  * queue an AT command string for transmission to the Gigaset device
231  * parameters:
232  *      cs              controller state structure
233  *      buf             buffer containing the string to send
234  *      len             number of characters to send
235  *      wake_tasklet    tasklet to run when transmission is complete, or NULL
236  * return value:
237  *      number of bytes queued, or error code < 0
238  */
239 static int gigaset_write_cmd(struct cardstate *cs, const unsigned char *buf,
240                              int len, struct tasklet_struct *wake_tasklet)
241 {
242         struct cmdbuf_t *cb;
243         unsigned long flags;
244
245         gigaset_dbg_buffer(cs->mstate != MS_LOCKED ?
246                              DEBUG_TRANSCMD : DEBUG_LOCKCMD,
247                            "CMD Transmit", len, buf);
248
249         if (len <= 0)
250                 return 0;
251
252         if (!(cb = kmalloc(sizeof(struct cmdbuf_t) + len, GFP_ATOMIC))) {
253                 dev_err(cs->dev, "%s: out of memory!\n", __func__);
254                 return -ENOMEM;
255         }
256
257         memcpy(cb->buf, buf, len);
258         cb->len = len;
259         cb->offset = 0;
260         cb->next = NULL;
261         cb->wake_tasklet = wake_tasklet;
262
263         spin_lock_irqsave(&cs->cmdlock, flags);
264         cb->prev = cs->lastcmdbuf;
265         if (cs->lastcmdbuf)
266                 cs->lastcmdbuf->next = cb;
267         else {
268                 cs->cmdbuf = cb;
269                 cs->curlen = len;
270         }
271         cs->cmdbytes += len;
272         cs->lastcmdbuf = cb;
273         spin_unlock_irqrestore(&cs->cmdlock, flags);
274
275         spin_lock_irqsave(&cs->lock, flags);
276         if (cs->connected)
277                 tasklet_schedule(&cs->write_tasklet);
278         spin_unlock_irqrestore(&cs->lock, flags);
279         return len;
280 }
281
282 /*
283  * tty_driver.write_room interface routine
284  * return number of characters the driver will accept to be written
285  * parameter:
286  *      controller state structure
287  * return value:
288  *      number of characters
289  */
290 static int gigaset_write_room(struct cardstate *cs)
291 {
292         unsigned bytes;
293
294         bytes = cs->cmdbytes;
295         return bytes < IF_WRITEBUF ? IF_WRITEBUF - bytes : 0;
296 }
297
298 /*
299  * tty_driver.chars_in_buffer interface routine
300  * return number of characters waiting to be sent
301  * parameter:
302  *      controller state structure
303  * return value:
304  *      number of characters
305  */
306 static int gigaset_chars_in_buffer(struct cardstate *cs)
307 {
308         return cs->cmdbytes;
309 }
310
311 /*
312  * implementation of ioctl(GIGASET_BRKCHARS)
313  * parameter:
314  *      controller state structure
315  * return value:
316  *      -EINVAL (unimplemented function)
317  */
318 static int gigaset_brkchars(struct cardstate *cs, const unsigned char buf[6])
319 {
320         /* not implemented */
321         return -EINVAL;
322 }
323
324 /*
325  * Open B channel
326  * Called by "do_action" in ev-layer.c
327  */
328 static int gigaset_init_bchannel(struct bc_state *bcs)
329 {
330         /* nothing to do for M10x */
331         gigaset_bchannel_up(bcs);
332         return 0;
333 }
334
335 /*
336  * Close B channel
337  * Called by "do_action" in ev-layer.c
338  */
339 static int gigaset_close_bchannel(struct bc_state *bcs)
340 {
341         /* nothing to do for M10x */
342         gigaset_bchannel_down(bcs);
343         return 0;
344 }
345
346 /*
347  * Set up B channel structure
348  * This is called by "gigaset_initcs" in common.c
349  */
350 static int gigaset_initbcshw(struct bc_state *bcs)
351 {
352         /* unused */
353         bcs->hw.ser = NULL;
354         return 1;
355 }
356
357 /*
358  * Free B channel structure
359  * Called by "gigaset_freebcs" in common.c
360  */
361 static int gigaset_freebcshw(struct bc_state *bcs)
362 {
363         /* unused */
364         return 1;
365 }
366
367 /*
368  * Reinitialize B channel structure
369  * This is called by "bcs_reinit" in common.c
370  */
371 static void gigaset_reinitbcshw(struct bc_state *bcs)
372 {
373         /* nothing to do for M10x */
374 }
375
376 /*
377  * Free hardware specific device data
378  * This will be called by "gigaset_freecs" in common.c
379  */
380 static void gigaset_freecshw(struct cardstate *cs)
381 {
382         tasklet_kill(&cs->write_tasklet);
383         if (!cs->hw.ser)
384                 return;
385         dev_set_drvdata(&cs->hw.ser->dev.dev, NULL);
386         platform_device_unregister(&cs->hw.ser->dev);
387         kfree(cs->hw.ser);
388         cs->hw.ser = NULL;
389 }
390
391 static void gigaset_device_release(struct device *dev)
392 {
393         struct platform_device *pdev =
394                 container_of(dev, struct platform_device, dev);
395
396         /* adapted from platform_device_release() in drivers/base/platform.c */
397         //FIXME is this actually necessary?
398         kfree(dev->platform_data);
399         kfree(pdev->resource);
400 }
401
402 /*
403  * Set up hardware specific device data
404  * This is called by "gigaset_initcs" in common.c
405  */
406 static int gigaset_initcshw(struct cardstate *cs)
407 {
408         int rc;
409
410         if (!(cs->hw.ser = kzalloc(sizeof(struct ser_cardstate), GFP_KERNEL))) {
411                 err("%s: out of memory!", __func__);
412                 return 0;
413         }
414
415         cs->hw.ser->dev.name = GIGASET_MODULENAME;
416         cs->hw.ser->dev.id = cs->minor_index;
417         cs->hw.ser->dev.dev.release = gigaset_device_release;
418         if ((rc = platform_device_register(&cs->hw.ser->dev)) != 0) {
419                 err("error %d registering platform device", rc);
420                 kfree(cs->hw.ser);
421                 cs->hw.ser = NULL;
422                 return 0;
423         }
424         dev_set_drvdata(&cs->hw.ser->dev.dev, cs);
425
426         tasklet_init(&cs->write_tasklet,
427                      &gigaset_modem_fill, (unsigned long) cs);
428         return 1;
429 }
430
431 /*
432  * set modem control lines
433  * Parameters:
434  *      card state structure
435  *      modem control line state ([TIOCM_DTR]|[TIOCM_RTS])
436  * Called by "gigaset_start" and "gigaset_enterconfigmode" in common.c
437  * and by "if_lock" and "if_termios" in interface.c
438  */
439 static int gigaset_set_modem_ctrl(struct cardstate *cs, unsigned old_state, unsigned new_state)
440 {
441         struct tty_struct *tty = cs->hw.ser->tty;
442         unsigned int set, clear;
443
444         if (!tty || !tty->driver || !tty->ops->tiocmset)
445                 return -EINVAL;
446         set = new_state & ~old_state;
447         clear = old_state & ~new_state;
448         if (!set && !clear)
449                 return 0;
450         gig_dbg(DEBUG_IF, "tiocmset set %x clear %x", set, clear);
451         return tty->ops->tiocmset(tty, NULL, set, clear);
452 }
453
454 static int gigaset_baud_rate(struct cardstate *cs, unsigned cflag)
455 {
456         return -EINVAL;
457 }
458
459 static int gigaset_set_line_ctrl(struct cardstate *cs, unsigned cflag)
460 {
461         return -EINVAL;
462 }
463
464 static const struct gigaset_ops ops = {
465         gigaset_write_cmd,
466         gigaset_write_room,
467         gigaset_chars_in_buffer,
468         gigaset_brkchars,
469         gigaset_init_bchannel,
470         gigaset_close_bchannel,
471         gigaset_initbcshw,
472         gigaset_freebcshw,
473         gigaset_reinitbcshw,
474         gigaset_initcshw,
475         gigaset_freecshw,
476         gigaset_set_modem_ctrl,
477         gigaset_baud_rate,
478         gigaset_set_line_ctrl,
479         gigaset_m10x_send_skb,  /* asyncdata.c */
480         gigaset_m10x_input,     /* asyncdata.c */
481 };
482
483
484 /* Line Discipline Interface */
485 /* ========================= */
486
487 /* helper functions for cardstate refcounting */
488 static struct cardstate *cs_get(struct tty_struct *tty)
489 {
490         struct cardstate *cs = tty->disc_data;
491
492         if (!cs || !cs->hw.ser) {
493                 gig_dbg(DEBUG_ANY, "%s: no cardstate", __func__);
494                 return NULL;
495         }
496         atomic_inc(&cs->hw.ser->refcnt);
497         return cs;
498 }
499
500 static void cs_put(struct cardstate *cs)
501 {
502         if (atomic_dec_and_test(&cs->hw.ser->refcnt))
503                 complete(&cs->hw.ser->dead_cmp);
504 }
505
506 /*
507  * Called by the tty driver when the line discipline is pushed onto the tty.
508  * Called in process context.
509  */
510 static int
511 gigaset_tty_open(struct tty_struct *tty)
512 {
513         struct cardstate *cs;
514
515         gig_dbg(DEBUG_INIT, "Starting HLL for Gigaset M101");
516
517         info(DRIVER_AUTHOR);
518         info(DRIVER_DESC);
519
520         if (!driver) {
521                 err("%s: no driver structure", __func__);
522                 return -ENODEV;
523         }
524
525         /* allocate memory for our device state and intialize it */
526         if (!(cs = gigaset_initcs(driver, 1, 1, 0, cidmode,
527                                   GIGASET_MODULENAME)))
528                 goto error;
529
530         cs->dev = &cs->hw.ser->dev.dev;
531         cs->hw.ser->tty = tty;
532         atomic_set(&cs->hw.ser->refcnt, 1);
533         init_completion(&cs->hw.ser->dead_cmp);
534
535         tty->disc_data = cs;
536
537         /* OK.. Initialization of the datastructures and the HW is done.. Now
538          * startup system and notify the LL that we are ready to run
539          */
540         if (startmode == SM_LOCKED)
541                 cs->mstate = MS_LOCKED;
542         if (!gigaset_start(cs)) {
543                 tasklet_kill(&cs->write_tasklet);
544                 goto error;
545         }
546
547         gig_dbg(DEBUG_INIT, "Startup of HLL done");
548         return 0;
549
550 error:
551         gig_dbg(DEBUG_INIT, "Startup of HLL failed");
552         tty->disc_data = NULL;
553         gigaset_freecs(cs);
554         return -ENODEV;
555 }
556
557 /*
558  * Called by the tty driver when the line discipline is removed.
559  * Called from process context.
560  */
561 static void
562 gigaset_tty_close(struct tty_struct *tty)
563 {
564         struct cardstate *cs = tty->disc_data;
565
566         gig_dbg(DEBUG_INIT, "Stopping HLL for Gigaset M101");
567
568         if (!cs) {
569                 gig_dbg(DEBUG_INIT, "%s: no cardstate", __func__);
570                 return;
571         }
572
573         /* prevent other callers from entering ldisc methods */
574         tty->disc_data = NULL;
575
576         if (!cs->hw.ser)
577                 err("%s: no hw cardstate", __func__);
578         else {
579                 /* wait for running methods to finish */
580                 if (!atomic_dec_and_test(&cs->hw.ser->refcnt))
581                         wait_for_completion(&cs->hw.ser->dead_cmp);
582         }
583
584         /* stop operations */
585         gigaset_stop(cs);
586         tasklet_kill(&cs->write_tasklet);
587         flush_send_queue(cs);
588         cs->dev = NULL;
589         gigaset_freecs(cs);
590
591         gig_dbg(DEBUG_INIT, "Shutdown of HLL done");
592 }
593
594 /*
595  * Called by the tty driver when the tty line is hung up.
596  * Wait for I/O to driver to complete and unregister ISDN device.
597  * This is already done by the close routine, so just call that.
598  * Called from process context.
599  */
600 static int gigaset_tty_hangup(struct tty_struct *tty)
601 {
602         gigaset_tty_close(tty);
603         return 0;
604 }
605
606 /*
607  * Read on the tty.
608  * Unused, received data goes only to the Gigaset driver.
609  */
610 static ssize_t
611 gigaset_tty_read(struct tty_struct *tty, struct file *file,
612                  unsigned char __user *buf, size_t count)
613 {
614         return -EAGAIN;
615 }
616
617 /*
618  * Write on the tty.
619  * Unused, transmit data comes only from the Gigaset driver.
620  */
621 static ssize_t
622 gigaset_tty_write(struct tty_struct *tty, struct file *file,
623                   const unsigned char *buf, size_t count)
624 {
625         return -EAGAIN;
626 }
627
628 /*
629  * Ioctl on the tty.
630  * Called in process context only.
631  * May be re-entered by multiple ioctl calling threads.
632  */
633 static int
634 gigaset_tty_ioctl(struct tty_struct *tty, struct file *file,
635                   unsigned int cmd, unsigned long arg)
636 {
637         struct cardstate *cs = cs_get(tty);
638         int rc, val;
639         int __user *p = (int __user *)arg;
640
641         if (!cs)
642                 return -ENXIO;
643
644         switch (cmd) {
645         case TCGETS:
646         case TCGETA:
647                 /* pass through to underlying serial device */
648                 rc = n_tty_ioctl(tty, file, cmd, arg);
649                 break;
650
651         case TCFLSH:
652                 /* flush our buffers and the serial port's buffer */
653                 switch (arg) {
654                 case TCIFLUSH:
655                         /* no own input buffer to flush */
656                         break;
657                 case TCIOFLUSH:
658                 case TCOFLUSH:
659                         flush_send_queue(cs);
660                         break;
661                 }
662                 /* flush the serial port's buffer */
663                 rc = n_tty_ioctl(tty, file, cmd, arg);
664                 break;
665
666         case FIONREAD:
667                 /* unused, always return zero */
668                 val = 0;
669                 rc = put_user(val, p);
670                 break;
671
672         default:
673                 rc = -ENOIOCTLCMD;
674         }
675
676         cs_put(cs);
677         return rc;
678 }
679
680 /*
681  * Poll on the tty.
682  * Unused, always return zero.
683  */
684 static unsigned int
685 gigaset_tty_poll(struct tty_struct *tty, struct file *file, poll_table *wait)
686 {
687         return 0;
688 }
689
690 /*
691  * Called by the tty driver when a block of data has been received.
692  * Will not be re-entered while running but other ldisc functions
693  * may be called in parallel.
694  * Can be called from hard interrupt level as well as soft interrupt
695  * level or mainline.
696  * Parameters:
697  *      tty     tty structure
698  *      buf     buffer containing received characters
699  *      cflags  buffer containing error flags for received characters (ignored)
700  *      count   number of received characters
701  */
702 static void
703 gigaset_tty_receive(struct tty_struct *tty, const unsigned char *buf,
704                     char *cflags, int count)
705 {
706         struct cardstate *cs = cs_get(tty);
707         unsigned tail, head, n;
708         struct inbuf_t *inbuf;
709
710         if (!cs)
711                 return;
712         if (!(inbuf = cs->inbuf)) {
713                 dev_err(cs->dev, "%s: no inbuf\n", __func__);
714                 cs_put(cs);
715                 return;
716         }
717
718         tail = inbuf->tail;
719         head = inbuf->head;
720         gig_dbg(DEBUG_INTR, "buffer state: %u -> %u, receive %u bytes",
721                 head, tail, count);
722
723         if (head <= tail) {
724                 /* possible buffer wraparound */
725                 n = min_t(unsigned, count, RBUFSIZE - tail);
726                 memcpy(inbuf->data + tail, buf, n);
727                 tail = (tail + n) % RBUFSIZE;
728                 buf += n;
729                 count -= n;
730         }
731
732         if (count > 0) {
733                 /* tail < head and some data left */
734                 n = head - tail - 1;
735                 if (count > n) {
736                         dev_err(cs->dev,
737                                 "inbuf overflow, discarding %d bytes\n",
738                                 count - n);
739                         count = n;
740                 }
741                 memcpy(inbuf->data + tail, buf, count);
742                 tail += count;
743         }
744
745         gig_dbg(DEBUG_INTR, "setting tail to %u", tail);
746         inbuf->tail = tail;
747
748         /* Everything was received .. Push data into handler */
749         gig_dbg(DEBUG_INTR, "%s-->BH", __func__);
750         gigaset_schedule_event(cs);
751         cs_put(cs);
752 }
753
754 /*
755  * Called by the tty driver when there's room for more data to send.
756  */
757 static void
758 gigaset_tty_wakeup(struct tty_struct *tty)
759 {
760         struct cardstate *cs = cs_get(tty);
761
762         clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
763         if (!cs)
764                 return;
765         tasklet_schedule(&cs->write_tasklet);
766         cs_put(cs);
767 }
768
769 static struct tty_ldisc_ops gigaset_ldisc = {
770         .owner          = THIS_MODULE,
771         .magic          = TTY_LDISC_MAGIC,
772         .name           = "ser_gigaset",
773         .open           = gigaset_tty_open,
774         .close          = gigaset_tty_close,
775         .hangup         = gigaset_tty_hangup,
776         .read           = gigaset_tty_read,
777         .write          = gigaset_tty_write,
778         .ioctl          = gigaset_tty_ioctl,
779         .poll           = gigaset_tty_poll,
780         .receive_buf    = gigaset_tty_receive,
781         .write_wakeup   = gigaset_tty_wakeup,
782 };
783
784
785 /* Initialization / Shutdown */
786 /* ========================= */
787
788 static int __init ser_gigaset_init(void)
789 {
790         int rc;
791
792         gig_dbg(DEBUG_INIT, "%s", __func__);
793         if ((rc = platform_driver_register(&device_driver)) != 0) {
794                 err("error %d registering platform driver", rc);
795                 return rc;
796         }
797
798         /* allocate memory for our driver state and intialize it */
799         if (!(driver = gigaset_initdriver(GIGASET_MINOR, GIGASET_MINORS,
800                                           GIGASET_MODULENAME, GIGASET_DEVNAME,
801                                           &ops, THIS_MODULE)))
802                 goto error;
803
804         if ((rc = tty_register_ldisc(N_GIGASET_M101, &gigaset_ldisc)) != 0) {
805                 err("error %d registering line discipline", rc);
806                 goto error;
807         }
808
809         return 0;
810
811 error:
812         if (driver) {
813                 gigaset_freedriver(driver);
814                 driver = NULL;
815         }
816         platform_driver_unregister(&device_driver);
817         return rc;
818 }
819
820 static void __exit ser_gigaset_exit(void)
821 {
822         int rc;
823
824         gig_dbg(DEBUG_INIT, "%s", __func__);
825
826         if (driver) {
827                 gigaset_freedriver(driver);
828                 driver = NULL;
829         }
830
831         if ((rc = tty_unregister_ldisc(N_GIGASET_M101)) != 0)
832                 err("error %d unregistering line discipline", rc);
833
834         platform_driver_unregister(&device_driver);
835 }
836
837 module_init(ser_gigaset_init);
838 module_exit(ser_gigaset_exit);