| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Date: Fri, 01 Jun 2007 12:39:56 -0400
From: Dan Williams <dcbw@...hat.com>
To: MOKUNO Masakazu <mokuno@...sony.co.jp>
Cc: netdev@...r.kernel.org, Geoff Levand <geoffrey.levand@...sony.com>,
Geert Uytterhoeven <Geert.Uytterhoeven@...ycom.com>
Subject: Re: [PATCH 2/2] ps3: add wireless LAN support
On Fri, 2007-06-01 at 15:10 +0900, MOKUNO Masakazu wrote:
> Add support of the internal wireless LAN of PS3.
Also, any further patches you send should be sent to:
linux-wireless@...r.kernel.org
which is the list for wireless stuff.
Dan
> Signed-off-by: Masakazu Mokuno <mokuno@...sony.co.jp>
> ---
> drivers/net/Kconfig | 7
> drivers/net/Makefile | 4
> drivers/net/gelic_net.c | 30
> drivers/net/gelic_net.h | 227 ++++
> drivers/net/gelic_wireless.c | 2132 +++++++++++++++++++++++++++++++++++++++++++
> 5 files changed, 2396 insertions(+), 4 deletions(-)
>
> --- a/drivers/net/Kconfig
> +++ b/drivers/net/Kconfig
> @@ -2274,6 +2274,13 @@ config GELIC_NET
> To compile this driver as a module, choose M here: the
> module will be called gelic_net.
>
> +config GELIC_WIRELESS
> + bool "Gelic net Wireless Extension"
> + depends on GELIC_NET
> + select WIRELESS_EXT
> + help
> + Wireless Extension support for Gelic Gigabit Ethernet driver
> +
> config GIANFAR
> tristate "Gianfar Ethernet"
> depends on 85xx || 83xx || PPC_86xx
> --- a/drivers/net/Makefile
> +++ b/drivers/net/Makefile
> @@ -60,7 +60,9 @@ obj-$(CONFIG_TIGON3) += tg3.o
> obj-$(CONFIG_BNX2) += bnx2.o
> spidernet-y += spider_net.o spider_net_ethtool.o
> obj-$(CONFIG_SPIDER_NET) += spidernet.o sungem_phy.o
> -obj-$(CONFIG_GELIC_NET) += gelic_net.o
> +obj-$(CONFIG_GELIC_NET) += ps3_gelic.o
> +gelic-$(CONFIG_GELIC_WIRELESS) += gelic_wireless.o
> +ps3_gelic-objs += gelic_net.o $(gelic-y)
> obj-$(CONFIG_TC35815) += tc35815.o
> obj-$(CONFIG_SKGE) += skge.o
> obj-$(CONFIG_SKY2) += sky2.o
> --- a/drivers/net/gelic_net.c
> +++ b/drivers/net/gelic_net.c
> @@ -550,6 +550,9 @@ static int gelic_net_stop(struct net_dev
> {
> struct gelic_net_card *card = netdev_priv(netdev);
>
> +#ifdef CONFIG_GELIC_WIRELESS
> + gelicw_down(netdev);
> +#endif
> netif_poll_disable(netdev);
> netif_stop_queue(netdev);
>
> @@ -1024,6 +1027,9 @@ static irqreturn_t gelic_net_interrupt(i
> /* start pending DMA */
> gelic_net_xmit(NULL, netdev);
> }
> +#ifdef CONFIG_GELIC_WIRELESS
> + gelicw_interrupt(netdev, status);
> +#endif
> return IRQ_HANDLED;
> }
>
> @@ -1120,13 +1126,18 @@ static int gelic_net_open(struct net_dev
>
> card->tx_dma_progress = 0;
> card->ghiintmask = GELIC_NET_RXINT | GELIC_NET_TXINT;
> -
> +#ifdef CONFIG_GELIC_WIRELESS
> + card->ghiintmask |= GELICW_DEVICE_CMD_COMP | GELICW_DEVICE_EVENT_RECV;
> +#endif
> gelic_net_set_irq_mask(card, card->ghiintmask);
> gelic_net_enable_rxdmac(card);
>
> netif_start_queue(netdev);
> netif_carrier_on(netdev);
> netif_poll_enable(netdev);
> +#ifdef CONFIG_GELIC_WIRELESS
> + gelicw_up(netdev);
> +#endif
>
> return 0;
>
> @@ -1205,7 +1216,12 @@ static u32 gelic_net_get_link(struct net
> link = 1;
> else
> link = 0;
> -
> +#ifdef CONFIG_GELIC_WIRELESS
> + /* (v1 & GELIC_NET_LINK_UP) is always 0 in wireless mode */
> + if (gelicw_is_associated(netdev)) {
> + link = 1;
> + }
> +#endif
> return link;
> }
>
> @@ -1396,7 +1412,12 @@ static int gelic_net_setup_netdev(struct
> }
> if (card->vlan_id[GELIC_NET_VLAN_WIRED - 1])
> card->vlan_index = GELIC_NET_VLAN_WIRED - 1;
> -
> +#ifdef CONFIG_GELIC_WIRELESS
> + card->w.card = card;
> + /* init wireless extension */
> + /* No wireless vlan_index:-1 */
> + gelicw_setup_netdev(netdev, card->vlan_index);
> +#endif
> status = register_netdev(netdev);
> if (status) {
> dev_err(ctodev(card), "%s:Couldn't register net_device: %d\n",
> @@ -1530,6 +1551,9 @@ static int ps3_gelic_driver_remove (stru
>
> card = ps3_system_bus_get_driver_data(dev);
>
> +#ifdef CONFIG_GELIC_WIRELESS
> + gelicw_remove(card->netdev);
> +#endif
> wait_event(card->waitq,
> atomic_read(&card->tx_timeout_task_counter) == 0);
>
> --- a/drivers/net/gelic_net.h
> +++ b/drivers/net/gelic_net.h
> @@ -30,6 +30,9 @@
> #ifndef _GELIC_NET_H
> #define _GELIC_NET_H
>
> +#include <linux/wireless.h>
> +#include <net/ieee80211.h>
> +
> #define GELIC_NET_DRV_NAME "Gelic Network Driver"
> #define GELIC_NET_DRV_VERSION "1.0"
>
> @@ -170,6 +173,220 @@ enum gelic_net_descr_status {
>
> #define GELIC_NET_PORT 2 /* for port status */
>
> +/* wireless */
> +#define GELICW_WIRELESS_NOT_EXIST 0
> +#define GELICW_WIRELESS_SUPPORTED 1
> +#define GELICW_WIRELESS_ON 2
> +#define GELICW_WIRELESS_SHUTDOWN 3
> +/* state */
> +#define GELICW_STATE_DOWN 0
> +#define GELICW_STATE_UP 1
> +#define GELICW_STATE_SCANNING 2
> +#define GELICW_STATE_SCAN_DONE 3
> +#define GELICW_STATE_ASSOCIATED 4
> +
> +/* cmd_send_flg */
> +#define GELICW_CMD_SEND_NONE 0x00
> +#define GELICW_CMD_SEND_COMMON 0x01
> +#define GELICW_CMD_SEND_ENCODE 0x02
> +#define GELICW_CMD_SEND_SCAN 0x04
> +#define GELICW_CMD_SEND_ALL (GELICW_CMD_SEND_COMMON \
> + | GELICW_CMD_SEND_ENCODE \
> + | GELICW_CMD_SEND_SCAN)
> +
> +#define GELICW_SCAN_INTERVAL (HZ)
> +
> +#ifdef DEBUG
> +#define CH_INFO_FAIL 0x0600 /* debug */
> +#else
> +#define CH_INFO_FAIL 0
> +#endif
> +
> +
> +/* net_control command */
> +#define GELICW_SET_PORT 3 /* control Ether port */
> +#define GELICW_GET_INFO 6 /* get supported channels */
> +#define GELICW_SET_CMD 9 /* set configuration */
> +#define GELICW_GET_RES 10 /* get command response */
> +#define GELICW_GET_EVENT 11 /* get event from device */
> +/* net_control command data buffer */
> +#define GELICW_DATA_BUF_SIZE 0x1000
> +
> +/* GELICW_SET_CMD params */
> +#define GELICW_CMD_START 1
> +#define GELICW_CMD_STOP 2
> +#define GELICW_CMD_SCAN 3
> +#define GELICW_CMD_GET_SCAN 4
> +#define GELICW_CMD_SET_CONFIG 5
> +#define GELICW_CMD_GET_CONFIG 6
> +#define GELICW_CMD_SET_WEP 7
> +#define GELICW_CMD_GET_WEP 8
> +#define GELICW_CMD_SET_WPA 9
> +#define GELICW_CMD_GET_WPA 10
> +#define GELICW_CMD_GET_RSSI 11
> +
> +/* GELICW_SET_PORT params */
> +#define GELICW_ETHER_PORT 2
> +#define GELICW_PORT_DOWN 0 /* Ether port off */
> +#define GELICW_PORT_UP 4 /* Ether port on (auto neg) */
> +
> +/* interrupt status bit */
> +#define GELICW_DEVICE_CMD_COMP (1UL << 31)
> +#define GELICW_DEVICE_EVENT_RECV (1UL << 30)
> +
> +/* GELICW_GET_EVENT ID */
> +#define GELICW_EVENT_UNKNOWN 0x00
> +#define GELICW_EVENT_DEVICE_READY 0x01
> +#define GELICW_EVENT_SCAN_COMPLETED 0x02
> +#define GELICW_EVENT_DEAUTH 0x04
> +#define GELICW_EVENT_BEACON_LOST 0x08
> +#define GELICW_EVENT_CONNECTED 0x10
> +#define GELICW_EVENT_WPA_CONNECTED 0x20
> +#define GELICW_EVENT_WPA_ERROR 0x40
> +#define GELICW_EVENT_NO_ENTRY (-6)
> +
> +#define MAX_IW_PRIV_SIZE 32
> +
> +/* structure of data buffer for lv1_net_contol */
> +/* wep_config: sec */
> +#define GELICW_WEP_SEC_NONE 0
> +#define GELICW_WEP_SEC_40BIT 1
> +#define GELICW_WEP_SEC_104BIT 2
> +struct wep_config {
> + u16 sec;
> + u8 key[4][16];
> +} __attribute__ ((packed));
> +
> +/* wpa_config: sec */
> +#define GELICW_WPA_SEC_NONE 0
> +#define GELICW_WPA_SEC_TKIP 1
> +#define GELICW_WPA_SEC_AES 2
> +/* wpa_config: psk_type */
> +#define GELICW_PSK_PASSPHRASE 0
> +#define GELICW_PSK_64HEX 1
> +struct wpa_config {
> + u16 sec;
> + u16 psk_type;
> + u8 psk_material[64]; /* key */
> +} __attribute__ ((packed));
> +
> +/* common_config: bss_type */
> +#define GELICW_BSS_INFRA 0
> +#define GELICW_BSS_ADHOC 1
> +/* common_config: auth_method */
> +#define GELICW_AUTH_OPEN 0
> +#define GELICW_AUTH_SHARED 1
> +/* common_config: op_mode */
> +#define GELICW_OP_MODE_11BG 0
> +#define GELICW_OP_MODE_11B 1
> +#define GELICW_OP_MODE_11G 2
> +struct common_config {
> + u16 scan_index; /* index of scan_desc list */
> + u16 bss_type;
> + u16 auth_method;
> + u16 op_mode;
> +} __attribute__ ((packed));
> +
> +/* scan_descriptor: security */
> +#define GELICW_SEC_TYPE_NONE 0x0000
> +#define GELICW_SEC_TYPE_WEP 0x0100
> +#define GELICW_SEC_TYPE_WEP40 0x0101
> +#define GELICW_SEC_TYPE_WEP104 0x0102
> +#define GELICW_SEC_TYPE_TKIP 0x0201
> +#define GELICW_SEC_TYPE_AES 0x0202
> +#define GELICW_SEC_TYPE_WEP_MASK 0xFF00
> +struct scan_desc {
> + u16 size;
> + u16 rssi;
> + u16 channel;
> + u16 beacon_period;
> + u16 capability;
> + u16 security;
> + u64 bssid;
> + u8 essid[32];
> + u8 rate[16];
> + u8 ext_rate[16];
> + u32 reserved1;
> + u32 reserved2;
> + u32 reserved3;
> + u32 reserved4;
> +} __attribute__ ((packed));
> +
> +/* rssi_descriptor */
> +struct rssi_desc {
> + u16 rssi; /* max rssi = 100 */
> +} __attribute__ ((packed));
> +
> +
> +struct gelicw_bss {
> + u8 bssid[ETH_ALEN];
> + u8 channel;
> + u8 mode;
> + u8 essid_len;
> + u8 essid[IW_ESSID_MAX_SIZE + 1]; /* null terminated for debug msg */
> +
> + u16 capability;
> + u16 beacon_interval;
> +
> + u8 rates_len;
> + u8 rates[MAX_RATES_LENGTH];
> + u8 rates_ex_len;
> + u8 rates_ex[MAX_RATES_EX_LENGTH];
> + u8 rssi;
> +
> + /* scan results have sec_info instead of rsn_ie or wpa_ie */
> + u16 sec_info;
> +};
> +
> +/* max station count of station list which hvc returns */
> +#define MAX_SCAN_BSS (16)
> +
> +struct gelic_wireless {
> + struct gelic_net_card *card;
> + struct completion cmd_done, rssi_done;
> + struct work_struct work_event, work_start_done;
> + struct delayed_work work_rssi, work_scan_all, work_scan_essid;
> + struct delayed_work work_common, work_encode;
> + struct delayed_work work_start, work_stop, work_roam;
> + wait_queue_head_t waitq_cmd, waitq_scan;
> +
> + u64 cmd_tag, cmd_id;
> + u8 cmd_send_flg;
> +
> + struct iw_public_data wireless_data;
> + u8 *data_buf; /* data buffer for lv1_net_control */
> +
> + u8 wireless; /* wireless support */
> + u8 state;
> + u8 scan_all; /* essid scan or all scan */
> + u8 essid_search; /* essid background scan */
> + u8 is_assoc;
> +
> + u16 ch_info; /* supoprted channels */
> + u8 wireless_mode; /* 11b/g */
> + u8 channel; /* current ch */
> + u8 iw_mode; /* INFRA or Ad-hoc */
> + u8 rssi;
> + u8 essid_len;
> + u8 essid[IW_ESSID_MAX_SIZE + 1]; /* null terminated for debug msg */
> + u8 nick[IW_ESSID_MAX_SIZE + 1];
> + u8 bssid[ETH_ALEN];
> +
> + u8 key_index;
> + u8 key[WEP_KEYS][IW_ENCODING_TOKEN_MAX]; /* 4 * 64byte */
> + u8 key_len[WEP_KEYS];
> + u8 key_alg; /* key algorithm */
> + u8 auth_mode; /* authenticaton mode */
> +
> + u8 bss_index; /* current bss in bss_list */
> + u8 num_bss_list;
> + u8 bss_key_alg; /* key alg of bss */
> + u8 wap_bssid[ETH_ALEN];
> + unsigned long last_scan; /* last scan time */
> + struct gelicw_bss current_bss;
> + struct gelicw_bss bss_list[MAX_SCAN_BSS];
> +};
> +
> /* size of hardware part of gelic descriptor */
> #define GELIC_NET_DESCR_SIZE (32)
> struct gelic_net_descr {
> @@ -225,9 +442,19 @@ struct gelic_net_card {
> wait_queue_head_t waitq;
>
> struct gelic_net_descr *tx_top, *rx_top;
> +#ifdef CONFIG_GELIC_WIRELESS
> + struct gelic_wireless w;
> +#endif
> struct gelic_net_descr descr[0];
> };
>
>
> extern unsigned long p_to_lp(long pa);
> +extern int gelicw_setup_netdev(struct net_device *netdev, int wi);
> +extern void gelicw_up(struct net_device *netdev);
> +extern int gelicw_down(struct net_device *netdev);
> +extern void gelicw_remove(struct net_device *netdev);
> +extern void gelicw_interrupt(struct net_device *netdev, u64 status);
> +extern int gelicw_is_associated(struct net_device *netdev);
> +
> #endif //_GELIC_NET_H
> --- /dev/null
> +++ b/drivers/net/gelic_wireless.c
> @@ -0,0 +1,2132 @@
> +/*
> + * gelic_wireless.c: wireless extension for gelic_net
> + *
> + * Copyright (C) 2007 Sony Computer Entertainment Inc.
> + * Copyright 2007 Sony Corporation
> + *
> + * 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; version 2 of the License.
> + *
> + * This program is distributed in the hope that it will be useful, but
> + * WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
> + * General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License along
> + * with this program; if not, write to the Free Software Foundation, Inc.,
> + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
> + */
> +
> +#undef DEBUG
> +
> +#include <linux/kernel.h>
> +#include <linux/netdevice.h>
> +#include <linux/if_vlan.h>
> +#include <linux/completion.h>
> +#include <linux/ctype.h>
> +#include <asm/ps3.h>
> +#include <asm/lv1call.h>
> +
> +#include "gelic_net.h"
> +
> +static struct iw_handler_def gelicw_handler_def;
> +
> +/*
> + * Data tables
> + */
> +static const u32 freq_list[] = {
> + 2412, 2417, 2422, 2427, 2432,
> + 2437, 2442, 2447, 2452, 2457,
> + 2462, 2467, 2472, 2484 };
> +
> +static const u32 bitrate_list[] = {
> + 1000000, 2000000, 5500000, 11000000, /* 11b */
> + 6000000, 9000000, 12000000, 18000000,
> + 24000000, 36000000, 48000000, 54000000
> +};
> +#define GELICW_NUM_11B_BITRATES 4 /* 802.11b: 1 ~ 11 Mb/s */
> +
> +static inline struct device * ntodev(struct net_device *netdev)
> +{
> + return &((struct gelic_net_card *)netdev_priv(netdev))->dev->core;
> +}
> +
> +static inline struct device * wtodev(struct gelic_wireless *w)
> +{
> + return &w->card->dev->core;
> +}
> +static inline struct gelic_wireless *gelicw_priv(struct net_device *netdev)
> +{
> + struct gelic_net_card *card = netdev_priv(netdev);
> + return &card->w;
> +}
> +static inline unsigned int bus_id(struct gelic_wireless *w)
> +{
> + return w->card->dev->did.bus_id;
> +}
> +static inline unsigned int dev_id(struct gelic_wireless *w)
> +{
> + return w->card->dev->did.dev_id;
> +}
> +
> +/* control wired or wireless */
> +static void gelicw_vlan_mode(struct net_device *netdev, int mode)
> +{
> + struct gelic_net_card *card = netdev_priv(netdev);
> +
> + if ((mode < GELIC_NET_VLAN_WIRED) ||
> + (mode > GELIC_NET_VLAN_WIRELESS))
> + return;
> +
> + card->vlan_index = mode - 1;
> +}
> +
> +/* wireless_send_event */
> +static void notify_assoc_event(struct net_device *netdev)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + union iwreq_data wrqu;
> +
> + cancel_delayed_work(&w->work_scan_all);
> + cancel_delayed_work(&w->work_scan_essid);
> +
> + wrqu.ap_addr.sa_family = ARPHRD_ETHER;
> + if (w->state < GELICW_STATE_ASSOCIATED) {
> + dev_dbg(ntodev(netdev), "notify disassociated\n");
> + w->is_assoc = 0;
> + memset(w->bssid, 0, ETH_ALEN);
> + } else {
> + dev_dbg(ntodev(netdev), "notify associated\n");
> + w->channel = w->current_bss.channel;
> + w->is_assoc = 1;
> + memcpy(w->bssid, w->current_bss.bssid, ETH_ALEN);
> + }
> + memcpy(wrqu.ap_addr.sa_data, w->bssid, ETH_ALEN);
> + wireless_send_event(netdev, SIOCGIWAP, &wrqu, NULL);
> +}
> +
> +/* association/disassociation */
> +static void gelicw_assoc(struct net_device *netdev)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> +
> + if (w->state == GELICW_STATE_ASSOCIATED)
> + return;
> + schedule_delayed_work(&w->work_start, 0);
> +}
> +
> +static int gelicw_disassoc(struct net_device *netdev)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> +
> + memset(w->bssid, 0, ETH_ALEN); /* clear current bssid */
> + if (w->state < GELICW_STATE_ASSOCIATED)
> + return 0;
> +
> + schedule_delayed_work(&w->work_stop, 0);
> + w->state = GELICW_STATE_SCAN_DONE;
> + /* notify disassociation */
> + notify_assoc_event(netdev);
> +
> + return 0;
> +}
> +
> +static void gelicw_reassoc(struct net_device *netdev)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> +
> + if (w->cmd_send_flg != GELICW_CMD_SEND_ALL)
> + return;
> +
> + if (!gelicw_disassoc(netdev))
> + gelicw_assoc(netdev);
> +}
> +
> +
> +/*
> + * lv1_net_control command
> + */
> +/* control Ether port */
> +static int gelicw_cmd_set_port(struct net_device *netdev, int mode)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + u64 tag, val;
> + int status;
> +
> + status = lv1_net_control(bus_id(w), dev_id(w),
> + GELICW_SET_PORT, GELICW_ETHER_PORT, mode, 0,
> + &tag, &val);
> + if (status)
> + dev_dbg(ntodev(netdev), "GELICW_SET_PORT failed:%d\n", status);
> + return status;
> +}
> +
> +/* check support channels */
> +static int gelicw_cmd_get_ch_info(struct net_device *netdev)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + u64 ch_info, val;
> + int status;
> +
> + if (w->state < GELICW_STATE_UP)
> + return -EIO;
> +
> + status = lv1_net_control(bus_id(w), dev_id(w),
> + GELICW_GET_INFO, 0, 0 , 0,
> + &ch_info, &val);
> + if (status) {
> + dev_dbg(ntodev(netdev), "GELICW_GET_INFO failed:%d\n", status);
> + w->ch_info = CH_INFO_FAIL;
> + } else {
> + dev_dbg(ntodev(netdev), "ch_info:%lx val:%lx\n", ch_info, val);
> + w->ch_info = ch_info >> 48; /* MSB 16bit shows supported channnels */
> + }
> + return status;
> +}
> +
> +
> +/*
> + * lv1_net_control GELICW_SET_CMD command
> + * queued using schedule_work()
> + */
> +/* association */
> +static void gelicw_cmd_start(struct net_device *netdev)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + u64 val;
> + int status;
> +
> + if (w->state < GELICW_STATE_SCAN_DONE)
> + return;
> +
> + dev_dbg(ntodev(netdev), "GELICW_CMD_START\n");
> + w->cmd_id = GELICW_CMD_START;
> + status = lv1_net_control(bus_id(w), dev_id(w),
> + GELICW_SET_CMD, w->cmd_id, 0, 0,
> + &w->cmd_tag, &val);
> + if (status) {
> + w->cmd_tag = 0;
> + dev_dbg(ntodev(netdev), "GELICW_CMD_START failed:%d\n", status);
> + }
> +}
> +
> +/* association done */
> +static void gelicw_cmd_start_done(struct net_device *netdev)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + u64 res, val;
> + int status;
> +
> + status = lv1_net_control(bus_id(w), dev_id(w),
> + GELICW_GET_RES, w->cmd_tag, 0, 0,
> + &res, &val);
> + w->cmd_tag = 0;
> + wake_up_interruptible(&w->waitq_cmd);
> +
> + if (status || res)
> + dev_dbg(ntodev(netdev), "GELICW_CMD_START res:%d,%ld\n", status, res);
> +}
> +
> +/* disassociation */
> +static void gelicw_cmd_stop(struct net_device *netdev)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + u64 res, val;
> + int status;
> +
> + if (w->state < GELICW_STATE_SCAN_DONE)
> + return;
> +
> + dev_dbg(ntodev(netdev), "GELICW_CMD_STOP\n");
> + init_completion(&w->cmd_done);
> + w->cmd_id = GELICW_CMD_STOP;
> + status = lv1_net_control(bus_id(w), dev_id(w),
> + GELICW_SET_CMD, w->cmd_id, 0, 0,
> + &w->cmd_tag, &val);
> + if (status) {
> + w->cmd_tag = 0;
> + dev_dbg(ntodev(netdev), "GELICW_CMD_STOP failed:%d\n", status);
> + return;
> + }
> + wait_for_completion_interruptible(&w->cmd_done);
> +
> + status = lv1_net_control(bus_id(w), dev_id(w),
> + GELICW_GET_RES, w->cmd_tag, 0, 0,
> + &res, &val);
> + w->cmd_tag = 0;
> + if (status || res) {
> + dev_dbg(ntodev(netdev), "GELICW_CMD_STOP res:%d,%ld\n", status, res);
> + return;
> + }
> +}
> +
> +/* get rssi */
> +static void gelicw_cmd_rssi(struct net_device *netdev)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + u64 lpar, res, val;
> + int status;
> + struct rssi_desc *rssi;
> +
> + if (w->state < GELICW_STATE_ASSOCIATED) {
> + w->rssi = 0;
> + complete(&w->rssi_done);
> + return;
> + }
> +
> + lpar = ps3_mm_phys_to_lpar(__pa(w->data_buf));
> + init_completion(&w->cmd_done);
> + w->cmd_id = GELICW_CMD_GET_RSSI;
> + status = lv1_net_control(bus_id(w), dev_id(w),
> + GELICW_SET_CMD, w->cmd_id, 0, 0,
> + &w->cmd_tag, &val);
> + if (status) {
> + w->cmd_tag = 0;
> + w->rssi = 0;
> + dev_dbg(ntodev(netdev), "GELICW_CMD_GET_RSSI failed:%d\n", status);
> + } else {
> + wait_for_completion_interruptible(&w->cmd_done);
> + status = lv1_net_control(bus_id(w), dev_id(w),
> + GELICW_GET_RES, w->cmd_tag, lpar, sizeof(*rssi),
> + &res, &val);
> + w->cmd_tag = 0;
> + if (status || res) {
> + w->rssi = 0;
> + dev_dbg(ntodev(netdev), "GELICW_CMD_GET_RSSI res:%d,%ld\n", status, res);
> + }
> + rssi = (struct rssi_desc *)w->data_buf;
> + w->rssi = rssi->rssi;
> + dev_dbg(ntodev(netdev), "GELICW_CMD_GET_RSSI:%d\n", rssi->rssi);
> + }
> +
> + complete(&w->rssi_done);
> +}
> +
> +/* set common configuration */
> +static int gelicw_cmd_common(struct net_device *netdev)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + u64 lpar, res, val;
> + int status;
> + struct common_config *config;
> +
> + if (w->state < GELICW_STATE_SCAN_DONE)
> + return -EIO;
> +
> + lpar = ps3_mm_phys_to_lpar(__pa(w->data_buf));
> + config = (struct common_config *)w->data_buf;
> + config->scan_index = w->bss_index;
> + config->bss_type = (w->iw_mode == IW_MODE_ADHOC) ?
> + GELICW_BSS_ADHOC : GELICW_BSS_INFRA;
> + config->auth_method = (w->auth_mode == IW_AUTH_ALG_SHARED_KEY) ?
> + GELICW_AUTH_SHARED : GELICW_AUTH_OPEN;
> + switch (w->wireless_mode) {
> + case IEEE_B:
> + config->op_mode = GELICW_OP_MODE_11B;
> + break;
> + case IEEE_G:
> + config->op_mode = GELICW_OP_MODE_11G;
> + break;
> + case IEEE_B | IEEE_G:
> + default:
> + /* default 11bg mode */
> + config->op_mode = GELICW_OP_MODE_11BG;
> + break;
> + }
> +
> + dev_dbg(ntodev(netdev), "GELICW_CMD_SET_CONFIG: index:%d type:%d auth:%d mode:%d\n",\
> + config->scan_index, config->bss_type,\
> + config->auth_method,config->op_mode);
> + init_completion(&w->cmd_done);
> + w->cmd_id = GELICW_CMD_SET_CONFIG;
> + status = lv1_net_control(bus_id(w), dev_id(w),
> + GELICW_SET_CMD, w->cmd_id,
> + lpar, sizeof(struct common_config),
> + &w->cmd_tag, &val);
> + if (status) {
> + w->cmd_tag = 0;
> + dev_dbg(ntodev(netdev), "GELICW_CMD_SET_CONFIG failed:%d\n", status);
> + return status;
> + }
> + wait_for_completion_interruptible(&w->cmd_done);
> +
> + status = lv1_net_control(bus_id(w), dev_id(w),
> + GELICW_GET_RES, w->cmd_tag, 0, 0,
> + &res, &val);
> + w->cmd_tag = 0;
> + if (status || res) {
> + dev_dbg(ntodev(netdev), "GELICW_CMD_SET_CONFIG res:%d,%ld\n", status, res);
> + return -EFAULT;
> + }
> +
> + w->cmd_send_flg |= GELICW_CMD_SEND_COMMON;
> +
> + return 0;
> +}
> +
> +#define h2i(c) (isdigit(c) ? c - '0' : toupper(c) - 'A' + 10)
> +/* send WEP/WPA configuration */
> +static int gelicw_cmd_encode(struct net_device *netdev)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + u64 res, val, lpar;
> + int status;
> + struct wep_config *config;
> + struct wpa_config *wpa_config;
> +
> + u8 *key, key_len;
> +
> + if (w->state < GELICW_STATE_SCAN_DONE)
> + return -EIO;
> +
> + lpar = ps3_mm_phys_to_lpar(__pa(w->data_buf));
> +
> + if (w->key_alg == IW_ENCODE_ALG_WEP ||
> + w->key_alg == IW_ENCODE_ALG_NONE) {
> + /* WEP */
> + config = (struct wep_config *)w->data_buf;
> + memset(config, 0, sizeof(struct wep_config));
> +
> + /* check key len */
> + key_len = w->key_len[w->key_index];
> + key = w->key[w->key_index];
> + if (w->key_alg == IW_ENCODE_ALG_NONE)
> + config->sec = GELICW_WEP_SEC_NONE;
> + else
> + config->sec = (key_len == 5) ? GELICW_WEP_SEC_40BIT :
> + GELICW_WEP_SEC_104BIT;
> + /* copy key */
> + memcpy(config->key[w->key_index], key, key_len);
> +
> + /* send wep config */
> + dev_dbg(ntodev(netdev), "GELICW_CMD_SET_WEP\n");
> + init_completion(&w->cmd_done);
> + w->cmd_id = GELICW_CMD_SET_WEP;
> + status = lv1_net_control(bus_id(w), dev_id(w),
> + GELICW_SET_CMD, w->cmd_id,
> + lpar, sizeof(struct wep_config),
> + &w->cmd_tag, &val);
> + if (status) {
> + w->cmd_tag = 0;
> + dev_dbg(ntodev(netdev), "GELICW_CMD_SET_WEP failed:%d\n", status);
> + goto err;
> + }
> + wait_for_completion_interruptible(&w->cmd_done);
> +
> + status = lv1_net_control(bus_id(w), dev_id(w),
> + GELICW_GET_RES, w->cmd_tag, 0, 0,
> + &res, &val);
> + w->cmd_tag = 0;
> + if (status || res) {
> + dev_dbg(ntodev(netdev), "GELICW_CMD_SET_WEP res:%d,%ld\n", status, res);
> + status = -EFAULT;
> + goto err;
> + }
> + } else {
> + /* WPA */
> + wpa_config = (struct wpa_config *)w->data_buf;
> + memset(wpa_config, 0, sizeof(struct wpa_config));
> +
> + switch (w->key_alg) {
> + case IW_ENCODE_ALG_TKIP:
> + wpa_config->sec = GELICW_WPA_SEC_TKIP;
> + break;
> + default:
> + case IW_ENCODE_ALG_CCMP:
> + wpa_config->sec = GELICW_WPA_SEC_AES;
> + break;
> + }
> + /* check key len */
> + key = w->key[w->key_index];
> + key_len = w->key_len[w->key_index];
> +
> + if (key_len > 64) key_len = 64;
> + if (key_len != 64) {
> + /* if key_len isn't 64byte ,it should be passphrase */
> + /* pass phrase */
> + memcpy(wpa_config->psk_material, key, key_len);
> + wpa_config->psk_type = GELICW_PSK_PASSPHRASE;
> + } else {
> + int i;
> + /* 64 hex */
> + for (i = 0; i < 32; i++)
> + wpa_config->psk_material[i] =
> + h2i(key[2 * i]) * 16
> + + h2i(key[2 * i + 1]);
> + wpa_config->psk_type = GELICW_PSK_64HEX;
> + }
> +
> + /* send wpa config */
> + dev_dbg(ntodev(netdev), "GELICW_CMD_SET_WPA:type:%d\n", wpa_config->psk_type);
> + init_completion(&w->cmd_done);
> + w->cmd_id = GELICW_CMD_SET_WPA;
> + status = lv1_net_control(bus_id(w), dev_id(w),
> + GELICW_SET_CMD, w->cmd_id,
> + lpar, sizeof(struct wpa_config),
> + &w->cmd_tag, &val);
> + if (status) {
> + w->cmd_tag = 0;
> + dev_dbg(ntodev(netdev), "GELICW_CMD_SET_WPA failed:%d\n", status);
> + goto err;
> + }
> + wait_for_completion_interruptible(&w->cmd_done);
> +
> + status = lv1_net_control(bus_id(w), dev_id(w),
> + GELICW_GET_RES, w->cmd_tag, 0, 0, &res, &val);
> + w->cmd_tag = 0;
> + if (status || res) {
> + dev_dbg(ntodev(netdev), "GELICW_CMD_SET_WPA res:%d,%ld\n", status, res);
> + status = -EFAULT;
> + goto err;
> + }
> + }
> +
> + w->cmd_send_flg |= GELICW_CMD_SEND_ENCODE;
> + /* (re)associate */
> + gelicw_reassoc(netdev);
> +
> + return 0;
> +err:
> + gelicw_disassoc(netdev);
> + return status;
> +}
> +
> +static int gelicw_is_ap_11b(struct gelicw_bss *list)
> +{
> + if (list->rates_len + list->rates_ex_len == GELICW_NUM_11B_BITRATES)
> + return 1;
> + else
> + return 0;
> +}
> +
> +/* get scan results */
> +static int gelicw_cmd_get_scan(struct gelic_wireless *w)
> +{
> + u64 lpar, res, val;
> + int status;
> + struct scan_desc *desc;
> + int i, j;
> + u8 *p;
> +
> +
> + /* get scan */
> + dev_dbg(wtodev(w), "GELICW_CMD_GET_SCAN\n");
> + init_completion(&w->cmd_done);
> + w->cmd_id = GELICW_CMD_GET_SCAN;
> + status = lv1_net_control(bus_id(w), dev_id(w),
> + GELICW_SET_CMD, w->cmd_id, 0, 0,
> + &w->cmd_tag, &val);
> + if (status) {
> + w->cmd_tag = 0;
> + dev_dbg(wtodev(w), "GELICW_CMD_GET_SCAN failed:%d\n", status);
> + return status;
> + }
> + wait_for_completion_interruptible(&w->cmd_done);
> +
> + lpar = ps3_mm_phys_to_lpar(__pa(w->data_buf));
> + status = lv1_net_control(bus_id(w), dev_id(w),
> + GELICW_GET_RES, w->cmd_tag, lpar, PAGE_SIZE,
> + &res, &val);
> + w->cmd_tag = 0;
> + if (status || res) {
> + dev_dbg(wtodev(w), "GELICW_CMD_GET_SCAN res:%d,%ld\n",
> + status, res);
> + return -EFAULT;
> + }
> +
> + desc = (struct scan_desc *)w->data_buf;
> + for (i = 0;
> + i < val / sizeof(struct scan_desc) && i < MAX_SCAN_BSS;
> + i++) {
> + struct gelicw_bss *bss = &w->bss_list[i];
> +
> + bss->rates_len = 0;
> + for (j = 0; j < MAX_RATES_LENGTH; j++)
> + if (desc[i].rate[j])
> + bss->rates[bss->rates_len++] = desc[i].rate[j];
> + bss->rates_ex_len = 0;
> + for (j = 0; j < MAX_RATES_EX_LENGTH; j++)
> + if (desc[i].ext_rate[j])
> + bss->rates_ex[bss->rates_ex_len++]
> + = desc[i].ext_rate[j];
> +
> + if (desc[i].capability & 0x3) {
> + if (desc[i].capability & 0x1)
> + bss->mode = IW_MODE_INFRA;
> + else
> + bss->mode = IW_MODE_ADHOC;
> + }
> + bss->channel = desc[i].channel;
> + bss->essid_len = strnlen(desc[i].essid, IW_ESSID_MAX_SIZE);
> + bss->rssi = (u8)desc[i].rssi;
> + bss->capability = desc[i].capability;
> + bss->beacon_interval = desc[i].beacon_period;
> + memset(bss->essid, 0, sizeof(bss->essid));
> + memcpy(bss->essid, desc[i].essid, bss->essid_len);
> + p = (u8 *)&desc[i].bssid;
> + memcpy(bss->bssid, &p[2], ETH_ALEN);/* bssid:64bit in desc */
> + bss->sec_info = desc[i].security;
> + }
> + w->num_bss_list = i;
> +
> + if (w->num_bss_list)
> + return 0; /* ap found */
> + else
> + return -1; /* no ap found */
> +}
> +
> +/* search bssid in bss list */
> +static int gelicw_search_bss_list(struct net_device *netdev)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + static const u8 off[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
> + int i;
> + int check_bss = 0, check_11g = 0, found_bss, found_11g;
> +
> + if (!w->num_bss_list)
> + return -1; /* no bss list */
> +
> + if (memcmp(off, w->wap_bssid, ETH_ALEN))
> + check_bss = 1;
> +
> + /* wireless op_mode seems not working with CMD_SET_CONFIG */
> + if (w->wireless_mode == IEEE_G)
> + check_11g = 1;
> +
> + if (!check_bss && !check_11g)
> + return 0; /* no check bssid, wmode */
> +
> + for (i = 0; i < w->num_bss_list; i++) {
> + found_bss = found_11g = 1;
> + if (check_bss &&
> + memcmp(w->bss_list[i].bssid, w->wap_bssid, ETH_ALEN))
> + found_bss = 0; /* not found */
> +
> + if (check_11g &&
> + gelicw_is_ap_11b(&w->bss_list[i]))
> + found_11g = 0; /* not found */
> +
> + if (found_bss && found_11g)
> + break;
> + }
> +
> + if (i == w->num_bss_list)
> + return -1; /* not found */
> + else
> + return i;
> +}
> +
> +/* scan done */
> +static void gelicw_scan_complete(struct net_device *netdev)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + int res;
> + int bss_index;
> +
> + /* get scan results */
> + res = gelicw_cmd_get_scan(w);
> + if (w->is_assoc)
> + w->state = GELICW_STATE_ASSOCIATED;
> + else
> + w->state = GELICW_STATE_SCAN_DONE;
> +
> + if (res) {
> + /* No AP found */
> + if (!w->scan_all) {
> + /* no specified AP */
> + gelicw_disassoc(netdev);
> + /* rescan */
> + if (w->essid_search && w->essid_len)
> + schedule_delayed_work(&w->work_scan_essid,
> + GELICW_SCAN_INTERVAL);
> + return;
> + }
> + }
> +
> + if (w->scan_all) {
> + /* all params should be set again after scan */
> + w->cmd_send_flg = 0;
> + return;
> + }
> +
> + bss_index = gelicw_search_bss_list(netdev);
> + if (bss_index < 0) {
> + /* no wap_bssid in bss_list */
> + if (w->essid_search && w->essid_len)
> + schedule_delayed_work(&w->work_scan_essid,
> + GELICW_SCAN_INTERVAL);
> + return;
> + }
> + w->bss_index = (u8)bss_index;
> + w->current_bss = w->bss_list[w->bss_index];
> +
> + /* essid search complete */
> + w->essid_search = 0;
> + w->cmd_send_flg |= GELICW_CMD_SEND_SCAN;
> +
> + /* (re)connect to AP */
> + if (w->is_assoc) {
> + /* notify disassociation */
> + w->state = GELICW_STATE_SCAN_DONE;
> + notify_assoc_event(netdev);
> + }
> + schedule_delayed_work(&w->work_common, 0);
> + schedule_delayed_work(&w->work_encode, 0);
> +}
> +
> +/* start scan */
> +static int gelicw_cmd_set_scan(struct net_device *netdev)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + u64 res, val, lpar;
> + int status;
> + u8 *p;
> +
> + if (w->state < GELICW_STATE_UP) {
> + w->scan_all = 0;
> + return -EIO;
> + }
> + if (!w->scan_all && !w->essid_len)
> + return -EINVAL; /* unsupported essid ANY */
> +
> + /* set device wired to wireless when essid is set */
> + if (!w->scan_all && w->wireless < GELICW_WIRELESS_ON) {
> + gelicw_vlan_mode(netdev, GELIC_NET_VLAN_WIRELESS);
> + gelicw_cmd_set_port(netdev, GELICW_PORT_DOWN);
> + w->wireless = GELICW_WIRELESS_ON;
> + }
> +
> + p = (u8 *)w->data_buf;
> + lpar = ps3_mm_phys_to_lpar(__pa(w->data_buf));
> +
> + /* avoid frequent scanning */
> + if (!w->essid_search && /* background scan off */
> + w->scan_all &&
> + (time_before64(get_jiffies_64(), w->last_scan + 5 * HZ)))
> + return 0;
> +
> + w->bss_key_alg = IW_ENCODE_ALG_NONE;
> +
> + init_completion(&w->cmd_done);
> + w->state = GELICW_STATE_SCANNING;
> + w->cmd_id = GELICW_CMD_SCAN;
> +
> + if (w->scan_all) {
> + /* scan all ch */
> + dev_dbg(ntodev(netdev), "GELICW_CMD_SCAN all\n");
> + w->last_scan = get_jiffies_64(); /* last scan time */
> + status = lv1_net_control(bus_id(w), dev_id(w),
> + GELICW_SET_CMD, w->cmd_id, 0, 0,
> + &w->cmd_tag, &val);
> + } else {
> + /* scan essid */
> + memset(p, 0, 32);
> + memcpy(p, w->essid, w->essid_len);
> + dev_dbg(ntodev(netdev), "GELICW_CMD_SCAN essid\n");
> + status = lv1_net_control(bus_id(w), dev_id(w),
> + GELICW_SET_CMD, w->cmd_id, lpar, 32,
> + &w->cmd_tag, &val);
> + }
> +
> + if (status) {
> + w->cmd_tag = 0;
> + dev_dbg(ntodev(netdev), "GELICW_CMD_SCAN failed:%d\n", status);
> + return status;
> + }
> + wait_for_completion_interruptible(&w->cmd_done);
> +
> + status = lv1_net_control(bus_id(w), dev_id(w),
> + GELICW_GET_RES, w->cmd_tag, 0, 0,
> + &res, &val);
> + w->cmd_tag = 0;
> + if (status || res) {
> + dev_dbg(ntodev(netdev), "GELICW_CMD_SCAN res:%d,%ld\n", status, res);
> + return -EFAULT;
> + }
> +
> + return 0;
> +}
> +
> +static void gelicw_send_common_config(struct net_device *netdev,
> + u8 *cur, u8 mode)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> +
> + if (*cur != mode) {
> + *cur = mode;
> + if (w->state < GELICW_STATE_SCAN_DONE)
> + return;
> +
> + if (!(w->cmd_send_flg & GELICW_CMD_SEND_SCAN) &&
> + w->essid_len)
> + /* scan essid and set other params */
> + schedule_delayed_work(&w->work_scan_essid, 0);
> + else {
> + schedule_delayed_work(&w->work_common, 0);
> + if (w->cmd_send_flg
> + & GELICW_CMD_SEND_ENCODE)
> + /* (re)send encode key */
> + schedule_delayed_work(&w->work_encode, 0);
> + }
> + }
> +}
> +
> +
> +/*
> + * work queue
> + */
> +static void gelicw_work_rssi(struct work_struct *work)
> +{
> + struct gelic_wireless *w =
> + container_of(work, struct gelic_wireless, work_rssi.work);
> + struct net_device *netdev = w->card->netdev;
> +
> + if (w->cmd_tag) {
> + schedule_delayed_work(&w->work_rssi, HZ / 5);
> + return;
> + }
> +
> + gelicw_cmd_rssi(netdev);
> +}
> +
> +static void gelicw_work_scan_all(struct work_struct *work)
> +{
> + struct gelic_wireless *w =
> + container_of(work, struct gelic_wireless, work_scan_all.work);
> + struct net_device *netdev = w->card->netdev;
> +
> + if (w->cmd_tag || w->state == GELICW_STATE_SCANNING) {
> + schedule_delayed_work(&w->work_scan_all, HZ / 5);
> + return;
> + }
> +
> + w->scan_all = 1;
> + gelicw_cmd_set_scan(netdev);
> +}
> +
> +static void gelicw_work_scan_essid(struct work_struct *work)
> +{
> + struct gelic_wireless *w =
> + container_of(work, struct gelic_wireless, work_scan_essid.work);
> + struct net_device *netdev = w->card->netdev;
> +
> + if (w->cmd_tag || w->scan_all || w->state == GELICW_STATE_SCANNING) {
> + schedule_delayed_work(&w->work_scan_essid, HZ / 5);
> + return;
> + }
> + w->bss_index = 0;
> + w->scan_all = 0;
> + gelicw_cmd_set_scan(netdev);
> +}
> +
> +static void gelicw_work_common(struct work_struct *work)
> +{
> + struct gelic_wireless *w =
> + container_of(work, struct gelic_wireless, work_common.work);
> + struct net_device *netdev = w->card->netdev;
> +
> + if (w->cmd_tag) {
> + schedule_delayed_work(&w->work_common, HZ / 5);
> + return;
> + }
> + gelicw_cmd_common(netdev);
> +}
> +
> +static void gelicw_work_encode(struct work_struct *work)
> +{
> + struct gelic_wireless *w =
> + container_of(work, struct gelic_wireless, work_encode.work);
> + struct net_device *netdev = w->card->netdev;
> +
> + if (w->cmd_tag) {
> + schedule_delayed_work(&w->work_encode, HZ / 5);
> + return;
> + }
> + gelicw_cmd_encode(netdev);
> +}
> +
> +static void gelicw_work_start(struct work_struct *work)
> +{
> + struct gelic_wireless *w =
> + container_of(work, struct gelic_wireless, work_start.work);
> + struct net_device *netdev = w->card->netdev;
> +
> + if (w->cmd_tag) {
> + schedule_delayed_work(&w->work_start, HZ / 5);
> + return;
> + }
> + gelicw_cmd_start(netdev);
> +}
> +
> +static void gelicw_work_start_done(struct work_struct *work)
> +{
> + struct gelic_wireless *w =
> + container_of(work, struct gelic_wireless, work_start_done);
> + struct net_device *netdev = w->card->netdev;
> +
> + gelicw_cmd_start_done(netdev);
> +}
> +
> +static void gelicw_work_stop(struct work_struct *work)
> +{
> + struct gelic_wireless *w =
> + container_of(work, struct gelic_wireless, work_stop.work);
> + struct net_device *netdev = w->card->netdev;
> +
> + if (w->cmd_tag) {
> + schedule_delayed_work(&w->work_stop, HZ / 5);
> + return;
> + }
> + gelicw_cmd_stop(netdev);
> +}
> +
> +static void gelicw_work_roam(struct work_struct *work)
> +{
> + struct gelic_wireless *w =
> + container_of(work, struct gelic_wireless, work_roam.work);
> + struct net_device *netdev = w->card->netdev;
> +
> + if (w->cmd_tag || w->scan_all || w->state == GELICW_STATE_SCANNING) {
> + schedule_delayed_work(&w->work_roam, HZ / 5);
> + return;
> + }
> + gelicw_cmd_stop(netdev);
> + w->bss_index = 0;
> + w->scan_all = 0;
> + gelicw_cmd_set_scan(netdev);
> +}
> +
> +/*
> + * Event handler
> + */
> +#define GELICW_EVENT_LOOP_MAX 16
> +static void gelicw_event(struct work_struct *work)
> +{
> + struct gelic_wireless *w =
> + container_of(work, struct gelic_wireless, work_event);
> + struct net_device *netdev = w->card->netdev;
> + u64 event_type, val;
> + int i, status;
> +
> + for (i = 0; i < GELICW_EVENT_LOOP_MAX; i++) {
> + status = lv1_net_control(bus_id(w), dev_id(w),
> + GELICW_GET_EVENT, 0, 0 , 0,
> + &event_type, &val);
> + if (status == GELICW_EVENT_NO_ENTRY)
> + /* got all events */
> + break;
> + else if (status){
> + dev_dbg(ntodev(netdev), "GELICW_GET_EVENT failed:%d\n", status);
> + return;
> + }
> + switch(event_type) {
> + case GELICW_EVENT_DEVICE_READY:
> + dev_dbg(ntodev(netdev), " GELICW_EVENT_DEVICE_READY\n");
> + break;
> + case GELICW_EVENT_SCAN_COMPLETED:
> + dev_dbg(ntodev(netdev), " GELICW_EVENT_SCAN_COMPLETED\n");
> + gelicw_scan_complete(netdev);
> + break;
> + case GELICW_EVENT_BEACON_LOST:
> + dev_dbg(ntodev(netdev), " GELICW_EVENT_BEACON_LOST\n");
> + w->state = GELICW_STATE_SCAN_DONE;
> + notify_assoc_event(netdev);
> + /* roaming */
> + w->essid_search = 1;
> + schedule_delayed_work(&w->work_roam, 0);
> + break;
> + case GELICW_EVENT_CONNECTED:
> + {
> + u16 ap_sec;
> + dev_dbg(ntodev(netdev), " GELICW_EVENT_CONNECTED\n");
> + /* this event ocuured with any key_alg */
> + ap_sec = w->current_bss.sec_info;
> + if (w->key_alg == IW_ENCODE_ALG_NONE) {
> + /* no encryption */
> + if (ap_sec == 0) {
> + w->state = GELICW_STATE_ASSOCIATED;
> + notify_assoc_event(netdev);
> + }
> + } else if (w->key_alg == IW_ENCODE_ALG_WEP){
> + if ((ap_sec & GELICW_SEC_TYPE_WEP_MASK)
> + == GELICW_SEC_TYPE_WEP) {
> + /* wep */
> + w->state = GELICW_STATE_ASSOCIATED;
> + notify_assoc_event(netdev);
> + }
> + }
> + break;
> + }
> + case GELICW_EVENT_WPA_CONNECTED:
> + dev_dbg(ntodev(netdev), " GELICW_EVENT_WPA_CONNECTED\n");
> + w->state = GELICW_STATE_ASSOCIATED;
> + notify_assoc_event(netdev);
> + break;
> + case GELICW_EVENT_WPA_ERROR:
> + dev_dbg(ntodev(netdev), " GELICW_EVENT_WPA_ERROR\n");
> + break;
> + default:
> + dev_dbg(ntodev(netdev), " GELICW_EVENT_UNKNOWN\n");
> + break;
> + }
> + }
> +}
> +
> +static void gelicw_clear_event(struct net_device *netdev)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + u64 event_type, val;
> + int i, status;
> +
> + for (i = 0; i < GELICW_EVENT_LOOP_MAX; i++) {
> + status = lv1_net_control(bus_id(w), dev_id(w),
> + GELICW_GET_EVENT, 0, 0 , 0,
> + &event_type, &val);
> + if (status)
> + return;/* got all events */
> +
> + switch(event_type) {
> + case GELICW_EVENT_SCAN_COMPLETED:
> + w->state = GELICW_STATE_SCAN_DONE;
> + wake_up_interruptible(&w->waitq_scan);
> + break;
> + default:
> + break;
> + }
> + }
> +}
> +
> +/*
> + * gelic_net support function
> + */
> +static void gelicw_clear_params(struct gelic_wireless *w)
> +{
> + int i;
> +
> + /* clear status */
> + w->state = GELICW_STATE_DOWN;
> + w->cmd_send_flg = 0;
> + w->scan_all = 0;
> + w->is_assoc = 0;
> + w->essid_search = 0;
> + w->cmd_tag = 0;
> + w->cmd_id = 0;
> + w->last_scan = 0;
> +
> + /* default mode and settings */
> + w->essid_len = 0;
> + w->essid[0] = '\0';
> + w->nick[0] = '\0';
> + w->iw_mode = IW_MODE_INFRA;
> + w->auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
> + w->wireless_mode = IEEE_B | IEEE_G;
> + w->bss_index = 0;
> + memset(w->bssid, 0, ETH_ALEN);
> + memset(w->wap_bssid, 0, ETH_ALEN);
> +
> + /* init key */
> + w->key_index = 0;
> + for (i = 0; i < WEP_KEYS; i++) {
> + w->key[i][0] = '\0';
> + w->key_len[i] = 0;
> + }
> + w->key_alg = IW_ENCODE_ALG_NONE;
> + w->bss_key_alg = IW_ENCODE_ALG_NONE;
> +}
> +
> +int gelicw_setup_netdev(struct net_device *netdev, int wi)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + union ps3_firmware_version ver;
> + union ps3_firmware_version initial_ver;
> +
> + if (wi < 0) {
> + /* PS3 low model has no wireless */
> + dev_info(ntodev(netdev), "No wireless dvice in this system\n");
> + w->wireless = 0;
> + return 0;
> + }
> + /* version check */
> + initial_ver.raw = 0;
> + initial_ver.major = 1;
> + initial_ver.minor = 6;
> + if (ps3_get_firmware_version(&ver) ||
> + (ver.raw < initial_ver.raw)) {
> + dev_info(ntodev(netdev),
> + "firmware %d.%d is too old for wireless.\n",
> + ver.major, ver.minor);
> + w->wireless = 0;
> + return 0;
> + }
> + /* we need 4K aligned, 16 units of scan_desc sized */
> + BUILD_BUG_ON(PAGE_SIZE < sizeof(struct scan_desc) * MAX_SCAN_BSS);
> + w->data_buf = (u8*)get_zeroed_page(GFP_KERNEL);
> + if (!w->data_buf) {
> + w->wireless = 0;
> + dev_info(ntodev(netdev), "%s:get_page failed\n", __func__);
> + return -ENOMEM;
> + }
> +
> + w->wireless = GELICW_WIRELESS_SUPPORTED;
> +
> + w->ch_info = 0;
> + w->channel = 0;
> + netdev->wireless_data = &w->wireless_data;
> + netdev->wireless_handlers = &gelicw_handler_def;
> + INIT_WORK(&w->work_event, gelicw_event);
> + INIT_WORK(&w->work_start_done, gelicw_work_start_done);
> + INIT_DELAYED_WORK(&w->work_rssi, gelicw_work_rssi);
> + INIT_DELAYED_WORK(&w->work_scan_all, gelicw_work_scan_all);
> + INIT_DELAYED_WORK(&w->work_scan_essid, gelicw_work_scan_essid);
> + INIT_DELAYED_WORK(&w->work_common, gelicw_work_common);
> + INIT_DELAYED_WORK(&w->work_encode, gelicw_work_encode);
> + INIT_DELAYED_WORK(&w->work_start, gelicw_work_start);
> + INIT_DELAYED_WORK(&w->work_stop, gelicw_work_stop);
> + INIT_DELAYED_WORK(&w->work_roam, gelicw_work_roam);
> + init_waitqueue_head(&w->waitq_cmd);
> + init_waitqueue_head(&w->waitq_scan);
> +
> + gelicw_clear_params(w);
> +
> + return 0;
> +}
> +
> +void gelicw_up(struct net_device *netdev)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> +
> + if (!w->wireless)
> + return;
> +
> + dev_dbg(ntodev(netdev), "gelicw_up\n");
> + if (w->state < GELICW_STATE_UP)
> + w->state = GELICW_STATE_UP;
> +
> + /* start essid scanning */
> + if (w->essid_len)
> + schedule_delayed_work(&w->work_scan_essid, 0);
> +}
> +
> +int gelicw_down(struct net_device *netdev)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> +
> + if (!w->wireless || w->state == GELICW_STATE_DOWN)
> + return 0;
> +
> + dev_dbg(ntodev(netdev), "gelicw_down\n");
> + w->wireless = GELICW_WIRELESS_SHUTDOWN;
> + flush_scheduled_work();
> +
> + /* check cmd_tag of CMD_START */
> + if (w->cmd_id == GELICW_CMD_START)
> + wait_event_interruptible(w->waitq_cmd, !w->cmd_tag);
> + /* wait scan done */
> + if (w->state == GELICW_STATE_SCANNING) {
> + wait_event_interruptible(w->waitq_scan,
> + w->state != GELICW_STATE_SCANNING);
> + gelicw_cmd_get_scan(w);
> + }
> +
> + gelicw_cmd_stop(netdev);
> + if (w->is_assoc) {
> + w->state = GELICW_STATE_DOWN;
> + notify_assoc_event(netdev);
> + }
> + gelicw_clear_params(w);
> +
> + /* set device wireless to wired */
> + gelicw_vlan_mode(netdev, GELIC_NET_VLAN_WIRED);
> + gelicw_cmd_set_port(netdev, GELICW_PORT_UP);
> + w->wireless = GELICW_WIRELESS_SUPPORTED;
> +
> + return 0;
> +}
> +
> +void gelicw_remove(struct net_device *netdev)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> +
> + if (!w->wireless)
> + return;
> +
> + dev_dbg(ntodev(netdev), "gelicw_remove\n");
> + gelicw_down(netdev);
> + w->wireless = 0;
> + netdev->wireless_handlers = NULL;
> + free_page((unsigned long)w->data_buf);
> +}
> +
> +void gelicw_interrupt(struct net_device *netdev, u64 status)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> +
> + if (!w->wireless)
> + return;
> +
> + if (status & GELICW_DEVICE_CMD_COMP) {
> + dev_dbg(ntodev(netdev), "GELICW_DEVICE_CMD_COMP\n");
> + if (w->cmd_id == GELICW_CMD_START)
> + schedule_work(&w->work_start_done);
> + else
> + complete(&w->cmd_done);
> + }
> + if (status & GELICW_DEVICE_EVENT_RECV) {
> + dev_dbg(ntodev(netdev), "GELICW_DEVICE_EVENT_RECV\n");
> + if (w->wireless == GELICW_WIRELESS_SHUTDOWN)
> + gelicw_clear_event(netdev);
> + else
> + schedule_work(&w->work_event);
> + }
> +}
> +
> +int gelicw_is_associated(struct net_device *netdev)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> +
> + if (!w->wireless)
> + return 0;
> +
> + return w->is_assoc;
> +}
> +
> +
> +/*
> + * Wireless externsions
> + */
> +static int gelicw_get_name(struct net_device *netdev,
> + struct iw_request_info *info,
> + union iwreq_data *wrqu, char *extra)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> +
> + dev_dbg(ntodev(netdev), "wx: get_name\n");
> + if (w->state < GELICW_STATE_UP) {
> + strcpy(wrqu->name, "radio off");
> + return 0;
> + }
> +
> + if (w->wireless_mode == IEEE_B ||
> + (w->is_assoc && gelicw_is_ap_11b(&w->current_bss)))
> + strcpy(wrqu->name, "IEEE 802.11b");
> + else {
> + switch (w->wireless_mode) {
> + case IEEE_G:
> + strcpy(wrqu->name, "IEEE 802.11g");
> + break;
> + case IEEE_B | IEEE_G:
> + default:
> + strcpy(wrqu->name, "IEEE 802.11bg");
> + break;
> + }
> + }
> +
> + return 0;
> +}
> +
> +static int gelicw_set_freq(struct net_device *netdev,
> + struct iw_request_info *info,
> + union iwreq_data *wrqu, char *extra)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + struct iw_freq *fwrq = &wrqu->freq;
> + int ch;
> +
> + dev_dbg(ntodev(netdev), "wx: set_freq e:%d m:%d\n", fwrq->e, fwrq->m);
> + if (w->is_assoc || w->state < GELICW_STATE_UP)
> + return 0;
> +
> + /* this setting has no effect for INFRA mode */
> + if (fwrq->e == 1) {
> + u32 f = fwrq->m / 100000;
> + int i;
> + for (i = 0; i < ARRAY_SIZE(freq_list); i++)
> + if (freq_list[i] == f)
> + break;
> + if (i == ARRAY_SIZE(freq_list))
> + return -EINVAL;
> + fwrq->m = i + 1; /* ch number */
> + fwrq->e = 0;
> + }
> + if (fwrq->e > 0)
> + return -EINVAL;
> +
> + ch = fwrq->m;
> + if (ch < 1)
> + w->channel = 0; /* auto */
> + else if (ch > ARRAY_SIZE(freq_list))
> + return -EINVAL;
> + else {
> + /* check supported channnel */
> + if (!w->ch_info)
> + gelicw_cmd_get_ch_info(netdev);
> + if (w->ch_info & (1 << (ch - 1)))
> + w->channel = ch;
> + else
> + return -EINVAL;
> + }
> + dev_dbg(ntodev(netdev), " set cnannel: %d\n", w->channel);
> +
> + return 0;
> +}
> +
> +static int gelicw_get_freq(struct net_device *netdev,
> + struct iw_request_info *info,
> + union iwreq_data *wrqu, char *extra)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> +
> + dev_dbg(ntodev(netdev), "wx: get_freq:%d\n", w->channel);
> + if (w->channel == 0)
> + wrqu->freq.m = 0;
> + else
> + wrqu->freq.m = freq_list[w->channel - 1] * 100000;
> + wrqu->freq.e = 1;
> +
> + return 0;
> +}
> +
> +static int gelicw_set_mode(struct net_device *netdev,
> + struct iw_request_info *info,
> + union iwreq_data *wrqu, char *extra)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + int mode = wrqu->mode;
> + u8 iw_mode = IW_MODE_INFRA;
> +
> + dev_dbg(ntodev(netdev), "wx: set_mode:%x\n",mode);
> + switch (mode) {
> + case IW_MODE_ADHOC:
> + dev_dbg(ntodev(netdev), "IW_MODE_ADHOC\n");
> + iw_mode = mode;
> + return -EOPNOTSUPP; /* adhoc not supported */
> + case IW_MODE_INFRA:
> + default:
> + dev_dbg(ntodev(netdev), "IW_MODE_INFRA\n");
> + iw_mode = IW_MODE_INFRA;
> + break;
> + }
> +
> + /* send common config */
> + gelicw_send_common_config(netdev, &w->iw_mode, iw_mode);
> +
> + return 0;
> +}
> +
> +static int gelicw_get_mode(struct net_device *netdev,
> + struct iw_request_info *info,
> + union iwreq_data *wrqu, char *extra)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> +
> + dev_dbg(ntodev(netdev), "wx: get_mode\n");
> + wrqu->mode = w->iw_mode;
> +
> + return 0;
> +}
> +
> +static inline int gelicw_qual2level(int qual)
> +{
> + return (qual * 4 - 820)/10; /* FIXME: dummy */
> +}
> +
> +static int gelicw_get_range(struct net_device *netdev,
> + struct iw_request_info *info,
> + union iwreq_data *wrqu, char *extra)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + struct iw_range *range = (struct iw_range *)extra;
> + int num_ch, i;
> +
> + dev_dbg(ntodev(netdev), "wx: get_range\n");
> + wrqu->data.length = sizeof(*range);
> + memset(range, 0, sizeof(*range));
> +
> + /* wireless extension */
> + range->we_version_compiled = WIRELESS_EXT;
> + range->we_version_source = 19;
> +
> + /* supported bitrates */
> + if (w->wireless_mode == IEEE_B)
> + range->num_bitrates = GELICW_NUM_11B_BITRATES;
> + else
> + range->num_bitrates = ARRAY_SIZE(bitrate_list);
> + range->throughput = bitrate_list[range->num_bitrates -1] / 2; /* half */
> + for (i = 0; i < range->num_bitrates; i++)
> + range->bitrate[i] = bitrate_list[i];
> +
> + range->max_qual.qual = 100; /* relative value */
> + range->max_qual.level = 0;
> + range->avg_qual.qual = 50;
> + range->avg_qual.level = 0;
> + range->sensitivity = 0;
> +
> + /* encryption capabilities */
> + range->encoding_size[0] = 5; /* 40bit WEP */
> + range->encoding_size[1] = 13; /* 104bit WEP */
> + range->encoding_size[2] = 64; /* WPA-PSK */
> + range->num_encoding_sizes = 3;
> + range->max_encoding_tokens = WEP_KEYS;
> + range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
> + IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
> +
> + /* freq */
> + if (!w->ch_info)
> + gelicw_cmd_get_ch_info(netdev); /* get supported freq */
> +
> + num_ch = 0;
> + for (i = 0; i < ARRAY_SIZE(freq_list); i++)
> + if (w->ch_info & (1 << i)) {
> + range->freq[num_ch].i = i + 1;
> + range->freq[num_ch].m = freq_list[i] * 100000;
> + range->freq[num_ch].e = 1;
> + if (++num_ch == IW_MAX_FREQUENCIES)
> + break;
> + }
> +
> + range->num_channels = num_ch;
> + range->num_frequency = num_ch;
> +
> + /* event capabilities */
> + range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
> + IW_EVENT_CAPA_MASK(SIOCGIWAP));
> + range->event_capa[1] = IW_EVENT_CAPA_K_1;
> +
> + return 0;
> +}
> +
> +static int gelicw_set_wap(struct net_device *netdev,
> + struct iw_request_info *info,
> + union iwreq_data *wrqu, char *extra)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + static const u8 any[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
> + static const u8 off[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
> +
> + dev_dbg(ntodev(netdev), "wx: set_wap\n");
> + if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
> + return -EINVAL;
> +
> + if (!memcmp(any, wrqu->ap_addr.sa_data, ETH_ALEN) ||
> + !memcmp(off, wrqu->ap_addr.sa_data, ETH_ALEN)) {
> + if (!memcmp(off, w->wap_bssid, ETH_ALEN))
> + return 0; /* ap off, no change */
> + else {
> + memset(w->wap_bssid, 0, ETH_ALEN);
> + /* start scan */
> + }
> + } else if (!memcmp(w->wap_bssid, wrqu->ap_addr.sa_data, ETH_ALEN))
> + /* no change */
> + return 0;
> + else if (!memcmp(w->bssid, wrqu->ap_addr.sa_data, ETH_ALEN)) {
> + /* current bss */
> + memcpy(w->wap_bssid, wrqu->ap_addr.sa_data, ETH_ALEN);
> + return 0;
> + } else
> + memcpy(w->wap_bssid, wrqu->ap_addr.sa_data, ETH_ALEN);
> +
> + /* start scan */
> + if (w->essid_len && w->state >= GELICW_STATE_SCAN_DONE) {
> + gelicw_disassoc(netdev);
> + /* scan essid */
> + cancel_delayed_work(&w->work_scan_all);
> + cancel_delayed_work(&w->work_scan_essid);
> + w->essid_search = 1;
> + schedule_delayed_work(&w->work_scan_essid, 0);
> + }
> +
> + return 0;
> +}
> +
> +static int gelicw_get_wap(struct net_device *netdev,
> + struct iw_request_info *info,
> + union iwreq_data *wrqu, char *extra)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> +
> + dev_dbg(ntodev(netdev), "wx: get_wap\n");
> + wrqu->ap_addr.sa_family = ARPHRD_ETHER;
> + memcpy(wrqu->ap_addr.sa_data, w->bssid, ETH_ALEN);
> +
> + return 0;
> +}
> +
> +static int gelicw_set_scan(struct net_device *netdev,
> + struct iw_request_info *info,
> + union iwreq_data *wrqu, char *extra)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> +
> + dev_dbg(ntodev(netdev), "wx: set_scan\n");
> + if (w->state < GELICW_STATE_UP)
> + return -EIO;
> +
> + /* cancel scan */
> + cancel_delayed_work(&w->work_scan_all);
> + cancel_delayed_work(&w->work_scan_essid);
> +
> + schedule_delayed_work(&w->work_scan_all, 0);
> +
> + return 0;
> +}
> +
> +#define MAX_CUSTOM_LEN 64
> +static char *gelicw_translate_scan(struct net_device *netdev,
> + char *start, char *stop,
> + struct gelicw_bss *list)
> +{
> + char custom[MAX_CUSTOM_LEN];
> + struct iw_event iwe;
> + int i;
> + char *p, *current_val;
> +
> + /* BSSID */
> + iwe.cmd = SIOCGIWAP;
> + iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
> + memcpy(iwe.u.ap_addr.sa_data, list->bssid, ETH_ALEN);
> + start = iwe_stream_add_event(start, stop, &iwe, IW_EV_ADDR_LEN);
> +
> + /* ESSID */
> + iwe.cmd = SIOCGIWESSID;
> + iwe.u.data.flags = 1;
> + iwe.u.data.length = list->essid_len;
> + start = iwe_stream_add_point(start, stop, &iwe, list->essid);
> +
> + /* protocol name */
> + iwe.cmd = SIOCGIWNAME;
> + if (gelicw_is_ap_11b(list))
> + snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11b");
> + else
> + snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11bg");
> + start = iwe_stream_add_event(start, stop, &iwe, IW_EV_CHAR_LEN);
> +
> + /* MODE */
> + iwe.cmd = SIOCGIWMODE;
> + iwe.u.mode = list->mode;
> + start = iwe_stream_add_event(start, stop, &iwe, IW_EV_UINT_LEN);
> +
> + /* FREQ */
> + iwe.cmd = SIOCGIWFREQ;
> + iwe.u.freq.m = list->channel;
> + iwe.u.freq.e = 0;
> + iwe.u.freq.i = 0;
> + start = iwe_stream_add_event(start, stop, &iwe, IW_EV_FREQ_LEN);
> +
> + /* ENCODE */
> + iwe.cmd = SIOCGIWENCODE;
> + if (list->capability & WLAN_CAPABILITY_PRIVACY)
> + iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
> + else
> + iwe.u.data.flags = IW_ENCODE_DISABLED;
> + iwe.u.data.length = 0;
> + start = iwe_stream_add_point(start, stop, &iwe, list->essid);
> +
> + /* QUAL */
> + iwe.cmd = IWEVQUAL;
> + iwe.u.qual.updated = IW_QUAL_QUAL_UPDATED |
> + IW_QUAL_LEVEL_UPDATED | IW_QUAL_NOISE_INVALID;
> + iwe.u.qual.qual = list->rssi;
> + iwe.u.qual.level = gelicw_qual2level(list->rssi);
> + start = iwe_stream_add_event(start, stop, &iwe, IW_EV_QUAL_LEN);
> +
> + /* RATE */
> + current_val = start + IW_EV_LCP_LEN;
> + iwe.cmd = SIOCGIWRATE;
> + iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
> + for (i = 0; i < list->rates_len; i++) {
> + iwe.u.bitrate.value = ((list->rates[i] & 0x7f) * 500000);
> + current_val = iwe_stream_add_value(start, current_val, stop,
> + &iwe, IW_EV_PARAM_LEN);
> + }
> + for (i = 0; i < list->rates_ex_len; i++) {
> + iwe.u.bitrate.value = ((list->rates_ex[i] & 0x7f) * 500000);
> + current_val = iwe_stream_add_value(start, current_val, stop,
> + &iwe, IW_EV_PARAM_LEN);
> + }
> + if ((current_val - start) > IW_EV_LCP_LEN)
> + start = current_val;
> +
> + /* Extra */
> + /* BEACON */
> + memset(&iwe, 0, sizeof(iwe));
> + iwe.cmd = IWEVCUSTOM;
> + p = custom;
> + p += snprintf(p, MAX_CUSTOM_LEN, "bcn_int=%d", list->beacon_interval);
> + iwe.u.data.length = p - custom;
> + start = iwe_stream_add_point(start, stop, &iwe, custom);
> +
> + /* AP security */
> + memset(&iwe, 0, sizeof(iwe));
> + iwe.cmd = IWEVCUSTOM;
> + p = custom;
> + p += snprintf(p, MAX_CUSTOM_LEN, "ap_sec=%04X", list->sec_info);
> + iwe.u.data.length = p - custom;
> + start = iwe_stream_add_point(start, stop, &iwe, custom);
> +
> + return start;
> +}
> +
> +static int gelicw_get_scan(struct net_device *netdev,
> + struct iw_request_info *info,
> + union iwreq_data *wrqu, char *extra)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + int i;
> + char *ev = extra;
> + char *stop = ev + wrqu->data.length;
> +
> + dev_dbg(ntodev(netdev), "wx: get_scan \n");
> + switch (w->state) {
> + case GELICW_STATE_DOWN:
> + case GELICW_STATE_UP:
> + return 0; /* no scan results */
> + case GELICW_STATE_SCANNING:
> + return -EAGAIN; /* now scanning */
> + case GELICW_STATE_SCAN_DONE:
> + if (!w->scan_all) /* essid scan */
> + return -EAGAIN;
> + break;
> + default:
> + break;
> + }
> +
> + w->scan_all = 0;
> + for (i = 0; i < w->num_bss_list; i++)
> + ev = gelicw_translate_scan(netdev, ev, stop, &w->bss_list[i]);
> + wrqu->data.length = ev - extra;
> + wrqu->data.flags = 0;
> +
> + /* start background scan */
> + if (w->essid_search)
> + schedule_delayed_work(&w->work_scan_essid,
> + GELICW_SCAN_INTERVAL);
> +
> + return 0;
> +}
> +
> +static int gelicw_set_essid(struct net_device *netdev,
> + struct iw_request_info *info,
> + union iwreq_data *wrqu, char *extra)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + u16 length = 0;
> +
> + dev_dbg(ntodev(netdev), "wx:set_essid\n");
> + /* cancel scan */
> + w->essid_search = 0;
> + cancel_delayed_work(&w->work_scan_all);
> + cancel_delayed_work(&w->work_scan_essid);
> +
> + if (wrqu->essid.flags && wrqu->essid.length)
> + length = wrqu->essid.length;
> +
> + if (length == 0) {
> + /* essid ANY scan not supported */
> + dev_dbg(ntodev(netdev), "ESSID ANY\n");
> + w->essid_len = 0; /* clear essid */
> + w->essid[0] = '\0';
> + return 0;
> + } else {
> + /* check essid */
> + if (length > IW_ESSID_MAX_SIZE)
> + return -EINVAL;
> + if (w->essid_len == length &&
> + !strncmp(w->essid, extra, length)) {
> + /* same essid */
> + if (w->is_assoc)
> + return 0;
> + } else {
> + /* set new essid */
> + w->essid_len = length;
> + memcpy(w->essid, extra, length);
> + }
> + }
> + /* start essid scan */
> + w->essid_search = 1;
> + schedule_delayed_work(&w->work_scan_essid, 0);
> +
> + return 0;
> +}
> +
> +static int gelicw_get_essid(struct net_device *netdev,
> + struct iw_request_info *info,
> + union iwreq_data *wrqu, char *extra)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> +
> + dev_dbg(ntodev(netdev), "wx:get_essid\n");
> + if (w->essid_len) {
> + memcpy(extra, w->essid, w->essid_len);
> + wrqu->essid.length = w->essid_len;
> + wrqu->essid.flags = 1;
> + } else {
> + wrqu->essid.length = 0;
> + wrqu->essid.flags = 0;
> + }
> +
> + return 0;
> +}
> +
> +static int gelicw_set_nick(struct net_device *netdev,
> + struct iw_request_info *info,
> + union iwreq_data *wrqu, char *extra)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + u32 len = wrqu->data.length;
> +
> + dev_dbg(ntodev(netdev), "wx:set_nick\n");
> + if (len > IW_ESSID_MAX_SIZE)
> + return -EINVAL;
> +
> + memset(w->nick, 0, sizeof(w->nick));
> + memcpy(w->nick, extra, len);
> +
> + return 0;
> +}
> +
> +static int gelicw_get_nick(struct net_device *netdev,
> + struct iw_request_info *info,
> + union iwreq_data *wrqu, char *extra)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> +
> + dev_dbg(ntodev(netdev), "wx:get_nick\n");
> + wrqu->data.length = strlen(w->nick);
> + memcpy(extra, w->nick, wrqu->data.length);
> + wrqu->data.flags = 1;
> +
> + return 0;
> +}
> +
> +static int gelicw_set_rate(struct net_device *netdev,
> + struct iw_request_info *info,
> + union iwreq_data *wrqu, char *extra)
> +{
> + dev_dbg(ntodev(netdev), "wx:set_rate:%d\n", wrqu->bitrate.value);
> + if (wrqu->bitrate.value == -1)
> + return 0; /* auto rate only */
> +
> + return -EOPNOTSUPP;
> +}
> +
> +static int gelicw_get_rate(struct net_device *netdev,
> + struct iw_request_info *info,
> + union iwreq_data *wrqu, char *extra)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> +
> + dev_dbg(ntodev(netdev), "wx:get_rate\n");
> +
> + if (w->wireless_mode == IEEE_B ||
> + (w->is_assoc && gelicw_is_ap_11b(&w->current_bss)))
> + wrqu->bitrate.value = bitrate_list[GELICW_NUM_11B_BITRATES -1];
> + else
> + wrqu->bitrate.value = bitrate_list[ARRAY_SIZE(bitrate_list) -1];
> +
> + wrqu->bitrate.fixed = 0;
> +
> + return 0;
> +}
> +
> +static int gelicw_set_encode(struct net_device *netdev,
> + struct iw_request_info *info,
> + union iwreq_data *wrqu, char *extra)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + struct iw_point *enc = &wrqu->encoding;
> + int i, index, key_index;
> +
> + dev_dbg(ntodev(netdev), "wx:set_encode: flags:%x\n", enc->flags );
> + index = enc->flags & IW_ENCODE_INDEX;
> + if (index < 0 || index > WEP_KEYS)
> + return -EINVAL;
> + index--;
> +
> + if (enc->length > IW_ENCODING_TOKEN_MAX)
> + return -EINVAL;
> +
> + if (index != -1)
> + w->key_index = index;
> + key_index = w->key_index;
> +
> + if (enc->flags & IW_ENCODE_DISABLED) {
> + /* disable encryption */
> + if (index == -1) {
> + /* disable all */
> + w->key_alg = IW_ENCODE_ALG_NONE;
> + for (i = 0; i < WEP_KEYS; i++)
> + w->key_len[i] = 0;
> + } else
> + w->key_len[key_index] = 0;
> + } else if (enc->flags & IW_ENCODE_NOKEY) {
> + /* key not changed */
> + if (w->key_alg == IW_ENCODE_ALG_NONE)
> + w->key_alg = IW_ENCODE_ALG_WEP; /* default wep */
> + } else {
> + /* enable encryption */
> + w->key_len[key_index] = enc->length;
> + if (w->key_alg == IW_ENCODE_ALG_NONE)
> + w->key_alg = IW_ENCODE_ALG_WEP; /* default wep */
> + memcpy(w->key[key_index], extra, w->key_len[key_index]);
> + }
> + dev_dbg(ntodev(netdev), "key %d len:%d alg:%x\n",\
> + key_index, w->key_len[key_index], w->key_alg);
> +
> + if (w->state >= GELICW_STATE_SCAN_DONE &&
> + w->cmd_send_flg == 0 && w->essid_len)
> + /* scan essid and set other params */
> + schedule_delayed_work(&w->work_scan_essid, 0);
> + else
> + schedule_delayed_work(&w->work_encode, 0);
> +
> + return 0;
> +}
> +
> +static int gelicw_get_encode(struct net_device *netdev,
> + struct iw_request_info *info,
> + union iwreq_data *wrqu, char *extra)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + struct iw_point *enc = &wrqu->encoding;
> + int index, key_index;
> +
> + dev_dbg(ntodev(netdev), "wx:get_encode\n");
> + index = enc->flags & IW_ENCODE_INDEX;
> + if (index < 0 || index > WEP_KEYS)
> + return -EINVAL;
> +
> + index--;
> + key_index = (index == -1 ? w->key_index : index);
> + enc->flags = key_index + 1;
> +
> + if (w->key_alg == IW_ENCODE_ALG_NONE || !w->key_len[key_index]) {
> + /* no encryption */
> + enc->flags |= IW_ENCODE_DISABLED;
> + enc->length = 0;
> + } else {
> + enc->flags |= IW_ENCODE_NOKEY;
> + enc->length = w->key_len[key_index];
> + memset(extra, 0, w->key_len[key_index]);
> + }
> +
> + return 0;
> +}
> +
> +static int gelicw_set_auth(struct net_device *netdev,
> + struct iw_request_info *info,
> + union iwreq_data *wrqu, char *extra)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + struct iw_param *param = &wrqu->param;
> + int value = param->value;
> + int ret = 0;
> +
> + dev_dbg(ntodev(netdev), "wx:set_auth:%x\n", param->flags & IW_AUTH_INDEX);
> + switch(param->flags & IW_AUTH_INDEX) {
> + case IW_AUTH_WPA_VERSION:
> + case IW_AUTH_CIPHER_PAIRWISE:
> + case IW_AUTH_CIPHER_GROUP:
> + case IW_AUTH_KEY_MGMT:
> + case IW_AUTH_TKIP_COUNTERMEASURES:
> + case IW_AUTH_DROP_UNENCRYPTED:
> + case IW_AUTH_WPA_ENABLED:
> + case IW_AUTH_RX_UNENCRYPTED_EAPOL:
> + case IW_AUTH_ROAMING_CONTROL:
> + case IW_AUTH_PRIVACY_INVOKED:
> + /* ignore */
> + dev_dbg(ntodev(netdev), "IW_AUTH(%x)\n", param->flags & IW_AUTH_INDEX);
> + break;
> + case IW_AUTH_80211_AUTH_ALG:
> + dev_dbg(ntodev(netdev), "IW_AUTH_80211_AUTH_ALG:\n");
> + if (value & IW_AUTH_ALG_SHARED_KEY)
> + w->auth_mode = IW_AUTH_ALG_SHARED_KEY;
> + else if (value & IW_AUTH_ALG_OPEN_SYSTEM)
> + w->auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
> + else
> + ret = -EINVAL;
> + break;
> + default:
> + dev_dbg(ntodev(netdev), "IW_AUTH_UNKNOWN flags:%x\n", param->flags);
> + ret = -EOPNOTSUPP;
> + }
> +
> + return ret;
> +}
> +
> +static int gelicw_get_auth(struct net_device *netdev,
> + struct iw_request_info *info,
> + union iwreq_data *wrqu, char *extra)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + struct iw_param *param = &wrqu->param;
> +
> + dev_dbg(ntodev(netdev), "wx:get_auth\n");
> + switch(param->flags & IW_AUTH_INDEX) {
> + case IW_AUTH_80211_AUTH_ALG:
> + param->value = w->auth_mode;
> + break;
> + case IW_AUTH_WPA_ENABLED:
> + if ((w->key_alg & IW_ENCODE_ALG_TKIP) ||
> + (w->key_alg & IW_ENCODE_ALG_CCMP))
> + param->value = 1;
> + else
> + param->value = 0;
> + break;
> + default:
> + return -EOPNOTSUPP;
> + }
> +
> + return 0;
> +}
> +
> +static int gelicw_set_encodeext(struct net_device *netdev,
> + struct iw_request_info *info,
> + union iwreq_data *wrqu, char *extra)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + struct iw_point *enc = &wrqu->encoding;
> + struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
> + int i, index, key_index;
> +
> + dev_dbg(ntodev(netdev), "wx:set_encodeext\n");
> + index = enc->flags & IW_ENCODE_INDEX;
> + if (index < 0 || index > WEP_KEYS)
> + return -EINVAL;
> +
> + index--;
> + if (ext->key_len > IW_ENCODING_TOKEN_MAX)
> + return -EINVAL;
> +
> + if (index != -1)
> + w->key_index = index;
> + key_index = w->key_index;
> +
> + if (enc->flags & IW_ENCODE_DISABLED) {
> + /* disable encryption */
> + if (index == -1) {
> + /* disable all */
> + w->key_alg = IW_ENCODE_ALG_NONE;
> + for (i = 0; i < WEP_KEYS; i++)
> + w->key_len[i] = 0;
> + } else
> + w->key_len[key_index] = 0;
> + } else if (enc->flags & IW_ENCODE_NOKEY)
> + /* key not changed */
> + w->key_alg = ext->alg;
> + else {
> + w->key_len[key_index] = ext->key_len;
> + w->key_alg = ext->alg;
> + if (w->key_alg != IW_ENCODE_ALG_NONE && w->key_len[key_index])
> + memcpy(w->key[key_index], ext->key, w->key_len[key_index]);
> + }
> + dev_dbg(ntodev(netdev), "key %d len:%d alg:%x\n",\
> + key_index, w->key_len[key_index], w->key_alg);
> +
> + if (w->state >= GELICW_STATE_SCAN_DONE &&
> + w->cmd_send_flg == 0 && w->essid_len)
> + /* scan essid and set other params */
> + schedule_delayed_work(&w->work_scan_essid, 0);
> + else
> + schedule_delayed_work(&w->work_encode, 0);
> +
> + return 0;
> +}
> +
> +static int gelicw_get_encodeext(struct net_device *netdev,
> + struct iw_request_info *info,
> + union iwreq_data *wrqu, char *extra)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + struct iw_point *enc = &wrqu->encoding;
> + struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
> + int index, key_index, key_len;
> +
> + dev_dbg(ntodev(netdev), "wx:get_encodeext\n");
> + key_len = enc->length - sizeof(*ext);
> + if (key_len < 0)
> + return -EINVAL;
> +
> + index = enc->flags & IW_ENCODE_INDEX;
> + if (index < 0 || index > WEP_KEYS)
> + return -EINVAL;
> +
> + index--;
> + key_index = (index == -1 ? w->key_index : index);
> +
> + memset(ext, 0, sizeof(*ext));
> + enc->flags = key_index + 1;
> +
> + if (w->key_alg == IW_ENCODE_ALG_NONE || !w->key_len[key_index]) {
> + /* no encryption */
> + enc->flags |= IW_ENCODE_DISABLED;
> + ext->alg = IW_ENCODE_ALG_NONE;
> + ext->key_len = 0;
> + } else {
> + enc->flags |= IW_ENCODE_NOKEY;
> + ext->alg = w->key_alg;
> + ext->key_len = w->key_len[key_index];
> + }
> +
> + return 0;
> +}
> +
> +/*
> + * wireless stats
> + */
> +static struct iw_statistics *gelicw_get_wireless_stats(struct net_device *netdev)
> +{
> + static struct iw_statistics wstats;
> + struct gelic_wireless *w = gelicw_priv(netdev);
> +
> + dev_dbg(ntodev(netdev), "wx:wireless_stats\n");
> + if (w->state < GELICW_STATE_ASSOCIATED) {
> + wstats.qual.updated = IW_QUAL_QUAL_UPDATED |
> + IW_QUAL_LEVEL_UPDATED | IW_QUAL_NOISE_INVALID;
> + wstats.qual.qual = 0;
> + wstats.qual.level = 0;
> + return &wstats;
> + }
> + init_completion(&w->rssi_done);
> + schedule_delayed_work(&w->work_rssi, 0);
> +
> + wait_for_completion_interruptible(&w->rssi_done);
> + wstats.qual.updated = IW_QUAL_QUAL_UPDATED |
> + IW_QUAL_LEVEL_UPDATED | IW_QUAL_NOISE_INVALID;
> + wstats.qual.qual = w->rssi;
> + wstats.qual.level = gelicw_qual2level(w->rssi);
> +
> + return &wstats;
> +}
> +
> +/*
> + * private handler
> + */
> +static int gelicw_priv_set_alg_mode(struct net_device *netdev,
> + struct iw_request_info *info,
> + union iwreq_data *wrqu, char *extra)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + int mode = *(int *)extra;
> +
> + dev_dbg(ntodev(netdev), "wx:priv_set_alg\n");
> + switch (mode) {
> + case IW_ENCODE_ALG_NONE:
> + case IW_ENCODE_ALG_WEP:
> + case IW_ENCODE_ALG_TKIP:
> + case IW_ENCODE_ALG_CCMP:
> + break;
> + default:
> + return -EINVAL;
> + }
> + /* send common config */
> + gelicw_send_common_config(netdev, &w->key_alg, (u8)mode);
> +
> + return 0;
> +}
> +
> +static int gelicw_priv_get_alg_mode(struct net_device *netdev,
> + struct iw_request_info *info,
> + union iwreq_data *wrqu, char *extra)
> +{
> + struct gelic_wireless *w = gelicw_priv(netdev);
> + char *p;
> +
> + dev_dbg(ntodev(netdev), "wx:priv_get_alg\n");
> + switch (w->key_alg) {
> + case IW_ENCODE_ALG_NONE:
> + strncpy(extra, "OFF", MAX_IW_PRIV_SIZE);
> + break;
> + case IW_ENCODE_ALG_WEP:
> + strncpy(extra, "WEP", MAX_IW_PRIV_SIZE);
> + break;
> + case IW_ENCODE_ALG_TKIP:
> + strncpy(extra, "TKIP", MAX_IW_PRIV_SIZE);
> + break;
> + case IW_ENCODE_ALG_CCMP:
> + strncpy(extra, "AES-CCMP", MAX_IW_PRIV_SIZE);
> + break;
> + default:
> + break;
> + }
> + p = extra + strlen(extra);
> +
> + if (w->key_alg == IW_ENCODE_ALG_TKIP ||
> + w->key_alg == IW_ENCODE_ALG_CCMP) {
> + if (w->key_len[w->key_index] == 64) /* current key index */
> + strncpy(p, " hex", MAX_IW_PRIV_SIZE);
> + else
> + strncpy(p, " passphrase", MAX_IW_PRIV_SIZE);
> + }
> + wrqu->data.length = strlen(extra);
> +
> + return 0;
> +}
> +
> +
> +/*
> + * Wireless handlers
> + */
> +static const iw_handler gelicw_handler[] =
> +{
> + [IW_IOCTL_IDX(SIOCGIWNAME)] = gelicw_get_name,
> + [IW_IOCTL_IDX(SIOCSIWFREQ)] = gelicw_set_freq,
> + [IW_IOCTL_IDX(SIOCGIWFREQ)] = gelicw_get_freq,
> + [IW_IOCTL_IDX(SIOCSIWMODE)] = gelicw_set_mode,
> + [IW_IOCTL_IDX(SIOCGIWMODE)] = gelicw_get_mode,
> + [IW_IOCTL_IDX(SIOCGIWRANGE)] = gelicw_get_range,
> + [IW_IOCTL_IDX(SIOCSIWAP)] = gelicw_set_wap,
> + [IW_IOCTL_IDX(SIOCGIWAP)] = gelicw_get_wap,
> + [IW_IOCTL_IDX(SIOCSIWSCAN)] = gelicw_set_scan,
> + [IW_IOCTL_IDX(SIOCGIWSCAN)] = gelicw_get_scan,
> + [IW_IOCTL_IDX(SIOCSIWESSID)] = gelicw_set_essid,
> + [IW_IOCTL_IDX(SIOCGIWESSID)] = gelicw_get_essid,
> + [IW_IOCTL_IDX(SIOCSIWNICKN)] = gelicw_set_nick,
> + [IW_IOCTL_IDX(SIOCGIWNICKN)] = gelicw_get_nick,
> + [IW_IOCTL_IDX(SIOCSIWRATE)] = gelicw_set_rate,
> + [IW_IOCTL_IDX(SIOCGIWRATE)] = gelicw_get_rate,
> + [IW_IOCTL_IDX(SIOCSIWENCODE)] = gelicw_set_encode,
> + [IW_IOCTL_IDX(SIOCGIWENCODE)] = gelicw_get_encode,
> + [IW_IOCTL_IDX(SIOCSIWAUTH)] = gelicw_set_auth,
> + [IW_IOCTL_IDX(SIOCGIWAUTH)] = gelicw_get_auth,
> + [IW_IOCTL_IDX(SIOCSIWENCODEEXT)] = gelicw_set_encodeext,
> + [IW_IOCTL_IDX(SIOCGIWENCODEEXT)] = gelicw_get_encodeext,
> +};
> +
> +/*
> + * Private wireless handlers
> + */
> +enum {
> + GELICW_PRIV_SET_AUTH = SIOCIWFIRSTPRIV,
> + GELICW_PRIV_GET_AUTH
> +};
> +
> +static struct iw_priv_args gelicw_private_args[] = {
> + {
> + .cmd = GELICW_PRIV_SET_AUTH,
> + .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
> + .name = "set_alg"
> + },
> + {
> + .cmd = GELICW_PRIV_GET_AUTH,
> + .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_IW_PRIV_SIZE,
> + .name = "get_alg"
> + },
> +};
> +
> +static const iw_handler gelicw_private_handler[] =
> +{
> + gelicw_priv_set_alg_mode,
> + gelicw_priv_get_alg_mode,
> +};
> +
> +static struct iw_handler_def gelicw_handler_def =
> +{
> + .num_standard = ARRAY_SIZE(gelicw_handler),
> + .num_private = ARRAY_SIZE(gelicw_private_handler),
> + .num_private_args = ARRAY_SIZE(gelicw_private_args),
> + .standard = (iw_handler *)gelicw_handler,
> + .private = (iw_handler *)gelicw_private_handler,
> + .private_args = (struct iw_priv_args *)gelicw_private_args,
> + .get_wireless_stats = gelicw_get_wireless_stats
> +};
>
> --
> Masakazu MOKUNO
>
> -
> To unsubscribe from this list: send the line "unsubscribe netdev" in
> the body of a message to majordomo@...r.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
-
To unsubscribe from this list: send the line "unsubscribe netdev" in
the body of a message to majordomo@...r.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Powered by blists - more mailing lists