blob: 8ff7e35c70696de765b8ab3dc2e4b61a02ee3356 [file] [log] [blame]
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -08001/*
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 * =====================================================================
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -080012 */
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
21static int if_lock(struct cardstate *cs, int *arg)
22{
23 int cmd = *arg;
24
Tilman Schmidt784d5852006-04-10 22:55:04 -070025 gig_dbg(DEBUG_IF, "%u: if_lock (%d)", cs->minor_index, cmd);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -080026
27 if (cmd > 1)
28 return -EINVAL;
29
30 if (cmd < 0) {
Tilman Schmidt9d4bee22008-02-06 01:38:28 -080031 *arg = cs->mstate == MS_LOCKED;
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -080032 return 0;
33 }
34
Tilman Schmidt9d4bee22008-02-06 01:38:28 -080035 if (!cmd && cs->mstate == MS_LOCKED && cs->connected) {
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -080036 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,
Tilman Schmidt784d5852006-04-10 22:55:04 -070044 NULL, cmd, NULL)) {
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -080045 cs->waiting = 0;
46 return -ENOMEM;
47 }
48
Tilman Schmidt784d5852006-04-10 22:55:04 -070049 gig_dbg(DEBUG_CMD, "scheduling IF_LOCK");
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -080050 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
62static 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
Tilman Schmidt784d5852006-04-10 22:55:04 -070068 gig_dbg(DEBUG_IF, "%u: if_version (%d)", cs->minor_index, cmd);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -080069
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,
Tilman Schmidt784d5852006-04-10 22:55:04 -070080 NULL, 0, arg)) {
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -080081 cs->waiting = 0;
82 return -ENOMEM;
83 }
84
Tilman Schmidt784d5852006-04-10 22:55:04 -070085 gig_dbg(DEBUG_CMD, "scheduling IF_VER");
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -080086 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
99static int if_config(struct cardstate *cs, int *arg)
100{
Tilman Schmidt784d5852006-04-10 22:55:04 -0700101 gig_dbg(DEBUG_IF, "%u: if_config (%d)", cs->minor_index, *arg);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800102
103 if (*arg != 1)
104 return -EINVAL;
105
Tilman Schmidt9d4bee22008-02-06 01:38:28 -0800106 if (cs->mstate != MS_LOCKED)
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800107 return -EBUSY;
108
Tilman Schmidt69049cc2006-04-10 22:55:16 -0700109 if (!cs->connected) {
Tilman Schmidtc8770dc2008-12-26 01:21:29 -0800110 pr_err("%s: not connected\n", __func__);
Tilman Schmidt69049cc2006-04-10 22:55:16 -0700111 return -ENODEV;
112 }
113
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800114 *arg = 0;
115 return gigaset_enterconfigmode(cs);
116}
117
118/*** the terminal driver ***/
119/* stolen from usbserial and some other tty drivers */
120
121static int if_open(struct tty_struct *tty, struct file *filp);
122static void if_close(struct tty_struct *tty, struct file *filp);
123static int if_ioctl(struct tty_struct *tty, struct file *file,
Tilman Schmidt784d5852006-04-10 22:55:04 -0700124 unsigned int cmd, unsigned long arg);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800125static int if_write_room(struct tty_struct *tty);
126static int if_chars_in_buffer(struct tty_struct *tty);
127static void if_throttle(struct tty_struct *tty);
128static void if_unthrottle(struct tty_struct *tty);
Alan Cox606d0992006-12-08 02:38:45 -0800129static void if_set_termios(struct tty_struct *tty, struct ktermios *old);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800130static int if_tiocmget(struct tty_struct *tty, struct file *file);
131static int if_tiocmset(struct tty_struct *tty, struct file *file,
Tilman Schmidt784d5852006-04-10 22:55:04 -0700132 unsigned int set, unsigned int clear);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800133static int if_write(struct tty_struct *tty,
Tilman Schmidt784d5852006-04-10 22:55:04 -0700134 const unsigned char *buf, int count);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800135
Jeff Dikeb68e31d2006-10-02 02:17:18 -0700136static const struct tty_operations if_ops = {
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800137 .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,
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800146 .tiocmget = if_tiocmget,
147 .tiocmset = if_tiocmset,
148};
149
150static int if_open(struct tty_struct *tty, struct file *filp)
151{
152 struct cardstate *cs;
153 unsigned long flags;
154
Tilman Schmidt784d5852006-04-10 22:55:04 -0700155 gig_dbg(DEBUG_IF, "%d+%d: %s()",
156 tty->driver->minor_start, tty->index, __func__);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800157
158 tty->driver_data = NULL;
159
160 cs = gigaset_get_cs_by_tty(tty);
Tilman Schmidte468c042008-02-06 01:38:29 -0800161 if (!cs || !try_module_get(cs->driver->owner))
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800162 return -ENODEV;
163
Tilman Schmidtabfd1dc2006-04-10 22:55:12 -0700164 if (mutex_lock_interruptible(&cs->mutex))
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800165 return -ERESTARTSYS; // FIXME -EINTR?
166 tty->driver_data = cs;
167
168 ++cs->open_count;
169
170 if (cs->open_count == 1) {
171 spin_lock_irqsave(&cs->lock, flags);
172 cs->tty = tty;
173 spin_unlock_irqrestore(&cs->lock, flags);
174 tty->low_latency = 1; //FIXME test
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800175 }
176
Tilman Schmidtabfd1dc2006-04-10 22:55:12 -0700177 mutex_unlock(&cs->mutex);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800178 return 0;
179}
180
181static void if_close(struct tty_struct *tty, struct file *filp)
182{
183 struct cardstate *cs;
184 unsigned long flags;
185
186 cs = (struct cardstate *) tty->driver_data;
187 if (!cs) {
Tilman Schmidtc8770dc2008-12-26 01:21:29 -0800188 pr_err("%s: no cardstate\n", __func__);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800189 return;
190 }
191
Tilman Schmidt784d5852006-04-10 22:55:04 -0700192 gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800193
Tilman Schmidtabfd1dc2006-04-10 22:55:12 -0700194 mutex_lock(&cs->mutex);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800195
Tilman Schmidt51370e52009-04-05 06:39:33 +0000196 if (!cs->connected)
197 gig_dbg(DEBUG_IF, "not connected"); /* nothing to do */
198 else if (!cs->open_count)
Tilman Schmidt50027792008-07-23 21:28:27 -0700199 dev_warn(cs->dev, "%s: device not opened\n", __func__);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800200 else {
201 if (!--cs->open_count) {
202 spin_lock_irqsave(&cs->lock, flags);
203 cs->tty = NULL;
204 spin_unlock_irqrestore(&cs->lock, flags);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800205 }
206 }
207
Tilman Schmidtabfd1dc2006-04-10 22:55:12 -0700208 mutex_unlock(&cs->mutex);
Tilman Schmidte468c042008-02-06 01:38:29 -0800209
210 module_put(cs->driver->owner);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800211}
212
213static int if_ioctl(struct tty_struct *tty, struct file *file,
Tilman Schmidt784d5852006-04-10 22:55:04 -0700214 unsigned int cmd, unsigned long arg)
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800215{
216 struct cardstate *cs;
217 int retval = -ENODEV;
218 int int_arg;
219 unsigned char buf[6];
220 unsigned version[4];
221
222 cs = (struct cardstate *) tty->driver_data;
223 if (!cs) {
Tilman Schmidtc8770dc2008-12-26 01:21:29 -0800224 pr_err("%s: no cardstate\n", __func__);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800225 return -ENODEV;
226 }
227
Tilman Schmidt784d5852006-04-10 22:55:04 -0700228 gig_dbg(DEBUG_IF, "%u: %s(0x%x)", cs->minor_index, __func__, cmd);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800229
Tilman Schmidtabfd1dc2006-04-10 22:55:12 -0700230 if (mutex_lock_interruptible(&cs->mutex))
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800231 return -ERESTARTSYS; // FIXME -EINTR?
232
Tilman Schmidt51370e52009-04-05 06:39:33 +0000233 if (!cs->connected) {
234 gig_dbg(DEBUG_IF, "not connected");
235 retval = -ENODEV;
236 } else if (!cs->open_count)
Tilman Schmidt50027792008-07-23 21:28:27 -0700237 dev_warn(cs->dev, "%s: device not opened\n", __func__);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800238 else {
239 retval = 0;
240 switch (cmd) {
241 case GIGASET_REDIR:
242 retval = get_user(int_arg, (int __user *) arg);
243 if (retval >= 0)
244 retval = if_lock(cs, &int_arg);
245 if (retval >= 0)
246 retval = put_user(int_arg, (int __user *) arg);
247 break;
248 case GIGASET_CONFIG:
249 retval = get_user(int_arg, (int __user *) arg);
250 if (retval >= 0)
251 retval = if_config(cs, &int_arg);
252 if (retval >= 0)
253 retval = put_user(int_arg, (int __user *) arg);
254 break;
255 case GIGASET_BRKCHARS:
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800256 retval = copy_from_user(&buf,
Tilman Schmidt784d5852006-04-10 22:55:04 -0700257 (const unsigned char __user *) arg, 6)
258 ? -EFAULT : 0;
Tilman Schmidt01371502006-04-10 22:55:11 -0700259 if (retval >= 0) {
260 gigaset_dbg_buffer(DEBUG_IF, "GIGASET_BRKCHARS",
261 6, (const unsigned char *) arg);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800262 retval = cs->ops->brkchars(cs, buf);
Tilman Schmidt01371502006-04-10 22:55:11 -0700263 }
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800264 break;
265 case GIGASET_VERSION:
Tilman Schmidt917f5082006-04-10 22:55:00 -0700266 retval = copy_from_user(version,
Tilman Schmidt784d5852006-04-10 22:55:04 -0700267 (unsigned __user *) arg, sizeof version)
268 ? -EFAULT : 0;
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800269 if (retval >= 0)
270 retval = if_version(cs, version);
271 if (retval >= 0)
Tilman Schmidt917f5082006-04-10 22:55:00 -0700272 retval = copy_to_user((unsigned __user *) arg,
Tilman Schmidt784d5852006-04-10 22:55:04 -0700273 version, sizeof version)
274 ? -EFAULT : 0;
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800275 break;
Tilman Schmidt784d5852006-04-10 22:55:04 -0700276 default:
277 gig_dbg(DEBUG_ANY, "%s: arg not supported - 0x%04x",
278 __func__, cmd);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800279 retval = -ENOIOCTLCMD;
280 }
281 }
282
Tilman Schmidtabfd1dc2006-04-10 22:55:12 -0700283 mutex_unlock(&cs->mutex);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800284
285 return retval;
286}
287
288static int if_tiocmget(struct tty_struct *tty, struct file *file)
289{
290 struct cardstate *cs;
291 int retval;
292
293 cs = (struct cardstate *) tty->driver_data;
294 if (!cs) {
Tilman Schmidtc8770dc2008-12-26 01:21:29 -0800295 pr_err("%s: no cardstate\n", __func__);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800296 return -ENODEV;
297 }
298
Tilman Schmidt784d5852006-04-10 22:55:04 -0700299 gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800300
Tilman Schmidtabfd1dc2006-04-10 22:55:12 -0700301 if (mutex_lock_interruptible(&cs->mutex))
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800302 return -ERESTARTSYS; // FIXME -EINTR?
303
304 // FIXME read from device?
305 retval = cs->control_state & (TIOCM_RTS|TIOCM_DTR);
306
Tilman Schmidtabfd1dc2006-04-10 22:55:12 -0700307 mutex_unlock(&cs->mutex);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800308
309 return retval;
310}
311
312static int if_tiocmset(struct tty_struct *tty, struct file *file,
Tilman Schmidt784d5852006-04-10 22:55:04 -0700313 unsigned int set, unsigned int clear)
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800314{
315 struct cardstate *cs;
316 int retval;
317 unsigned mc;
318
319 cs = (struct cardstate *) tty->driver_data;
320 if (!cs) {
Tilman Schmidtc8770dc2008-12-26 01:21:29 -0800321 pr_err("%s: no cardstate\n", __func__);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800322 return -ENODEV;
323 }
324
Tilman Schmidt784d5852006-04-10 22:55:04 -0700325 gig_dbg(DEBUG_IF, "%u: %s(0x%x, 0x%x)",
326 cs->minor_index, __func__, set, clear);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800327
Tilman Schmidtabfd1dc2006-04-10 22:55:12 -0700328 if (mutex_lock_interruptible(&cs->mutex))
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800329 return -ERESTARTSYS; // FIXME -EINTR?
330
Tilman Schmidt69049cc2006-04-10 22:55:16 -0700331 if (!cs->connected) {
Tilman Schmidt51370e52009-04-05 06:39:33 +0000332 gig_dbg(DEBUG_IF, "not connected");
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800333 retval = -ENODEV;
334 } else {
335 mc = (cs->control_state | set) & ~clear & (TIOCM_RTS|TIOCM_DTR);
336 retval = cs->ops->set_modem_ctrl(cs, cs->control_state, mc);
337 cs->control_state = mc;
338 }
339
Tilman Schmidtabfd1dc2006-04-10 22:55:12 -0700340 mutex_unlock(&cs->mutex);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800341
342 return retval;
343}
344
345static int if_write(struct tty_struct *tty, const unsigned char *buf, int count)
346{
347 struct cardstate *cs;
348 int retval = -ENODEV;
349
350 cs = (struct cardstate *) tty->driver_data;
351 if (!cs) {
Tilman Schmidtc8770dc2008-12-26 01:21:29 -0800352 pr_err("%s: no cardstate\n", __func__);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800353 return -ENODEV;
354 }
355
Tilman Schmidt784d5852006-04-10 22:55:04 -0700356 gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800357
Tilman Schmidtabfd1dc2006-04-10 22:55:12 -0700358 if (mutex_lock_interruptible(&cs->mutex))
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800359 return -ERESTARTSYS; // FIXME -EINTR?
360
Tilman Schmidt51370e52009-04-05 06:39:33 +0000361 if (!cs->connected) {
362 gig_dbg(DEBUG_IF, "not connected");
363 retval = -ENODEV;
364 } else if (!cs->open_count)
Tilman Schmidt50027792008-07-23 21:28:27 -0700365 dev_warn(cs->dev, "%s: device not opened\n", __func__);
Tilman Schmidt9d4bee22008-02-06 01:38:28 -0800366 else if (cs->mstate != MS_LOCKED) {
Tilman Schmidt50027792008-07-23 21:28:27 -0700367 dev_warn(cs->dev, "can't write to unlocked device\n");
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800368 retval = -EBUSY;
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800369 } else {
370 retval = cs->ops->write_cmd(cs, buf, count,
Tilman Schmidt784d5852006-04-10 22:55:04 -0700371 &cs->if_wake_tasklet);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800372 }
373
Tilman Schmidtabfd1dc2006-04-10 22:55:12 -0700374 mutex_unlock(&cs->mutex);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800375
376 return retval;
377}
378
379static int if_write_room(struct tty_struct *tty)
380{
381 struct cardstate *cs;
382 int retval = -ENODEV;
383
384 cs = (struct cardstate *) tty->driver_data;
385 if (!cs) {
Tilman Schmidtc8770dc2008-12-26 01:21:29 -0800386 pr_err("%s: no cardstate\n", __func__);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800387 return -ENODEV;
388 }
389
Tilman Schmidt784d5852006-04-10 22:55:04 -0700390 gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800391
Tilman Schmidtabfd1dc2006-04-10 22:55:12 -0700392 if (mutex_lock_interruptible(&cs->mutex))
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800393 return -ERESTARTSYS; // FIXME -EINTR?
394
Tilman Schmidt51370e52009-04-05 06:39:33 +0000395 if (!cs->connected) {
396 gig_dbg(DEBUG_IF, "not connected");
397 retval = -ENODEV;
398 } else if (!cs->open_count)
Tilman Schmidt50027792008-07-23 21:28:27 -0700399 dev_warn(cs->dev, "%s: device not opened\n", __func__);
Tilman Schmidt9d4bee22008-02-06 01:38:28 -0800400 else if (cs->mstate != MS_LOCKED) {
Tilman Schmidt50027792008-07-23 21:28:27 -0700401 dev_warn(cs->dev, "can't write to unlocked device\n");
Tilman Schmidt9d4bee22008-02-06 01:38:28 -0800402 retval = -EBUSY;
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800403 } else
404 retval = cs->ops->write_room(cs);
405
Tilman Schmidtabfd1dc2006-04-10 22:55:12 -0700406 mutex_unlock(&cs->mutex);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800407
408 return retval;
409}
410
Alan Cox23198fd2009-07-20 16:05:27 +0100411/* FIXME: This function does not have error returns */
412
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800413static int if_chars_in_buffer(struct tty_struct *tty)
414{
415 struct cardstate *cs;
416 int retval = -ENODEV;
417
418 cs = (struct cardstate *) tty->driver_data;
419 if (!cs) {
Tilman Schmidtc8770dc2008-12-26 01:21:29 -0800420 pr_err("%s: no cardstate\n", __func__);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800421 return -ENODEV;
422 }
423
Tilman Schmidt784d5852006-04-10 22:55:04 -0700424 gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800425
Tilman Schmidtabfd1dc2006-04-10 22:55:12 -0700426 if (mutex_lock_interruptible(&cs->mutex))
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800427 return -ERESTARTSYS; // FIXME -EINTR?
428
Tilman Schmidt51370e52009-04-05 06:39:33 +0000429 if (!cs->connected) {
430 gig_dbg(DEBUG_IF, "not connected");
431 retval = -ENODEV;
432 } else if (!cs->open_count)
Tilman Schmidt50027792008-07-23 21:28:27 -0700433 dev_warn(cs->dev, "%s: device not opened\n", __func__);
Tilman Schmidt9d4bee22008-02-06 01:38:28 -0800434 else if (cs->mstate != MS_LOCKED) {
Tilman Schmidt50027792008-07-23 21:28:27 -0700435 dev_warn(cs->dev, "can't write to unlocked device\n");
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800436 retval = -EBUSY;
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800437 } else
438 retval = cs->ops->chars_in_buffer(cs);
439
Tilman Schmidtabfd1dc2006-04-10 22:55:12 -0700440 mutex_unlock(&cs->mutex);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800441
442 return retval;
443}
444
445static void if_throttle(struct tty_struct *tty)
446{
447 struct cardstate *cs;
448
449 cs = (struct cardstate *) tty->driver_data;
450 if (!cs) {
Tilman Schmidtc8770dc2008-12-26 01:21:29 -0800451 pr_err("%s: no cardstate\n", __func__);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800452 return;
453 }
454
Tilman Schmidt784d5852006-04-10 22:55:04 -0700455 gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800456
Tilman Schmidtabfd1dc2006-04-10 22:55:12 -0700457 mutex_lock(&cs->mutex);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800458
Tilman Schmidt51370e52009-04-05 06:39:33 +0000459 if (!cs->connected)
460 gig_dbg(DEBUG_IF, "not connected"); /* nothing to do */
461 else if (!cs->open_count)
Tilman Schmidt50027792008-07-23 21:28:27 -0700462 dev_warn(cs->dev, "%s: device not opened\n", __func__);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800463 else {
464 //FIXME
465 }
466
Tilman Schmidtabfd1dc2006-04-10 22:55:12 -0700467 mutex_unlock(&cs->mutex);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800468}
469
470static void if_unthrottle(struct tty_struct *tty)
471{
472 struct cardstate *cs;
473
474 cs = (struct cardstate *) tty->driver_data;
475 if (!cs) {
Tilman Schmidtc8770dc2008-12-26 01:21:29 -0800476 pr_err("%s: no cardstate\n", __func__);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800477 return;
478 }
479
Tilman Schmidt784d5852006-04-10 22:55:04 -0700480 gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800481
Tilman Schmidtabfd1dc2006-04-10 22:55:12 -0700482 mutex_lock(&cs->mutex);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800483
Tilman Schmidt51370e52009-04-05 06:39:33 +0000484 if (!cs->connected)
485 gig_dbg(DEBUG_IF, "not connected"); /* nothing to do */
486 else if (!cs->open_count)
Tilman Schmidt50027792008-07-23 21:28:27 -0700487 dev_warn(cs->dev, "%s: device not opened\n", __func__);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800488 else {
489 //FIXME
490 }
491
Tilman Schmidtabfd1dc2006-04-10 22:55:12 -0700492 mutex_unlock(&cs->mutex);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800493}
494
Alan Cox606d0992006-12-08 02:38:45 -0800495static void if_set_termios(struct tty_struct *tty, struct ktermios *old)
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800496{
497 struct cardstate *cs;
498 unsigned int iflag;
499 unsigned int cflag;
500 unsigned int old_cflag;
501 unsigned int control_state, new_state;
502
503 cs = (struct cardstate *) tty->driver_data;
504 if (!cs) {
Tilman Schmidtc8770dc2008-12-26 01:21:29 -0800505 pr_err("%s: no cardstate\n", __func__);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800506 return;
507 }
508
Tilman Schmidt784d5852006-04-10 22:55:04 -0700509 gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800510
Tilman Schmidtabfd1dc2006-04-10 22:55:12 -0700511 mutex_lock(&cs->mutex);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800512
Tilman Schmidt51370e52009-04-05 06:39:33 +0000513 if (!cs->connected) {
514 gig_dbg(DEBUG_IF, "not connected");
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800515 goto out;
516 }
517
Tilman Schmidt51370e52009-04-05 06:39:33 +0000518 if (!cs->open_count) {
519 dev_warn(cs->dev, "%s: device not opened\n", __func__);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800520 goto out;
521 }
522
523 // stolen from mct_u232.c
524 iflag = tty->termios->c_iflag;
525 cflag = tty->termios->c_cflag;
526 old_cflag = old ? old->c_cflag : cflag; //FIXME?
Tilman Schmidt784d5852006-04-10 22:55:04 -0700527 gig_dbg(DEBUG_IF, "%u: iflag %x cflag %x old %x",
528 cs->minor_index, iflag, cflag, old_cflag);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800529
530 /* get a local copy of the current port settings */
531 control_state = cs->control_state;
532
533 /*
534 * Update baud rate.
535 * Do not attempt to cache old rates and skip settings,
536 * disconnects screw such tricks up completely.
537 * Premature optimization is the root of all evil.
538 */
539
Tilman Schmidt784d5852006-04-10 22:55:04 -0700540 /* reassert DTR and (maybe) RTS on transition from B0 */
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800541 if ((old_cflag & CBAUD) == B0) {
542 new_state = control_state | TIOCM_DTR;
543 /* don't set RTS if using hardware flow control */
544 if (!(old_cflag & CRTSCTS))
545 new_state |= TIOCM_RTS;
Tilman Schmidt784d5852006-04-10 22:55:04 -0700546 gig_dbg(DEBUG_IF, "%u: from B0 - set DTR%s",
547 cs->minor_index,
548 (new_state & TIOCM_RTS) ? " only" : "/RTS");
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800549 cs->ops->set_modem_ctrl(cs, control_state, new_state);
550 control_state = new_state;
551 }
552
553 cs->ops->baud_rate(cs, cflag & CBAUD);
554
555 if ((cflag & CBAUD) == B0) {
556 /* Drop RTS and DTR */
Tilman Schmidt784d5852006-04-10 22:55:04 -0700557 gig_dbg(DEBUG_IF, "%u: to B0 - drop DTR/RTS", cs->minor_index);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800558 new_state = control_state & ~(TIOCM_DTR | TIOCM_RTS);
559 cs->ops->set_modem_ctrl(cs, control_state, new_state);
560 control_state = new_state;
561 }
562
563 /*
564 * Update line control register (LCR)
565 */
566
567 cs->ops->set_line_ctrl(cs, cflag);
568
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800569 /* save off the modified port settings */
570 cs->control_state = control_state;
571
572out:
Tilman Schmidtabfd1dc2006-04-10 22:55:12 -0700573 mutex_unlock(&cs->mutex);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800574}
575
576
577/* wakeup tasklet for the write operation */
578static void if_wake(unsigned long data)
579{
580 struct cardstate *cs = (struct cardstate *) data;
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800581
Jiri Slabyb963a842007-02-10 01:44:55 -0800582 if (cs->tty)
583 tty_wakeup(cs->tty);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800584}
585
586/*** interface to common ***/
587
588void gigaset_if_init(struct cardstate *cs)
589{
590 struct gigaset_driver *drv;
591
592 drv = cs->driver;
593 if (!drv->have_tty)
594 return;
595
596 tasklet_init(&cs->if_wake_tasklet, &if_wake, (unsigned long) cs);
Tilman Schmidt7435f502007-02-12 00:52:24 -0800597
598 mutex_lock(&cs->mutex);
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -0700599 cs->tty_dev = tty_register_device(drv->tty, cs->minor_index, NULL);
Hansjoerg Lipp3dda4e32006-04-22 18:43:00 +0200600
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -0700601 if (!IS_ERR(cs->tty_dev))
602 dev_set_drvdata(cs->tty_dev, cs);
Hansjoerg Lipp3dda4e32006-04-22 18:43:00 +0200603 else {
Tilman Schmidt42e3d612009-05-13 12:44:17 +0000604 pr_warning("could not register device to the tty subsystem\n");
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -0700605 cs->tty_dev = NULL;
Hansjoerg Lipp3dda4e32006-04-22 18:43:00 +0200606 }
Tilman Schmidt7435f502007-02-12 00:52:24 -0800607 mutex_unlock(&cs->mutex);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800608}
609
610void gigaset_if_free(struct cardstate *cs)
611{
612 struct gigaset_driver *drv;
613
614 drv = cs->driver;
615 if (!drv->have_tty)
616 return;
617
618 tasklet_disable(&cs->if_wake_tasklet);
619 tasklet_kill(&cs->if_wake_tasklet);
Greg Kroah-Hartman01107d32006-08-07 22:19:37 -0700620 cs->tty_dev = NULL;
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800621 tty_unregister_device(drv->tty, cs->minor_index);
622}
623
624void gigaset_if_receive(struct cardstate *cs,
Tilman Schmidt784d5852006-04-10 22:55:04 -0700625 unsigned char *buffer, size_t len)
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800626{
627 unsigned long flags;
628 struct tty_struct *tty;
629
630 spin_lock_irqsave(&cs->lock, flags);
631 if ((tty = cs->tty) == NULL)
Tilman Schmidt784d5852006-04-10 22:55:04 -0700632 gig_dbg(DEBUG_ANY, "receive on closed device");
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800633 else {
634 tty_buffer_request_room(tty, len);
635 tty_insert_flip_string(tty, buffer, len);
636 tty_flip_buffer_push(tty);
637 }
638 spin_unlock_irqrestore(&cs->lock, flags);
639}
640EXPORT_SYMBOL_GPL(gigaset_if_receive);
641
642/* gigaset_if_initdriver
643 * Initialize tty interface.
644 * parameters:
Tilman Schmidt784d5852006-04-10 22:55:04 -0700645 * drv Driver
646 * procname Name of the driver (e.g. for /proc/tty/drivers)
647 * devname Name of the device files (prefix without minor number)
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800648 */
649void gigaset_if_initdriver(struct gigaset_driver *drv, const char *procname,
Greg Kroah-Hartmanf4eaa372005-06-20 21:15:16 -0700650 const char *devname)
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800651{
652 unsigned minors = drv->minors;
653 int ret;
654 struct tty_driver *tty;
655
656 drv->have_tty = 0;
657
658 if ((drv->tty = alloc_tty_driver(minors)) == NULL)
659 goto enomem;
660 tty = drv->tty;
661
662 tty->magic = TTY_DRIVER_MAGIC,
663 tty->major = GIG_MAJOR,
664 tty->type = TTY_DRIVER_TYPE_SERIAL,
665 tty->subtype = SERIAL_TYPE_NORMAL,
Greg Kroah-Hartman331b8312005-06-20 21:15:16 -0700666 tty->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800667
668 tty->driver_name = procname;
669 tty->name = devname;
670 tty->minor_start = drv->minor;
671 tty->num = drv->minors;
672
673 tty->owner = THIS_MODULE;
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800674
675 tty->init_termios = tty_std_termios; //FIXME
676 tty->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; //FIXME
677 tty_set_operations(tty, &if_ops);
678
679 ret = tty_register_driver(tty);
680 if (ret < 0) {
Tilman Schmidtc8770dc2008-12-26 01:21:29 -0800681 pr_err("error %d registering tty driver\n", ret);
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800682 goto error;
683 }
Tilman Schmidt784d5852006-04-10 22:55:04 -0700684 gig_dbg(DEBUG_IF, "tty driver initialized");
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800685 drv->have_tty = 1;
686 return;
687
688enomem:
Tilman Schmidtc8770dc2008-12-26 01:21:29 -0800689 pr_err("out of memory\n");
Hansjoerg Lippee8a4b72006-03-26 01:38:32 -0800690error:
691 if (drv->tty)
692 put_tty_driver(drv->tty);
693}
694
695void gigaset_if_freedriver(struct gigaset_driver *drv)
696{
697 if (!drv->have_tty)
698 return;
699
700 drv->have_tty = 0;
701 tty_unregister_driver(drv->tty);
702 put_tty_driver(drv->tty);
703}