Release 4.8 net/irda/irlan/irlan_common.c

/*********************************************************************
 *
 * Filename:      irlan_common.c
 * Version:       0.9
 * Description:   IrDA LAN Access Protocol Implementation
 * Status:        Experimental.
 * Author:        Dag Brattli <dagb@cs.uit.no>
 * Created at:    Sun Aug 31 20:14:37 1997
 * Modified at:   Sun Dec 26 21:53:10 1999
 * Modified by:   Dag Brattli <dagb@cs.uit.no>
 *
 *     Copyright (c) 1997, 1999 Dag Brattli <dagb@cs.uit.no>,
 *     All Rights Reserved.
 *
 *     This program is free software; you can redistribute it and/or
 *     modify it under the terms of the GNU General Public License as
 *     published by the Free Software Foundation; either version 2 of
 *     the License, or (at your option) any later version.
 *
 *     Neither Dag Brattli nor University of Tromsø admit liability nor
 *     provide warranty for any of this software. This material is
 *     provided "AS-IS" and at no charge.
 *
 ********************************************************************/

#include <linux/module.h>

#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/gfp.h>
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/proc_fs.h>
#include <linux/sched.h>
#include <linux/seq_file.h>
#include <linux/random.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/rtnetlink.h>
#include <linux/moduleparam.h>
#include <linux/bitops.h>

#include <asm/byteorder.h>

#include <net/irda/irda.h>
#include <net/irda/irttp.h>
#include <net/irda/irlmp.h>
#include <net/irda/iriap.h>
#include <net/irda/timer.h>

#include <net/irda/irlan_common.h>
#include <net/irda/irlan_client.h>
#include <net/irda/irlan_provider.h>
#include <net/irda/irlan_eth.h>
#include <net/irda/irlan_filter.h>


/* extern char sysctl_devname[]; */

/*
 *  Master structure
 */
static LIST_HEAD(irlans);


static void *ckey;

static void *skey;

/* Module parameters */

static bool eth;   
/* Use "eth" or "irlan" name for devices */

static int access = ACCESS_PEER; 
/* PEER, DIRECT or HOSTED */

#ifdef CONFIG_PROC_FS

static const char *const irlan_access[] = {
	"UNKNOWN",
	"DIRECT",
	"PEER",
	"HOSTED"
};


static const char *const irlan_media[] = {
	"UNKNOWN",
	"802.3",
	"802.5"
};

extern struct proc_dir_entry *proc_irda;

static int irlan_seq_open(struct inode *inode, struct file *file);


static const struct file_operations irlan_fops = {
	.owner	 = THIS_MODULE,
	.open    = irlan_seq_open,
	.read    = seq_read,
	.llseek  = seq_lseek,
	.release = seq_release,
};

extern struct proc_dir_entry *proc_irda;
#endif /* CONFIG_PROC_FS */

static struct irlan_cb __init *irlan_open(__u32 saddr, __u32 daddr);
static void __irlan_close(struct irlan_cb *self);
static int __irlan_insert_param(struct sk_buff *skb, char *param, int type,
				__u8 value_byte, __u16 value_short,
				__u8 *value_array, __u16 value_len);
static void irlan_open_unicast_addr(struct irlan_cb *self);
static void irlan_get_unicast_addr(struct irlan_cb *self);
void irlan_close_tsaps(struct irlan_cb *self);

/*
 * Function irlan_init (void)
 *
 *    Initialize IrLAN layer
 *
 */


