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 42static int ircomm_param_service_type(void *instance, irda_param_t *param, 43 int get); 44static int ircomm_param_port_type(void *instance, irda_param_t *param, 45 int get); 46static int ircomm_param_port_name(void *instance, irda_param_t *param, 47 int get); 48static int ircomm_param_service_type(void *instance, irda_param_t *param, 49 int get); 50static int ircomm_param_data_rate(void *instance, irda_param_t *param, 51 int get); 52static int ircomm_param_data_format(void *instance, irda_param_t *param, 53 int get); 54static int ircomm_param_flow_control(void *instance, irda_param_t *param, 55 int get); 56static int ircomm_param_xon_xoff(void *instance, irda_param_t *param, int get); 57static int ircomm_param_enq_ack(void *instance, irda_param_t *param, int get); 58static int ircomm_param_line_status(void *instance, irda_param_t *param, 59 int get); 60static int ircomm_param_dte(void *instance, irda_param_t *param, int get); 61static int ircomm_param_dce(void *instance, irda_param_t *param, int get); 62static int ircomm_param_poll(void *instance, irda_param_t *param, int get); 63 64static 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}; 69static 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}; 77static 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 83static 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 90pi_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 */ 98int 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 */ 157static 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 */ 223static 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 */ 247static 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 */ 270static 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 */ 293static 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 */ 315static 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 */ 339static 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 */ 366static 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 */ 393static 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 */ 407static 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 */ 452static 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 */ 484static 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 503