1 /*********************************************************************
2 *
3 * Filename: ircomm_tty_ioctl.c
4 * Version:
5 * Description:
6 * Status: Experimental.
7 * Author: Dag Brattli <dagb@cs.uit.no>
8 * Created at: Thu Jun 10 14:39:09 1999
9 * Modified at: Wed Jan 5 14:45:43 2000
10 * Modified by: Dag Brattli <dagb@cs.uit.no>
11 *
12 * Copyright (c) 1999-2000 Dag Brattli, All Rights Reserved.
13 *
14 * This program is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU General Public License as
16 * published by the Free Software Foundation; either version 2 of
17 * the License, or (at your option) any later version.
18 *
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
23 *
24 * You should have received a copy of the GNU General Public License
25 * along with this program; if not, see <http://www.gnu.org/licenses/>.
26 *
27 ********************************************************************/
28
29 #include <linux/init.h>
30 #include <linux/fs.h>
31 #include <linux/termios.h>
32 #include <linux/tty.h>
33 #include <linux/serial.h>
34
35 #include <asm/uaccess.h>
36
37 #include <net/irda/irda.h>
38 #include <net/irda/irmod.h>
39
40 #include <net/irda/ircomm_core.h>
41 #include <net/irda/ircomm_param.h>
42 #include <net/irda/ircomm_tty_attach.h>
43 #include <net/irda/ircomm_tty.h>
44
45 #define RELEVANT_IFLAG(iflag) (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
46
47 /*
48 * Function ircomm_tty_change_speed (driver)
49 *
50 * Change speed of the driver. If the remote device is a DCE, then this
51 * should make it change the speed of its serial port
52 */
ircomm_tty_change_speed(struct ircomm_tty_cb * self,struct tty_struct * tty)53 static void ircomm_tty_change_speed(struct ircomm_tty_cb *self,
54 struct tty_struct *tty)
55 {
56 unsigned int cflag, cval;
57 int baud;
58
59 if (!self->ircomm)
60 return;
61
62 cflag = tty->termios.c_cflag;
63
64 /* byte size and parity */
65 switch (cflag & CSIZE) {
66 case CS5: cval = IRCOMM_WSIZE_5; break;
67 case CS6: cval = IRCOMM_WSIZE_6; break;
68 case CS7: cval = IRCOMM_WSIZE_7; break;
69 case CS8: cval = IRCOMM_WSIZE_8; break;
70 default: cval = IRCOMM_WSIZE_5; break;
71 }
72 if (cflag & CSTOPB)
73 cval |= IRCOMM_2_STOP_BIT;
74
75 if (cflag & PARENB)
76 cval |= IRCOMM_PARITY_ENABLE;
77 if (!(cflag & PARODD))
78 cval |= IRCOMM_PARITY_EVEN;
79
80 /* Determine divisor based on baud rate */
81 baud = tty_get_baud_rate(tty);
82 if (!baud)
83 baud = 9600; /* B0 transition handled in rs_set_termios */
84
85 self->settings.data_rate = baud;
86 ircomm_param_request(self, IRCOMM_DATA_RATE, FALSE);
87
88 /* CTS flow control flag and modem status interrupts */
89 if (cflag & CRTSCTS) {
90 self->port.flags |= ASYNC_CTS_FLOW;
91 self->settings.flow_control |= IRCOMM_RTS_CTS_IN;
92 /* This got me. Bummer. Jean II */
93 if (self->service_type == IRCOMM_3_WIRE_RAW)
94 net_warn_ratelimited("%s(), enabling RTS/CTS on link that doesn't support it (3-wire-raw)\n",
95 __func__);
96 } else {
97 self->port.flags &= ~ASYNC_CTS_FLOW;
98 self->settings.flow_control &= ~IRCOMM_RTS_CTS_IN;
99 }
100 if (cflag & CLOCAL)
101 self->port.flags &= ~ASYNC_CHECK_CD;
102 else
103 self->port.flags |= ASYNC_CHECK_CD;
104 #if 0
105 /*
106 * Set up parity check flag
107 */
108
109 if (I_INPCK(self->tty))
110 driver->read_status_mask |= LSR_FE | LSR_PE;
111 if (I_BRKINT(driver->tty) || I_PARMRK(driver->tty))
112 driver->read_status_mask |= LSR_BI;
113
114 /*
115 * Characters to ignore
116 */
117 driver->ignore_status_mask = 0;
118 if (I_IGNPAR(driver->tty))
119 driver->ignore_status_mask |= LSR_PE | LSR_FE;
120
121 if (I_IGNBRK(self->tty)) {
122 self->ignore_status_mask |= LSR_BI;
123 /*
124 * If we're ignore parity and break indicators, ignore
125 * overruns too. (For real raw support).
126 */
127 if (I_IGNPAR(self->tty))
128 self->ignore_status_mask |= LSR_OE;
129 }
130 #endif
131 self->settings.data_format = cval;
132
133 ircomm_param_request(self, IRCOMM_DATA_FORMAT, FALSE);
134 ircomm_param_request(self, IRCOMM_FLOW_CONTROL, TRUE);
135 }
136
137 /*
138 * Function ircomm_tty_set_termios (tty, old_termios)
139 *
140 * This routine allows the tty driver to be notified when device's
141 * termios settings have changed. Note that a well-designed tty driver
142 * should be prepared to accept the case where old == NULL, and try to
143 * do something rational.
144 */
ircomm_tty_set_termios(struct tty_struct * tty,struct ktermios * old_termios)145 void ircomm_tty_set_termios(struct tty_struct *tty,
146 struct ktermios *old_termios)
147 {
148 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
149 unsigned int cflag = tty->termios.c_cflag;
150
151 if ((cflag == old_termios->c_cflag) &&
152 (RELEVANT_IFLAG(tty->termios.c_iflag) ==
153 RELEVANT_IFLAG(old_termios->c_iflag)))
154 {
155 return;
156 }
157
158 ircomm_tty_change_speed(self, tty);
159
160 /* Handle transition to B0 status */
161 if ((old_termios->c_cflag & CBAUD) &&
162 !(cflag & CBAUD)) {
163 self->settings.dte &= ~(IRCOMM_DTR|IRCOMM_RTS);
164 ircomm_param_request(self, IRCOMM_DTE, TRUE);
165 }
166
167 /* Handle transition away from B0 status */
168 if (!(old_termios->c_cflag & CBAUD) &&
169 (cflag & CBAUD)) {
170 self->settings.dte |= IRCOMM_DTR;
171 if (!(tty->termios.c_cflag & CRTSCTS) ||
172 !test_bit(TTY_THROTTLED, &tty->flags)) {
173 self->settings.dte |= IRCOMM_RTS;
174 }
175 ircomm_param_request(self, IRCOMM_DTE, TRUE);
176 }
177
178 /* Handle turning off CRTSCTS */
179 if ((old_termios->c_cflag & CRTSCTS) &&
180 !(tty->termios.c_cflag & CRTSCTS))
181 {
182 tty->hw_stopped = 0;
183 ircomm_tty_start(tty);
184 }
185 }
186
187 /*
188 * Function ircomm_tty_tiocmget (tty)
189 *
190 *
191 *
192 */
ircomm_tty_tiocmget(struct tty_struct * tty)193 int ircomm_tty_tiocmget(struct tty_struct *tty)
194 {
195 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
196 unsigned int result;
197
198 if (tty->flags & (1 << TTY_IO_ERROR))
199 return -EIO;
200
201 result = ((self->settings.dte & IRCOMM_RTS) ? TIOCM_RTS : 0)
202 | ((self->settings.dte & IRCOMM_DTR) ? TIOCM_DTR : 0)
203 | ((self->settings.dce & IRCOMM_CD) ? TIOCM_CAR : 0)
204 | ((self->settings.dce & IRCOMM_RI) ? TIOCM_RNG : 0)
205 | ((self->settings.dce & IRCOMM_DSR) ? TIOCM_DSR : 0)
206 | ((self->settings.dce & IRCOMM_CTS) ? TIOCM_CTS : 0);
207 return result;
208 }
209
210 /*
211 * Function ircomm_tty_tiocmset (tty, set, clear)
212 *
213 *
214 *
215 */
ircomm_tty_tiocmset(struct tty_struct * tty,unsigned int set,unsigned int clear)216 int ircomm_tty_tiocmset(struct tty_struct *tty,
217 unsigned int set, unsigned int clear)
218 {
219 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
220
221 if (tty->flags & (1 << TTY_IO_ERROR))
222 return -EIO;
223
224 IRDA_ASSERT(self != NULL, return -1;);
225 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
226
227 if (set & TIOCM_RTS)
228 self->settings.dte |= IRCOMM_RTS;
229 if (set & TIOCM_DTR)
230 self->settings.dte |= IRCOMM_DTR;
231
232 if (clear & TIOCM_RTS)
233 self->settings.dte &= ~IRCOMM_RTS;
234 if (clear & TIOCM_DTR)
235 self->settings.dte &= ~IRCOMM_DTR;
236
237 if ((set|clear) & TIOCM_RTS)
238 self->settings.dte |= IRCOMM_DELTA_RTS;
239 if ((set|clear) & TIOCM_DTR)
240 self->settings.dte |= IRCOMM_DELTA_DTR;
241
242 ircomm_param_request(self, IRCOMM_DTE, TRUE);
243
244 return 0;
245 }
246
247 /*
248 * Function get_serial_info (driver, retinfo)
249 *
250 *
251 *
252 */
ircomm_tty_get_serial_info(struct ircomm_tty_cb * self,struct serial_struct __user * retinfo)253 static int ircomm_tty_get_serial_info(struct ircomm_tty_cb *self,
254 struct serial_struct __user *retinfo)
255 {
256 struct serial_struct info;
257
258 if (!retinfo)
259 return -EFAULT;
260
261 memset(&info, 0, sizeof(info));
262 info.line = self->line;
263 info.flags = self->port.flags;
264 info.baud_base = self->settings.data_rate;
265 info.close_delay = self->port.close_delay;
266 info.closing_wait = self->port.closing_wait;
267
268 /* For compatibility */
269 info.type = PORT_16550A;
270 info.port = 0;
271 info.irq = 0;
272 info.xmit_fifo_size = 0;
273 info.hub6 = 0;
274 info.custom_divisor = 0;
275
276 if (copy_to_user(retinfo, &info, sizeof(*retinfo)))
277 return -EFAULT;
278
279 return 0;
280 }
281
282 /*
283 * Function set_serial_info (driver, new_info)
284 *
285 *
286 *
287 */
ircomm_tty_set_serial_info(struct ircomm_tty_cb * self,struct serial_struct __user * new_info)288 static int ircomm_tty_set_serial_info(struct ircomm_tty_cb *self,
289 struct serial_struct __user *new_info)
290 {
291 #if 0
292 struct serial_struct new_serial;
293 struct ircomm_tty_cb old_state, *state;
294
295 if (copy_from_user(&new_serial,new_info,sizeof(new_serial)))
296 return -EFAULT;
297
298
299 state = self
300 old_state = *self;
301
302 if (!capable(CAP_SYS_ADMIN)) {
303 if ((new_serial.baud_base != state->settings.data_rate) ||
304 (new_serial.close_delay != state->close_delay) ||
305 ((new_serial.flags & ~ASYNC_USR_MASK) !=
306 (self->flags & ~ASYNC_USR_MASK)))
307 return -EPERM;
308 state->flags = ((state->flags & ~ASYNC_USR_MASK) |
309 (new_serial.flags & ASYNC_USR_MASK));
310 self->flags = ((self->flags & ~ASYNC_USR_MASK) |
311 (new_serial.flags & ASYNC_USR_MASK));
312 /* self->custom_divisor = new_serial.custom_divisor; */
313 goto check_and_exit;
314 }
315
316 /*
317 * OK, past this point, all the error checking has been done.
318 * At this point, we start making changes.....
319 */
320
321 if (self->settings.data_rate != new_serial.baud_base) {
322 self->settings.data_rate = new_serial.baud_base;
323 ircomm_param_request(self, IRCOMM_DATA_RATE, TRUE);
324 }
325
326 self->close_delay = new_serial.close_delay * HZ/100;
327 self->closing_wait = new_serial.closing_wait * HZ/100;
328 /* self->custom_divisor = new_serial.custom_divisor; */
329
330 self->flags = ((self->flags & ~ASYNC_FLAGS) |
331 (new_serial.flags & ASYNC_FLAGS));
332 self->tty->low_latency = (self->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
333
334 check_and_exit:
335
336 if (self->flags & ASYNC_INITIALIZED) {
337 if (((old_state.flags & ASYNC_SPD_MASK) !=
338 (self->flags & ASYNC_SPD_MASK)) ||
339 (old_driver.custom_divisor != driver->custom_divisor)) {
340 if ((driver->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
341 driver->tty->alt_speed = 57600;
342 if ((driver->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
343 driver->tty->alt_speed = 115200;
344 if ((driver->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
345 driver->tty->alt_speed = 230400;
346 if ((driver->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
347 driver->tty->alt_speed = 460800;
348 ircomm_tty_change_speed(driver);
349 }
350 }
351 #endif
352 return 0;
353 }
354
355 /*
356 * Function ircomm_tty_ioctl (tty, cmd, arg)
357 *
358 *
359 *
360 */
ircomm_tty_ioctl(struct tty_struct * tty,unsigned int cmd,unsigned long arg)361 int ircomm_tty_ioctl(struct tty_struct *tty,
362 unsigned int cmd, unsigned long arg)
363 {
364 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
365 int ret = 0;
366
367 if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
368 (cmd != TIOCSERCONFIG) && (cmd != TIOCSERGSTRUCT) &&
369 (cmd != TIOCMIWAIT) && (cmd != TIOCGICOUNT)) {
370 if (tty->flags & (1 << TTY_IO_ERROR))
371 return -EIO;
372 }
373
374 switch (cmd) {
375 case TIOCGSERIAL:
376 ret = ircomm_tty_get_serial_info(self, (struct serial_struct __user *) arg);
377 break;
378 case TIOCSSERIAL:
379 ret = ircomm_tty_set_serial_info(self, (struct serial_struct __user *) arg);
380 break;
381 case TIOCMIWAIT:
382 pr_debug("(), TIOCMIWAIT, not impl!\n");
383 break;
384
385 case TIOCGICOUNT:
386 pr_debug("%s(), TIOCGICOUNT not impl!\n", __func__);
387 #if 0
388 save_flags(flags); cli();
389 cnow = driver->icount;
390 restore_flags(flags);
391 p_cuser = (struct serial_icounter_struct __user *) arg;
392 if (put_user(cnow.cts, &p_cuser->cts) ||
393 put_user(cnow.dsr, &p_cuser->dsr) ||
394 put_user(cnow.rng, &p_cuser->rng) ||
395 put_user(cnow.dcd, &p_cuser->dcd) ||
396 put_user(cnow.rx, &p_cuser->rx) ||
397 put_user(cnow.tx, &p_cuser->tx) ||
398 put_user(cnow.frame, &p_cuser->frame) ||
399 put_user(cnow.overrun, &p_cuser->overrun) ||
400 put_user(cnow.parity, &p_cuser->parity) ||
401 put_user(cnow.brk, &p_cuser->brk) ||
402 put_user(cnow.buf_overrun, &p_cuser->buf_overrun))
403 return -EFAULT;
404 #endif
405 return 0;
406 default:
407 ret = -ENOIOCTLCMD; /* ioctls which we must ignore */
408 }
409 return ret;
410 }
411
412
413
414