static int __init irlan_init(void)
{
	struct irlan_cb *new;
	__u16 hints;

#ifdef CONFIG_PROC_FS
	{ struct proc_dir_entry *proc;
	proc = proc_create("irlan", 0, proc_irda, &irlan_fops);
	if (!proc) {
		printk(KERN_ERR "irlan_init: can't create /proc entry!\n");
		return -ENODEV;
	}
	}
#endif /* CONFIG_PROC_FS */

	hints = irlmp_service_to_hint(S_LAN);

	/* Register with IrLMP as a client */
	ckey = irlmp_register_client(hints, &irlan_client_discovery_indication,
				     NULL, NULL);
	if (!ckey)
		goto err_ckey;

	/* Register with IrLMP as a service */
	skey = irlmp_register_service(hints);
	if (!skey)
		goto err_skey;

	/* Start the master IrLAN instance (the only one for now) */
	new = irlan_open(DEV_ADDR_ANY, DEV_ADDR_ANY);
	if (!new)
		goto err_open;

	/* The master will only open its (listen) control TSAP */
	irlan_provider_open_ctrl_tsap(new);

	/* Do some fast discovery! */
	irlmp_discovery_request(DISCOVERY_DEFAULT_SLOTS);

	return 0;

err_open:
	irlmp_unregister_service(skey);
err_skey:
	irlmp_unregister_client(ckey);
err_ckey:
#ifdef CONFIG_PROC_FS
	remove_proc_entry("irlan", proc_irda);
#endif /* CONFIG_PROC_FS */

	return -ENOMEM;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
85
49.13%
8
66.67%
akinobu mita
akinobu mita
57
32.95%
1
8.33%
stephen hemminger
stephen hemminger
26
15.03%
1
8.33%
wang chen
wang chen
4
2.31%
1
8.33%
jean tourrilhes
jean tourrilhes
1
0.58%
1
8.33%
Total
173
100.00%
12
100.00%



static void __exit irlan_cleanup(void)
{
	struct irlan_cb *self, *next;

	irlmp_unregister_client(ckey);
	irlmp_unregister_service(skey);

#ifdef CONFIG_PROC_FS
	remove_proc_entry("irlan", proc_irda);
#endif /* CONFIG_PROC_FS */

	/* Cleanup any leftover network devices */
	rtnl_lock();
	list_for_each_entry_safe(self, next, &irlans, dev_list) {
		__irlan_close(self);
	}
	rtnl_unlock();
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
35
54.69%
3
50.00%
stephen hemminger
stephen hemminger
27
42.19%
1
16.67%
jean tourrilhes
jean tourrilhes
2
3.12%
2
33.33%
Total
64
100.00%
6
100.00%

/*
 * Function irlan_open (void)
 *
 *    Open new instance of a client/provider, we should only register the
 *    network device if this instance is ment for a particular client/provider
 */


static struct irlan_cb __init *irlan_open(__u32 saddr, __u32 daddr)
{
	struct net_device *dev;
	struct irlan_cb *self;

	/* Create network device with irlan */
	dev = alloc_irlandev(eth ? "eth%d" : "irlan%d");
	if (!dev)
		return NULL;

	self = netdev_priv(dev);
	self->dev = dev;

	/*
         *  Initialize local device structure
         */
	self->magic = IRLAN_MAGIC;
	self->saddr = saddr;
	self->daddr = daddr;

	/* Provider access can only be PEER, DIRECT, or HOSTED */
	self->provider.access_type = access;
	if (access == ACCESS_DIRECT) {
		/*
                 * Since we are emulating an IrLAN sever we will have to
                 * give ourself an ethernet address!
                 */
		dev->dev_addr[0] = 0x40;
		dev->dev_addr[1] = 0x00;
		dev->dev_addr[2] = 0x00;
		dev->dev_addr[3] = 0x00;
		get_random_bytes(dev->dev_addr+4, 1);
		get_random_bytes(dev->dev_addr+5, 1);
	}

	self->media = MEDIA_802_3;
	self->disconnect_reason = LM_USER_REQUEST;
	init_timer(&self->watchdog_timer);
	init_timer(&self->client.kick_timer);
	init_waitqueue_head(&self->open_wait);

	skb_queue_head_init(&self->client.txq);

	irlan_next_client_state(self, IRLAN_IDLE);
	irlan_next_provider_state(self, IRLAN_IDLE);

	if (register_netdev(dev)) {
		pr_debug("%s(), register_netdev() failed!\n",
			 __func__);
		self = NULL;
		free_netdev(dev);
	} else {
		rtnl_lock();
		list_add_rcu(&self->dev_list, &irlans);
		rtnl_unlock();
	}

	return self;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
131
49.81%
5
35.71%
jean tourrilhes
jean tourrilhes
67
25.48%
1
7.14%
stephen hemminger
stephen hemminger
56
21.29%
1
7.14%
wang chen
wang chen
3
1.14%
1
7.14%
adrian bunk
adrian bunk
1
0.38%
1
7.14%
harvey harrison
harvey harrison
1
0.38%
1
7.14%
fabian frederick
fabian frederick
1
0.38%
1
7.14%
joe perches
joe perches
1
0.38%
1
7.14%
al viro
al viro
1
0.38%
1
7.14%
hideaki yoshifuji
hideaki yoshifuji
1
0.38%
1
7.14%
Total
263
100.00%
14
100.00%

/*
 * Function __irlan_close (self)
 *
 *    This function closes and deallocates the IrLAN client instances. Be
 *    aware that other functions which calls client_close() must
 *    remove self from irlans list first.
 */


static void __irlan_close(struct irlan_cb *self)
{
	ASSERT_RTNL();
	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);

	del_timer_sync(&self->watchdog_timer);
	del_timer_sync(&self->client.kick_timer);

	/* Close all open connections and remove TSAPs */
	irlan_close_tsaps(self);

	if (self->client.iriap)
		iriap_close(self->client.iriap);

	/* Remove frames queued on the control channel */
	skb_queue_purge(&self->client.txq);

	/* Unregister and free self via destructor */
	unregister_netdevice(self->dev);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
78
88.64%
3
37.50%
jean tourrilhes
jean tourrilhes
5
5.68%
3
37.50%
stephen hemminger
stephen hemminger
5
5.68%
2
25.00%
Total
88
100.00%
8
100.00%

/* Find any instance of irlan, used for client discovery wakeup */


struct irlan_cb *irlan_get_any(void)
{
	struct irlan_cb *self;

	list_for_each_entry_rcu(self, &irlans, dev_list) {
		return self;
	}
	return NULL;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
stephen hemminger
stephen hemminger
30
100.00%
1
100.00%
Total
30
100.00%
1
100.00%

/*
 * Function irlan_connect_indication (instance, sap, qos, max_sdu_size, skb)
 *
 *    Here we receive the connect indication for the data channel
 *
 */


static void irlan_connect_indication(void *instance, void *sap,
				     struct qos_info *qos,
				     __u32 max_sdu_size,
				     __u8 max_header_size,
				     struct sk_buff *skb)
{
	struct irlan_cb *self;
	struct tsap_cb *tsap;

	self = instance;
	tsap = sap;

	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
	IRDA_ASSERT(tsap == self->tsap_data,return;);

	self->max_sdu_size = max_sdu_size;
	self->max_header_size = max_header_size;

	pr_debug("%s: We are now connected!\n", __func__);

	del_timer(&self->watchdog_timer);

	/* If you want to pass the skb to *both* state machines, you will
         * need to skb_clone() it, so that you don't free it twice.
         * As the state machines don't need it, git rid of it here...
         * Jean II */
	if (skb)
		dev_kfree_skb(skb);

	irlan_do_provider_event(self, IRLAN_DATA_CONNECT_INDICATION, NULL);
	irlan_do_client_event(self, IRLAN_DATA_CONNECT_INDICATION, NULL);

	if (self->provider.access_type == ACCESS_PEER) {
		/*
                 * Data channel is open, so we are now allowed to
                 * configure the remote filter
                 */
		irlan_get_unicast_addr(self);
		irlan_open_unicast_addr(self);
	}
	/* Ready to transfer Ethernet frames (at last) */
	netif_start_queue(self->dev); /* Clear reason */
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
135
86.54%
5
41.67%
linus torvalds
linus torvalds
12
7.69%
1
8.33%
jean tourrilhes
jean tourrilhes
5
3.21%
2
16.67%
adrian bunk
adrian bunk
1
0.64%
1
8.33%
harvey harrison
harvey harrison
1
0.64%
1
8.33%
joe perches
joe perches
1
0.64%
1
8.33%
hideaki yoshifuji
hideaki yoshifuji
1
0.64%
1
8.33%
Total
156
100.00%
12
100.00%



static void irlan_connect_confirm(void *instance, void *sap,
				  struct qos_info *qos,
				  __u32 max_sdu_size,
				  __u8 max_header_size,
				  struct sk_buff *skb)
{
	struct irlan_cb *self;

	self = instance;

	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);

	self->max_sdu_size = max_sdu_size;
	self->max_header_size = max_header_size;

	/* TODO: we could set the MTU depending on the max_sdu_size */

	pr_debug("%s: We are now connected!\n", __func__);
	del_timer(&self->watchdog_timer);

	/*
         * Data channel is open, so we are now allowed to configure the remote
         * filter
         */
	irlan_get_unicast_addr(self);
	irlan_open_unicast_addr(self);

	/* Open broadcast and multicast filter by default */
	irlan_set_broadcast_filter(self, TRUE);
	irlan_set_multicast_filter(self, TRUE);

	/* Ready to transfer Ethernet frames */
	netif_start_queue(self->dev);
	self->disconnect_reason = 0; /* Clear reason */
	wake_up_interruptible(&self->open_wait);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
123
94.62%
6
50.00%
jean tourrilhes
jean tourrilhes
3
2.31%
2
16.67%
adrian bunk
adrian bunk
1
0.77%
1
8.33%
harvey harrison
harvey harrison
1
0.77%
1
8.33%
hideaki yoshifuji
hideaki yoshifuji
1
0.77%
1
8.33%
joe perches
joe perches
1
0.77%
1
8.33%
Total
130
100.00%
12
100.00%

/*
 * Function irlan_client_disconnect_indication (handle)
 *
 *    Callback function for the IrTTP layer. Indicates a disconnection of
 *    the specified connection (handle)
 */


static void irlan_disconnect_indication(void *instance,
					void *sap, LM_REASON reason,
					struct sk_buff *userdata)
{
	struct irlan_cb *self;
	struct tsap_cb *tsap;

	pr_debug("%s(), reason=%d\n", __func__ , reason);

	self = instance;
	tsap = sap;

	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
	IRDA_ASSERT(tsap != NULL, return;);
	IRDA_ASSERT(tsap->magic == TTP_TSAP_MAGIC, return;);

	IRDA_ASSERT(tsap == self->tsap_data, return;);

	pr_debug("IrLAN, data channel disconnected by peer!\n");

	/* Save reason so we know if we should try to reconnect or not */
	self->disconnect_reason = reason;

	switch (reason) {
	case LM_USER_REQUEST: /* User request */
		pr_debug("%s(), User requested\n", __func__);
		break;
	case LM_LAP_DISCONNECT: /* Unexpected IrLAP disconnect */
		pr_debug("%s(), Unexpected IrLAP disconnect\n", __func__);
		break;
	case LM_CONNECT_FAILURE: /* Failed to establish IrLAP connection */
		pr_debug("%s(), IrLAP connect failed\n", __func__);
		break;
	case LM_LAP_RESET:  /* IrLAP reset */
		pr_debug("%s(), IrLAP reset\n", __func__);
		break;
	case LM_INIT_DISCONNECT:
		pr_debug("%s(), IrLMP connect failed\n", __func__);
		break;
	default:
		net_err_ratelimited("%s(), Unknown disconnect reason\n",
				    __func__);
		break;
	}

	/* If you want to pass the skb to *both* state machines, you will
         * need to skb_clone() it, so that you don't free it twice.
         * As the state machines don't need it, git rid of it here...
         * Jean II */
	if (userdata)
		dev_kfree_skb(userdata);

	irlan_do_client_event(self, IRLAN_LMP_DISCONNECT, NULL);
	irlan_do_provider_event(self, IRLAN_LMP_DISCONNECT, NULL);

	wake_up_interruptible(&self->open_wait);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
161
78.16%
3
27.27%
jean tourrilhes
jean tourrilhes
17
8.25%
2
18.18%
linus torvalds
linus torvalds
10
4.85%
1
9.09%
joe perches
joe perches
8
3.88%
2
18.18%
harvey harrison
harvey harrison
7
3.40%
1
9.09%
jeff garzik
jeff garzik
2
0.97%
1
9.09%
adrian bunk
adrian bunk
1
0.49%
1
9.09%
Total
206
100.00%
11
100.00%



void irlan_open_data_tsap(struct irlan_cb *self)
{
	struct tsap_cb *tsap;
	notify_t notify;

	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);

	/* Check if already open */
	if (self->tsap_data)
		return;

	irda_notify_init(&notify);

	notify.data_indication       = irlan_eth_receive;
	notify.udata_indication      = irlan_eth_receive;
	notify.connect_indication    = irlan_connect_indication;
	notify.connect_confirm       = irlan_connect_confirm;
	notify.flow_indication       = irlan_eth_flow_indication;
	notify.disconnect_indication = irlan_disconnect_indication;
	notify.instance              = self;
	strlcpy(notify.name, "IrLAN data", sizeof(notify.name));

	tsap = irttp_open_tsap(LSAP_ANY, DEFAULT_INITIAL_CREDIT, &notify);
	if (!tsap) {
		pr_debug("%s(), Got no tsap!\n", __func__);
		return;
	}
	self->tsap_data = tsap;

	/*
         *  This is the data TSAP selector which we will pass to the client
         *  when the client ask for it.
         */
	self->stsap_sel_data = self->tsap_data->stsap_sel;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
128
86.49%
2
22.22%
jean tourrilhes
jean tourrilhes
10
6.76%
3
33.33%
ben collins
ben collins
7
4.73%
1
11.11%
harvey harrison
harvey harrison
1
0.68%
1
11.11%
joe perches
joe perches
1
0.68%
1
11.11%
hideaki yoshifuji
hideaki yoshifuji
1
0.68%
1
11.11%
Total
148
100.00%
9
100.00%



void irlan_close_tsaps(struct irlan_cb *self)
{
	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);

	/* Disconnect and close all open TSAP connections */
	if (self->tsap_data) {
		irttp_disconnect_request(self->tsap_data, NULL, P_NORMAL);
		irttp_close_tsap(self->tsap_data);
		self->tsap_data = NULL;
	}
	if (self->client.tsap_ctrl) {
		irttp_disconnect_request(self->client.tsap_ctrl, NULL,
					 P_NORMAL);
		irttp_close_tsap(self->client.tsap_ctrl);
		self->client.tsap_ctrl = NULL;
	}
	if (self->provider.tsap_ctrl) {
		irttp_disconnect_request(self->provider.tsap_ctrl, NULL,
					 P_NORMAL);
		irttp_close_tsap(self->provider.tsap_ctrl);
		self->provider.tsap_ctrl = NULL;
	}
	self->disconnect_reason = LM_USER_REQUEST;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
141
98.60%
2
66.67%
jean tourrilhes
jean tourrilhes
2
1.40%
1
33.33%
Total
143
100.00%
3
100.00%

/*
 * Function irlan_ias_register (self, tsap_sel)
 *
 *    Register with LM-IAS
 *
 */


void irlan_ias_register(struct irlan_cb *self, __u8 tsap_sel)
{
	struct ias_object *obj;
	struct ias_value *new_value;

	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);

	/*
         * Check if object has already been registered by a previous provider.
         * If that is the case, we just change the value of the attribute
         */
	if (!irias_find_object("IrLAN")) {
		obj = irias_new_object("IrLAN", IAS_IRLAN_ID);
		irias_add_integer_attrib(obj, "IrDA:TinyTP:LsapSel", tsap_sel,
					 IAS_KERNEL_ATTR);
		irias_insert_object(obj);
	} else {
		new_value = irias_new_integer_value(tsap_sel);
		irias_object_change_attribute("IrLAN", "IrDA:TinyTP:LsapSel",
					      new_value);
	}

	/* Register PnP object only if not registered before */
	if (!irias_find_object("PnP")) {
		obj = irias_new_object("PnP", IAS_PNP_ID);
#if 0
		irias_add_string_attrib(obj, "Name", sysctl_devname,
                                        IAS_KERNEL_ATTR);
#else
		irias_add_string_attrib(obj, "Name", "Linux", IAS_KERNEL_ATTR);
#endif
		irias_add_string_attrib(obj, "DeviceID", "HWP19F0",
					IAS_KERNEL_ATTR);
		irias_add_integer_attrib(obj, "CompCnt", 1, IAS_KERNEL_ATTR);
		if (self->provider.access_type == ACCESS_PEER)
			irias_add_string_attrib(obj, "Comp#01", "PNP8389",
						IAS_KERNEL_ATTR);
		else
			irias_add_string_attrib(obj, "Comp#01", "PNP8294",
						IAS_KERNEL_ATTR);

		irias_add_string_attrib(obj, "Manufacturer",
					"Linux-IrDA Project", IAS_KERNEL_ATTR);
		irias_insert_object(obj);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
198
98.02%
5
62.50%
jean tourrilhes
jean tourrilhes
2
0.99%
1
12.50%
hideaki yoshifuji
hideaki yoshifuji
1
0.50%
1
12.50%
steven cole
steven cole
1
0.50%
1
12.50%
Total
202
100.00%
8
100.00%

/*
 * Function irlan_run_ctrl_tx_queue (self)
 *
 *    Try to send the next command in the control transmit queue
 *
 */


int irlan_run_ctrl_tx_queue(struct irlan_cb *self)
{
	struct sk_buff *skb;

	if (irda_lock(&self->client.tx_busy) == FALSE)
		return -EBUSY;

	skb = skb_dequeue(&self->client.txq);
	if (!skb) {
		self->client.tx_busy = FALSE;
		return 0;
	}

	/* Check that it's really possible to send commands */
	if ((self->client.tsap_ctrl == NULL) ||
	    (self->client.state == IRLAN_IDLE))
	{
		self->client.tx_busy = FALSE;
		dev_kfree_skb(skb);
		return -1;
	}
	pr_debug("%s(), sending ...\n", __func__);

	return irttp_data_request(self->client.tsap_ctrl, skb);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
120
96.77%
2
40.00%
jean tourrilhes
jean tourrilhes
2
1.61%
1
20.00%
joe perches
joe perches
1
0.81%
1
20.00%
harvey harrison
harvey harrison
1
0.81%
1
20.00%
Total
124
100.00%
5
100.00%

/*
 * Function irlan_ctrl_data_request (self, skb)
 *
 *    This function makes sure that commands on the control channel is being
 *    sent in a command/response fashion
 */


static void irlan_ctrl_data_request(struct irlan_cb *self, struct sk_buff *skb)
{
	/* Queue command */
	skb_queue_tail(&self->client.txq, skb);

	/* Try to send command */
	irlan_run_ctrl_tx_queue(self);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
34
97.14%
1
50.00%
adrian bunk
adrian bunk
1
2.86%
1
50.00%
Total
35
100.00%
2
100.00%

/*
 * Function irlan_get_provider_info (self)
 *
 *    Send Get Provider Information command to peer IrLAN layer
 *
 */


void irlan_get_provider_info(struct irlan_cb *self)
{
	struct sk_buff *skb;
	__u8 *frame;

	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);

	skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER,
			GFP_ATOMIC);
	if (!skb)
		return;

	/* Reserve space for TTP, LMP, and LAP header */
	skb_reserve(skb, self->client.max_header_size);
	skb_put(skb, 2);

	frame = skb->data;

	frame[0] = CMD_GET_PROVIDER_INFO;
	frame[1] = 0x00;                 /* Zero parameters */

	irlan_ctrl_data_request(self, skb);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
89
91.75%
4
57.14%
samuel ortiz
samuel ortiz
6
6.19%
2
28.57%
jean tourrilhes
jean tourrilhes
2
2.06%
1
14.29%
Total
97
100.00%
7
100.00%

/*
 * Function irlan_open_data_channel (self)
 *
 *    Send an Open Data Command to provider
 *
 */


void irlan_open_data_channel(struct irlan_cb *self)
{
	struct sk_buff *skb;
	__u8 *frame;

	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);

	skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
			IRLAN_STRING_PARAMETER_LEN("MEDIA", "802.3") +
			IRLAN_STRING_PARAMETER_LEN("ACCESS_TYPE", "DIRECT"),
			GFP_ATOMIC);
	if (!skb)
		return;

	skb_reserve(skb, self->client.max_header_size);
	skb_put(skb, 2);

	frame = skb->data;

	/* Build frame */
	frame[0] = CMD_OPEN_DATA_CHANNEL;
	frame[1] = 0x02; /* Two parameters */

	irlan_insert_string_param(skb, "MEDIA", "802.3");
	irlan_insert_string_param(skb, "ACCESS_TYPE", "DIRECT");
	/* irlan_insert_string_param(skb, "MODE", "UNRELIABLE"); */

/*      self->use_udata = TRUE; */

	irlan_ctrl_data_request(self, skb);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
109
83.21%
4
57.14%
samuel ortiz
samuel ortiz
20
15.27%
2
28.57%
jean tourrilhes
jean tourrilhes
2
1.53%
1
14.29%
Total
131
100.00%
7
100.00%



void irlan_close_data_channel(struct irlan_cb *self)
{
	struct sk_buff *skb;
	__u8 *frame;

	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);

	/* Check if the TSAP is still there */
	if (self->client.tsap_ctrl == NULL)
		return;

	skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
			IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN"),
			GFP_ATOMIC);
	if (!skb)
		return;

	skb_reserve(skb, self->client.max_header_size);
	skb_put(skb, 2);

	frame = skb->data;

	/* Build frame */
	frame[0] = CMD_CLOSE_DATA_CHAN;
	frame[1] = 0x01; /* One parameter */

	irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data);

	irlan_ctrl_data_request(self, skb);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
111
88.80%
4
57.14%
samuel ortiz
samuel ortiz
12
9.60%
2
28.57%
jean tourrilhes
jean tourrilhes
2
1.60%
1
14.29%
Total
125
100.00%
7
100.00%

/*
 * Function irlan_open_unicast_addr (self)
 *
 *    Make IrLAN provider accept ethernet frames addressed to the unicast
 *    address.
 *
 */


static void irlan_open_unicast_addr(struct irlan_cb *self)
{
	struct sk_buff *skb;
	__u8 *frame;

	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);

	skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
			IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") +
			IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "DIRECTED") +
			IRLAN_STRING_PARAMETER_LEN("FILTER_MODE", "FILTER"),
			GFP_ATOMIC);
	if (!skb)
		return;

	/* Reserve space for TTP, LMP, and LAP header */
	skb_reserve(skb, self->max_header_size);
	skb_put(skb, 2);

	frame = skb->data;

	frame[0] = CMD_FILTER_OPERATION;
	frame[1] = 0x03;                 /* Three parameters */
	irlan_insert_byte_param(skb, "DATA_CHAN" , self->dtsap_sel_data);
	irlan_insert_string_param(skb, "FILTER_TYPE", "DIRECTED");
	irlan_insert_string_param(skb, "FILTER_MODE", "FILTER");

	irlan_ctrl_data_request(self, skb);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
116
80.56%
4
50.00%
samuel ortiz
samuel ortiz
25
17.36%
2
25.00%
jean tourrilhes
jean tourrilhes
2
1.39%
1
12.50%
adrian bunk
adrian bunk
1
0.69%
1
12.50%
Total
144
100.00%
8
100.00%

/*
 * Function irlan_set_broadcast_filter (self, status)
 *
 *    Make IrLAN provider accept ethernet frames addressed to the broadcast
 *    address. Be careful with the use of this one, since there may be a lot
 *    of broadcast traffic out there. We can still function without this
 *    one but then _we_ have to initiate all communication with other
 *    hosts, since ARP request for this host will not be answered.
 */


void irlan_set_broadcast_filter(struct irlan_cb *self, int status)
{
	struct sk_buff *skb;
	__u8 *frame;

	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);

	skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
			IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") +
			IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "BROADCAST") +
			/* We may waste one byte here...*/
			IRLAN_STRING_PARAMETER_LEN("FILTER_MODE", "FILTER"),
			GFP_ATOMIC);
	if (!skb)
		return;

	/* Reserve space for TTP, LMP, and LAP header */
	skb_reserve(skb, self->client.max_header_size);
	skb_put(skb, 2);

	frame = skb->data;

	frame[0] = CMD_FILTER_OPERATION;
	frame[1] = 0x03;                 /* Three parameters */
	irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data);
	irlan_insert_string_param(skb, "FILTER_TYPE", "BROADCAST");
	if (status)
		irlan_insert_string_param(skb, "FILTER_MODE", "FILTER");
	else
		irlan_insert_string_param(skb, "FILTER_MODE", "NONE");

	irlan_ctrl_data_request(self, skb);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
