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  PHC 
Open Source and information security mailing list archives
 
Hash Suite: Windows password security audit tool. GUI, reports in PDF.
[<prev] [next>] [thread-next>] [day] [month] [year] [list]
Date:	Fri, 01 Jun 2007 15:10:35 +0900
From:	MOKUNO Masakazu <mokuno@...sony.co.jp>
To:	netdev@...r.kernel.org
Cc:	Geoff Levand <geoffrey.levand@...sony.com>,
	Geert Uytterhoeven <Geert.Uytterhoeven@...ycom.com>
Subject: [PATCH 2/2] ps3: add wireless LAN support

Add support of the internal wireless LAN of PS3.
 
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

Powered by blists - more mailing lists