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.
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 * =====================================================================
14 #include <linux/module.h>
15 #include <linux/moduleparam.h>
16 #include <linux/platform_device.h>
17 #include <linux/completion.h>
19 /* Version Information */
20 #define DRIVER_AUTHOR "Tilman Schmidt"
21 #define DRIVER_DESC "Serial Driver for Gigaset 307x using Siemens M101"
23 #define GIGASET_MINORS 1
24 #define GIGASET_MINOR 0
25 #define GIGASET_MODULENAME "ser_gigaset"
26 #define GIGASET_DEVNAME "ttyGS"
28 /* length limit according to Siemens 3070usb-protokoll.doc ch. 2.1 */
29 #define IF_WRITEBUF 264
31 MODULE_AUTHOR(DRIVER_AUTHOR);
32 MODULE_DESCRIPTION(DRIVER_DESC);
33 MODULE_LICENSE("GPL");
34 MODULE_ALIAS_LDISC(N_GIGASET_M101);
36 static int startmode = SM_ISDN;
37 module_param(startmode, int, S_IRUGO);
38 MODULE_PARM_DESC(startmode, "initial operation mode");
39 static int cidmode = 1;
40 module_param(cidmode, int, S_IRUGO);
41 MODULE_PARM_DESC(cidmode, "stay in CID mode when idle");
43 static struct gigaset_driver *driver;
45 struct ser_cardstate {
46 struct platform_device dev;
47 struct tty_struct *tty;
49 struct completion dead_cmp;
52 static struct platform_driver device_driver = {
54 .name = GIGASET_MODULENAME,
58 static void flush_send_queue(struct cardstate *);
60 /* transmit data from current open skb
61 * result: number of bytes sent or error code < 0
63 static int write_modem(struct cardstate *cs)
65 struct tty_struct *tty = cs->hw.ser->tty;
66 struct bc_state *bcs = &cs->bcs[0]; /* only one channel */
67 struct sk_buff *skb = bcs->tx_skb;
68 int sent = -EOPNOTSUPP;
70 if (!tty || !tty->driver || !skb)
74 dev_kfree_skb_any(skb);
79 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
81 sent = tty->ops->write(tty, skb->data, skb->len);
82 gig_dbg(DEBUG_OUTPUT, "write_modem: sent %d", sent);
90 /* skb sent completely */
91 gigaset_skb_sent(bcs, skb);
93 gig_dbg(DEBUG_INTR, "kfree skb (Adr: %lx)!",
95 dev_kfree_skb_any(skb);
102 * transmit first queued command buffer
103 * result: number of bytes sent or error code < 0
105 static int send_cb(struct cardstate *cs)
107 struct tty_struct *tty = cs->hw.ser->tty;
108 struct cmdbuf_t *cb, *tcb;
112 if (!tty || !tty->driver)
117 return 0; /* nothing to do */
120 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
121 sent = tty->ops->write(tty, cb->buf + cb->offset, cb->len);
124 gig_dbg(DEBUG_OUTPUT, "send_cb: write error %d", sent);
125 flush_send_queue(cs);
130 gig_dbg(DEBUG_OUTPUT, "send_cb: sent %d, left %u, queued %u",
131 sent, cb->len, cs->cmdbytes);
134 while (cb && !cb->len) {
135 spin_lock_irqsave(&cs->cmdlock, flags);
136 cs->cmdbytes -= cs->curlen;
138 cs->cmdbuf = cb = cb->next;
141 cs->curlen = cb->len;
143 cs->lastcmdbuf = NULL;
146 spin_unlock_irqrestore(&cs->cmdlock, flags);
148 if (tcb->wake_tasklet)
149 tasklet_schedule(tcb->wake_tasklet);
157 * If there is already a skb opened, put data to the transfer buffer
158 * by calling "write_modem".
159 * Otherwise take a new skb out of the queue.
161 static void gigaset_modem_fill(unsigned long data)
163 struct cardstate *cs = (struct cardstate *) data;
164 struct bc_state *bcs;
165 struct sk_buff *nextskb;
169 gig_dbg(DEBUG_OUTPUT, "%s: no cardstate", __func__);
174 gig_dbg(DEBUG_OUTPUT, "%s: no cardstate", __func__);
178 /* no skb is being sent; send command if any */
180 gig_dbg(DEBUG_OUTPUT, "%s: send_cb -> %d", __func__, sent);
182 /* something sent or error */
185 /* no command to send; get skb */
186 nextskb = skb_dequeue(&bcs->squeue);
188 /* no skb either, nothing to do */
190 bcs->tx_skb = nextskb;
192 gig_dbg(DEBUG_INTR, "Dequeued skb (Adr: %lx)",
193 (unsigned long) bcs->tx_skb);
197 gig_dbg(DEBUG_OUTPUT, "%s: tx_skb", __func__);
198 if (write_modem(cs) < 0)
199 gig_dbg(DEBUG_OUTPUT, "%s: write_modem failed", __func__);
203 * throw away all data queued for sending
205 static void flush_send_queue(struct cardstate *cs)
212 spin_lock_irqsave(&cs->cmdlock, flags);
213 while ((cb = cs->cmdbuf) != NULL) {
214 cs->cmdbuf = cb->next;
215 if (cb->wake_tasklet)
216 tasklet_schedule(cb->wake_tasklet);
219 cs->cmdbuf = cs->lastcmdbuf = NULL;
220 cs->cmdbytes = cs->curlen = 0;
221 spin_unlock_irqrestore(&cs->cmdlock, flags);
225 dev_kfree_skb_any(cs->bcs->tx_skb);
226 while ((skb = skb_dequeue(&cs->bcs->squeue)) != NULL)
227 dev_kfree_skb_any(skb);
231 /* Gigaset Driver Interface */
232 /* ======================== */
235 * queue an AT command string for transmission to the Gigaset device
237 * cs controller state structure
238 * buf buffer containing the string to send
239 * len number of characters to send
240 * wake_tasklet tasklet to run when transmission is complete, or NULL
242 * number of bytes queued, or error code < 0
244 static int gigaset_write_cmd(struct cardstate *cs, const unsigned char *buf,
245 int len, struct tasklet_struct *wake_tasklet)
250 gigaset_dbg_buffer(cs->mstate != MS_LOCKED ?
251 DEBUG_TRANSCMD : DEBUG_LOCKCMD,
252 "CMD Transmit", len, buf);
257 cb = kmalloc(sizeof(struct cmdbuf_t) + len, GFP_ATOMIC);
259 dev_err(cs->dev, "%s: out of memory!\n", __func__);
263 memcpy(cb->buf, buf, len);
267 cb->wake_tasklet = wake_tasklet;
269 spin_lock_irqsave(&cs->cmdlock, flags);
270 cb->prev = cs->lastcmdbuf;
272 cs->lastcmdbuf->next = cb;
279 spin_unlock_irqrestore(&cs->cmdlock, flags);
281 spin_lock_irqsave(&cs->lock, flags);
283 tasklet_schedule(&cs->write_tasklet);
284 spin_unlock_irqrestore(&cs->lock, flags);
289 * tty_driver.write_room interface routine
290 * return number of characters the driver will accept to be written
292 * controller state structure
294 * number of characters
296 static int gigaset_write_room(struct cardstate *cs)
300 bytes = cs->cmdbytes;
301 return bytes < IF_WRITEBUF ? IF_WRITEBUF - bytes : 0;
305 * tty_driver.chars_in_buffer interface routine
306 * return number of characters waiting to be sent
308 * controller state structure
310 * number of characters
312 static int gigaset_chars_in_buffer(struct cardstate *cs)
318 * implementation of ioctl(GIGASET_BRKCHARS)
320 * controller state structure
322 * -EINVAL (unimplemented function)
324 static int gigaset_brkchars(struct cardstate *cs, const unsigned char buf[6])
326 /* not implemented */
332 * Called by "do_action" in ev-layer.c
334 static int gigaset_init_bchannel(struct bc_state *bcs)
336 /* nothing to do for M10x */
337 gigaset_bchannel_up(bcs);
343 * Called by "do_action" in ev-layer.c
345 static int gigaset_close_bchannel(struct bc_state *bcs)
347 /* nothing to do for M10x */
348 gigaset_bchannel_down(bcs);
353 * Set up B channel structure
354 * This is called by "gigaset_initcs" in common.c
356 static int gigaset_initbcshw(struct bc_state *bcs)
364 * Free B channel structure
365 * Called by "gigaset_freebcs" in common.c
367 static int gigaset_freebcshw(struct bc_state *bcs)
374 * Reinitialize B channel structure
375 * This is called by "bcs_reinit" in common.c
377 static void gigaset_reinitbcshw(struct bc_state *bcs)
379 /* nothing to do for M10x */
383 * Free hardware specific device data
384 * This will be called by "gigaset_freecs" in common.c
386 static void gigaset_freecshw(struct cardstate *cs)
388 tasklet_kill(&cs->write_tasklet);
391 dev_set_drvdata(&cs->hw.ser->dev.dev, NULL);
392 platform_device_unregister(&cs->hw.ser->dev);
397 static void gigaset_device_release(struct device *dev)
399 struct platform_device *pdev = to_platform_device(dev);
401 /* adapted from platform_device_release() in drivers/base/platform.c */
402 kfree(dev->platform_data);
403 kfree(pdev->resource);
407 * Set up hardware specific device data
408 * This is called by "gigaset_initcs" in common.c
410 static int gigaset_initcshw(struct cardstate *cs)
413 struct ser_cardstate *scs;
415 scs = kzalloc(sizeof(struct ser_cardstate), GFP_KERNEL);
417 pr_err("out of memory\n");
422 cs->hw.ser->dev.name = GIGASET_MODULENAME;
423 cs->hw.ser->dev.id = cs->minor_index;
424 cs->hw.ser->dev.dev.release = gigaset_device_release;
425 rc = platform_device_register(&cs->hw.ser->dev);
427 pr_err("error %d registering platform device\n", rc);
432 dev_set_drvdata(&cs->hw.ser->dev.dev, cs);
434 tasklet_init(&cs->write_tasklet,
435 gigaset_modem_fill, (unsigned long) cs);
440 * set modem control lines
442 * card state structure
443 * modem control line state ([TIOCM_DTR]|[TIOCM_RTS])
444 * Called by "gigaset_start" and "gigaset_enterconfigmode" in common.c
445 * and by "if_lock" and "if_termios" in interface.c
447 static int gigaset_set_modem_ctrl(struct cardstate *cs, unsigned old_state,
450 struct tty_struct *tty = cs->hw.ser->tty;
451 unsigned int set, clear;
453 if (!tty || !tty->driver || !tty->ops->tiocmset)
455 set = new_state & ~old_state;
456 clear = old_state & ~new_state;
459 gig_dbg(DEBUG_IF, "tiocmset set %x clear %x", set, clear);
460 return tty->ops->tiocmset(tty, NULL, set, clear);
463 static int gigaset_baud_rate(struct cardstate *cs, unsigned cflag)
468 static int gigaset_set_line_ctrl(struct cardstate *cs, unsigned cflag)
473 static const struct gigaset_ops ops = {
476 gigaset_chars_in_buffer,
478 gigaset_init_bchannel,
479 gigaset_close_bchannel,
485 gigaset_set_modem_ctrl,
487 gigaset_set_line_ctrl,
488 gigaset_m10x_send_skb, /* asyncdata.c */
489 gigaset_m10x_input, /* asyncdata.c */
493 /* Line Discipline Interface */
494 /* ========================= */
496 /* helper functions for cardstate refcounting */
497 static struct cardstate *cs_get(struct tty_struct *tty)
499 struct cardstate *cs = tty->disc_data;
501 if (!cs || !cs->hw.ser) {
502 gig_dbg(DEBUG_ANY, "%s: no cardstate", __func__);
505 atomic_inc(&cs->hw.ser->refcnt);
509 static void cs_put(struct cardstate *cs)
511 if (atomic_dec_and_test(&cs->hw.ser->refcnt))
512 complete(&cs->hw.ser->dead_cmp);
516 * Called by the tty driver when the line discipline is pushed onto the tty.
517 * Called in process context.
520 gigaset_tty_open(struct tty_struct *tty)
522 struct cardstate *cs;
524 gig_dbg(DEBUG_INIT, "Starting HLL for Gigaset M101");
526 pr_info(DRIVER_DESC "\n");
529 pr_err("%s: no driver structure\n", __func__);
533 /* allocate memory for our device state and intialize it */
534 cs = gigaset_initcs(driver, 1, 1, 0, cidmode, GIGASET_MODULENAME);
538 cs->dev = &cs->hw.ser->dev.dev;
539 cs->hw.ser->tty = tty;
540 atomic_set(&cs->hw.ser->refcnt, 1);
541 init_completion(&cs->hw.ser->dead_cmp);
545 /* OK.. Initialization of the datastructures and the HW is done.. Now
546 * startup system and notify the LL that we are ready to run
548 if (startmode == SM_LOCKED)
549 cs->mstate = MS_LOCKED;
550 if (!gigaset_start(cs)) {
551 tasklet_kill(&cs->write_tasklet);
555 gig_dbg(DEBUG_INIT, "Startup of HLL done");
559 gig_dbg(DEBUG_INIT, "Startup of HLL failed");
560 tty->disc_data = NULL;
566 * Called by the tty driver when the line discipline is removed.
567 * Called from process context.
570 gigaset_tty_close(struct tty_struct *tty)
572 struct cardstate *cs = tty->disc_data;
574 gig_dbg(DEBUG_INIT, "Stopping HLL for Gigaset M101");
577 gig_dbg(DEBUG_INIT, "%s: no cardstate", __func__);
581 /* prevent other callers from entering ldisc methods */
582 tty->disc_data = NULL;
585 pr_err("%s: no hw cardstate\n", __func__);
587 /* wait for running methods to finish */
588 if (!atomic_dec_and_test(&cs->hw.ser->refcnt))
589 wait_for_completion(&cs->hw.ser->dead_cmp);
592 /* stop operations */
594 tasklet_kill(&cs->write_tasklet);
595 flush_send_queue(cs);
599 gig_dbg(DEBUG_INIT, "Shutdown of HLL done");
603 * Called by the tty driver when the tty line is hung up.
604 * Wait for I/O to driver to complete and unregister ISDN device.
605 * This is already done by the close routine, so just call that.
606 * Called from process context.
608 static int gigaset_tty_hangup(struct tty_struct *tty)
610 gigaset_tty_close(tty);
616 * Unused, received data goes only to the Gigaset driver.
619 gigaset_tty_read(struct tty_struct *tty, struct file *file,
620 unsigned char __user *buf, size_t count)
627 * Unused, transmit data comes only from the Gigaset driver.
630 gigaset_tty_write(struct tty_struct *tty, struct file *file,
631 const unsigned char *buf, size_t count)
638 * Called in process context only.
639 * May be re-entered by multiple ioctl calling threads.
642 gigaset_tty_ioctl(struct tty_struct *tty, struct file *file,
643 unsigned int cmd, unsigned long arg)
645 struct cardstate *cs = cs_get(tty);
647 int __user *p = (int __user *)arg;
655 /* unused, always return zero */
657 rc = put_user(val, p);
661 /* flush our buffers and the serial port's buffer */
664 /* no own input buffer to flush */
668 flush_send_queue(cs);
674 /* pass through to underlying serial device */
675 rc = n_tty_ioctl_helper(tty, file, cmd, arg);
683 * Called by the tty driver when a block of data has been received.
684 * Will not be re-entered while running but other ldisc functions
685 * may be called in parallel.
686 * Can be called from hard interrupt level as well as soft interrupt
690 * buf buffer containing received characters
691 * cflags buffer containing error flags for received characters (ignored)
692 * count number of received characters
695 gigaset_tty_receive(struct tty_struct *tty, const unsigned char *buf,
696 char *cflags, int count)
698 struct cardstate *cs = cs_get(tty);
699 unsigned tail, head, n;
700 struct inbuf_t *inbuf;
706 dev_err(cs->dev, "%s: no inbuf\n", __func__);
713 gig_dbg(DEBUG_INTR, "buffer state: %u -> %u, receive %u bytes",
717 /* possible buffer wraparound */
718 n = min_t(unsigned, count, RBUFSIZE - tail);
719 memcpy(inbuf->data + tail, buf, n);
720 tail = (tail + n) % RBUFSIZE;
726 /* tail < head and some data left */
730 "inbuf overflow, discarding %d bytes\n",
734 memcpy(inbuf->data + tail, buf, count);
738 gig_dbg(DEBUG_INTR, "setting tail to %u", tail);
741 /* Everything was received .. Push data into handler */
742 gig_dbg(DEBUG_INTR, "%s-->BH", __func__);
743 gigaset_schedule_event(cs);
748 * Called by the tty driver when there's room for more data to send.
751 gigaset_tty_wakeup(struct tty_struct *tty)
753 struct cardstate *cs = cs_get(tty);
755 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
758 tasklet_schedule(&cs->write_tasklet);
762 static struct tty_ldisc_ops gigaset_ldisc = {
763 .owner = THIS_MODULE,
764 .magic = TTY_LDISC_MAGIC,
765 .name = "ser_gigaset",
766 .open = gigaset_tty_open,
767 .close = gigaset_tty_close,
768 .hangup = gigaset_tty_hangup,
769 .read = gigaset_tty_read,
770 .write = gigaset_tty_write,
771 .ioctl = gigaset_tty_ioctl,
772 .receive_buf = gigaset_tty_receive,
773 .write_wakeup = gigaset_tty_wakeup,
777 /* Initialization / Shutdown */
778 /* ========================= */
780 static int __init ser_gigaset_init(void)
784 gig_dbg(DEBUG_INIT, "%s", __func__);
785 rc = platform_driver_register(&device_driver);
787 pr_err("error %d registering platform driver\n", rc);
791 /* allocate memory for our driver state and intialize it */
792 driver = gigaset_initdriver(GIGASET_MINOR, GIGASET_MINORS,
793 GIGASET_MODULENAME, GIGASET_DEVNAME,
798 rc = tty_register_ldisc(N_GIGASET_M101, &gigaset_ldisc);
800 pr_err("error %d registering line discipline\n", rc);
808 gigaset_freedriver(driver);
811 platform_driver_unregister(&device_driver);
815 static void __exit ser_gigaset_exit(void)
819 gig_dbg(DEBUG_INIT, "%s", __func__);
822 gigaset_freedriver(driver);
826 rc = tty_unregister_ldisc(N_GIGASET_M101);
828 pr_err("error %d unregistering line discipline\n", rc);
830 platform_driver_unregister(&device_driver);
833 module_init(ser_gigaset_init);
834 module_exit(ser_gigaset_exit);