135
82.82%
4
57.14%
samuel ortiz
samuel ortiz
26
15.95%
2
28.57%
jean tourrilhes
jean tourrilhes
2
1.23%
1
14.29%
Total
163
100.00%
7
100.00%

/*
 * Function irlan_set_multicast_filter (self, status)
 *
 *    Make IrLAN provider accept ethernet frames addressed to the multicast
 *    address.
 *
 */


void irlan_set_multicast_filter(struct irlan_cb *self, int status)
{
	struct sk_buff *skb;
	__u8 *frame;

	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);

	skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
			IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") +
			IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "MULTICAST") +
			/* We may waste one byte here...*/
			IRLAN_STRING_PARAMETER_LEN("FILTER_MODE", "NONE"),
			GFP_ATOMIC);
	if (!skb)
		return;

	/* Reserve space for TTP, LMP, and LAP header */
	skb_reserve(skb, self->client.max_header_size);
	skb_put(skb, 2);

	frame = skb->data;

	frame[0] = CMD_FILTER_OPERATION;
	frame[1] = 0x03;                 /* Three parameters */
	irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data);
	irlan_insert_string_param(skb, "FILTER_TYPE", "MULTICAST");
	if (status)
		irlan_insert_string_param(skb, "FILTER_MODE", "ALL");
	else
		irlan_insert_string_param(skb, "FILTER_MODE", "NONE");

	irlan_ctrl_data_request(self, skb);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
