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