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