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(¬ify);
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, ¬ify);
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% |
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.