LXR linux/net/irda/ircomm/ircomm_tty

   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 */
  53static 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 */
 145void 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 */
 193int 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 */
 216int 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 */
 253static 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 */
 288static 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 */
 361int 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