projects / deliverable / linux.git / blob
? search:


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