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