1 /*********************************************************************
3 * Filename: irlan_common.c
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>
12 * Copyright (c) 1997, 1999 Dag Brattli <dagb@cs.uit.no>,
13 * All Rights Reserved.
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.
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.
24 ********************************************************************/
26 #include <linux/module.h>
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>
41 #include <asm/system.h>
42 #include <asm/byteorder.h>
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>
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>
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.
62 #undef CONFIG_IRLAN_SEND_GRATUITOUS_ARP
64 /* extern char sysctl_devname[]; */
69 static LIST_HEAD(irlans
);
74 /* Module parameters */
75 static int eth
; /* Use "eth" or "irlan" name for devices */
76 static int access
= ACCESS_PEER
; /* PEER, DIRECT or HOSTED */
79 static const char *irlan_access
[] = {
86 static const char *irlan_media
[] = {
92 extern struct proc_dir_entry
*proc_irda
;
94 static int irlan_seq_open(struct inode
*inode
, struct file
*file
);
96 static const struct file_operations irlan_fops
= {
98 .open
= irlan_seq_open
,
101 .release
= seq_release
,
104 extern struct proc_dir_entry
*proc_irda
;
105 #endif /* CONFIG_PROC_FS */
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
);
117 * Function irlan_init (void)
119 * Initialize IrLAN layer
122 static int __init
irlan_init(void)
124 struct irlan_cb
*new;
127 IRDA_DEBUG(2, "%s()\n", __func__
);
129 #ifdef CONFIG_PROC_FS
130 { struct proc_dir_entry
*proc
;
131 proc
= proc_create("irlan", 0, proc_irda
, &irlan_fops
);
133 printk(KERN_ERR
"irlan_init: can't create /proc entry!\n");
137 #endif /* CONFIG_PROC_FS */
139 IRDA_DEBUG(4, "%s()\n", __func__
);
140 hints
= irlmp_service_to_hint(S_LAN
);
142 /* Register with IrLMP as a client */
143 ckey
= irlmp_register_client(hints
, &irlan_client_discovery_indication
,
148 /* Register with IrLMP as a service */
149 skey
= irlmp_register_service(hints
);
153 /* Start the master IrLAN instance (the only one for now) */
154 new = irlan_open(DEV_ADDR_ANY
, DEV_ADDR_ANY
);
158 /* The master will only open its (listen) control TSAP */
159 irlan_provider_open_ctrl_tsap(new);
161 /* Do some fast discovery! */
162 irlmp_discovery_request(DISCOVERY_DEFAULT_SLOTS
);
167 irlmp_unregister_service(skey
);
169 irlmp_unregister_client(ckey
);
171 #ifdef CONFIG_PROC_FS
172 remove_proc_entry("irlan", proc_irda
);
173 #endif /* CONFIG_PROC_FS */
178 static void __exit
irlan_cleanup(void)
180 struct irlan_cb
*self
, *next
;
182 IRDA_DEBUG(4, "%s()\n", __func__
);
184 irlmp_unregister_client(ckey
);
185 irlmp_unregister_service(skey
);
187 #ifdef CONFIG_PROC_FS
188 remove_proc_entry("irlan", proc_irda
);
189 #endif /* CONFIG_PROC_FS */
191 /* Cleanup any leftover network devices */
193 list_for_each_entry_safe(self
, next
, &irlans
, dev_list
) {
200 * Function irlan_open (void)
202 * Open new instance of a client/provider, we should only register the
203 * network device if this instance is ment for a particular client/provider
205 static struct irlan_cb
*irlan_open(__u32 saddr
, __u32 daddr
)
207 struct net_device
*dev
;
208 struct irlan_cb
*self
;
210 IRDA_DEBUG(2, "%s()\n", __func__
);
212 /* Create network device with irlan */
213 dev
= alloc_irlandev(eth
? "eth%d" : "irlan%d");
221 * Initialize local device structure
223 self
->magic
= IRLAN_MAGIC
;
227 /* Provider access can only be PEER, DIRECT, or HOSTED */
228 self
->provider
.access_type
= access
;
229 if (access
== ACCESS_DIRECT
) {
231 * Since we are emulating an IrLAN sever we will have to
232 * give ourself an ethernet address!
234 dev
->dev_addr
[0] = 0x40;
235 dev
->dev_addr
[1] = 0x00;
236 dev
->dev_addr
[2] = 0x00;
237 dev
->dev_addr
[3] = 0x00;
238 get_random_bytes(dev
->dev_addr
+4, 1);
239 get_random_bytes(dev
->dev_addr
+5, 1);
242 self
->media
= MEDIA_802_3
;
243 self
->disconnect_reason
= LM_USER_REQUEST
;
244 init_timer(&self
->watchdog_timer
);
245 init_timer(&self
->client
.kick_timer
);
246 init_waitqueue_head(&self
->open_wait
);
248 skb_queue_head_init(&self
->client
.txq
);
250 irlan_next_client_state(self
, IRLAN_IDLE
);
251 irlan_next_provider_state(self
, IRLAN_IDLE
);
253 if (register_netdev(dev
)) {
254 IRDA_DEBUG(2, "%s(), register_netdev() failed!\n",
260 list_add_rcu(&self
->dev_list
, &irlans
);
267 * Function __irlan_close (self)
269 * This function closes and deallocates the IrLAN client instances. Be
270 * aware that other functions which calls client_close() must
271 * remove self from irlans list first.
273 static void __irlan_close(struct irlan_cb
*self
)
275 IRDA_DEBUG(2, "%s()\n", __func__
);
278 IRDA_ASSERT(self
!= NULL
, return;);
279 IRDA_ASSERT(self
->magic
== IRLAN_MAGIC
, return;);
281 del_timer_sync(&self
->watchdog_timer
);
282 del_timer_sync(&self
->client
.kick_timer
);
284 /* Close all open connections and remove TSAPs */
285 irlan_close_tsaps(self
);
287 if (self
->client
.iriap
)
288 iriap_close(self
->client
.iriap
);
290 /* Remove frames queued on the control channel */
291 skb_queue_purge(&self
->client
.txq
);
293 /* Unregister and free self via destructor */
294 unregister_netdevice(self
->dev
);
297 /* Find any instance of irlan, used for client discovery wakeup */
298 struct irlan_cb
*irlan_get_any(void)
300 struct irlan_cb
*self
;
302 list_for_each_entry_rcu(self
, &irlans
, dev_list
) {
309 * Function irlan_connect_indication (instance, sap, qos, max_sdu_size, skb)
311 * Here we receive the connect indication for the data channel
314 static void irlan_connect_indication(void *instance
, void *sap
,
315 struct qos_info
*qos
,
317 __u8 max_header_size
,
320 struct irlan_cb
*self
;
321 struct tsap_cb
*tsap
;
323 IRDA_DEBUG(2, "%s()\n", __func__
);
325 self
= (struct irlan_cb
*) instance
;
326 tsap
= (struct tsap_cb
*) sap
;
328 IRDA_ASSERT(self
!= NULL
, return;);
329 IRDA_ASSERT(self
->magic
== IRLAN_MAGIC
, return;);
330 IRDA_ASSERT(tsap
== self
->tsap_data
,return;);
332 self
->max_sdu_size
= max_sdu_size
;
333 self
->max_header_size
= max_header_size
;
335 IRDA_DEBUG(0, "%s: We are now connected!\n", __func__
);
337 del_timer(&self
->watchdog_timer
);
339 /* If you want to pass the skb to *both* state machines, you will
340 * need to skb_clone() it, so that you don't free it twice.
341 * As the state machines don't need it, git rid of it here...
346 irlan_do_provider_event(self
, IRLAN_DATA_CONNECT_INDICATION
, NULL
);
347 irlan_do_client_event(self
, IRLAN_DATA_CONNECT_INDICATION
, NULL
);
349 if (self
->provider
.access_type
== ACCESS_PEER
) {
351 * Data channel is open, so we are now allowed to
352 * configure the remote filter
354 irlan_get_unicast_addr(self
);
355 irlan_open_unicast_addr(self
);
357 /* Ready to transfer Ethernet frames (at last) */
358 netif_start_queue(self
->dev
); /* Clear reason */
361 static void irlan_connect_confirm(void *instance
, void *sap
,
362 struct qos_info
*qos
,
364 __u8 max_header_size
,
367 struct irlan_cb
*self
;
369 self
= (struct irlan_cb
*) instance
;
371 IRDA_ASSERT(self
!= NULL
, return;);
372 IRDA_ASSERT(self
->magic
== IRLAN_MAGIC
, return;);
374 self
->max_sdu_size
= max_sdu_size
;
375 self
->max_header_size
= max_header_size
;
377 /* TODO: we could set the MTU depending on the max_sdu_size */
379 IRDA_DEBUG(0, "%s: We are now connected!\n", __func__
);
380 del_timer(&self
->watchdog_timer
);
383 * Data channel is open, so we are now allowed to configure the remote
386 irlan_get_unicast_addr(self
);
387 irlan_open_unicast_addr(self
);
389 /* Open broadcast and multicast filter by default */
390 irlan_set_broadcast_filter(self
, TRUE
);
391 irlan_set_multicast_filter(self
, TRUE
);
393 /* Ready to transfer Ethernet frames */
394 netif_start_queue(self
->dev
);
395 self
->disconnect_reason
= 0; /* Clear reason */
396 #ifdef CONFIG_IRLAN_SEND_GRATUITOUS_ARP
397 irlan_eth_send_gratuitous_arp(&self
->dev
);
399 wake_up_interruptible(&self
->open_wait
);
403 * Function irlan_client_disconnect_indication (handle)
405 * Callback function for the IrTTP layer. Indicates a disconnection of
406 * the specified connection (handle)
408 static void irlan_disconnect_indication(void *instance
,
409 void *sap
, LM_REASON reason
,
410 struct sk_buff
*userdata
)
412 struct irlan_cb
*self
;
413 struct tsap_cb
*tsap
;
415 IRDA_DEBUG(0, "%s(), reason=%d\n", __func__
, reason
);
417 self
= (struct irlan_cb
*) instance
;
418 tsap
= (struct tsap_cb
*) sap
;
420 IRDA_ASSERT(self
!= NULL
, return;);
421 IRDA_ASSERT(self
->magic
== IRLAN_MAGIC
, return;);
422 IRDA_ASSERT(tsap
!= NULL
, return;);
423 IRDA_ASSERT(tsap
->magic
== TTP_TSAP_MAGIC
, return;);
425 IRDA_ASSERT(tsap
== self
->tsap_data
, return;);
427 IRDA_DEBUG(2, "IrLAN, data channel disconnected by peer!\n");
429 /* Save reason so we know if we should try to reconnect or not */
430 self
->disconnect_reason
= reason
;
433 case LM_USER_REQUEST
: /* User request */
434 IRDA_DEBUG(2, "%s(), User requested\n", __func__
);
436 case LM_LAP_DISCONNECT
: /* Unexpected IrLAP disconnect */
437 IRDA_DEBUG(2, "%s(), Unexpected IrLAP disconnect\n", __func__
);
439 case LM_CONNECT_FAILURE
: /* Failed to establish IrLAP connection */
440 IRDA_DEBUG(2, "%s(), IrLAP connect failed\n", __func__
);
442 case LM_LAP_RESET
: /* IrLAP reset */
443 IRDA_DEBUG(2, "%s(), IrLAP reset\n", __func__
);
445 case LM_INIT_DISCONNECT
:
446 IRDA_DEBUG(2, "%s(), IrLMP connect failed\n", __func__
);
449 IRDA_ERROR("%s(), Unknown disconnect reason\n", __func__
);
453 /* If you want to pass the skb to *both* state machines, you will
454 * need to skb_clone() it, so that you don't free it twice.
455 * As the state machines don't need it, git rid of it here...
458 dev_kfree_skb(userdata
);
460 irlan_do_client_event(self
, IRLAN_LMP_DISCONNECT
, NULL
);
461 irlan_do_provider_event(self
, IRLAN_LMP_DISCONNECT
, NULL
);
463 wake_up_interruptible(&self
->open_wait
);
466 void irlan_open_data_tsap(struct irlan_cb
*self
)
468 struct tsap_cb
*tsap
;
471 IRDA_DEBUG(2, "%s()\n", __func__
);
473 IRDA_ASSERT(self
!= NULL
, return;);
474 IRDA_ASSERT(self
->magic
== IRLAN_MAGIC
, return;);
476 /* Check if already open */
480 irda_notify_init(¬ify
);
482 notify
.data_indication
= irlan_eth_receive
;
483 notify
.udata_indication
= irlan_eth_receive
;
484 notify
.connect_indication
= irlan_connect_indication
;
485 notify
.connect_confirm
= irlan_connect_confirm
;
486 notify
.flow_indication
= irlan_eth_flow_indication
;
487 notify
.disconnect_indication
= irlan_disconnect_indication
;
488 notify
.instance
= self
;
489 strlcpy(notify
.name
, "IrLAN data", sizeof(notify
.name
));
491 tsap
= irttp_open_tsap(LSAP_ANY
, DEFAULT_INITIAL_CREDIT
, ¬ify
);
493 IRDA_DEBUG(2, "%s(), Got no tsap!\n", __func__
);
496 self
->tsap_data
= tsap
;
499 * This is the data TSAP selector which we will pass to the client
500 * when the client ask for it.
502 self
->stsap_sel_data
= self
->tsap_data
->stsap_sel
;
505 void irlan_close_tsaps(struct irlan_cb
*self
)
507 IRDA_DEBUG(4, "%s()\n", __func__
);
509 IRDA_ASSERT(self
!= NULL
, return;);
510 IRDA_ASSERT(self
->magic
== IRLAN_MAGIC
, return;);
512 /* Disconnect and close all open TSAP connections */
513 if (self
->tsap_data
) {
514 irttp_disconnect_request(self
->tsap_data
, NULL
, P_NORMAL
);
515 irttp_close_tsap(self
->tsap_data
);
516 self
->tsap_data
= NULL
;
518 if (self
->client
.tsap_ctrl
) {
519 irttp_disconnect_request(self
->client
.tsap_ctrl
, NULL
,
521 irttp_close_tsap(self
->client
.tsap_ctrl
);
522 self
->client
.tsap_ctrl
= NULL
;
524 if (self
->provider
.tsap_ctrl
) {
525 irttp_disconnect_request(self
->provider
.tsap_ctrl
, NULL
,
527 irttp_close_tsap(self
->provider
.tsap_ctrl
);
528 self
->provider
.tsap_ctrl
= NULL
;
530 self
->disconnect_reason
= LM_USER_REQUEST
;
534 * Function irlan_ias_register (self, tsap_sel)
536 * Register with LM-IAS
539 void irlan_ias_register(struct irlan_cb
*self
, __u8 tsap_sel
)
541 struct ias_object
*obj
;
542 struct ias_value
*new_value
;
544 IRDA_ASSERT(self
!= NULL
, return;);
545 IRDA_ASSERT(self
->magic
== IRLAN_MAGIC
, return;);
548 * Check if object has already been registered by a previous provider.
549 * If that is the case, we just change the value of the attribute
551 if (!irias_find_object("IrLAN")) {
552 obj
= irias_new_object("IrLAN", IAS_IRLAN_ID
);
553 irias_add_integer_attrib(obj
, "IrDA:TinyTP:LsapSel", tsap_sel
,
555 irias_insert_object(obj
);
557 new_value
= irias_new_integer_value(tsap_sel
);
558 irias_object_change_attribute("IrLAN", "IrDA:TinyTP:LsapSel",
562 /* Register PnP object only if not registered before */
563 if (!irias_find_object("PnP")) {
564 obj
= irias_new_object("PnP", IAS_PNP_ID
);
566 irias_add_string_attrib(obj
, "Name", sysctl_devname
,
569 irias_add_string_attrib(obj
, "Name", "Linux", IAS_KERNEL_ATTR
);
571 irias_add_string_attrib(obj
, "DeviceID", "HWP19F0",
573 irias_add_integer_attrib(obj
, "CompCnt", 1, IAS_KERNEL_ATTR
);
574 if (self
->provider
.access_type
== ACCESS_PEER
)
575 irias_add_string_attrib(obj
, "Comp#01", "PNP8389",
578 irias_add_string_attrib(obj
, "Comp#01", "PNP8294",
581 irias_add_string_attrib(obj
, "Manufacturer",
582 "Linux-IrDA Project", IAS_KERNEL_ATTR
);
583 irias_insert_object(obj
);
588 * Function irlan_run_ctrl_tx_queue (self)
590 * Try to send the next command in the control transmit queue
593 int irlan_run_ctrl_tx_queue(struct irlan_cb
*self
)
597 IRDA_DEBUG(2, "%s()\n", __func__
);
599 if (irda_lock(&self
->client
.tx_busy
) == FALSE
)
602 skb
= skb_dequeue(&self
->client
.txq
);
604 self
->client
.tx_busy
= FALSE
;
608 /* Check that it's really possible to send commands */
609 if ((self
->client
.tsap_ctrl
== NULL
) ||
610 (self
->client
.state
== IRLAN_IDLE
))
612 self
->client
.tx_busy
= FALSE
;
616 IRDA_DEBUG(2, "%s(), sending ...\n", __func__
);
618 return irttp_data_request(self
->client
.tsap_ctrl
, skb
);
622 * Function irlan_ctrl_data_request (self, skb)
624 * This function makes sure that commands on the control channel is being
625 * sent in a command/response fashion
627 static void irlan_ctrl_data_request(struct irlan_cb
*self
, struct sk_buff
*skb
)
629 IRDA_DEBUG(2, "%s()\n", __func__
);
632 skb_queue_tail(&self
->client
.txq
, skb
);
634 /* Try to send command */
635 irlan_run_ctrl_tx_queue(self
);
639 * Function irlan_get_provider_info (self)
641 * Send Get Provider Information command to peer IrLAN layer
644 void irlan_get_provider_info(struct irlan_cb
*self
)
649 IRDA_DEBUG(4, "%s()\n", __func__
);
651 IRDA_ASSERT(self
!= NULL
, return;);
652 IRDA_ASSERT(self
->magic
== IRLAN_MAGIC
, return;);
654 skb
= alloc_skb(IRLAN_MAX_HEADER
+ IRLAN_CMD_HEADER
,
659 /* Reserve space for TTP, LMP, and LAP header */
660 skb_reserve(skb
, self
->client
.max_header_size
);
665 frame
[0] = CMD_GET_PROVIDER_INFO
;
666 frame
[1] = 0x00; /* Zero parameters */
668 irlan_ctrl_data_request(self
, skb
);
672 * Function irlan_open_data_channel (self)
674 * Send an Open Data Command to provider
677 void irlan_open_data_channel(struct irlan_cb
*self
)
682 IRDA_DEBUG(4, "%s()\n", __func__
);
684 IRDA_ASSERT(self
!= NULL
, return;);
685 IRDA_ASSERT(self
->magic
== IRLAN_MAGIC
, return;);
687 skb
= alloc_skb(IRLAN_MAX_HEADER
+ IRLAN_CMD_HEADER
+
688 IRLAN_STRING_PARAMETER_LEN("MEDIA", "802.3") +
689 IRLAN_STRING_PARAMETER_LEN("ACCESS_TYPE", "DIRECT"),
694 skb_reserve(skb
, self
->client
.max_header_size
);
700 frame
[0] = CMD_OPEN_DATA_CHANNEL
;
701 frame
[1] = 0x02; /* Two parameters */
703 irlan_insert_string_param(skb
, "MEDIA", "802.3");
704 irlan_insert_string_param(skb
, "ACCESS_TYPE", "DIRECT");
705 /* irlan_insert_string_param(skb, "MODE", "UNRELIABLE"); */
707 /* self->use_udata = TRUE; */
709 irlan_ctrl_data_request(self
, skb
);
712 void irlan_close_data_channel(struct irlan_cb
*self
)
717 IRDA_DEBUG(4, "%s()\n", __func__
);
719 IRDA_ASSERT(self
!= NULL
, return;);
720 IRDA_ASSERT(self
->magic
== IRLAN_MAGIC
, return;);
722 /* Check if the TSAP is still there */
723 if (self
->client
.tsap_ctrl
== NULL
)
726 skb
= alloc_skb(IRLAN_MAX_HEADER
+ IRLAN_CMD_HEADER
+
727 IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN"),
732 skb_reserve(skb
, self
->client
.max_header_size
);
738 frame
[0] = CMD_CLOSE_DATA_CHAN
;
739 frame
[1] = 0x01; /* One parameter */
741 irlan_insert_byte_param(skb
, "DATA_CHAN", self
->dtsap_sel_data
);
743 irlan_ctrl_data_request(self
, skb
);
747 * Function irlan_open_unicast_addr (self)
749 * Make IrLAN provider accept ethernet frames addressed to the unicast
753 static void irlan_open_unicast_addr(struct irlan_cb
*self
)
758 IRDA_DEBUG(4, "%s()\n", __func__
);
760 IRDA_ASSERT(self
!= NULL
, return;);
761 IRDA_ASSERT(self
->magic
== IRLAN_MAGIC
, return;);
763 skb
= alloc_skb(IRLAN_MAX_HEADER
+ IRLAN_CMD_HEADER
+
764 IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") +
765 IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "DIRECTED") +
766 IRLAN_STRING_PARAMETER_LEN("FILTER_MODE", "FILTER"),
771 /* Reserve space for TTP, LMP, and LAP header */
772 skb_reserve(skb
, self
->max_header_size
);
777 frame
[0] = CMD_FILTER_OPERATION
;
778 frame
[1] = 0x03; /* Three parameters */
779 irlan_insert_byte_param(skb
, "DATA_CHAN" , self
->dtsap_sel_data
);
780 irlan_insert_string_param(skb
, "FILTER_TYPE", "DIRECTED");
781 irlan_insert_string_param(skb
, "FILTER_MODE", "FILTER");
783 irlan_ctrl_data_request(self
, skb
);
787 * Function irlan_set_broadcast_filter (self, status)
789 * Make IrLAN provider accept ethernet frames addressed to the broadcast
790 * address. Be careful with the use of this one, since there may be a lot
791 * of broadcast traffic out there. We can still function without this
792 * one but then _we_ have to initiate all communication with other
793 * hosts, since ARP request for this host will not be answered.
795 void irlan_set_broadcast_filter(struct irlan_cb
*self
, int status
)
800 IRDA_DEBUG(2, "%s()\n", __func__
);
802 IRDA_ASSERT(self
!= NULL
, return;);
803 IRDA_ASSERT(self
->magic
== IRLAN_MAGIC
, return;);
805 skb
= alloc_skb(IRLAN_MAX_HEADER
+ IRLAN_CMD_HEADER
+
806 IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") +
807 IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "BROADCAST") +
808 /* We may waste one byte here...*/
809 IRLAN_STRING_PARAMETER_LEN("FILTER_MODE", "FILTER"),
814 /* Reserve space for TTP, LMP, and LAP header */
815 skb_reserve(skb
, self
->client
.max_header_size
);
820 frame
[0] = CMD_FILTER_OPERATION
;
821 frame
[1] = 0x03; /* Three parameters */
822 irlan_insert_byte_param(skb
, "DATA_CHAN", self
->dtsap_sel_data
);
823 irlan_insert_string_param(skb
, "FILTER_TYPE", "BROADCAST");
825 irlan_insert_string_param(skb
, "FILTER_MODE", "FILTER");
827 irlan_insert_string_param(skb
, "FILTER_MODE", "NONE");
829 irlan_ctrl_data_request(self
, skb
);
833 * Function irlan_set_multicast_filter (self, status)
835 * Make IrLAN provider accept ethernet frames addressed to the multicast
839 void irlan_set_multicast_filter(struct irlan_cb
*self
, int status
)
844 IRDA_DEBUG(2, "%s()\n", __func__
);
846 IRDA_ASSERT(self
!= NULL
, return;);
847 IRDA_ASSERT(self
->magic
== IRLAN_MAGIC
, return;);
849 skb
= alloc_skb(IRLAN_MAX_HEADER
+ IRLAN_CMD_HEADER
+
850 IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") +
851 IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "MULTICAST") +
852 /* We may waste one byte here...*/
853 IRLAN_STRING_PARAMETER_LEN("FILTER_MODE", "NONE"),
858 /* Reserve space for TTP, LMP, and LAP header */
859 skb_reserve(skb
, self
->client
.max_header_size
);
864 frame
[0] = CMD_FILTER_OPERATION
;
865 frame
[1] = 0x03; /* Three parameters */
866 irlan_insert_byte_param(skb
, "DATA_CHAN", self
->dtsap_sel_data
);
867 irlan_insert_string_param(skb
, "FILTER_TYPE", "MULTICAST");
869 irlan_insert_string_param(skb
, "FILTER_MODE", "ALL");
871 irlan_insert_string_param(skb
, "FILTER_MODE", "NONE");
873 irlan_ctrl_data_request(self
, skb
);
877 * Function irlan_get_unicast_addr (self)
879 * Retrieves the unicast address from the IrLAN provider. This address
880 * will be inserted into the devices structure, so the ethernet layer
881 * can construct its packets.
884 static void irlan_get_unicast_addr(struct irlan_cb
*self
)
889 IRDA_DEBUG(2, "%s()\n", __func__
);
891 IRDA_ASSERT(self
!= NULL
, return;);
892 IRDA_ASSERT(self
->magic
== IRLAN_MAGIC
, return;);
894 skb
= alloc_skb(IRLAN_MAX_HEADER
+ IRLAN_CMD_HEADER
+
895 IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") +
896 IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "DIRECTED") +
897 IRLAN_STRING_PARAMETER_LEN("FILTER_OPERATION",
903 /* Reserve space for TTP, LMP, and LAP header */
904 skb_reserve(skb
, self
->client
.max_header_size
);
909 frame
[0] = CMD_FILTER_OPERATION
;
910 frame
[1] = 0x03; /* Three parameters */
911 irlan_insert_byte_param(skb
, "DATA_CHAN", self
->dtsap_sel_data
);
912 irlan_insert_string_param(skb
, "FILTER_TYPE", "DIRECTED");
913 irlan_insert_string_param(skb
, "FILTER_OPERATION", "DYNAMIC");
915 irlan_ctrl_data_request(self
, skb
);
919 * Function irlan_get_media_char (self)
924 void irlan_get_media_char(struct irlan_cb
*self
)
929 IRDA_DEBUG(4, "%s()\n", __func__
);
931 IRDA_ASSERT(self
!= NULL
, return;);
932 IRDA_ASSERT(self
->magic
== IRLAN_MAGIC
, return;);
934 skb
= alloc_skb(IRLAN_MAX_HEADER
+ IRLAN_CMD_HEADER
+
935 IRLAN_STRING_PARAMETER_LEN("MEDIA", "802.3"),
941 /* Reserve space for TTP, LMP, and LAP header */
942 skb_reserve(skb
, self
->client
.max_header_size
);
948 frame
[0] = CMD_GET_MEDIA_CHAR
;
949 frame
[1] = 0x01; /* One parameter */
951 irlan_insert_string_param(skb
, "MEDIA", "802.3");
952 irlan_ctrl_data_request(self
, skb
);
956 * Function insert_byte_param (skb, param, value)
958 * Insert byte parameter into frame
961 int irlan_insert_byte_param(struct sk_buff
*skb
, char *param
, __u8 value
)
963 return __irlan_insert_param(skb
, param
, IRLAN_BYTE
, value
, 0, NULL
, 0);
966 int irlan_insert_short_param(struct sk_buff
*skb
, char *param
, __u16 value
)
968 return __irlan_insert_param(skb
, param
, IRLAN_SHORT
, 0, value
, NULL
, 0);
972 * Function insert_string (skb, param, value)
974 * Insert string parameter into frame
977 int irlan_insert_string_param(struct sk_buff
*skb
, char *param
, char *string
)
979 int string_len
= strlen(string
);
981 return __irlan_insert_param(skb
, param
, IRLAN_ARRAY
, 0, 0, string
,
986 * Function insert_array_param(skb, param, value, len_value)
988 * Insert array parameter into frame
991 int irlan_insert_array_param(struct sk_buff
*skb
, char *name
, __u8
*array
,
994 return __irlan_insert_param(skb
, name
, IRLAN_ARRAY
, 0, 0, array
,
999 * Function insert_param (skb, param, value, byte)
1001 * Insert parameter at end of buffer, structure of a parameter is:
1003 * -----------------------------------------------------------------------
1004 * | Name Length[1] | Param Name[1..255] | Val Length[2] | Value[0..1016]|
1005 * -----------------------------------------------------------------------
1007 static int __irlan_insert_param(struct sk_buff
*skb
, char *param
, int type
,
1008 __u8 value_byte
, __u16 value_short
,
1009 __u8
*value_array
, __u16 value_len
)
1013 __le16 tmp_le
; /* Temporary value in little endian format */
1017 IRDA_DEBUG(2, "%s(), Got NULL skb\n", __func__
);
1021 param_len
= strlen(param
);
1030 IRDA_ASSERT(value_array
!= NULL
, return 0;);
1031 IRDA_ASSERT(value_len
> 0, return 0;);
1034 IRDA_DEBUG(2, "%s(), Unknown parameter type!\n", __func__
);
1039 /* Insert at end of sk-buffer */
1040 frame
= skb_tail_pointer(skb
);
1042 /* Make space for data */
1043 if (skb_tailroom(skb
) < (param_len
+value_len
+3)) {
1044 IRDA_DEBUG(2, "%s(), No more space at end of skb\n", __func__
);
1047 skb_put(skb
, param_len
+value_len
+3);
1049 /* Insert parameter length */
1050 frame
[n
++] = param_len
;
1052 /* Insert parameter */
1053 memcpy(frame
+n
, param
, param_len
); n
+= param_len
;
1055 /* Insert value length (2 byte little endian format, LSB first) */
1056 tmp_le
= cpu_to_le16(value_len
);
1057 memcpy(frame
+n
, &tmp_le
, 2); n
+= 2; /* To avoid alignment problems */
1062 frame
[n
++] = value_byte
;
1065 tmp_le
= cpu_to_le16(value_short
);
1066 memcpy(frame
+n
, &tmp_le
, 2); n
+= 2;
1069 memcpy(frame
+n
, value_array
, value_len
); n
+=value_len
;
1074 IRDA_ASSERT(n
== (param_len
+value_len
+3), return 0;);
1076 return param_len
+value_len
+3;
1080 * Function irlan_extract_param (buf, name, value, len)
1082 * Extracts a single parameter name/value pair from buffer and updates
1083 * the buffer pointer to point to the next name/value pair.
1085 int irlan_extract_param(__u8
*buf
, char *name
, char *value
, __u16
*len
)
1091 IRDA_DEBUG(4, "%s()\n", __func__
);
1093 /* get length of parameter name (1 byte) */
1094 name_len
= buf
[n
++];
1096 if (name_len
> 254) {
1097 IRDA_DEBUG(2, "%s(), name_len > 254\n", __func__
);
1098 return -RSP_INVALID_COMMAND_FORMAT
;
1101 /* get parameter name */
1102 memcpy(name
, buf
+n
, name_len
);
1103 name
[name_len
] = '\0';
1107 * Get length of parameter value (2 bytes in little endian
1110 memcpy(&val_len
, buf
+n
, 2); /* To avoid alignment problems */
1111 le16_to_cpus(&val_len
); n
+=2;
1113 if (val_len
> 1016) {
1114 IRDA_DEBUG(2, "%s(), parameter length to long\n", __func__
);
1115 return -RSP_INVALID_COMMAND_FORMAT
;
1119 /* get parameter value */
1120 memcpy(value
, buf
+n
, val_len
);
1121 value
[val_len
] = '\0';
1124 IRDA_DEBUG(4, "Parameter: %s ", name
);
1125 IRDA_DEBUG(4, "Value: %s\n", value
);
1130 #ifdef CONFIG_PROC_FS
1133 * Start of reading /proc entries.
1134 * Return entry at pos,
1135 * or start_token to indicate print header line
1136 * or NULL if end of file
1138 static void *irlan_seq_start(struct seq_file
*seq
, loff_t
*pos
)
1141 struct irlan_cb
*self
;
1145 return SEQ_START_TOKEN
;
1147 list_for_each_entry(self
, &irlans
, dev_list
) {
1155 /* Return entry after v, and increment pos */
1156 static void *irlan_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1158 struct list_head
*nxt
;
1161 if (v
== SEQ_START_TOKEN
)
1164 nxt
= ((struct irlan_cb
*)v
)->dev_list
.next
;
1166 return (nxt
== &irlans
) ? NULL
1167 : list_entry(nxt
, struct irlan_cb
, dev_list
);
1170 /* End of reading /proc file */
1171 static void irlan_seq_stop(struct seq_file
*seq
, void *v
)
1178 * Show one entry in /proc file.
1180 static int irlan_seq_show(struct seq_file
*seq
, void *v
)
1182 if (v
== SEQ_START_TOKEN
)
1183 seq_puts(seq
, "IrLAN instances:\n");
1185 struct irlan_cb
*self
= v
;
1187 IRDA_ASSERT(self
!= NULL
, return -1;);
1188 IRDA_ASSERT(self
->magic
== IRLAN_MAGIC
, return -1;);
1190 seq_printf(seq
,"ifname: %s,\n",
1192 seq_printf(seq
,"client state: %s, ",
1193 irlan_state
[ self
->client
.state
]);
1194 seq_printf(seq
,"provider state: %s,\n",
1195 irlan_state
[ self
->provider
.state
]);
1196 seq_printf(seq
,"saddr: %#08x, ",
1198 seq_printf(seq
,"daddr: %#08x\n",
1200 seq_printf(seq
,"version: %d.%d,\n",
1201 self
->version
[1], self
->version
[0]);
1202 seq_printf(seq
,"access type: %s\n",
1203 irlan_access
[self
->client
.access_type
]);
1204 seq_printf(seq
,"media: %s\n",
1205 irlan_media
[self
->media
]);
1207 seq_printf(seq
,"local filter:\n");
1208 seq_printf(seq
,"remote filter: ");
1209 irlan_print_filter(seq
, self
->client
.filter_type
);
1210 seq_printf(seq
,"tx busy: %s\n",
1211 netif_queue_stopped(self
->dev
) ? "TRUE" : "FALSE");
1218 static const struct seq_operations irlan_seq_ops
= {
1219 .start
= irlan_seq_start
,
1220 .next
= irlan_seq_next
,
1221 .stop
= irlan_seq_stop
,
1222 .show
= irlan_seq_show
,
1225 static int irlan_seq_open(struct inode
*inode
, struct file
*file
)
1227 return seq_open(file
, &irlan_seq_ops
);
1231 MODULE_AUTHOR("Dag Brattli <dagb@cs.uit.no>");
1232 MODULE_DESCRIPTION("The Linux IrDA LAN protocol");
1233 MODULE_LICENSE("GPL");
1235 module_param(eth
, bool, 0);
1236 MODULE_PARM_DESC(eth
, "Name devices ethX (0) or irlanX (1)");
1237 module_param(access
, int, 0);
1238 MODULE_PARM_DESC(access
, "Access type DIRECT=1, PEER=2, HOSTED=3");
1240 module_init(irlan_init
);
1241 module_exit(irlan_cleanup
);