135
82.82%
4
57.14%
samuel ortiz
samuel ortiz
26
15.95%
2
28.57%
jean tourrilhes
jean tourrilhes
2
1.23%
1
14.29%
Total
163
100.00%
7
100.00%

/*
 * Function irlan_get_unicast_addr (self)
 *
 *    Retrieves the unicast address from the IrLAN provider. This address
 *    will be inserted into the devices structure, so the ethernet layer
 *    can construct its packets.
 *
 */


static void irlan_get_unicast_addr(struct irlan_cb *self)
{
	struct sk_buff *skb;
	__u8 *frame;

	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);

	skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
			IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") +
			IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "DIRECTED") +
			IRLAN_STRING_PARAMETER_LEN("FILTER_OPERATION",
						   "DYNAMIC"),
			GFP_ATOMIC);
	if (!skb)
		return;

	/* Reserve space for TTP, LMP, and LAP header */
	skb_reserve(skb, self->client.max_header_size);
	skb_put(skb, 2);

	frame = skb->data;

	frame[0] = CMD_FILTER_OPERATION;
	frame[1] = 0x03;                 /* Three parameters */
	irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data);
	irlan_insert_string_param(skb, "FILTER_TYPE", "DIRECTED");
	irlan_insert_string_param(skb, "FILTER_OPERATION", "DYNAMIC");

	irlan_ctrl_data_request(self, skb);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
