1/********************************************************************* 2 * 3 * Filename: irlan_common.c 4 * Version: 0.9 5 * Description: IrDA LAN Access Protocol Implementation 6 * Status: Experimental. 7 * Author: Dag Brattli <dagb@cs.uit.no> 8 * Created at: Sun Aug 31 20:14:37 1997 9 * Modified at: Sun Dec 26 21:53:10 1999 10 * Modified by: Dag Brattli <dagb@cs.uit.no> 11 * 12 * Copyright (c) 1997, 1999 Dag Brattli <dagb@cs.uit.no>, 13 * All Rights Reserved. 14 * 15 * This program is free software; you can redistribute it and/or 16 * modify it under the terms of the GNU General Public License as 17 * published by the Free Software Foundation; either version 2 of 18 * the License, or (at your option) any later version. 19 * 20 * Neither Dag Brattli nor University of Tromsø admit liability nor 21 * provide warranty for any of this software. This material is 22 * provided "AS-IS" and at no charge. 23 * 24 ********************************************************************/ 25 26#include <linux/module.h> 27 28#include <linux/kernel.h> 29#include <linux/string.h> 30#include <linux/gfp.h> 31#include <linux/init.h> 32#include <linux/errno.h> 33#include <linux/proc_fs.h> 34#include <linux/sched.h> 35#include <linux/seq_file.h> 36#include <linux/random.h> 37#include <linux/netdevice.h> 38#include <linux/etherdevice.h> 39#include <linux/rtnetlink.h> 40#include <linux/moduleparam.h> 41#include <linux/bitops.h> 42 43#include <asm/byteorder.h> 44 45#include <net/irda/irda.h> 46#include <net/irda/irttp.h> 47#include <net/irda/irlmp.h> 48#include <net/irda/iriap.h> 49#include <net/irda/timer.h> 50 51#include <net/irda/irlan_common.h> 52#include <net/irda/irlan_client.h> 53#include <net/irda/irlan_provider.h> 54#include <net/irda/irlan_eth.h> 55#include <net/irda/irlan_filter.h> 56 57 58/* extern char sysctl_devname[]; */ 59 60/* 61 * Master structure 62 */ 63static LIST_HEAD(irlans); 64 65static void *ckey; 66static void *skey; 67 68/* Module parameters */ 69static bool eth; /* Use "eth" or "irlan" name for devices */ 70static int access = ACCESS_PEER; /* PEER, DIRECT or HOSTED */ 71 72#ifdef CONFIG_PROC_FS 73static const char *const irlan_access[] = { 74 "UNKNOWN", 75 "DIRECT", 76 "PEER", 77 "HOSTED" 78}; 79 80static const char *const irlan_media[] = { 81 "UNKNOWN", 82 "802.3", 83 "802.5" 84}; 85 86extern struct proc_dir_entry *proc_irda; 87 88static int irlan_seq_open(struct inode *inode, struct file *file); 89 90static const struct file_operations irlan_fops = { 91 .owner = THIS_MODULE, 92 .open = irlan_seq_open, 93 .read = seq_read, 94 .llseek = seq_lseek, 95 .release = seq_release, 96}; 97 98extern struct proc_dir_entry *proc_irda; 99#endif /* CONFIG_PROC_FS */ 100 101static struct irlan_cb __init *irlan_open(__u32 saddr, __u32 daddr); 102static void __irlan_close(struct irlan_cb *self); 103static int __irlan_insert_param(struct sk_buff *skb, char *param, int type, 104 __u8 value_byte, __u16 value_short, 105 __u8 *value_array, __u16 value_len); 106static void irlan_open_unicast_addr(struct irlan_cb *self); 107static void irlan_get_unicast_addr(struct irlan_cb *self); 108void irlan_close_tsaps(struct irlan_cb *self); 109 110/* 111 * Function irlan_init (void) 112 * 113 * Initialize IrLAN layer 114 * 115 */ 116static int __init irlan_init(void) 117{ 118 struct irlan_cb *new; 119 __u16 hints; 120 121#ifdef CONFIG_PROC_FS 122 { struct proc_dir_entry *proc; 123 proc = proc_create("irlan", 0, proc_irda, &irlan_fops); 124 if (!proc) { 125 printk(KERN_ERR "irlan_init: can't create /proc entry!\n"); 126 return -ENODEV; 127 } 128 } 129#endif /* CONFIG_PROC_FS */ 130 131 hints = irlmp_service_to_hint(S_LAN); 132 133 /* Register with IrLMP as a client */ 134 ckey = irlmp_register_client(hints, &irlan_client_discovery_indication, 135 NULL, NULL); 136 if (!ckey) 137 goto err_ckey; 138 139 /* Register with IrLMP as a service */ 140 skey = irlmp_register_service(hints); 141 if (!skey) 142 goto err_skey; 143 144 /* Start the master IrLAN instance (the only one for now) */ 145 new = irlan_open(DEV_ADDR_ANY, DEV_ADDR_ANY); 146 if (!new) 147 goto err_open; 148 149 /* The master will only open its (listen) control TSAP */ 150 irlan_provider_open_ctrl_tsap(new); 151 152 /* Do some fast discovery! */ 153 irlmp_discovery_request(DISCOVERY_DEFAULT_SLOTS); 154 155 return 0; 156 157err_open: 158 irlmp_unregister_service(skey); 159err_skey: 160 irlmp_unregister_client(ckey); 161err_ckey: 162#ifdef CONFIG_PROC_FS 163 remove_proc_entry("irlan", proc_irda); 164#endif /* CONFIG_PROC_FS */ 165 166 return -ENOMEM; 167} 168 169static void __exit irlan_cleanup(void) 170{ 171 struct irlan_cb *self, *next; 172 173 irlmp_unregister_client(ckey); 174 irlmp_unregister_service(skey); 175 176#ifdef CONFIG_PROC_FS 177 remove_proc_entry("irlan", proc_irda); 178#endif /* CONFIG_PROC_FS */ 179 180 /* Cleanup any leftover network devices */ 181 rtnl_lock(); 182 list_for_each_entry_safe(self, next, &irlans, dev_list) { 183 __irlan_close(self); 184 } 185 rtnl_unlock(); 186} 187 188/* 189 * Function irlan_open (void) 190 * 191 * Open new instance of a client/provider, we should only register the 192 * network device if this instance is ment for a particular client/provider 193 */ 194static struct irlan_cb __init *irlan_open(__u32 saddr, __u32 daddr) 195{ 196 struct net_device *dev; 197 struct irlan_cb *self; 198 199 /* Create network device with irlan */ 200 dev = alloc_irlandev(eth ? "eth%d" : "irlan%d"); 201 if (!dev) 202 return NULL; 203 204 self = netdev_priv(dev); 205 self->dev = dev; 206 207 /* 208 * Initialize local device structure 209 */ 210 self->magic = IRLAN_MAGIC; 211 self->saddr = saddr; 212 self->daddr = daddr; 213 214 /* Provider access can only be PEER, DIRECT, or HOSTED */ 215 self->provider.access_type = access; 216 if (access == ACCESS_DIRECT) { 217 /* 218 * Since we are emulating an IrLAN sever we will have to 219 * give ourself an ethernet address! 220 */ 221 dev->dev_addr[0] = 0x40; 222 dev->dev_addr[1] = 0x00; 223 dev->dev_addr[2] = 0x00; 224 dev->dev_addr[3] = 0x00; 225 get_random_bytes(dev->dev_addr+4, 1); 226 get_random_bytes(dev->dev_addr+5, 1); 227 } 228 229 self->media = MEDIA_802_3; 230 self->disconnect_reason = LM_USER_REQUEST; 231 init_timer(&self->watchdog_timer); 232 init_timer(&self->client.kick_timer); 233 init_waitqueue_head(&self->open_wait); 234 235 skb_queue_head_init(&self->client.txq); 236 237 irlan_next_client_state(self, IRLAN_IDLE); 238 irlan_next_provider_state(self, IRLAN_IDLE); 239 240 if (register_netdev(dev)) { 241 pr_debug("%s(), register_netdev() failed!\n", 242 __func__); 243 self = NULL; 244 free_netdev(dev); 245 } else { 246 rtnl_lock(); 247 list_add_rcu(&self->dev_list, &irlans); 248 rtnl_unlock(); 249 } 250 251 return self; 252} 253/* 254 * Function __irlan_close (self) 255 * 256 * This function closes and deallocates the IrLAN client instances. Be 257 * aware that other functions which calls client_close() must 258 * remove self from irlans list first. 259 */ 260static void __irlan_close(struct irlan_cb *self) 261{ 262 ASSERT_RTNL(); 263 IRDA_ASSERT(self != NULL, return;); 264 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); 265 266 del_timer_sync(&self->watchdog_timer); 267 del_timer_sync(&self->client.kick_timer); 268 269 /* Close all open connections and remove TSAPs */ 270 irlan_close_tsaps(self); 271 272 if (self->client.iriap) 273 iriap_close(self->client.iriap); 274 275 /* Remove frames queued on the control channel */ 276 skb_queue_purge(&self->client.txq); 277 278 /* Unregister and free self via destructor */ 279 unregister_netdevice(self->dev); 280} 281 282/* Find any instance of irlan, used for client discovery wakeup */ 283struct irlan_cb *irlan_get_any(void) 284{ 285 struct irlan_cb *self; 286 287 list_for_each_entry_rcu(self, &irlans, dev_list) { 288 return self; 289 } 290 return NULL; 291} 292 293/* 294 * Function irlan_connect_indication (instance, sap, qos, max_sdu_size, skb) 295 * 296 * Here we receive the connect indication for the data channel 297 * 298 */ 299static void irlan_connect_indication(void *instance, void *sap, 300 struct qos_info *qos, 301 __u32 max_sdu_size, 302 __u8 max_header_size, 303 struct sk_buff *skb) 304{ 305 struct irlan_cb *self; 306 struct tsap_cb *tsap; 307 308 self = instance; 309 tsap = sap; 310 311 IRDA_ASSERT(self != NULL, return;); 312 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); 313 IRDA_ASSERT(tsap == self->tsap_data,return;); 314 315 self->max_sdu_size = max_sdu_size; 316 self->max_header_size = max_header_size; 317 318 pr_debug("%s: We are now connected!\n", __func__); 319 320 del_timer(&self->watchdog_timer); 321 322 /* If you want to pass the skb to *both* state machines, you will 323 * need to skb_clone() it, so that you don't free it twice. 324 * As the state machines don't need it, git rid of it here... 325 * Jean II */ 326 if (skb) 327 dev_kfree_skb(skb); 328 329 irlan_do_provider_event(self, IRLAN_DATA_CONNECT_INDICATION, NULL); 330 irlan_do_client_event(self, IRLAN_DATA_CONNECT_INDICATION, NULL); 331 332 if (self->provider.access_type == ACCESS_PEER) { 333 /* 334 * Data channel is open, so we are now allowed to 335 * configure the remote filter 336 */ 337 irlan_get_unicast_addr(self); 338 irlan_open_unicast_addr(self); 339 } 340 /* Ready to transfer Ethernet frames (at last) */ 341 netif_start_queue(self->dev); /* Clear reason */ 342} 343 344static void irlan_connect_confirm(void *instance, void *sap, 345 struct qos_info *qos, 346 __u32 max_sdu_size, 347 __u8 max_header_size, 348 struct sk_buff *skb) 349{ 350 struct irlan_cb *self; 351 352 self = instance; 353 354 IRDA_ASSERT(self != NULL, return;); 355 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); 356 357 self->max_sdu_size = max_sdu_size; 358 self->max_header_size = max_header_size; 359 360 /* TODO: we could set the MTU depending on the max_sdu_size */ 361 362 pr_debug("%s: We are now connected!\n", __func__); 363 del_timer(&self->watchdog_timer); 364 365 /* 366 * Data channel is open, so we are now allowed to configure the remote 367 * filter 368 */ 369 irlan_get_unicast_addr(self); 370 irlan_open_unicast_addr(self); 371 372 /* Open broadcast and multicast filter by default */ 373 irlan_set_broadcast_filter(self, TRUE); 374 irlan_set_multicast_filter(self, TRUE); 375 376 /* Ready to transfer Ethernet frames */ 377 netif_start_queue(self->dev); 378 self->disconnect_reason = 0; /* Clear reason */ 379 wake_up_interruptible(&self->open_wait); 380} 381 382/* 383 * Function irlan_client_disconnect_indication (handle) 384 * 385 * Callback function for the IrTTP layer. Indicates a disconnection of 386 * the specified connection (handle) 387 */ 388static void irlan_disconnect_indication(void *instance, 389 void *sap, LM_REASON reason, 390 struct sk_buff *userdata) 391{ 392 struct irlan_cb *self; 393 struct tsap_cb *tsap; 394 395 pr_debug("%s(), reason=%d\n", __func__ , reason); 396 397 self = instance; 398 tsap = sap; 399 400 IRDA_ASSERT(self != NULL, return;); 401 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); 402 IRDA_ASSERT(tsap != NULL, return;); 403 IRDA_ASSERT(tsap->magic == TTP_TSAP_MAGIC, return;); 404 405 IRDA_ASSERT(tsap == self->tsap_data, return;); 406 407 pr_debug("IrLAN, data channel disconnected by peer!\n"); 408 409 /* Save reason so we know if we should try to reconnect or not */ 410 self->disconnect_reason = reason; 411 412 switch (reason) { 413 case LM_USER_REQUEST: /* User request */ 414 pr_debug("%s(), User requested\n", __func__); 415 break; 416 case LM_LAP_DISCONNECT: /* Unexpected IrLAP disconnect */ 417 pr_debug("%s(), Unexpected IrLAP disconnect\n", __func__); 418 break; 419 case LM_CONNECT_FAILURE: /* Failed to establish IrLAP connection */ 420 pr_debug("%s(), IrLAP connect failed\n", __func__); 421 break; 422 case LM_LAP_RESET: /* IrLAP reset */ 423 pr_debug("%s(), IrLAP reset\n", __func__); 424 break; 425 case LM_INIT_DISCONNECT: 426 pr_debug("%s(), IrLMP connect failed\n", __func__); 427 break; 428 default: 429 net_err_ratelimited("%s(), Unknown disconnect reason\n", 430 __func__); 431 break; 432 } 433 434 /* If you want to pass the skb to *both* state machines, you will 435 * need to skb_clone() it, so that you don't free it twice. 436 * As the state machines don't need it, git rid of it here... 437 * Jean II */ 438 if (userdata) 439 dev_kfree_skb(userdata); 440 441 irlan_do_client_event(self, IRLAN_LMP_DISCONNECT, NULL); 442 irlan_do_provider_event(self, IRLAN_LMP_DISCONNECT, NULL); 443 444 wake_up_interruptible(&self->open_wait); 445} 446 447void irlan_open_data_tsap(struct irlan_cb *self) 448{ 449 struct tsap_cb *tsap; 450 notify_t notify; 451 452 IRDA_ASSERT(self != NULL, return;); 453 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); 454 455 /* Check if already open */ 456 if (self->tsap_data) 457 return; 458 459 irda_notify_init(¬ify); 460 461 notify.data_indication = irlan_eth_receive; 462 notify.udata_indication = irlan_eth_receive; 463 notify.connect_indication = irlan_connect_indication; 464 notify.connect_confirm = irlan_connect_confirm; 465 notify.flow_indication = irlan_eth_flow_indication; 466 notify.disconnect_indication = irlan_disconnect_indication; 467 notify.instance = self; 468 strlcpy(notify.name, "IrLAN data", sizeof(notify.name)); 469 470 tsap = irttp_open_tsap(LSAP_ANY, DEFAULT_INITIAL_CREDIT, ¬ify); 471 if (!tsap) { 472 pr_debug("%s(), Got no tsap!\n", __func__); 473 return; 474 } 475 self->tsap_data = tsap; 476 477 /* 478 * This is the data TSAP selector which we will pass to the client 479 * when the client ask for it. 480 */ 481 self->stsap_sel_data = self->tsap_data->stsap_sel; 482} 483 484void irlan_close_tsaps(struct irlan_cb *self) 485{ 486 IRDA_ASSERT(self != NULL, return;); 487 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); 488 489 /* Disconnect and close all open TSAP connections */ 490 if (self->tsap_data) { 491 irttp_disconnect_request(self->tsap_data, NULL, P_NORMAL); 492 irttp_close_tsap(self->tsap_data); 493 self->tsap_data = NULL; 494 } 495 if (self->client.tsap_ctrl) { 496 irttp_disconnect_request(self->client.tsap_ctrl, NULL, 497 P_NORMAL); 498 irttp_close_tsap(self->client.tsap_ctrl); 499 self->client.tsap_ctrl = NULL; 500 } 501 if (self->provider.tsap_ctrl) { 502 irttp_disconnect_request(self->provider.tsap_ctrl, NULL, 503 P_NORMAL); 504 irttp_close_tsap(self->provider.tsap_ctrl); 505 self->provider.tsap_ctrl = NULL; 506 } 507 self->disconnect_reason = LM_USER_REQUEST; 508} 509 510/* 511 * Function irlan_ias_register (self, tsap_sel) 512 * 513 * Register with LM-IAS 514 * 515 */ 516void irlan_ias_register(struct irlan_cb *self, __u8 tsap_sel) 517{ 518 struct ias_object *obj; 519 struct ias_value *new_value; 520 521 IRDA_ASSERT(self != NULL, return;); 522 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); 523 524 /* 525 * Check if object has already been registered by a previous provider. 526 * If that is the case, we just change the value of the attribute 527 */ 528 if (!irias_find_object("IrLAN")) { 529 obj = irias_new_object("IrLAN", IAS_IRLAN_ID); 530 irias_add_integer_attrib(obj, "IrDA:TinyTP:LsapSel", tsap_sel, 531 IAS_KERNEL_ATTR); 532 irias_insert_object(obj); 533 } else { 534 new_value = irias_new_integer_value(tsap_sel); 535 irias_object_change_attribute("IrLAN", "IrDA:TinyTP:LsapSel", 536 new_value); 537 } 538 539 /* Register PnP object only if not registered before */ 540 if (!irias_find_object("PnP")) { 541 obj = irias_new_object("PnP", IAS_PNP_ID); 542#if 0 543 irias_add_string_attrib(obj, "Name", sysctl_devname, 544 IAS_KERNEL_ATTR); 545#else 546 irias_add_string_attrib(obj, "Name", "Linux", IAS_KERNEL_ATTR); 547#endif 548 irias_add_string_attrib(obj, "DeviceID", "HWP19F0", 549 IAS_KERNEL_ATTR); 550 irias_add_integer_attrib(obj, "CompCnt", 1, IAS_KERNEL_ATTR); 551 if (self->provider.access_type == ACCESS_PEER) 552 irias_add_string_attrib(obj, "Comp#01", "PNP8389", 553 IAS_KERNEL_ATTR); 554 else 555 irias_add_string_attrib(obj, "Comp#01", "PNP8294", 556 IAS_KERNEL_ATTR); 557 558 irias_add_string_attrib(obj, "Manufacturer", 559 "Linux-IrDA Project", IAS_KERNEL_ATTR); 560 irias_insert_object(obj); 561 } 562} 563 564/* 565 * Function irlan_run_ctrl_tx_queue (self) 566 * 567 * Try to send the next command in the control transmit queue 568 * 569 */ 570int irlan_run_ctrl_tx_queue(struct irlan_cb *self) 571{ 572 struct sk_buff *skb; 573 574 if (irda_lock(&self->client.tx_busy) == FALSE) 575 return -EBUSY; 576 577 skb = skb_dequeue(&self->client.txq); 578 if (!skb) { 579 self->client.tx_busy = FALSE; 580 return 0; 581 } 582 583 /* Check that it's really possible to send commands */ 584 if ((self->client.tsap_ctrl == NULL) || 585 (self->client.state == IRLAN_IDLE)) 586 { 587 self->client.tx_busy = FALSE; 588 dev_kfree_skb(skb); 589 return -1; 590 } 591 pr_debug("%s(), sending ...\n", __func__); 592 593 return irttp_data_request(self->client.tsap_ctrl, skb); 594} 595 596/* 597 * Function irlan_ctrl_data_request (self, skb) 598 * 599 * This function makes sure that commands on the control channel is being 600 * sent in a command/response fashion 601 */ 602static void irlan_ctrl_data_request(struct irlan_cb *self, struct sk_buff *skb) 603{ 604 /* Queue command */ 605 skb_queue_tail(&self->client.txq, skb); 606 607 /* Try to send command */ 608 irlan_run_ctrl_tx_queue(self); 609} 610 611/* 612 * Function irlan_get_provider_info (self) 613 * 614 * Send Get Provider Information command to peer IrLAN layer 615 * 616 */ 617void irlan_get_provider_info(struct irlan_cb *self) 618{ 619 struct sk_buff *skb; 620 __u8 *frame; 621 622 IRDA_ASSERT(self != NULL, return;); 623 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); 624 625 skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER, 626 GFP_ATOMIC); 627 if (!skb) 628 return; 629 630 /* Reserve space for TTP, LMP, and LAP header */ 631 skb_reserve(skb, self->client.max_header_size); 632 skb_put(skb, 2); 633 634 frame = skb->data; 635 636 frame[0] = CMD_GET_PROVIDER_INFO; 637 frame[1] = 0x00; /* Zero parameters */ 638 639 irlan_ctrl_data_request(self, skb); 640} 641 642/* 643 * Function irlan_open_data_channel (self) 644 * 645 * Send an Open Data Command to provider 646 * 647 */ 648void irlan_open_data_channel(struct irlan_cb *self) 649{ 650 struct sk_buff *skb; 651 __u8 *frame; 652 653 IRDA_ASSERT(self != NULL, return;); 654 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); 655 656 skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER + 657 IRLAN_STRING_PARAMETER_LEN("MEDIA", "802.3") + 658 IRLAN_STRING_PARAMETER_LEN("ACCESS_TYPE", "DIRECT"), 659 GFP_ATOMIC); 660 if (!skb) 661 return; 662 663 skb_reserve(skb, self->client.max_header_size); 664 skb_put(skb, 2); 665 666 frame = skb->data; 667 668 /* Build frame */ 669 frame[0] = CMD_OPEN_DATA_CHANNEL; 670 frame[1] = 0x02; /* Two parameters */ 671 672 irlan_insert_string_param(skb, "MEDIA", "802.3"); 673 irlan_insert_string_param(skb, "ACCESS_TYPE", "DIRECT"); 674 /* irlan_insert_string_param(skb, "MODE", "UNRELIABLE"); */ 675 676/* self->use_udata = TRUE; */ 677 678 irlan_ctrl_data_request(self, skb); 679} 680 681void irlan_close_data_channel(struct irlan_cb *self) 682{ 683 struct sk_buff *skb; 684 __u8 *frame; 685 686 IRDA_ASSERT(self != NULL, return;); 687 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); 688 689 /* Check if the TSAP is still there */ 690 if (self->client.tsap_ctrl == NULL) 691 return; 692 693 skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER + 694 IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN"), 695 GFP_ATOMIC); 696 if (!skb) 697 return; 698 699 skb_reserve(skb, self->client.max_header_size); 700 skb_put(skb, 2); 701 702 frame = skb->data; 703 704 /* Build frame */ 705 frame[0] = CMD_CLOSE_DATA_CHAN; 706 frame[1] = 0x01; /* One parameter */ 707 708 irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data); 709 710 irlan_ctrl_data_request(self, skb); 711} 712 713/* 714 * Function irlan_open_unicast_addr (self) 715 * 716 * Make IrLAN provider accept ethernet frames addressed to the unicast 717 * address. 718 * 719 */ 720static void irlan_open_unicast_addr(struct irlan_cb *self) 721{ 722 struct sk_buff *skb; 723 __u8 *frame; 724 725 IRDA_ASSERT(self != NULL, return;); 726 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); 727 728 skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER + 729 IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") + 730 IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "DIRECTED") + 731 IRLAN_STRING_PARAMETER_LEN("FILTER_MODE", "FILTER"), 732 GFP_ATOMIC); 733 if (!skb) 734 return; 735 736 /* Reserve space for TTP, LMP, and LAP header */ 737 skb_reserve(skb, self->max_header_size); 738 skb_put(skb, 2); 739 740 frame = skb->data; 741 742 frame[0] = CMD_FILTER_OPERATION; 743 frame[1] = 0x03; /* Three parameters */ 744 irlan_insert_byte_param(skb, "DATA_CHAN" , self->dtsap_sel_data); 745 irlan_insert_string_param(skb, "FILTER_TYPE", "DIRECTED"); 746 irlan_insert_string_param(skb, "FILTER_MODE", "FILTER"); 747 748 irlan_ctrl_data_request(self, skb); 749} 750 751/* 752 * Function irlan_set_broadcast_filter (self, status) 753 * 754 * Make IrLAN provider accept ethernet frames addressed to the broadcast 755 * address. Be careful with the use of this one, since there may be a lot 756 * of broadcast traffic out there. We can still function without this 757 * one but then _we_ have to initiate all communication with other 758 * hosts, since ARP request for this host will not be answered. 759 */ 760void irlan_set_broadcast_filter(struct irlan_cb *self, int status) 761{ 762 struct sk_buff *skb; 763 __u8 *frame; 764 765 IRDA_ASSERT(self != NULL, return;); 766 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); 767 768 skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER + 769 IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") + 770 IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "BROADCAST") + 771 /* We may waste one byte here...*/ 772 IRLAN_STRING_PARAMETER_LEN("FILTER_MODE", "FILTER"), 773 GFP_ATOMIC); 774 if (!skb) 775 return; 776 777 /* Reserve space for TTP, LMP, and LAP header */ 778 skb_reserve(skb, self->client.max_header_size); 779 skb_put(skb, 2); 780 781 frame = skb->data; 782 783 frame[0] = CMD_FILTER_OPERATION; 784 frame[1] = 0x03; /* Three parameters */ 785 irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data); 786 irlan_insert_string_param(skb, "FILTER_TYPE", "BROADCAST"); 787 if (status) 788 irlan_insert_string_param(skb, "FILTER_MODE", "FILTER"); 789 else 790 irlan_insert_string_param(skb, "FILTER_MODE", "NONE"); 791 792 irlan_ctrl_data_request(self, skb); 793} 794 795/* 796 * Function irlan_set_multicast_filter (self, status) 797 * 798 * Make IrLAN provider accept ethernet frames addressed to the multicast 799 * address. 800 * 801 */ 802void irlan_set_multicast_filter(struct irlan_cb *self, int status) 803{ 804 struct sk_buff *skb; 805 __u8 *frame; 806 807 IRDA_ASSERT(self != NULL, return;); 808 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); 809 810 skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER + 811 IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") + 812 IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "MULTICAST") + 813 /* We may waste one byte here...*/ 814 IRLAN_STRING_PARAMETER_LEN("FILTER_MODE", "NONE"), 815 GFP_ATOMIC); 816 if (!skb) 817 return; 818 819 /* Reserve space for TTP, LMP, and LAP header */ 820 skb_reserve(skb, self->client.max_header_size); 821 skb_put(skb, 2); 822 823 frame = skb->data; 824 825 frame[0] = CMD_FILTER_OPERATION; 826 frame[1] = 0x03; /* Three parameters */ 827 irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data); 828 irlan_insert_string_param(skb, "FILTER_TYPE", "MULTICAST"); 829 if (status) 830 irlan_insert_string_param(skb, "FILTER_MODE", "ALL"); 831 else 832 irlan_insert_string_param(skb, "FILTER_MODE", "NONE"); 833 834 irlan_ctrl_data_request(self, skb); 835} 836 837/* 838 * Function irlan_get_unicast_addr (self) 839 * 840 * Retrieves the unicast address from the IrLAN provider. This address 841 * will be inserted into the devices structure, so the ethernet layer 842 * can construct its packets. 843 * 844 */ 845static void irlan_get_unicast_addr(struct irlan_cb *self) 846{ 847 struct sk_buff *skb; 848 __u8 *frame; 849 850 IRDA_ASSERT(self != NULL, return;); 851 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); 852 853 skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER + 854 IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") + 855 IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "DIRECTED") + 856 IRLAN_STRING_PARAMETER_LEN("FILTER_OPERATION", 857 "DYNAMIC"), 858 GFP_ATOMIC); 859 if (!skb) 860 return; 861 862 /* Reserve space for TTP, LMP, and LAP header */ 863 skb_reserve(skb, self->client.max_header_size); 864 skb_put(skb, 2); 865 866 frame = skb->data; 867 868 frame[0] = CMD_FILTER_OPERATION; 869 frame[1] = 0x03; /* Three parameters */ 870 irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data); 871 irlan_insert_string_param(skb, "FILTER_TYPE", "DIRECTED"); 872 irlan_insert_string_param(skb, "FILTER_OPERATION", "DYNAMIC"); 873 874 irlan_ctrl_data_request(self, skb); 875} 876 877/* 878 * Function irlan_get_media_char (self) 879 * 880 * 881 * 882 */ 883void irlan_get_media_char(struct irlan_cb *self) 884{ 885 struct sk_buff *skb; 886 __u8 *frame; 887 888 IRDA_ASSERT(self != NULL, return;); 889 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); 890 891 skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER + 892 IRLAN_STRING_PARAMETER_LEN("MEDIA", "802.3"), 893 GFP_ATOMIC); 894 895 if (!skb) 896 return; 897 898 /* Reserve space for TTP, LMP, and LAP header */ 899 skb_reserve(skb, self->client.max_header_size); 900 skb_put(skb, 2); 901 902 frame = skb->data; 903 904 /* Build frame */ 905 frame[0] = CMD_GET_MEDIA_CHAR; 906 frame[1] = 0x01; /* One parameter */ 907 908 irlan_insert_string_param(skb, "MEDIA", "802.3"); 909 irlan_ctrl_data_request(self, skb); 910} 911 912/* 913 * Function insert_byte_param (skb, param, value) 914 * 915 * Insert byte parameter into frame 916 * 917 */ 918int irlan_insert_byte_param(struct sk_buff *skb, char *param, __u8 value) 919{ 920 return __irlan_insert_param(skb, param, IRLAN_BYTE, value, 0, NULL, 0); 921} 922 923int irlan_insert_short_param(struct sk_buff *skb, char *param, __u16 value) 924{ 925 return __irlan_insert_param(skb, param, IRLAN_SHORT, 0, value, NULL, 0); 926} 927 928/* 929 * Function insert_string (skb, param, value) 930 * 931 * Insert string parameter into frame 932 * 933 */ 934int irlan_insert_string_param(struct sk_buff *skb, char *param, char *string) 935{ 936 int string_len = strlen(string); 937 938 return __irlan_insert_param(skb, param, IRLAN_ARRAY, 0, 0, string, 939 string_len); 940} 941 942/* 943 * Function insert_array_param(skb, param, value, len_value) 944 * 945 * Insert array parameter into frame 946 * 947 */ 948int irlan_insert_array_param(struct sk_buff *skb, char *name, __u8 *array, 949 __u16 array_len) 950{ 951 return __irlan_insert_param(skb, name, IRLAN_ARRAY, 0, 0, array, 952 array_len); 953} 954 955/* 956 * Function insert_param (skb, param, value, byte) 957 * 958 * Insert parameter at end of buffer, structure of a parameter is: 959 * 960 * ----------------------------------------------------------------------- 961 * | Name Length[1] | Param Name[1..255] | Val Length[2] | Value[0..1016]| 962 * ----------------------------------------------------------------------- 963 */ 964static int __irlan_insert_param(struct sk_buff *skb, char *param, int type, 965 __u8 value_byte, __u16 value_short, 966 __u8 *value_array, __u16 value_len) 967{ 968 __u8 *frame; 969 __u8 param_len; 970 __le16 tmp_le; /* Temporary value in little endian format */ 971 int n=0; 972 973 if (skb == NULL) { 974 pr_debug("%s(), Got NULL skb\n", __func__); 975 return 0; 976 } 977 978 param_len = strlen(param); 979 switch (type) { 980 case IRLAN_BYTE: 981 value_len = 1; 982 break; 983 case IRLAN_SHORT: 984 value_len = 2; 985 break; 986 case IRLAN_ARRAY: 987 IRDA_ASSERT(value_array != NULL, return 0;); 988 IRDA_ASSERT(value_len > 0, return 0;); 989 break; 990 default: 991 pr_debug("%s(), Unknown parameter type!\n", __func__); 992 return 0; 993 } 994 995 /* Insert at end of sk-buffer */ 996 frame = skb_tail_pointer(skb); 997 998 /* Make space for data */ 999 if (skb_tailroom(skb) < (param_len+value_len+3)) { 1000 pr_debug("%s(), No more space at end of skb\n", __func__); 1001 return 0; 1002 } 1003 skb_put(skb, param_len+value_len+3); 1004 1005 /* Insert parameter length */ 1006 frame[n++] = param_len; 1007 1008 /* Insert parameter */ 1009 memcpy(frame+n, param, param_len); n += param_len; 1010 1011 /* Insert value length (2 byte little endian format, LSB first) */ 1012 tmp_le = cpu_to_le16(value_len); 1013 memcpy(frame+n, &tmp_le, 2); n += 2; /* To avoid alignment problems */ 1014 1015 /* Insert value */ 1016 switch (type) { 1017 case IRLAN_BYTE: 1018 frame[n++] = value_byte; 1019 break; 1020 case IRLAN_SHORT: 1021 tmp_le = cpu_to_le16(value_short); 1022 memcpy(frame+n, &tmp_le, 2); n += 2; 1023 break; 1024 case IRLAN_ARRAY: 1025 memcpy(frame+n, value_array, value_len); n+=value_len; 1026 break; 1027 default: 1028 break; 1029 } 1030 IRDA_ASSERT(n == (param_len+value_len+3), return 0;); 1031 1032 return param_len+value_len+3; 1033} 1034 1035/* 1036 * Function irlan_extract_param (buf, name, value, len) 1037 * 1038 * Extracts a single parameter name/value pair from buffer and updates 1039 * the buffer pointer to point to the next name/value pair. 1040 */ 1041int irlan_extract_param(__u8 *buf, char *name, char *value, __u16 *len) 1042{ 1043 __u8 name_len; 1044 __u16 val_len; 1045 int n=0; 1046 1047 /* get length of parameter name (1 byte) */ 1048 name_len = buf[n++]; 1049 1050 if (name_len > 254) { 1051 pr_debug("%s(), name_len > 254\n", __func__); 1052 return -RSP_INVALID_COMMAND_FORMAT; 1053 } 1054 1055 /* get parameter name */ 1056 memcpy(name, buf+n, name_len); 1057 name[name_len] = '\0'; 1058 n+=name_len; 1059 1060 /* 1061 * Get length of parameter value (2 bytes in little endian 1062 * format) 1063 */ 1064 memcpy(&val_len, buf+n, 2); /* To avoid alignment problems */ 1065 le16_to_cpus(&val_len); n+=2; 1066 1067 if (val_len >= 1016) { 1068 pr_debug("%s(), parameter length to long\n", __func__); 1069 return -RSP_INVALID_COMMAND_FORMAT; 1070 } 1071 *len = val_len; 1072 1073 /* get parameter value */ 1074 memcpy(value, buf+n, val_len); 1075 value[val_len] = '\0'; 1076 n+=val_len; 1077 1078 pr_debug("Parameter: %s ", name); 1079 pr_debug("Value: %s\n", value); 1080 1081 return n; 1082} 1083 1084#ifdef CONFIG_PROC_FS 1085 1086/* 1087 * Start of reading /proc entries. 1088 * Return entry at pos, 1089 * or start_token to indicate print header line 1090 * or NULL if end of file 1091 */ 1092static void *irlan_seq_start(struct seq_file *seq, loff_t *pos) 1093{ 1094 rcu_read_lock(); 1095 return seq_list_start_head(&irlans, *pos); 1096} 1097 1098/* Return entry after v, and increment pos */ 1099static void *irlan_seq_next(struct seq_file *seq, void *v, loff_t *pos) 1100{ 1101 return seq_list_next(v, &irlans, pos); 1102} 1103 1104/* End of reading /proc file */ 1105static void irlan_seq_stop(struct seq_file *seq, void *v) 1106{ 1107 rcu_read_unlock(); 1108} 1109 1110 1111/* 1112 * Show one entry in /proc file. 1113 */ 1114static int irlan_seq_show(struct seq_file *seq, void *v) 1115{ 1116 if (v == &irlans) 1117 seq_puts(seq, "IrLAN instances:\n"); 1118 else { 1119 struct irlan_cb *self = list_entry(v, struct irlan_cb, dev_list); 1120 1121 IRDA_ASSERT(self != NULL, return -1;); 1122 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;); 1123 1124 seq_printf(seq,"ifname: %s,\n", 1125 self->dev->name); 1126 seq_printf(seq,"client state: %s, ", 1127 irlan_state[ self->client.state]); 1128 seq_printf(seq,"provider state: %s,\n", 1129 irlan_state[ self->provider.state]); 1130 seq_printf(seq,"saddr: %#08x, ", 1131 self->saddr); 1132 seq_printf(seq,"daddr: %#08x\n", 1133 self->daddr); 1134 seq_printf(seq,"version: %d.%d,\n", 1135 self->version[1], self->version[0]); 1136 seq_printf(seq,"access type: %s\n", 1137 irlan_access[self->client.access_type]); 1138 seq_printf(seq,"media: %s\n", 1139 irlan_media[self->media]); 1140 1141 seq_printf(seq,"local filter:\n"); 1142 seq_printf(seq,"remote filter: "); 1143 irlan_print_filter(seq, self->client.filter_type); 1144 seq_printf(seq,"tx busy: %s\n", 1145 netif_queue_stopped(self->dev) ? "TRUE" : "FALSE"); 1146 1147 seq_putc(seq,'\n'); 1148 } 1149 return 0; 1150} 1151 1152static const struct seq_operations irlan_seq_ops = { 1153 .start = irlan_seq_start, 1154 .next = irlan_seq_next, 1155 .stop = irlan_seq_stop, 1156 .show = irlan_seq_show, 1157}; 1158 1159static int irlan_seq_open(struct inode *inode, struct file *file) 1160{ 1161 return seq_open(file, &irlan_seq_ops); 1162} 1163#endif 1164 1165MODULE_AUTHOR("Dag Brattli <dagb@cs.uit.no>"); 1166MODULE_DESCRIPTION("The Linux IrDA LAN protocol"); 1167MODULE_LICENSE("GPL"); 1168 1169module_param(eth, bool, 0); 1170MODULE_PARM_DESC(eth, "Name devices ethX (0) or irlanX (1)"); 1171module_param(access, int, 0); 1172MODULE_PARM_DESC(access, "Access type DIRECT=1, PEER=2, HOSTED=3"); 1173 1174module_init(irlan_init); 1175module_exit(irlan_cleanup); 1176 1177