drivers/staging/irda/net/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, 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 <linux/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  */
  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         tty_port_set_cts_flow(&self->port, cflag & CRTSCTS);
  90         if (cflag & CRTSCTS) {
  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->settings.flow_control &= ~IRCOMM_RTS_CTS_IN;
  98         }
  99         tty_port_set_check_carrier(&self->port, ~cflag & CLOCAL);
 100
 101         self->settings.data_format = cval;
 102
 103         ircomm_param_request(self, IRCOMM_DATA_FORMAT, FALSE);
 104         ircomm_param_request(self, IRCOMM_FLOW_CONTROL, TRUE);
 105 }
 106
 107 /*
 108  * Function ircomm_tty_set_termios (tty, old_termios)
 109  *
 110  *    This routine allows the tty driver to be notified when device's
 111  *    termios settings have changed.  Note that a well-designed tty driver
 112  *    should be prepared to accept the case where old == NULL, and try to
 113  *    do something rational.
 114  */
 115 void ircomm_tty_set_termios(struct tty_struct *tty,
 116                             struct ktermios *old_termios)
 117 {
 118         struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
 119         unsigned int cflag = tty->termios.c_cflag;
 120
 121         if ((cflag == old_termios->c_cflag) &&
 122             (RELEVANT_IFLAG(tty->termios.c_iflag) ==
 123              RELEVANT_IFLAG(old_termios->c_iflag)))
 124         {
 125                 return;
 126         }
 127
 128         ircomm_tty_change_speed(self, tty);
 129
 130         /* Handle transition to B0 status */
 131         if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD)) {
 132                 self->settings.dte &= ~(IRCOMM_DTR|IRCOMM_RTS);
 133                 ircomm_param_request(self, IRCOMM_DTE, TRUE);
 134         }
 135
 136         /* Handle transition away from B0 status */
 137         if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) {
 138                 self->settings.dte |= IRCOMM_DTR;
 139                 if (!C_CRTSCTS(tty) || !tty_throttled(tty))
 140                         self->settings.dte |= IRCOMM_RTS;
 141                 ircomm_param_request(self, IRCOMM_DTE, TRUE);
 142         }
 143
 144         /* Handle turning off CRTSCTS */
 145         if ((old_termios->c_cflag & CRTSCTS) && !C_CRTSCTS(tty))
 146         {
 147                 tty->hw_stopped = 0;
 148                 ircomm_tty_start(tty);
 149         }
 150 }
 151
 152 /*
 153  * Function ircomm_tty_tiocmget (tty)
 154  *
 155  *
 156  *
 157  */
 158 int ircomm_tty_tiocmget(struct tty_struct *tty)
 159 {
 160         struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
 161         unsigned int result;
 162
 163         if (tty_io_error(tty))
 164                 return -EIO;
 165
 166         result =  ((self->settings.dte & IRCOMM_RTS) ? TIOCM_RTS : 0)
 167                 | ((self->settings.dte & IRCOMM_DTR) ? TIOCM_DTR : 0)
 168                 | ((self->settings.dce & IRCOMM_CD)  ? TIOCM_CAR : 0)
 169                 | ((self->settings.dce & IRCOMM_RI)  ? TIOCM_RNG : 0)
 170                 | ((self->settings.dce & IRCOMM_DSR) ? TIOCM_DSR : 0)
 171                 | ((self->settings.dce & IRCOMM_CTS) ? TIOCM_CTS : 0);
 172         return result;
 173 }
 174
 175 /*
 176  * Function ircomm_tty_tiocmset (tty, set, clear)
 177  *
 178  *
 179  *
 180  */
 181 int ircomm_tty_tiocmset(struct tty_struct *tty,
 182                         unsigned int set, unsigned int clear)
 183 {
 184         struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
 185
 186         if (tty_io_error(tty))
 187                 return -EIO;
 188
 189         IRDA_ASSERT(self != NULL, return -1;);
 190         IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 191
 192         if (set & TIOCM_RTS)
 193                 self->settings.dte |= IRCOMM_RTS;
 194         if (set & TIOCM_DTR)
 195                 self->settings.dte |= IRCOMM_DTR;
 196
 197         if (clear & TIOCM_RTS)
 198                 self->settings.dte &= ~IRCOMM_RTS;
 199         if (clear & TIOCM_DTR)
 200                 self->settings.dte &= ~IRCOMM_DTR;
 201
 202         if ((set|clear) & TIOCM_RTS)
 203                 self->settings.dte |= IRCOMM_DELTA_RTS;
 204         if ((set|clear) & TIOCM_DTR)
 205                 self->settings.dte |= IRCOMM_DELTA_DTR;
 206
 207         ircomm_param_request(self, IRCOMM_DTE, TRUE);
 208
 209         return 0;
 210 }
 211
 212 /*
 213  * Function get_serial_info (driver, retinfo)
 214  *
 215  *
 216  *
 217  */
 218 static int ircomm_tty_get_serial_info(struct ircomm_tty_cb *self,
 219                                       struct serial_struct __user *retinfo)
 220 {
 221         struct serial_struct info;
 222
 223         memset(&info, 0, sizeof(info));
 224         info.line = self->line;
 225         info.flags = self->port.flags;
 226         info.baud_base = self->settings.data_rate;
 227         info.close_delay = self->port.close_delay;
 228         info.closing_wait = self->port.closing_wait;
 229
 230         /* For compatibility  */
 231         info.type = PORT_16550A;
 232
 233         if (copy_to_user(retinfo, &info, sizeof(*retinfo)))
 234                 return -EFAULT;
 235
 236         return 0;
 237 }
 238
 239 /*
 240  * Function set_serial_info (driver, new_info)
 241  *
 242  *
 243  *
 244  */
 245 static int ircomm_tty_set_serial_info(struct ircomm_tty_cb *self,
 246                                       struct serial_struct __user *new_info)
 247 {
 248         return 0;
 249 }
 250
 251 /*
 252  * Function ircomm_tty_ioctl (tty, cmd, arg)
 253  *
 254  *
 255  *
 256  */
 257 int ircomm_tty_ioctl(struct tty_struct *tty,
 258                      unsigned int cmd, unsigned long arg)
 259 {
 260         struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
 261         int ret = 0;
 262
 263         if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
 264             (cmd != TIOCSERCONFIG) && (cmd != TIOCSERGSTRUCT) &&
 265             (cmd != TIOCMIWAIT) && (cmd != TIOCGICOUNT)) {
 266                 if (tty_io_error(tty))
 267                     return -EIO;
 268         }
 269
 270         switch (cmd) {
 271         case TIOCGSERIAL:
 272                 ret = ircomm_tty_get_serial_info(self, (struct serial_struct __user *) arg);
 273                 break;
 274         case TIOCSSERIAL:
 275                 ret = ircomm_tty_set_serial_info(self, (struct serial_struct __user *) arg);
 276                 break;
 277         case TIOCMIWAIT:
 278                 pr_debug("(), TIOCMIWAIT, not impl!\n");
 279                 break;
 280
 281         case TIOCGICOUNT:
 282                 pr_debug("%s(), TIOCGICOUNT not impl!\n", __func__);
 283                 return 0;
 284         default:
 285                 ret = -ENOIOCTLCMD;  /* ioctls which we must ignore */
 286         }
 287         return ret;
 288 }
 289
 290
 291