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