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