118
80.82%
4
50.00%
samuel ortiz
samuel ortiz
25
17.12%
2
25.00%
jean tourrilhes
jean tourrilhes
2
1.37%
1
12.50%
adrian bunk
adrian bunk
1
0.68%
1
12.50%
Total
146
100.00%
8
100.00%

/*
 * Function irlan_get_media_char (self)
 *
 *
 *
 */


void irlan_get_media_char(struct irlan_cb *self)
{
	struct sk_buff *skb;
	__u8 *frame;

	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);

	skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
			IRLAN_STRING_PARAMETER_LEN("MEDIA", "802.3"),
			GFP_ATOMIC);

	if (!skb)
		return;

	/* Reserve space for TTP, LMP, and LAP header */
	skb_reserve(skb, self->client.max_header_size);
	skb_put(skb, 2);

	frame = skb->data;

	/* Build frame */
	frame[0] = CMD_GET_MEDIA_CHAR;
	frame[1] = 0x01; /* One parameter */

	irlan_insert_string_param(skb, "MEDIA", "802.3");
	irlan_ctrl_data_request(self, skb);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
99
86.84%
4
57.14%
samuel ortiz
samuel ortiz
13
11.40%
2
28.57%
jean tourrilhes
jean tourrilhes
2
1.75%
1
14.29%
Total
114
100.00%
7
100.00%

