kernel/net/irda/ircomm/ircomm_param.c

   1 /*********************************************************************
   2  *
   3  * Filename:      ircomm_param.c
   4  * Version:       1.0
   5  * Description:   Parameter handling for the IrCOMM protocol
   6  * Status:        Experimental.
   7  * Author:        Dag Brattli <dagb@cs.uit.no>
   8  * Created at:    Mon Jun  7 10:25:11 1999
   9  * Modified at:   Sun Jan 30 14:32:03 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/gfp.h>
  30 #include <linux/workqueue.h>
  31 #include <linux/interrupt.h>
  32
  33 #include <net/irda/irda.h>
  34 #include <net/irda/parameters.h>
  35
  36 #include <net/irda/ircomm_core.h>
  37 #include <net/irda/ircomm_tty_attach.h>
  38 #include <net/irda/ircomm_tty.h>
  39
  40 #include <net/irda/ircomm_param.h>
  41
  42 static int ircomm_param_service_type(void *instance, irda_param_t *param,
  43                                      int get);
  44 static int ircomm_param_port_type(void *instance, irda_param_t *param,
  45                                   int get);
  46 static int ircomm_param_port_name(void *instance, irda_param_t *param,
  47                                   int get);
  48 static int ircomm_param_service_type(void *instance, irda_param_t *param,
  49                                      int get);
  50 static int ircomm_param_data_rate(void *instance, irda_param_t *param,
  51                                   int get);
  52 static int ircomm_param_data_format(void *instance, irda_param_t *param,
  53                                     int get);
  54 static int ircomm_param_flow_control(void *instance, irda_param_t *param,
  55                                      int get);
  56 static int ircomm_param_xon_xoff(void *instance, irda_param_t *param, int get);
  57 static int ircomm_param_enq_ack(void *instance, irda_param_t *param, int get);
  58 static int ircomm_param_line_status(void *instance, irda_param_t *param,
  59                                     int get);
  60 static int ircomm_param_dte(void *instance, irda_param_t *param, int get);
  61 static int ircomm_param_dce(void *instance, irda_param_t *param, int get);
  62 static int ircomm_param_poll(void *instance, irda_param_t *param, int get);
  63
  64 static const pi_minor_info_t pi_minor_call_table_common[] = {
  65         { ircomm_param_service_type, PV_INT_8_BITS },
  66         { ircomm_param_port_type,    PV_INT_8_BITS },
  67         { ircomm_param_port_name,    PV_STRING }
  68 };
  69 static const pi_minor_info_t pi_minor_call_table_non_raw[] = {
  70         { ircomm_param_data_rate,    PV_INT_32_BITS | PV_BIG_ENDIAN },
  71         { ircomm_param_data_format,  PV_INT_8_BITS },
  72         { ircomm_param_flow_control, PV_INT_8_BITS },
  73         { ircomm_param_xon_xoff,     PV_INT_16_BITS },
  74         { ircomm_param_enq_ack,      PV_INT_16_BITS },
  75         { ircomm_param_line_status,  PV_INT_8_BITS }
  76 };
  77 static const pi_minor_info_t pi_minor_call_table_9_wire[] = {
  78         { ircomm_param_dte,          PV_INT_8_BITS },
  79         { ircomm_param_dce,          PV_INT_8_BITS },
  80         { ircomm_param_poll,         PV_NO_VALUE },
  81 };
  82
  83 static const pi_major_info_t pi_major_call_table[] = {
  84         { pi_minor_call_table_common,  3 },
  85         { pi_minor_call_table_non_raw, 6 },
  86         { pi_minor_call_table_9_wire,  3 }
  87 /*      { pi_minor_call_table_centronics }  */
  88 };
  89
  90 pi_param_info_t ircomm_param_info = { pi_major_call_table, 3, 0x0f, 4 };
  91
  92 /*
  93  * Function ircomm_param_request (self, pi, flush)
  94  *
  95  *    Queue a parameter for the control channel
  96  *
  97  */
  98 int ircomm_param_request(struct ircomm_tty_cb *self, __u8 pi, int flush)
  99 {
 100         unsigned long flags;
 101         struct sk_buff *skb;
 102         int count;
 103
 104         IRDA_ASSERT(self != NULL, return -1;);
 105         IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 106
 107         /* Make sure we don't send parameters for raw mode */
 108         if (self->service_type == IRCOMM_3_WIRE_RAW)
 109                 return 0;
 110
 111         spin_lock_irqsave(&self->spinlock, flags);
 112
 113         skb = self->ctrl_skb;
 114         if (!skb) {
 115                 skb = alloc_skb(256, GFP_ATOMIC);
 116                 if (!skb) {
 117                         spin_unlock_irqrestore(&self->spinlock, flags);
 118                         return -ENOMEM;
 119                 }
 120
 121                 skb_reserve(skb, self->max_header_size);
 122                 self->ctrl_skb = skb;
 123         }
 124         /*
 125          * Inserting is a little bit tricky since we don't know how much
 126          * room we will need. But this should hopefully work OK
 127          */
 128         count = irda_param_insert(self, pi, skb_tail_pointer(skb),
 129                                   skb_tailroom(skb), &ircomm_param_info);
 130         if (count < 0) {
 131                 net_warn_ratelimited("%s(), no room for parameter!\n",
 132                                      __func__);
 133                 spin_unlock_irqrestore(&self->spinlock, flags);
 134                 return -1;
 135         }
 136         skb_put(skb, count);
 137
 138         spin_unlock_irqrestore(&self->spinlock, flags);
 139
 140         pr_debug("%s(), skb->len=%d\n", __func__ , skb->len);
 141
 142         if (flush) {
 143                 /* ircomm_tty_do_softint will take care of the rest */
 144                 schedule_work(&self->tqueue);
 145         }
 146
 147         return count;
 148 }
 149
 150 /*
 151  * Function ircomm_param_service_type (self, buf, len)
 152  *
 153  *    Handle service type, this function will both be called after the LM-IAS
 154  *    query and then the remote device sends its initial parameters
 155  *
 156  */
 157 static int ircomm_param_service_type(void *instance, irda_param_t *param,
 158                                      int get)
 159 {
 160         struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
 161         __u8 service_type = (__u8) param->pv.i;
 162
 163         IRDA_ASSERT(self != NULL, return -1;);
 164         IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 165
 166         if (get) {
 167                 param->pv.i = self->settings.service_type;
 168                 return 0;
 169         }
 170
 171         /* Find all common service types */
 172         service_type &= self->service_type;
 173         if (!service_type) {
 174                 pr_debug("%s(), No common service type to use!\n", __func__);
 175                 return -1;
 176         }
 177         pr_debug("%s(), services in common=%02x\n", __func__ ,
 178                  service_type);
 179
 180         /*
 181          * Now choose a preferred service type of those available
 182          */
 183         if (service_type & IRCOMM_CENTRONICS)
 184                 self->settings.service_type = IRCOMM_CENTRONICS;
 185         else if (service_type & IRCOMM_9_WIRE)
 186                 self->settings.service_type = IRCOMM_9_WIRE;
 187         else if (service_type & IRCOMM_3_WIRE)
 188                 self->settings.service_type = IRCOMM_3_WIRE;
 189         else if (service_type & IRCOMM_3_WIRE_RAW)
 190                 self->settings.service_type = IRCOMM_3_WIRE_RAW;
 191
 192         pr_debug("%s(), resulting service type=0x%02x\n", __func__ ,
 193                  self->settings.service_type);
 194
 195         /*
 196          * Now the line is ready for some communication. Check if we are a
 197          * server, and send over some initial parameters.
 198          * Client do it in ircomm_tty_state_setup().
 199          * Note : we may get called from ircomm_tty_getvalue_confirm(),
 200          * therefore before we even have open any socket. And self->client
 201          * is initialised to TRUE only later. So, we check if the link is
 202          * really initialised. - Jean II
 203          */
 204         if ((self->max_header_size != IRCOMM_TTY_HDR_UNINITIALISED) &&
 205             (!self->client) &&
 206             (self->settings.service_type != IRCOMM_3_WIRE_RAW))
 207         {
 208                 /* Init connection */
 209                 ircomm_tty_send_initial_parameters(self);
 210                 ircomm_tty_link_established(self);
 211         }
 212
 213         return 0;
 214 }
 215
 216 /*
 217  * Function ircomm_param_port_type (self, param)
 218  *
 219  *    The port type parameter tells if the devices are serial or parallel.
 220  *    Since we only advertise serial service, this parameter should only
 221  *    be equal to IRCOMM_SERIAL.
 222  */
 223 static int ircomm_param_port_type(void *instance, irda_param_t *param, int get)
 224 {
 225         struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
 226
 227         IRDA_ASSERT(self != NULL, return -1;);
 228         IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 229
 230         if (get)
 231                 param->pv.i = IRCOMM_SERIAL;
 232         else {
 233                 self->settings.port_type = (__u8) param->pv.i;
 234
 235                 pr_debug("%s(), port type=%d\n", __func__ ,
 236                          self->settings.port_type);
 237         }
 238         return 0;
 239 }
 240
 241 /*
 242  * Function ircomm_param_port_name (self, param)
 243  *
 244  *    Exchange port name
 245  *
 246  */
 247 static int ircomm_param_port_name(void *instance, irda_param_t *param, int get)
 248 {
 249         struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
 250
 251         IRDA_ASSERT(self != NULL, return -1;);
 252         IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 253
 254         if (get) {
 255                 pr_debug("%s(), not imp!\n", __func__);
 256         } else {
 257                 pr_debug("%s(), port-name=%s\n", __func__ , param->pv.c);
 258                 strncpy(self->settings.port_name, param->pv.c, 32);
 259         }
 260
 261         return 0;
 262 }
 263
 264 /*
 265  * Function ircomm_param_data_rate (self, param)
 266  *
 267  *    Exchange data rate to be used in this settings
 268  *
 269  */
 270 static int ircomm_param_data_rate(void *instance, irda_param_t *param, int get)
 271 {
 272         struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
 273
 274         IRDA_ASSERT(self != NULL, return -1;);
 275         IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 276
 277         if (get)
 278                 param->pv.i = self->settings.data_rate;
 279         else
 280                 self->settings.data_rate = param->pv.i;
 281
 282         pr_debug("%s(), data rate = %d\n", __func__ , param->pv.i);
 283
 284         return 0;
 285 }
 286
 287 /*
 288  * Function ircomm_param_data_format (self, param)
 289  *
 290  *    Exchange data format to be used in this settings
 291  *
 292  */
 293 static int ircomm_param_data_format(void *instance, irda_param_t *param,
 294                                     int get)
 295 {
 296         struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
 297
 298         IRDA_ASSERT(self != NULL, return -1;);
 299         IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 300
 301         if (get)
 302                 param->pv.i = self->settings.data_format;
 303         else
 304                 self->settings.data_format = (__u8) param->pv.i;
 305
 306         return 0;
 307 }
 308
 309 /*
 310  * Function ircomm_param_flow_control (self, param)
 311  *
 312  *    Exchange flow control settings to be used in this settings
 313  *
 314  */
 315 static int ircomm_param_flow_control(void *instance, irda_param_t *param,
 316                                      int get)
 317 {
 318         struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
 319
 320         IRDA_ASSERT(self != NULL, return -1;);
 321         IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 322
 323         if (get)
 324                 param->pv.i = self->settings.flow_control;
 325         else
 326                 self->settings.flow_control = (__u8) param->pv.i;
 327
 328         pr_debug("%s(), flow control = 0x%02x\n", __func__ , (__u8)param->pv.i);
 329
 330         return 0;
 331 }
 332
 333 /*
 334  * Function ircomm_param_xon_xoff (self, param)
 335  *
 336  *    Exchange XON/XOFF characters
 337  *
 338  */
 339 static int ircomm_param_xon_xoff(void *instance, irda_param_t *param, int get)
 340 {
 341         struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
 342
 343         IRDA_ASSERT(self != NULL, return -1;);
 344         IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 345
 346         if (get) {
 347                 param->pv.i = self->settings.xonxoff[0];
 348                 param->pv.i |= self->settings.xonxoff[1] << 8;
 349         } else {
 350                 self->settings.xonxoff[0] = (__u16) param->pv.i & 0xff;
 351                 self->settings.xonxoff[1] = (__u16) param->pv.i >> 8;
 352         }
 353
 354         pr_debug("%s(), XON/XOFF = 0x%02x,0x%02x\n", __func__ ,
 355                  param->pv.i & 0xff, param->pv.i >> 8);
 356
 357         return 0;
 358 }
 359
 360 /*
 361  * Function ircomm_param_enq_ack (self, param)
 362  *
 363  *    Exchange ENQ/ACK characters
 364  *
 365  */
 366 static int ircomm_param_enq_ack(void *instance, irda_param_t *param, int get)
 367 {
 368         struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
 369
 370         IRDA_ASSERT(self != NULL, return -1;);
 371         IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 372
 373         if (get) {
 374                 param->pv.i = self->settings.enqack[0];
 375                 param->pv.i |= self->settings.enqack[1] << 8;
 376         } else {
 377                 self->settings.enqack[0] = (__u16) param->pv.i & 0xff;
 378                 self->settings.enqack[1] = (__u16) param->pv.i >> 8;
 379         }
 380
 381         pr_debug("%s(), ENQ/ACK = 0x%02x,0x%02x\n", __func__ ,
 382                  param->pv.i & 0xff, param->pv.i >> 8);
 383
 384         return 0;
 385 }
 386
 387 /*
 388  * Function ircomm_param_line_status (self, param)
 389  *
 390  *
 391  *
 392  */
 393 static int ircomm_param_line_status(void *instance, irda_param_t *param,
 394                                     int get)
 395 {
 396         pr_debug("%s(), not impl.\n", __func__);
 397
 398         return 0;
 399 }
 400
 401 /*
 402  * Function ircomm_param_dte (instance, param)
 403  *
 404  *    If we get here, there must be some sort of null-modem connection, and
 405  *    we are probably working in server mode as well.
 406  */
 407 static int ircomm_param_dte(void *instance, irda_param_t *param, int get)
 408 {
 409         struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
 410         __u8 dte;
 411
 412         IRDA_ASSERT(self != NULL, return -1;);
 413         IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 414
 415         if (get)
 416                 param->pv.i = self->settings.dte;
 417         else {
 418                 dte = (__u8) param->pv.i;
 419
 420                 self->settings.dce = 0;
 421
 422                 if (dte & IRCOMM_DELTA_DTR)
 423                         self->settings.dce |= (IRCOMM_DELTA_DSR|
 424                                               IRCOMM_DELTA_RI |
 425                                               IRCOMM_DELTA_CD);
 426                 if (dte & IRCOMM_DTR)
 427                         self->settings.dce |= (IRCOMM_DSR|
 428                                               IRCOMM_RI |
 429                                               IRCOMM_CD);
 430
 431                 if (dte & IRCOMM_DELTA_RTS)
 432                         self->settings.dce |= IRCOMM_DELTA_CTS;
 433                 if (dte & IRCOMM_RTS)
 434                         self->settings.dce |= IRCOMM_CTS;
 435
 436                 /* Take appropriate actions */
 437                 ircomm_tty_check_modem_status(self);
 438
 439                 /* Null modem cable emulator */
 440                 self->settings.null_modem = TRUE;
 441         }
 442
 443         return 0;
 444 }
 445
 446 /*
 447  * Function ircomm_param_dce (instance, param)
 448  *
 449  *
 450  *
 451  */
 452 static int ircomm_param_dce(void *instance, irda_param_t *param, int get)
 453 {
 454         struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
 455         __u8 dce;
 456
 457         pr_debug("%s(), dce = 0x%02x\n", __func__ , (__u8)param->pv.i);
 458
 459         dce = (__u8) param->pv.i;
 460
 461         IRDA_ASSERT(self != NULL, return -1;);
 462         IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 463
 464         self->settings.dce = dce;
 465
 466         /* Check if any of the settings have changed */
 467         if (dce & 0x0f) {
 468                 if (dce & IRCOMM_DELTA_CTS) {
 469                         pr_debug("%s(), CTS\n", __func__);
 470                 }
 471         }
 472
 473         ircomm_tty_check_modem_status(self);
 474
 475         return 0;
 476 }
 477
 478 /*
 479  * Function ircomm_param_poll (instance, param)
 480  *
 481  *    Called when the peer device is polling for the line settings
 482  *
 483  */
 484 static int ircomm_param_poll(void *instance, irda_param_t *param, int get)
 485 {
 486         struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
 487
 488         IRDA_ASSERT(self != NULL, return -1;);
 489         IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 490
 491         /* Poll parameters are always of length 0 (just a signal) */
 492         if (!get) {
 493                 /* Respond with DTE line settings */
 494                 ircomm_param_request(self, IRCOMM_DTE, TRUE);
 495         }
 496         return 0;
 497 }
 498
 499
 500
 501
 502