/*
 * Function insert_byte_param (skb, param, value)
 *
 *    Insert byte parameter into frame
 *
 */


int irlan_insert_byte_param(struct sk_buff *skb, char *param, __u8 value)
{
	return __irlan_insert_param(skb, param, IRLAN_BYTE, value, 0, NULL, 0);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
35
100.00%
2
100.00%
Total
35
100.00%
2
100.00%



int irlan_insert_short_param(struct sk_buff *skb, char *param, __u16 value)
{
	return __irlan_insert_param(skb, param, IRLAN_SHORT, 0, value, NULL, 0);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
35
100.00%
2
100.00%
Total
35
100.00%
2
100.00%

/*
 * Function insert_string (skb, param, value)
 *
 *    Insert string parameter into frame
 *
 */


int irlan_insert_string_param(struct sk_buff *skb, char *param, char *string)
{
	int string_len = strlen(string);

	return __irlan_insert_param(skb, param, IRLAN_ARRAY, 0, 0, string,
				    string_len);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
44
100.00%
2
100.00%
Total
44
100.00%
2
100.00%

/*
 * Function insert_array_param(skb, param, value, len_value)
 *
 *    Insert array parameter into frame
 *
 */


int irlan_insert_array_param(struct sk_buff *skb, char *name, __u8 *array,
			     __u16 array_len)
{
	return __irlan_insert_param(skb, name, IRLAN_ARRAY, 0, 0, array,
				    array_len);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
39
100.00%
2
100.00%
Total
39
100.00%
2
100.00%

/*
 * Function insert_param (skb, param, value, byte)
 *
 *    Insert parameter at end of buffer, structure of a parameter is:
 *
 *    -----------------------------------------------------------------------
 *    | Name Length[1] | Param Name[1..255] | Val Length[2] | Value[0..1016]|
 *    -----------------------------------------------------------------------
 */


static int __irlan_insert_param(struct sk_buff *skb, char *param, int type,
				__u8 value_byte, __u16 value_short,
				__u8 *value_array, __u16 value_len)
{
	__u8 *frame;
	__u8 param_len;
	__le16 tmp_le; /* Temporary value in little endian format */
	int n=0;

	if (skb == NULL) {
		pr_debug("%s(), Got NULL skb\n", __func__);
		return 0;
	}

	param_len = strlen(param);
	switch (type) {
	case IRLAN_BYTE:
		value_len = 1;
		break;
	case IRLAN_SHORT:
		value_len = 2;
		break;
	case IRLAN_ARRAY:
		IRDA_ASSERT(value_array != NULL, return 0;);
		IRDA_ASSERT(value_len > 0, return 0;);
		break;
	default:
		pr_debug("%s(), Unknown parameter type!\n", __func__);
		return 0;
	}

	/* Insert at end of sk-buffer */
	frame = skb_tail_pointer(skb);

	/* Make space for data */
	if (skb_tailroom(skb) < (param_len+value_len+3)) {
		pr_debug("%s(), No more space at end of skb\n", __func__);
		return 0;
	}
	skb_put(skb, param_len+value_len+3);

	/* Insert parameter length */
	frame[n++] = param_len;

	/* Insert parameter */
	memcpy(frame+n, param, param_len); n += param_len;

	/* Insert value length (2 byte little endian format, LSB first) */
	tmp_le = cpu_to_le16(value_len);
	memcpy(frame+n, &tmp_le, 2); n += 2; /* To avoid alignment problems */

	/* Insert value */
	switch (type) {
	case IRLAN_BYTE:
		frame[n++] = value_byte;
		break;
	case IRLAN_SHORT:
		tmp_le = cpu_to_le16(value_short);
		memcpy(frame+n, &tmp_le, 2); n += 2;
		break;
	case IRLAN_ARRAY:
		memcpy(frame+n, value_array, value_len); n+=value_len;
		break;
	default:
		break;
	}
	IRDA_ASSERT(n == (param_len+value_len+3), return 0;);

	return param_len+value_len+3;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
291
93.87%
3
33.33%
jean tourrilhes
jean tourrilhes
9
2.90%
2
22.22%
harvey harrison
harvey harrison
3
0.97%
1
11.11%
joe perches
joe perches
3
0.97%
1
11.11%
arnaldo carvalho de melo
arnaldo carvalho de melo
3
0.97%
1
11.11%
al viro
al viro
1
0.32%
1
11.11%
Total
310
100.00%
9
100.00%

/*
 * Function irlan_extract_param (buf, name, value, len)
 *
 *    Extracts a single parameter name/value pair from buffer and updates
 *    the buffer pointer to point to the next name/value pair.
 */


int irlan_extract_param(__u8 *buf, char *name, char *value, __u16 *len)
{
	__u8 name_len;
	__u16 val_len;
	int n=0;

	/* get length of parameter name (1 byte) */
	name_len = buf[n++];

	if (name_len > 254) {
		pr_debug("%s(), name_len > 254\n", __func__);
		return -RSP_INVALID_COMMAND_FORMAT;
	}

	/* get parameter name */
	memcpy(name, buf+n, name_len);
	name[name_len] = '\0';
	n+=name_len;

	/*
         *  Get length of parameter value (2 bytes in little endian
         *  format)
         */
	memcpy(&val_len, buf+n, 2); /* To avoid alignment problems */
	le16_to_cpus(&val_len); n+=2;

	if (val_len >= 1016) {
		pr_debug("%s(), parameter length to long\n", __func__);
		return -RSP_INVALID_COMMAND_FORMAT;
	}
	*len = val_len;

	/* get parameter value */
	memcpy(value, buf+n, val_len);
	value[val_len] = '\0';
	n+=val_len;

	pr_debug("Parameter: %s ", name);
	pr_debug("Value: %s\n", value);

	return n;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
159
92.98%
4
44.44%
jean tourrilhes
jean tourrilhes
4
2.34%
1
11.11%
joe perches
joe perches
4
2.34%
1
11.11%
harvey harrison
harvey harrison
2
1.17%
1
11.11%
hideaki yoshifuji
hideaki yoshifuji
1
0.58%
1
11.11%
dan carpenter
dan carpenter
1
0.58%
1
11.11%
Total
171
100.00%
9
100.00%

#ifdef CONFIG_PROC_FS

/*
 * Start of reading /proc entries.
 * Return entry at pos,
 *      or start_token to indicate print header line
 *      or NULL if end of file
 */


static void *irlan_seq_start(struct seq_file *seq, loff_t *pos)
{
	rcu_read_lock();
	return seq_list_start_head(&irlans, *pos);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
stephen hemminger
stephen hemminger
20
68.97%
1
33.33%
pre-git
pre-git
5
17.24%
1
33.33%
li zefan
li zefan
4
13.79%
1
33.33%
Total
29
100.00%
3
100.00%

/* Return entry after v, and increment pos */


static void *irlan_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
	return seq_list_next(v, &irlans, pos);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
stephen hemminger
stephen hemminger
22
70.97%
1
33.33%
li zefan
li zefan
5
16.13%
1
33.33%
pre-git
pre-git
4
12.90%
1
33.33%
Total
31
100.00%
3
100.00%

/* End of reading /proc file */


static void irlan_seq_stop(struct seq_file *seq, void *v)
{
	rcu_read_unlock();
}


Contributors
Person
Tokens
Prop
Commits
CommitProp
stephen hemminger
stephen hemminger
17
94.44%
2
66.67%
jean tourrilhes
jean tourrilhes
1
5.56%
1
33.33%
Total
18
100.00%
3
100.00%

/*
 * Show one entry in /proc file.
 */


static int irlan_seq_show(struct seq_file *seq, void *v)
{
	if (v == &irlans)
		seq_puts(seq, "IrLAN instances:\n");
	else {
		struct irlan_cb *self = list_entry(v, struct irlan_cb, dev_list);

		IRDA_ASSERT(self != NULL, return -1;);
		IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);

		seq_printf(seq,"ifname: %s,\n",
			       self->dev->name);
		seq_printf(seq,"client state: %s, ",
			       irlan_state[ self->client.state]);
		seq_printf(seq,"provider state: %s,\n",
			       irlan_state[ self->provider.state]);
		seq_printf(seq,"saddr: %#08x, ",
			       self->saddr);
		seq_printf(seq,"daddr: %#08x\n",
			       self->daddr);
		seq_printf(seq,"version: %d.%d,\n",
			       self->version[1], self->version[0]);
		seq_printf(seq,"access type: %s\n",
			       irlan_access[self->client.access_type]);
		seq_printf(seq,"media: %s\n",
			       irlan_media[self->media]);

		seq_printf(seq,"local filter:\n");
		seq_printf(seq,"remote filter: ");
		irlan_print_filter(seq, self->client.filter_type);
		seq_printf(seq,"tx busy: %s\n",
			       netif_queue_stopped(self->dev) ? "TRUE" : "FALSE");

		seq_putc(seq,'\n');
	}
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
154
65.25%
6
54.55%
stephen hemminger
stephen hemminger
70
29.66%
3
27.27%
li zefan
li zefan
10
4.24%
1
9.09%
jean tourrilhes
jean tourrilhes
2
0.85%
1
9.09%
Total
236
100.00%
11
100.00%


static const struct seq_operations irlan_seq_ops = {
	.start = irlan_seq_start,
	.next  = irlan_seq_next,
	.stop  = irlan_seq_stop,
	.show  = irlan_seq_show,
};



static int irlan_seq_open(struct inode *inode, struct file *file)
{
	return seq_open(file, &irlan_seq_ops);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
stephen hemminger
stephen hemminger
23
92.00%
1
50.00%
pre-git
pre-git
2
8.00%
1
50.00%
Total
25
100.00%
2
100.00%

#endif

MODULE_AUTHOR("Dag Brattli <dagb@cs.uit.no>");
MODULE_DESCRIPTION("The Linux IrDA LAN protocol");
MODULE_LICENSE("GPL");

module_param(eth, bool, 0);
MODULE_PARM_DESC(eth, "Name devices ethX (0) or irlanX (1)");
module_param(access, int, 0);
MODULE_PARM_DESC(access, "Access type DIRECT=1, PEER=2, HOSTED=3");


module_init(irlan_init);

module_exit(irlan_cleanup);

Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
3266
77.28%
16
28.57%
stephen hemminger
stephen hemminger
398
9.42%
3
5.36%
jean tourrilhes
jean tourrilhes
166
3.93%
7
12.50%
samuel ortiz
samuel ortiz
153
3.62%
2
3.57%
akinobu mita
akinobu mita
57
1.35%
1
1.79%
adrian bunk
adrian bunk
41
0.97%
2
3.57%
linus torvalds
linus torvalds
27
0.64%
2
3.57%
joe perches
joe perches
20
0.47%
2
3.57%
li zefan
li zefan
19
0.45%
1
1.79%
harvey harrison
harvey harrison
17
0.40%
1
1.79%
hideaki yoshifuji
hideaki yoshifuji
13
0.31%
1
1.79%
rusty russell
rusty russell
12
0.28%
2
3.57%
wang chen
wang chen
7
0.17%
2
3.57%
ben collins
ben collins
7
0.17%
1
1.79%
jan engelhardt
jan engelhardt
3
0.07%
2
3.57%
alexey dobriyan
alexey dobriyan
3
0.07%
1
1.79%
tejun heo
tejun heo
3
0.07%
1
1.79%
arnaldo carvalho de melo
arnaldo carvalho de melo
3
0.07%
1
1.79%
fabian frederick
fabian frederick
2
0.05%
1
1.79%
al viro
al viro
2
0.05%
2
3.57%
jeff garzik
jeff garzik
2
0.05%
1
1.79%
steven cole
steven cole
2
0.05%
1
1.79%
dan carpenter
dan carpenter
1
0.02%
1
1.79%
philippe de muyter
philippe de muyter
1
0.02%
1
1.79%
arjan van de ven
arjan van de ven
1
0.02%
1
1.79%
Total
4226
100.00%
56
100.00%
  
Directory: net/irda/irlan

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.