staging: wilc1000: Add SDIO/SPI 802.11 driver

This driver is for the wilc1000 which is a single chip IEEE 802.11
b/g/n device.
The driver works together with cfg80211, which is the kernel side of
configuration management for wireless devices because the wilc1000
chipset is fullmac where the MLME is managed in hardware.

The driver worked from kernel version 2.6.38 and being now ported
to several others since then.
A TODO file is included as well in this commit.
Signed-off-by: NJohnny Kim <johnny.kim@atmel.com>
Signed-off-by: NRachel Kim <rachel.kim@atmel.com>
Signed-off-by: NDean Lee <dean.lee@atmel.com>
Signed-off-by: NChris Park <chris.park@atmel.com>
Acked-by: NNicolas Ferre <nicolas.ferre@atmel.com>
Signed-off-by: NGreg Kroah-Hartman <gregkh@linuxfoundation.org>

drivers/staging/Kconfig

@@ -110,4 +110,6 @@ source "drivers/staging/fbtft/Kconfig"
 
 source "drivers/staging/fsl-mc/Kconfig"
 
+source "drivers/staging/wilc1000/Kconfig"
+
 endif # STAGING

drivers/staging/Makefile

@@ -47,3 +47,4 @@ obj-$(CONFIG_UNISYSSPAR)	+= unisys/
 obj-$(CONFIG_COMMON_CLK_XLNX_CLKWZRD)	+= clocking-wizard/
 obj-$(CONFIG_FB_TFT)		+= fbtft/
 obj-$(CONFIG_FSL_MC_BUS)	+= fsl-mc/
+obj-$(CONFIG_WILC1000)		+= wilc1000/

drivers/staging/wilc1000/Kconfig

+config WILC1000
+	tristate "WILC1000 support (WiFi only)"
+	---help---
+		This module only support IEEE 802.11n WiFi.
+
+choice
+        prompt "Memory Allocation"
+        depends on WILC1000
+        default WILC1000_PREALLOCATE_AT_LOADING_DRIVER
+
+        config WILC1000_PREALLOCATE_AT_LOADING_DRIVER
+                bool "Preallocate memory at loading driver"
+                ---help---
+                        This choice supports static allocation of the memory
+                        for the receive buffer. The driver will allocate the RX buffer 
+                        during initial time. The driver will also free the buffer
+                        by calling network device stop.
+
+        config WILC1000_DYNAMICALLY_ALLOCATE_MEMROY
+                bool "Dynamically allocate memory in real time"
+                ---help---
+                        This choice supports dynamic allocation of the memory
+                        for the receive buffer. The driver will allocate the RX buffer
+                        when it is required.
+endchoice
+
+
+choice
+    prompt "Bus Type"
+    depends on WILC1000 
+    default WILC1000_SDIO
+    
+	config WILC1000_SDIO
+	    bool "SDIO support"
+	    depends on MMC
+		---help---
+			This module adds support for the SDIO interface of adapters using
+			WILC chipset. Select this if your platform is using the SDIO bus. 
+
+	config WILC1000_SPI
+	    bool "SPI support"
+		---help---
+			This module adds support for the SPI interface of adapters using
+			WILC chipset. Select this if your platform is using the SPI bus. 
+endchoice
+
+
+config WILC1000_HW_OOB_INTR
+    bool "Use out of band interrupt"
+    depends on WILC1000 && WILC1000_SDIO
+    default n
+    ---help---
+		If your platform don't recognize SDIO IRQ, connect chipset external IRQ pin
+		and check this option. Or, Use this to get all interrupts including SDIO interrupts.
+

drivers/staging/wilc1000/Makefile

+obj-$(CONFIG_WILC1000) += wilc1000.o
+obj-$(CONFIG_WILC1000_PREALLOCATE_DURING_SYSTEM_BOOT) += wilc_exported_buf.o
+
+
+ccflags-$(CONFIG_WILC1000_SDIO) += -DWILC_SDIO -DCOMPLEMENT_BOOT
+ccflags-$(CONFIG_WILC1000_HW_OOB_INTR) += -DWILC_SDIO_IRQ_GPIO
+ccflags-$(CONFIG_WILC1000_SPI) += -DWILC_SPI
+
+ccflags-y += -DSTA_FIRMWARE=\"atmel/wilc1000_fw.bin\" \
+		-DAP_FIRMWARE=\"atmel/wilc1000_ap_fw.bin\" \
+		-DP2P_CONCURRENCY_FIRMWARE=\"atmel/wilc1000_p2p_fw.bin\"
+
+ccflags-y += -I$(src)/ -DEXPORT_SYMTAB  -D__CHECK_ENDIAN__ -DWILC_ASIC_A0 \
+		-DPLL_WORKAROUND -DCONNECT_DIRECT  -DAGING_ALG \
+		-DWILC_PARSE_SCAN_IN_HOST -DDISABLE_PWRSAVE_AND_SCAN_DURING_IP \
+		-DWILC_PLATFORM=WILC_LINUXKERNEL -Wno-unused-function -DUSE_WIRELESS \
+		-DWILC_DEBUGFS
+#ccflags-y += -DTCP_ACK_FILTER
+
+ccflags-$(CONFIG_WILC1000_PREALLOCATE_DURING_SYSTEM_BOOT) += -DMEMORY_STATIC \
+								-DWILC_PREALLOC_AT_BOOT
+
+ccflags-$(CONFIG_WILC1000_PREALLOCATE_AT_LOADING_DRIVER) += -DMEMORY_STATIC \
+								-DWILC_PREALLOC_AT_INSMOD
+
+ccflags-$(CONFIG_WILC1000_DYNAMICALLY_ALLOCATE_MEMROY) += -DWILC_NORMAL_ALLOC
+
+
+wilc1000-objs := wilc_wfi_netdevice.o wilc_wfi_cfgoperations.o linux_wlan.o linux_mon.o \
+			wilc_memory.o wilc_msgqueue.o wilc_semaphore.o wilc_sleep.o wilc_strutils.o \
+			wilc_thread.o wilc_time.o wilc_timer.o coreconfigurator.o host_interface.o \
+			fifo_buffer.o wilc_sdio.o wilc_spi.o wilc_wlan_cfg.o wilc_debugfs.o
+
+wilc1000-$(CONFIG_WILC1000_SDIO) += linux_wlan_sdio.o
+wilc1000-$(CONFIG_WILC1000_SPI) += linux_wlan_spi.o
+
+WILC1000_SRC_VERSION = 10.0
+PATCHLEVEL = 2
+WILC1000_FW_VERSION = 0
+
+ccflags-y += -D__DRIVER_VERSION__=\"$(WILC1000_SRC_VERSION).$(PATCHLEVEL)\"

drivers/staging/wilc1000/TODO

+TODO:
+- remove the defined feature as kernel versions
+- remove OS wrapper functions
+- remove custom debug and tracing functions
+- rework comments and function headers(also coding style)
+- remove build warnings
+- support soft-ap and p2p mode
+- support resume/suspend function

drivers/staging/wilc1000/coreconfigsimulator.h

+
+/*!
+ *  @file	coreconfigsimulator.h
+ *  @brief
+ *  @author
+ *  @sa		coreconfigsimulator.c
+ *  @date	1 Mar 2012
+ *  @version	1.0
+ */
+
+
+#ifndef CORECONFIGSIMULATOR_H
+#define CORECONFIGSIMULATOR_H
+
+
+extern WILC_Sint32 CoreConfigSimulatorInit (void);
+extern WILC_Sint32 CoreConfigSimulatorDeInit (void);
+
+
+#endif
\ No newline at end of file

drivers/staging/wilc1000/coreconfigurator.h

+
+/*!
+ *  @file	coreconfigurator.h
+ *  @brief
+ *  @author
+ *  @sa		coreconfigurator.c
+ *  @date	1 Mar 2012
+ *  @version	1.0
+ */
+
+
+#ifndef CORECONFIGURATOR_H
+#define CORECONFIGURATOR_H
+
+#include "wilc_oswrapper.h"
+#include "wilc_wlan_if.h"
+/*****************************************************************************/
+/* Constants                                                                 */
+/*****************************************************************************/
+/* Number of WID Options Supported */
+#define NUM_BASIC_SWITCHES      45
+#define NUM_FHSS_SWITCHES        0
+
+#define NUM_RSSI	5
+
+#ifdef MAC_802_11N
+#define NUM_11N_BASIC_SWITCHES  25
+#define NUM_11N_HUT_SWITCHES    47
+#else /* MAC_802_11N */
+#define NUM_11N_BASIC_SWITCHES  0
+#define NUM_11N_HUT_SWITCHES    0
+#endif /* MAC_802_11N */
+
+extern WILC_Uint16 g_num_total_switches;
+
+#define MAC_HDR_LEN             24          /* No Address4 - non-ESS         */
+#define MAX_SSID_LEN            33
+#define FCS_LEN                 4
+#define TIME_STAMP_LEN          8
+#define BEACON_INTERVAL_LEN     2
+#define CAP_INFO_LEN            2
+#define STATUS_CODE_LEN         2
+#define AID_LEN                 2
+#define IE_HDR_LEN              2
+
+
+/* Operating Mode: SET */
+#define SET_CFG              0
+/* Operating Mode: GET */
+#define GET_CFG              1
+
+#define MAX_PACKET_BUFF_SIZE 1596
+
+#define MAX_STRING_LEN					256
+#define MAX_SURVEY_RESULT_FRAG_SIZE MAX_STRING_LEN
+#define SURVEY_RESULT_LENGTH		44
+#define MAX_ASSOC_RESP_FRAME_SIZE MAX_STRING_LEN
+
+#define STATUS_MSG_LEN			12
+#define MAC_CONNECTED			1
+#define MAC_DISCONNECTED		0
+
+
+
+/*****************************************************************************/
+/* Function Macros                                                           */
+/*****************************************************************************/
+#define MAKE_WORD16(lsb, msb) ((((WILC_Uint16)(msb) << 8) & 0xFF00) | (lsb))
+#define MAKE_WORD32(lsw, msw) ((((WILC_Uint32)(msw) << 16) & 0xFFFF0000) | (lsw))
+
+
+/*****************************************************************************/
+/* Type Definitions                                                                                                                       */
+/*****************************************************************************/
+/* WID Data Types */
+#if 0
+typedef enum {
+	WID_CHAR  = 0,
+	WID_SHORT = 1,
+	WID_INT   = 2,
+	WID_STR   = 3,
+	WID_ADR   = 4,
+	WID_BIN   = 5,
+	WID_IP    = 6,
+	WID_UNDEF = 7,
+	WID_TYPE_FORCE_32BIT  = 0xFFFFFFFF
+} tenuWIDtype;
+
+/* WLAN Identifiers */
+typedef enum {
+	WID_NIL                            = -1,
+	/* EMAC Character WID list */
+	WID_BSS_TYPE                       = 0x0000,
+	WID_CURRENT_TX_RATE                = 0x0001,
+	WID_CURRENT_CHANNEL                = 0x0002,
+	WID_PREAMBLE                       = 0x0003,
+	WID_11G_OPERATING_MODE             = 0x0004,
+	WID_STATUS                         = 0x0005,
+	WID_11G_PROT_MECH                  = 0x0006,
+	WID_SCAN_TYPE                      = 0x0007,
+	WID_PRIVACY_INVOKED                = 0x0008,
+	WID_KEY_ID                         = 0x0009,
+	WID_QOS_ENABLE                     = 0x000A,
+	WID_POWER_MANAGEMENT               = 0x000B,
+	WID_11I_MODE                       = 0x000C,
+	WID_AUTH_TYPE                      = 0x000D,
+	WID_SITE_SURVEY                    = 0x000E,
+	WID_LISTEN_INTERVAL                = 0x000F,
+	WID_DTIM_PERIOD                    = 0x0010,
+	WID_ACK_POLICY                     = 0x0011,
+	WID_RESET                          = 0x0012,
+	WID_PCF_MODE                       = 0x0013,
+	WID_CFP_PERIOD                     = 0x0014,
+	WID_BCAST_SSID                     = 0x0015,
+	WID_PHY_TEST_PATTERN               = 0x0016,
+	WID_DISCONNECT                     = 0x0016,
+	WID_READ_ADDR_SDRAM                = 0x0017,
+	WID_TX_POWER_LEVEL_11A             = 0x0018,
+	WID_REKEY_POLICY                   = 0x0019,
+	WID_SHORT_SLOT_ALLOWED             = 0x001A,
+	WID_PHY_ACTIVE_REG                 = 0x001B,
+	WID_PHY_ACTIVE_REG_VAL             = 0x001C,
+	WID_TX_POWER_LEVEL_11B             = 0x001D,
+	WID_START_SCAN_REQ                 = 0x001E,
+	WID_RSSI                           = 0x001F,
+	WID_JOIN_REQ                       = 0x0020,
+	WID_ANTENNA_SELECTION              = 0x0021,
+	WID_USER_CONTROL_ON_TX_POWER       = 0x0027,
+	WID_MEMORY_ACCESS_8BIT             = 0x0029,
+	WID_UAPSD_SUPPORT_AP               = 0x002A,
+	WID_CURRENT_MAC_STATUS             = 0x0031,
+	WID_AUTO_RX_SENSITIVITY            = 0x0032,
+	WID_DATAFLOW_CONTROL               = 0x0033,
+	WID_SCAN_FILTER                    = 0x0036,
+	WID_LINK_LOSS_THRESHOLD            = 0x0037,
+	WID_AUTORATE_TYPE                  = 0x0038,
+	WID_CCA_THRESHOLD                  = 0x0039,
+	WID_802_11H_DFS_MODE               = 0x003B,
+	WID_802_11H_TPC_MODE               = 0x003C,
+	WID_DEVICE_READY                   = 0x003D,
+	WID_PM_NULL_FRAME_INTERVAL         = 0x003E,
+	WID_PM_ACTIVITY_TIMER              = 0x003F,
+	WID_PM_NULL_FRAME_WAIT_ENABLE      = 0x0040,
+	WID_SCAN_WAIT_TIME                 = 0x0041,
+	WID_WSC_IE_EN                      = 0x0042,
+	WID_WPS_START                      = 0x0043,
+	WID_WPS_DEV_MODE                   = 0x0044,
+	WID_BT_COEXISTENCE                 = 0x0050,
+	WID_TRACKING_ROAMING               = 0x0070,
+	WID_NUM_PKTS_FOR_RSSI_AVG          = 0x0071,
+	WID_FHSS_SCAN_CHAN_INDEX           = 0x0072,
+	WID_FHSS_SCAN_STEP_INDEX           = 0x0073,
+
+	/* NMAC Character WID list */
+	WID_11N_PROT_MECH                  = 0x0080,
+	WID_11N_ERP_PROT_TYPE              = 0x0081,
+	WID_11N_ENABLE                     = 0x0082,
+	WID_11N_OPERATING_MODE             = 0x0083,
+	WID_11N_OBSS_NONHT_DETECTION       = 0x0084,
+	WID_11N_HT_PROT_TYPE               = 0x0085,
+	WID_11N_RIFS_PROT_ENABLE           = 0x0086,
+	WID_11N_SMPS_MODE                  = 0x0087,
+	WID_11N_CURRENT_TX_MCS             = 0x0088,
+	WID_11N_PRINT_STATS                = 0x0089,
+	WID_HUT_FCS_CORRUPT_MODE           = 0x008A,
+	WID_HUT_RESTART                    = 0x008B,
+	WID_HUT_TX_FORMAT                  = 0x008C,
+	WID_11N_SHORT_GI_20MHZ_ENABLE      = 0x008D,
+	WID_HUT_BANDWIDTH                  = 0x008E,
+	WID_HUT_OP_BAND                    = 0x008F,
+	WID_HUT_STBC                       = 0x0090,
+	WID_HUT_ESS                        = 0x0091,
+	WID_HUT_ANTSET                     = 0x0092,
+	WID_HUT_HT_OP_MODE                 = 0x0093,
+	WID_HUT_RIFS_MODE                  = 0x0094,
+	WID_HUT_SMOOTHING_REC              = 0x0095,
+	WID_HUT_SOUNDING_PKT               = 0x0096,
+	WID_HUT_HT_CODING                  = 0x0097,
+	WID_HUT_TEST_DIR                   = 0x0098,
+	WID_HUT_CAPTURE_MODE               = 0x0099,
+	WID_HUT_PHY_TEST_MODE              = 0x009A,
+	WID_HUT_PHY_TEST_RATE_HI           = 0x009B,
+	WID_HUT_PHY_TEST_RATE_LO           = 0x009C,
+	WID_HUT_DISABLE_RXQ_REPLENISH      = 0x009D,
+	WID_HUT_KEY_ORIGIN                 = 0x009E,
+	WID_HUT_BCST_PERCENT               = 0x009F,
+	WID_HUT_GROUP_CIPHER_TYPE          = 0x00A0,
+	WID_TX_ABORT_CONFIG                = 0x00A1,
+	WID_HOST_DATA_IF_TYPE              = 0x00A2,
+	WID_HOST_CONFIG_IF_TYPE            = 0x00A3,
+	WID_HUT_TSF_TEST_MODE              = 0x00A4,
+	WID_HUT_TSSI_VALUE                 = 0x00A5,
+	WID_HUT_PKT_TSSI_VALUE             = 0x00A5,
+	WID_REG_TSSI_11B_VALUE             = 0x00A6,
+	WID_REG_TSSI_11G_VALUE             = 0x00A7,
+	WID_REG_TSSI_11N_VALUE             = 0x00A8,
+	WID_TX_CALIBRATION                 = 0x00A9,
+	WID_DSCR_TSSI_11B_VALUE            = 0x00AA,
+	WID_DSCR_TSSI_11G_VALUE            = 0x00AB,
+	WID_DSCR_TSSI_11N_VALUE            = 0x00AC,
+	WID_HUT_RSSI_EX                    = 0x00AD,
+	WID_HUT_ADJ_RSSI_EX                = 0x00AE,
+	WID_11N_IMMEDIATE_BA_ENABLED       = 0x00AF,
+	WID_11N_TXOP_PROT_DISABLE          = 0x00B0,
+	WID_TX_POWER_LEVEL_11N             = 0x00B1,
+	WID_HUT_MGMT_PERCENT               = 0x00B3,
+	WID_HUT_MGMT_BCST_PERCENT          = 0x00B4,
+	WID_HUT_MGMT_ALLOW_HT              = 0x00B5,
+	WID_HUT_UC_MGMT_TYPE               = 0x00B6,
+	WID_HUT_BC_MGMT_TYPE               = 0x00B7,
+	WID_HUT_11W_MFP_REQUIRED_TX        = 0x00B8,
+	WID_HUT_11W_MFP_PEER_CAPABLE       = 0x00B9,
+	WID_HUT_11W_TX_IGTK_ID             = 0x00BA,
+	WID_11W_ENABLE                     = 0x00BB,
+	WID_11W_MGMT_PROT_REQ              = 0x00BC,
+	WID_USER_SEC_CHANNEL_OFFSET        = 0x00C0,
+	WID_2040_COEXISTENCE               = 0x00C1,
+	WID_HUT_FC_TXOP_MOD                = 0x00C2,
+	WID_HUT_FC_PROT_TYPE               = 0x00C3,
+	WID_HUT_SEC_CCA_ASSERT             = 0x00C4,
+	WID_2040_ENABLE                    = 0x00C5,
+	WID_2040_CURR_CHANNEL_OFFSET       = 0x00C6,
+	WID_2040_40MHZ_INTOLERANT          = 0x00C7,
+
+
+	/* Custom Character WID list */
+	WID_POWER_SAVE                     = 0x0100,
+	WID_WAKE_STATUS                    = 0x0101,
+	WID_WAKE_CONTROL                   = 0x0102,
+	WID_CCA_BUSY_START                 = 0x0103,
+
+	/* EMAC Short WID list */
+	WID_RTS_THRESHOLD                  = 0x1000,
+	WID_FRAG_THRESHOLD                 = 0x1001,
+	WID_SHORT_RETRY_LIMIT              = 0x1002,
+	WID_LONG_RETRY_LIMIT               = 0x1003,
+	WID_CFP_MAX_DUR                    = 0x1004,
+	WID_PHY_TEST_FRAME_LEN             = 0x1005,
+	WID_BEACON_INTERVAL                = 0x1006,
+	WID_MEMORY_ACCESS_16BIT            = 0x1008,
+	WID_RX_SENSE                       = 0x100B,
+	WID_ACTIVE_SCAN_TIME               = 0x100C,
+	WID_PASSIVE_SCAN_TIME              = 0x100D,
+	WID_SITE_SURVEY_SCAN_TIME          = 0x100E,
+	WID_JOIN_START_TIMEOUT             = 0x100F,
+	WID_AUTH_TIMEOUT                   = 0x1010,
+	WID_ASOC_TIMEOUT                   = 0x1011,
+	WID_11I_PROTOCOL_TIMEOUT           = 0x1012,
+	WID_EAPOL_RESPONSE_TIMEOUT         = 0x1013,
+	WID_WPS_PASS_ID                    = 0x1017,
+	WID_WPS_CONFIG_METHOD              = 0x1018,
+	WID_FHSS_INIT_SCAN_TIME            = 0x1070,
+	WID_FHSS_ROAM_SCAN_TIME            = 0x1071,
+
+	/* NMAC Short WID list */
+	WID_11N_RF_REG_VAL                 = 0x1080,
+	WID_HUT_FRAME_LEN                  = 0x1081,
+	WID_HUT_TXOP_LIMIT                 = 0x1082,
+	WID_HUT_SIG_QUAL_AVG               = 0x1083,
+	WID_HUT_SIG_QUAL_AVG_CNT           = 0x1084,
+	WID_11N_SIG_QUAL_VAL               = 0x1085,
+	WID_HUT_RSSI_EX_COUNT              = 0x1086,
+	WID_HUT_UC_MGMT_FRAME_LEN          = 0x1088,
+	WID_HUT_BC_MGMT_FRAME_LEN          = 0x1089,
+
+	/* Custom Short WID list */
+
+	WID_CCA_BUSY_STATUS                = 0x1100,
+
+	/* EMAC Integer WID list */
+	WID_FAILED_COUNT                   = 0x2000,
+	WID_RETRY_COUNT                    = 0x2001,
+	WID_MULTIPLE_RETRY_COUNT           = 0x2002,
+	WID_FRAME_DUPLICATE_COUNT          = 0x2003,
+	WID_ACK_FAILURE_COUNT              = 0x2004,
+	WID_RECEIVED_FRAGMENT_COUNT        = 0x2005,
+	WID_MCAST_RECEIVED_FRAME_COUNT     = 0x2006,
+	WID_FCS_ERROR_COUNT                = 0x2007,
+	WID_SUCCESS_FRAME_COUNT            = 0x2008,
+	WID_PHY_TEST_PKT_CNT               = 0x2009,
+	WID_HUT_TX_COUNT                   = 0x200A,
+	WID_TX_FRAGMENT_COUNT              = 0x200B,
+	WID_TX_MULTICAST_FRAME_COUNT       = 0x200C,
+	WID_RTS_SUCCESS_COUNT              = 0x200D,
+	WID_RTS_FAILURE_COUNT              = 0x200E,
+	WID_WEP_UNDECRYPTABLE_COUNT        = 0x200F,
+	WID_REKEY_PERIOD                   = 0x2010,
+	WID_REKEY_PACKET_COUNT             = 0x2011,
+	WID_1X_SERV_ADDR                   = 0x2012,
+	WID_STACK_IP_ADDR                  = 0x2013,
+	WID_STACK_NETMASK_ADDR             = 0x2014,
+	WID_HW_RX_COUNT                    = 0x2015,
+	WID_MEMORY_ADDRESS                 = 0x201E,
+	WID_MEMORY_ACCESS_32BIT            = 0x201F,
+	WID_RF_REG_VAL                     = 0x2021,
+	WID_FIRMWARE_INFO                  = 0x2023,
+	WID_DEV_OS_VERSION                 = 0x2025,
+	WID_ROAM_RSSI_THESHOLDS            = 0x2070,
+	WID_TRACK_INTERVAL_SEC             = 0x2071,
+	WID_FHSS_HOPPING_PARAMS            = 0x2072,
+	WID_FHSS_HOP_DWELL_TIME            = 0x2073,
+
+	/* NMAC Integer WID list */
+	WID_11N_PHY_ACTIVE_REG_VAL         = 0x2080,
+	WID_HUT_NUM_TX_PKTS                = 0x2081,
+	WID_HUT_TX_TIME_TAKEN              = 0x2082,
+	WID_HUT_TX_TEST_TIME               = 0x2083,
+	WID_HUT_LOG_INTERVAL               = 0x2084,
+
+	/* EMAC String WID list */
+	WID_SSID                           = 0x3000,
+	WID_FIRMWARE_VERSION               = 0x3001,
+	WID_OPERATIONAL_RATE_SET           = 0x3002,
+	WID_BSSID                          = 0x3003,
+	#if 0
+	WID_WEP_KEY_VALUE0                 = 0x3004,
+	#endif
+	WID_11I_PSK                        = 0x3008,
+	WID_11E_P_ACTION_REQ               = 0x3009,
+	WID_1X_KEY                         = 0x300A,
+	WID_HARDWARE_VERSION               = 0x300B,
+	WID_MAC_ADDR                       = 0x300C,
+	WID_HUT_DEST_ADDR                  = 0x300D,
+	/*WID_HUT_STATS                      = 0x300E,*/
+	WID_PHY_VERSION                    = 0x300F,
+	WID_SUPP_USERNAME                  = 0x3010,
+	WID_SUPP_PASSWORD                  = 0x3011,
+	WID_SITE_SURVEY_RESULTS            = 0x3012,
+	WID_RX_POWER_LEVEL                 = 0x3013,
+	WID_MANUFACTURER                   = 0x3026,             /*Added for CAPI tool */
+	WID_MODEL_NAME                                         = 0x3027,             /*Added for CAPI tool */
+	WID_MODEL_NUM                      = 0x3028,             /*Added for CAPI tool */
+	WID_DEVICE_NAME                                        = 0x3029,             /*Added for CAPI tool */
+
+	WID_ASSOC_RES_INFO                 = 0x3020,
+
+	/* NMAC String WID list */
+	WID_11N_P_ACTION_REQ               = 0x3080,
+	WID_HUT_TEST_ID                    = 0x3081,
+	WID_PMKID_INFO                     = 0x3082,
+
+	/* Custom String WID list */
+	WID_FLASH_DATA                     = 0x3100,
+	WID_EEPROM_DATA                    = 0x3101,
+	WID_SERIAL_NUMBER                  = 0x3102,
+
+	/* EMAC Binary WID list */
+	WID_UAPSD_CONFIG                   = 0x4001,
+	WID_UAPSD_STATUS                   = 0x4002,
+	WID_AC_PARAMS_AP                   = 0x4003,
+	WID_AC_PARAMS_STA                  = 0x4004,
+	WID_NEWORK_INFO                    = 0x4005,
+	WID_WPS_CRED_LIST                  = 0x4006,
+	WID_PRIM_DEV_TYPE                  = 0x4007,
+	WID_STA_JOIN_INFO                  = 0x4008,
+	WID_CONNECTED_STA_LIST             = 0x4009,
+
+	/* NMAC Binary WID list */
+	WID_11N_AUTORATE_TABLE             = 0x4080,
+	WID_HUT_TX_PATTERN                 = 0x4081,
+	WID_HUT_STATS                      = 0x4082,
+	WID_HUT_LOG_STATS                  = 0x4083,
+
+	/*BugID_3746 WID to add IE to be added in next probe request*/
+	WID_INFO_ELEMENT_PROBE	= 0x4085,
+	/*BugID_3746 WID to add IE to be added in next associate request*/
+	WID_INFO_ELEMENT_ASSOCIATE	= 0x4086,
+
+	/* Miscellaneous WIDs */
+	WID_ALL                            = 0x7FFE,
+	WID_MAX                            = 0xFFFF
+} tenuWIDid;
+#endif
+
+/* Status Codes for Authentication and Association Frames */
+typedef enum {
+	SUCCESSFUL_STATUSCODE	= 0,
+	UNSPEC_FAIL				  = 1,
+	UNSUP_CAP				  = 10,
+	REASOC_NO_ASOC				  = 11,
+	FAIL_OTHER				  = 12,
+	UNSUPT_ALG				  = 13,
+	AUTH_SEQ_FAIL			  = 14,
+	CHLNG_FAIL				  = 15,
+	AUTH_TIMEOUT			  = 16,
+	AP_FULL					  = 17,
+	UNSUP_RATE				  = 18,
+	SHORT_PREAMBLE_UNSUP	  = 19,
+	PBCC_UNSUP				  = 20,
+	CHANNEL_AGIL_UNSUP	  = 21,
+	SHORT_SLOT_UNSUP		  = 25,
+	OFDM_DSSS_UNSUP			  = 26,
+	CONNECT_STS_FORCE_16_BIT = 0xFFFF
+} tenuConnectSts;
+
+typedef struct {
+	WILC_Uint16 u16WIDid;
+	tenuWIDtype enuWIDtype;
+	WILC_Sint32 s32ValueSize;
+	WILC_Sint8      *ps8WidVal;
+
+} tstrWID;
+
+typedef struct {
+	WILC_Uint8 u8Full;
+	WILC_Uint8 u8Index;
+	WILC_Sint8 as8RSSI[NUM_RSSI];
+} tstrRSSI;
+/* This structure is used to support parsing of the received 'N' message */
+typedef struct {
+	WILC_Sint8 s8rssi;
+	WILC_Uint16 u16CapInfo;
+	WILC_Uint8 au8ssid[MAX_SSID_LEN];
+	WILC_Uint8 u8SsidLen;
+	WILC_Uint8 au8bssid[6];
+	WILC_Uint16 u16BeaconPeriod;
+	WILC_Uint8 u8DtimPeriod;
+	WILC_Uint8 u8channel;
+	unsigned long u32TimeRcvdInScanCached; /* of type unsigned long to be accepted by the linux kernel macro time_after() */
+	unsigned long u32TimeRcvdInScan;
+	WILC_Bool bNewNetwork;
+#ifdef AGING_ALG
+	WILC_Uint8 u8Found;
+#endif
+#ifdef WILC_P2P
+	WILC_Uint32 u32Tsf; /* time-stamp [Low only 32 bit] */
+#endif
+	WILC_Uint8 *pu8IEs;
+	WILC_Uint16 u16IEsLen;
+	void *pJoinParams;
+	tstrRSSI strRssi;
+	WILC_Uint64 u64Tsf; /* time-stamp [Low and High 64 bit] */
+} tstrNetworkInfo;
+
+/* This structure is used to support parsing of the received Association Response frame */
+typedef struct {
+	WILC_Uint16 u16capability;
+	WILC_Uint16 u16ConnectStatus;
+	WILC_Uint16 u16AssocID;
+	WILC_Uint8 *pu8RespIEs;
+	WILC_Uint16 u16RespIEsLen;
+} tstrConnectRespInfo;
+
+
+typedef struct {
+	WILC_Uint8 au8bssid[6];
+	WILC_Uint8 *pu8ReqIEs;
+	size_t ReqIEsLen;
+	WILC_Uint8 *pu8RespIEs;
+	WILC_Uint16 u16RespIEsLen;
+	WILC_Uint16 u16ConnectStatus;
+} tstrConnectInfo;
+
+
+
+typedef struct {
+	WILC_Uint16 u16reason;
+	WILC_Uint8 *ie;
+	size_t ie_len;
+} tstrDisconnectNotifInfo;
+
+#ifndef CONNECT_DIRECT
+typedef struct wid_site_survey_reslts {
+	WILC_Char SSID[MAX_SSID_LEN];
+	WILC_Uint8 BssType;
+	WILC_Uint8 Channel;
+	WILC_Uint8 SecurityStatus;
+	WILC_Uint8 BSSID[6];
+	WILC_Char RxPower;
+	WILC_Uint8 Reserved;
+
+} wid_site_survey_reslts_s;
+#endif
+
+extern WILC_Sint32 CoreConfiguratorInit(void);
+extern WILC_Sint32 CoreConfiguratorDeInit(void);
+
+extern WILC_Sint32 SendConfigPkt(WILC_Uint8 u8Mode, tstrWID *pstrWIDs,
+				 WILC_Uint32 u32WIDsCount, WILC_Bool bRespRequired, WILC_Uint32 drvHandler);
+extern WILC_Sint32 ParseNetworkInfo(WILC_Uint8 *pu8MsgBuffer, tstrNetworkInfo **ppstrNetworkInfo);
+extern WILC_Sint32 DeallocateNetworkInfo(tstrNetworkInfo *pstrNetworkInfo);
+
+extern WILC_Sint32 ParseAssocRespInfo(WILC_Uint8 *pu8Buffer, WILC_Uint32 u32BufferLen,
+				      tstrConnectRespInfo **ppstrConnectRespInfo);
+extern WILC_Sint32 DeallocateAssocRespInfo(tstrConnectRespInfo *pstrConnectRespInfo);
+
+#ifndef CONNECT_DIRECT
+extern WILC_Sint32 ParseSurveyResults(WILC_Uint8 ppu8RcvdSiteSurveyResults[][MAX_SURVEY_RESULT_FRAG_SIZE],
+				      wid_site_survey_reslts_s **ppstrSurveyResults, WILC_Uint32 *pu32SurveyResultsCount);
+extern WILC_Sint32 DeallocateSurveyResults(wid_site_survey_reslts_s *pstrSurveyResults);
+#endif
+
+extern WILC_Sint32 SendRawPacket(WILC_Sint8 *pspacket, WILC_Sint32 s32PacketLen);
+extern void NetworkInfoReceived(WILC_Uint8 *pu8Buffer, WILC_Uint32 u32Length);
+void GnrlAsyncInfoReceived(WILC_Uint8 *pu8Buffer, WILC_Uint32 u32Length);
+void host_int_ScanCompleteReceived(WILC_Uint8 *pu8Buffer, WILC_Uint32 u32Length);
+
+#endif

drivers/staging/wilc1000/fifo_buffer.c

+
+
+#include "wilc_oswrapper.h"
+#include "fifo_buffer.h"
+
+
+
+WILC_Uint32 FIFO_InitBuffer(tHANDLE *hBuffer, WILC_Uint32 u32BufferLength)
+{
+	WILC_Uint32 u32Error = 0;
+	tstrFifoHandler *pstrFifoHandler = WILC_MALLOC (sizeof (tstrFifoHandler));
+	if (pstrFifoHandler) {
+		WILC_memset (pstrFifoHandler, 0, sizeof (tstrFifoHandler));
+		pstrFifoHandler->pu8Buffer = WILC_MALLOC (u32BufferLength);
+		if (pstrFifoHandler->pu8Buffer)	{
+			tstrWILC_SemaphoreAttrs strSemBufferAttrs;
+			pstrFifoHandler->u32BufferLength = u32BufferLength;
+			WILC_memset (pstrFifoHandler->pu8Buffer, 0, u32BufferLength);
+			/* create semaphore */
+			WILC_SemaphoreFillDefault (&strSemBufferAttrs);
+			strSemBufferAttrs.u32InitCount = 1;
+			WILC_SemaphoreCreate(&pstrFifoHandler->SemBuffer, &strSemBufferAttrs);
+			*hBuffer = pstrFifoHandler;
+		} else {
+			*hBuffer = NULL;
+			u32Error = 1;
+		}
+	} else {
+		u32Error = 1;
+	}
+	return u32Error;
+}
+WILC_Uint32 FIFO_DeInit(tHANDLE hFifo)
+{
+	WILC_Uint32 u32Error = 0;
+	tstrFifoHandler *pstrFifoHandler = (tstrFifoHandler *) hFifo;
+	if (pstrFifoHandler) {
+		if (pstrFifoHandler->pu8Buffer)	{
+			WILC_FREE (pstrFifoHandler->pu8Buffer);
+		} else {
+			u32Error = 1;
+		}
+
+		WILC_SemaphoreDestroy (&pstrFifoHandler->SemBuffer, WILC_NULL);
+
+		WILC_FREE (pstrFifoHandler);
+	} else {
+		u32Error = 1;
+	}
+	return u32Error;
+}
+
+WILC_Uint32 FIFO_ReadBytes(tHANDLE hFifo, WILC_Uint8 *pu8Buffer, WILC_Uint32 u32BytesToRead, WILC_Uint32 *pu32BytesRead)
+{
+	WILC_Uint32 u32Error = 0;
+	tstrFifoHandler *pstrFifoHandler = (tstrFifoHandler *) hFifo;
+	if (pstrFifoHandler && pu32BytesRead) {
+		if (pstrFifoHandler->u32TotalBytes) {
+			if (WILC_SemaphoreAcquire(&pstrFifoHandler->SemBuffer, WILC_NULL) == WILC_SUCCESS) {
+				if (u32BytesToRead > pstrFifoHandler->u32TotalBytes) {
+					*pu32BytesRead = pstrFifoHandler->u32TotalBytes;
+				} else {
+					*pu32BytesRead = u32BytesToRead;
+				}
+				if ((pstrFifoHandler->u32ReadOffset + u32BytesToRead) <= pstrFifoHandler->u32BufferLength) {
+					WILC_memcpy(pu8Buffer, pstrFifoHandler->pu8Buffer + pstrFifoHandler->u32ReadOffset,
+						    *pu32BytesRead);
+					/* update read offset and total bytes */
+					pstrFifoHandler->u32ReadOffset += u32BytesToRead;
+					pstrFifoHandler->u32TotalBytes -= u32BytesToRead;
+
+				} else {
+					WILC_Uint32 u32FirstPart =
+						pstrFifoHandler->u32BufferLength - pstrFifoHandler->u32ReadOffset;
+					WILC_memcpy(pu8Buffer, pstrFifoHandler->pu8Buffer + pstrFifoHandler->u32ReadOffset,
+						    u32FirstPart);
+					WILC_memcpy(pu8Buffer + u32FirstPart, pstrFifoHandler->pu8Buffer,
+						    u32BytesToRead - u32FirstPart);
+					/* update read offset and total bytes */
+					pstrFifoHandler->u32ReadOffset = u32BytesToRead - u32FirstPart;
+					pstrFifoHandler->u32TotalBytes -= u32BytesToRead;
+				}
+				WILC_SemaphoreRelease (&pstrFifoHandler->SemBuffer, WILC_NULL);
+			} else {
+				u32Error = 1;
+			}
+		} else {
+			u32Error = 1;
+		}
+	} else {
+		u32Error = 1;
+	}
+	return u32Error;
+}
+
+WILC_Uint32 FIFO_WriteBytes(tHANDLE hFifo, WILC_Uint8 *pu8Buffer, WILC_Uint32 u32BytesToWrite, WILC_Bool bForceOverWrite)
+{
+	WILC_Uint32 u32Error = 0;
+	tstrFifoHandler *pstrFifoHandler = (tstrFifoHandler *) hFifo;
+	if (pstrFifoHandler) {
+		if (u32BytesToWrite < pstrFifoHandler->u32BufferLength)	{
+			if ((pstrFifoHandler->u32TotalBytes + u32BytesToWrite) <= pstrFifoHandler->u32BufferLength ||
+			    bForceOverWrite) {
+				if (WILC_SemaphoreAcquire(&pstrFifoHandler->SemBuffer, WILC_NULL) == WILC_SUCCESS) {
+					if ((pstrFifoHandler->u32WriteOffset + u32BytesToWrite) <= pstrFifoHandler->u32BufferLength) {
+						WILC_memcpy(pstrFifoHandler->pu8Buffer + pstrFifoHandler->u32WriteOffset, pu8Buffer,
+							    u32BytesToWrite);
+						/* update read offset and total bytes */
+						pstrFifoHandler->u32WriteOffset += u32BytesToWrite;
+						pstrFifoHandler->u32TotalBytes  += u32BytesToWrite;
+
+					} else {
+						WILC_Uint32 u32FirstPart =
+							pstrFifoHandler->u32BufferLength - pstrFifoHandler->u32WriteOffset;
+						WILC_memcpy(pstrFifoHandler->pu8Buffer + pstrFifoHandler->u32WriteOffset, pu8Buffer,
+							    u32FirstPart);
+						WILC_memcpy(pstrFifoHandler->pu8Buffer, pu8Buffer + u32FirstPart,
+							    u32BytesToWrite - u32FirstPart);
+						/* update read offset and total bytes */
+						pstrFifoHandler->u32WriteOffset = u32BytesToWrite - u32FirstPart;
+						pstrFifoHandler->u32TotalBytes += u32BytesToWrite;
+					}
+					/* if data overwriten */
+					if (pstrFifoHandler->u32TotalBytes > pstrFifoHandler->u32BufferLength) {
+						/* adjust read offset to the oldest data available */
+						pstrFifoHandler->u32ReadOffset = pstrFifoHandler->u32WriteOffset;
+						/* data availabe is the buffer length */
+						pstrFifoHandler->u32TotalBytes = pstrFifoHandler->u32BufferLength;
+					}
+					WILC_SemaphoreRelease(&pstrFifoHandler->SemBuffer, WILC_NULL);
+				}
+			} else {
+				u32Error = 1;
+			}
+		} else {
+			u32Error = 1;
+		}
+	} else {
+		u32Error = 1;
+	}
+	return u32Error;
+}
\ No newline at end of file

drivers/staging/wilc1000/fifo_buffer.h

+
+#include "wilc_oswrapper.h"
+
+
+#define tHANDLE	void *
+
+typedef struct {
+	WILC_Uint8		*pu8Buffer;
+	WILC_Uint32 u32BufferLength;
+	WILC_Uint32 u32WriteOffset;
+	WILC_Uint32 u32ReadOffset;
+	WILC_Uint32 u32TotalBytes;
+	WILC_SemaphoreHandle SemBuffer;
+} tstrFifoHandler;
+
+
+extern WILC_Uint32 FIFO_InitBuffer(tHANDLE *hBuffer,
+								   WILC_Uint32 u32BufferLength);
+extern WILC_Uint32 FIFO_DeInit(tHANDLE hFifo);
+extern WILC_Uint32 FIFO_ReadBytes(tHANDLE hFifo, WILC_Uint8 *pu8Buffer,
+				WILC_Uint32 u32BytesToRead, WILC_Uint32 *pu32BytesRead);
+extern WILC_Uint32 FIFO_WriteBytes(tHANDLE hFifo, WILC_Uint8 *pu8Buffer,
+				WILC_Uint32 u32BytesToWrite, WILC_Bool bForceOverWrite);
\ No newline at end of file

drivers/staging/wilc1000/itypes.h

+/*****************************************************************************/
+/*                                                                           */
+/*                     Ittiam 802.11 MAC SOFTWARE                            */
+/*                                                                           */
+/*                  ITTIAM SYSTEMS PVT LTD, BANGALORE                        */
+/*                           COPYRIGHT(C) 2005                               */
+/*                                                                           */
+/*  This program  is  proprietary to  Ittiam  Systems  Private  Limited  and */
+/*  is protected under Indian  Copyright Law as an unpublished work. Its use */
+/*  and  disclosure  is  limited by  the terms  and  conditions of a license */
+/*  agreement. It may not be copied or otherwise  reproduced or disclosed to */
+/*  persons outside the licensee's organization except in accordance with the*/
+/*  terms  and  conditions   of  such  an  agreement.  All  copies  and      */
+/*  reproductions shall be the property of Ittiam Systems Private Limited and*/
+/*  must bear this notice in its entirety.                                   */
+/*                                                                           */
+/*****************************************************************************/
+
+/*****************************************************************************/
+/*                                                                           */
+/*  File Name         : itypes.h                                             */
+/*                                                                           */
+/*  Description       : This file contains all the data type definitions for */
+/*                      MAC implementation.                                  */
+/*                                                                           */
+/*  List of Functions : None                                                 */
+/*  Issues / Problems : None                                                 */
+/*                                                                           */
+/*  Revision History  :                                                      */
+/*                                                                           */
+/*         DD MM YYYY   Author(s)       Changes                              */
+/*         01 05 2005   Ittiam          Draft                                */
+/*                                                                           */
+/*****************************************************************************/
+
+#ifndef ITYPES_H
+#define ITYPES_H
+
+
+/*****************************************************************************/
+/* Data Types                                                                */
+/*****************************************************************************/
+
+typedef int WORD32;
+typedef short WORD16;
+typedef char WORD8;
+typedef unsigned int UWORD32;
+typedef unsigned short UWORD16;
+typedef unsigned char UWORD8;
+
+/*****************************************************************************/
+/* Enums                                                                     */
+/*****************************************************************************/
+
+typedef enum {
+	BFALSE = 0,
+	BTRUE  = 1
+} BOOL_T;
+
+#endif /* ITYPES_H */

drivers/staging/wilc1000/linux_wlan_common.h

+#ifndef LINUX_WLAN_COMMON_H
+#define LINUX_WLAN_COMMON_H
+
+enum debug_region {
+	Generic_debug = 0,
+	Hostapd_debug,
+	Hostinf_debug,
+	CFG80211_debug,
+	Coreconfig_debug,
+	Interrupt_debug,
+	TX_debug,
+	RX_debug,
+	Lock_debug,
+	Tcp_enhance,
+	/*Added by amr - BugID_4720*/
+	Spin_debug,
+
+	Init_debug,
+	Bus_debug,
+	Mem_debug,
+	Firmware_debug,
+	COMP = 0xFFFFFFFF,
+};
+
+#define GENERIC_DBG			(1 << Generic_debug)
+#define HOSTAPD_DBG		(1 << Hostapd_debug)
+#define HOSTINF_DBG			(1 << Hostinf_debug)
+#define CORECONFIG_DBG		(1 << Coreconfig_debug)
+#define CFG80211_DBG		(1 << CFG80211_debug)
+#define INT_DBG				(1 << Interrupt_debug)
+#define TX_DBG				(1 << TX_debug)
+#define RX_DBG				(1 << RX_debug)
+#define LOCK_DBG			(1 << Lock_debug)
+#define TCP_ENH				(1 << Tcp_enhance)
+
+
+/*Added by Amr - BugID_4720*/
+#define SPIN_DEBUG			(1 << Spin_debug)
+
+#define INIT_DBG				(1 << Init_debug)
+#define BUS_DBG				(1 << Bus_debug)
+#define MEM_DBG				(1 << Mem_debug)
+#define FIRM_DBG			(1 << Firmware_debug)
+
+#if defined (WILC_DEBUGFS)
+extern int wilc_debugfs_init(void);
+extern void wilc_debugfs_remove(void);
+
+extern atomic_t REGION;
+extern atomic_t DEBUG_LEVEL;
+
+#define DEBUG		(1 << 0)
+#define INFO		(1 << 1)
+#define WRN			(1 << 2)
+#define ERR			(1 << 3)
+
+#define PRINT_D(region, ...)	 do { \
+		if ((atomic_read(&DEBUG_LEVEL) & DEBUG) && ((atomic_read(&REGION)) & (region))) { \
+			printk("DBG [%s: %d]", __FUNCTION__, __LINE__);	\
+			printk(__VA_ARGS__); \
+		} \
+} while (0)
+
+#define PRINT_INFO(region, ...) do { \
+		if ((atomic_read(&DEBUG_LEVEL) & INFO) && ((atomic_read(&REGION)) & (region))) { \
+			printk("INFO [%s]", __FUNCTION__); \
+			printk(__VA_ARGS__); \
+		} \
+} while (0)
+
+#define PRINT_WRN(region, ...) do { \
+		if ((atomic_read(&DEBUG_LEVEL) & WRN) && ((atomic_read(&REGION)) & (region))) {	\
+			printk("WRN [%s: %d]", __FUNCTION__, __LINE__);	\
+			printk(__VA_ARGS__); \
+		} \
+} while (0)
+
+#define PRINT_ER(...)	do { \
+		if ((atomic_read(&DEBUG_LEVEL) & ERR)) { \
+			printk("ERR [%s: %d]", __FUNCTION__, __LINE__);	\
+			printk(__VA_ARGS__); \
+		} \
+} while (0)
+
+#else
+
+#define REGION  (INIT_DBG | GENERIC_DBG | CFG80211_DBG | FIRM_DBG | HOSTAPD_DBG)
+
+#define DEBUG       1
+#define INFO        0
+#define WRN         0
+#define PRINT_D(region, ...)	 do { if (DEBUG == 1 && ((REGION)&(region))) { \
+											printk("DBG [%s: %d]", __FUNCTION__, __LINE__); \
+											printk(__VA_ARGS__); \
+										} \
+									} while (0)
+
+#define PRINT_INFO(region, ...) do { if (INFO == 1 && ((REGION)&(region))) { \
+											printk("INFO [%s]", __FUNCTION__); \
+											printk(__VA_ARGS__); \
+										} \
+								} while (0)
+
+#define PRINT_WRN(region, ...) do { if (WRN == 1 && ((REGION)&(region))) { \
+											printk("WRN [%s: %d]", __FUNCTION__, __LINE__); \
+											printk(__VA_ARGS__); \
+										} \
+								} while (0)
+
+#define PRINT_ER(...)	do { printk("ERR [%s: %d]", __FUNCTION__, __LINE__); \
+			     printk(__VA_ARGS__); \
+				 } while (0)
+#endif
+
+#define FN_IN   /* PRINT_D(">>> \n") */
+#define FN_OUT  /* PRINT_D("<<<\n") */
+
+#ifdef MEMORY_STATIC
+#define LINUX_RX_SIZE	(96 * 1024)
+#endif
+#define LINUX_TX_SIZE	(64 * 1024)
+
+
+#define WILC_MULTICAST_TABLE_SIZE	8
+
+#if defined (NM73131_0_BOARD)
+
+#define MODALIAS "wilc_spi"
+#define GPIO_NUM	IRQ_WILC1000_GPIO
+
+#elif defined (BEAGLE_BOARD)
+	#define SPI_CHANNEL	4
+
+	#if SPI_CHANNEL == 4
+		#define MODALIAS	"wilc_spi4"
+		#define GPIO_NUM	162
+	#else
+		#define MODALIAS	"wilc_spi3"
+		#define GPIO_NUM	133
+	#endif
+#elif defined(PANDA_BOARD)
+	#define MODALIAS	"WILC_SPI"
+	#define GPIO_NUM	139
+#elif defined(PLAT_WMS8304)             /* rachel */
+	#define MODALIAS	"wilc_spi"
+	#define GPIO_NUM	139
+#elif defined (PLAT_RKXXXX)
+ #define MODALIAS	"WILC_IRQ"
+ #define GPIO_NUM	RK30_PIN3_PD2 /* RK30_PIN3_PA1 */
+/* RK30_PIN3_PD2 */
+/* RK2928_PIN1_PA7 */
+
+#elif defined(CUSTOMER_PLATFORM)
+/*
+ TODO : specify MODALIAS name and GPIO number. This is certainly necessary for SPI interface.
+ *
+ * ex)
+ * #define MODALIAS  "WILC_SPI"
+ * #define GPIO_NUM  139
+ */
+
+#else
+/* base on SAMA5D3_Xplained Board */
+	#define MODALIAS	"WILC_SPI"
+	#define GPIO_NUM	0x44
+#endif
+
+
+void linux_wlan_enable_irq(void);
+#endif

drivers/staging/wilc1000/linux_wlan_sdio.c

+#include "wilc_wfi_netdevice.h"
+
+#include <linux/mmc/sdio_func.h>
+#include <linux/mmc/card.h>
+#include <linux/mmc/sdio_ids.h>
+#include <linux/mmc/sdio.h>
+#include <linux/mmc/host.h>
+
+
+
+#if defined (NM73131_0_BOARD)
+#define SDIO_MODALIAS "wilc_sdio"
+#else
+#define SDIO_MODALIAS "wilc1000_sdio"
+#endif
+
+#if defined (NM73131_0_BOARD)
+ #define MAX_SPEED 50000000
+#elif defined(CUSTOMER_PLATFORM)
+/* TODO : User have to stable bus clock as user's environment. */
+ #ifdef MAX_BUS_SPEED
+ #define MAX_SPEED MAX_BUS_SPEED
+ #else
+ #define MAX_SPEED 50000000
+ #endif
+#else
+ #define MAX_SPEED (6 * 1000000) /* Max 50M */
+#endif
+
+
+struct sdio_func *local_sdio_func;
+extern linux_wlan_t *g_linux_wlan;
+extern int wilc_netdev_init(void);
+extern int sdio_clear_int(void);
+extern void wilc_handle_isr(void);
+
+static unsigned int sdio_default_speed;
+
+#define SDIO_VENDOR_ID_WILC 0x0296
+#define SDIO_DEVICE_ID_WILC 0x5347
+
+static const struct sdio_device_id wilc_sdio_ids[] = {
+	{ SDIO_DEVICE(SDIO_VENDOR_ID_WILC, SDIO_DEVICE_ID_WILC) },
+};
+
+
+static void wilc_sdio_interrupt(struct sdio_func *func)
+{
+#ifndef WILC_SDIO_IRQ_GPIO
+	sdio_release_host(func);
+	wilc_handle_isr();
+	sdio_claim_host(func);
+#endif
+}
+
+
+int linux_sdio_cmd52(sdio_cmd52_t *cmd)
+{
+	struct sdio_func *func = g_linux_wlan->wilc_sdio_func;
+	int ret;
+	u8 data;
+
+	sdio_claim_host(func);
+
+	func->num = cmd->function;
+	if (cmd->read_write) {  /* write */
+		if (cmd->raw) {
+			sdio_writeb(func, cmd->data, cmd->address, &ret);
+			data = sdio_readb(func, cmd->address, &ret);
+			cmd->data = data;
+		} else {
+			sdio_writeb(func, cmd->data, cmd->address, &ret);
+		}
+	} else {        /* read */
+		data = sdio_readb(func, cmd->address, &ret);
+		cmd->data = data;
+	}
+
+	sdio_release_host(func);
+
+	if (ret < 0) {
+		PRINT_ER("wilc_sdio_cmd52..failed, err(%d)\n", ret);
+		return 0;
+	}
+	return 1;
+}
+
+
+int linux_sdio_cmd53(sdio_cmd53_t *cmd)
+{
+	struct sdio_func *func = g_linux_wlan->wilc_sdio_func;
+	int size, ret;
+
+	sdio_claim_host(func);
+
+	func->num = cmd->function;
+	func->cur_blksize = cmd->block_size;
+	if (cmd->block_mode)
+		size = cmd->count * cmd->block_size;
+	else
+		size = cmd->count;
+
+	if (cmd->read_write) {  /* write */
+		ret = sdio_memcpy_toio(func, cmd->address, (void *)cmd->buffer, size);
+	} else {        /* read */
+		ret = sdio_memcpy_fromio(func, (void *)cmd->buffer, cmd->address,  size);
+	}
+
+	sdio_release_host(func);
+
+
+	if (ret < 0) {
+		PRINT_ER("wilc_sdio_cmd53..failed, err(%d)\n", ret);
+		return 0;
+	}
+
+	return 1;
+}
+
+volatile int probe; /* COMPLEMENT_BOOT */
+static int linux_sdio_probe(struct sdio_func *func, const struct sdio_device_id *id)
+{
+	PRINT_D(INIT_DBG, "probe function\n");
+
+#ifdef COMPLEMENT_BOOT
+	if (local_sdio_func != NULL) {
+		local_sdio_func = func;
+		probe = 1;
+		PRINT_D(INIT_DBG, "local_sdio_func isn't NULL\n");
+		return 0;
+	}
+#endif
+	PRINT_D(INIT_DBG, "Initializing netdev\n");
+	local_sdio_func = func;
+	if (wilc_netdev_init()) {
+		PRINT_ER("Couldn't initialize netdev\n");
+		return -1;
+	}
+
+	printk("Driver Initializing success\n");
+	return 0;
+}
+
+static void linux_sdio_remove(struct sdio_func *func)
+{
+	/**
+	 *      TODO
+	 **/
+
+}
+
+struct sdio_driver wilc_bus = {
+	.name		= SDIO_MODALIAS,
+	.id_table	= wilc_sdio_ids,
+	.probe		= linux_sdio_probe,
+	.remove		= linux_sdio_remove,
+};
+
+int enable_sdio_interrupt(void)
+{
+	int ret = 0;
+#ifndef WILC_SDIO_IRQ_GPIO
+
+	sdio_claim_host(local_sdio_func);
+	ret = sdio_claim_irq(local_sdio_func, wilc_sdio_interrupt);
+	sdio_release_host(local_sdio_func);
+
+	if (ret < 0) {
+		PRINT_ER("can't claim sdio_irq, err(%d)\n", ret);
+		ret = -EIO;
+	}
+#endif
+	return ret;
+}
+
+void disable_sdio_interrupt(void)
+{
+
+#ifndef WILC_SDIO_IRQ_GPIO
+	int ret;
+
+	PRINT_D(INIT_DBG, "disable_sdio_interrupt IN\n");
+
+	sdio_claim_host(local_sdio_func);
+	ret = sdio_release_irq(local_sdio_func);
+	if (ret < 0) {
+		PRINT_ER("can't release sdio_irq, err(%d)\n", ret);
+	}
+	sdio_release_host(local_sdio_func);
+
+	PRINT_D(INIT_DBG, "disable_sdio_interrupt OUT\n");
+#endif
+}
+
+static int linux_sdio_set_speed(int speed)
+{
+	struct mmc_ios ios;
+	sdio_claim_host(local_sdio_func);
+
+	memcpy((void *)&ios, (void *)&local_sdio_func->card->host->ios, sizeof(struct mmc_ios));
+	local_sdio_func->card->host->ios.clock = speed;
+	ios.clock = speed;
+	local_sdio_func->card->host->ops->set_ios(local_sdio_func->card->host, &ios);
+	sdio_release_host(local_sdio_func);
+	PRINT_INFO(INIT_DBG, "@@@@@@@@@@@@ change SDIO speed to %d @@@@@@@@@\n", speed);
+
+	return 1;
+}
+
+static int linux_sdio_get_speed(void)
+{
+	return local_sdio_func->card->host->ios.clock;
+}
+
+int linux_sdio_init(void *pv)
+{
+
+	/**
+	 *      TODO :
+	 **/
+
+
+	sdio_default_speed = linux_sdio_get_speed();
+	return 1;
+}
+
+void linux_sdio_deinit(void *pv)
+{
+
+	/**
+	 *      TODO :
+	 **/
+
+
+	sdio_unregister_driver(&wilc_bus);
+}
+
+int linux_sdio_set_max_speed(void)
+{
+	return linux_sdio_set_speed(MAX_SPEED);
+}
+
+int linux_sdio_set_default_speed(void)
+{
+	return linux_sdio_set_speed(sdio_default_speed);
+}
+
+
+

drivers/staging/wilc1000/linux_wlan_sdio.h

+extern struct sdio_func *local_sdio_func;
+extern struct sdio_driver wilc_bus;
+
+#include <linux/mmc/sdio_func.h>
+
+int linux_sdio_init(void *);
+void linux_sdio_deinit(void *);
+int linux_sdio_cmd52(sdio_cmd52_t *cmd);
+int linux_sdio_cmd53(sdio_cmd53_t *cmd);
+int enable_sdio_interrupt(void);
+void disable_sdio_interrupt(void);
+int linux_sdio_set_max_speed(void);
+int linux_sdio_set_default_speed(void);
+

drivers/staging/wilc1000/linux_wlan_spi.h

+#ifndef LINUX_WLAN_SPI_H
+#define LINUX_WLAN_SPI_H
+
+#include <linux/spi/spi.h>
+extern struct spi_device *wilc_spi_dev;
+extern struct spi_driver wilc_bus;
+
+int linux_spi_init(void *vp);
+void linux_spi_deinit(void *vp);
+int linux_spi_write(uint8_t *b, uint32_t len);
+int linux_spi_read(uint8_t *rb, uint32_t rlen);
+int linux_spi_write_read(unsigned char *wb, unsigned char *rb, unsigned int rlen);
+int linux_spi_set_max_speed(void);
+#endif

drivers/staging/wilc1000/wilc_errorsupport.h

+#ifndef __WILC_ERRORSUPPORT_H__
+#define __WILC_ERRORSUPPORT_H__
+
+/*!
+ *  @file		wilc_errorsupport.h
+ *  @brief		Error reporting and handling support
+ *  @author		syounan
+ *  @sa			wilc_oswrapper.h top level OS wrapper file
+ *  @date		10 Aug 2010
+ *  @version		1.0
+ */
+
+#include "linux_wlan_common.h"
+
+/* Psitive Numbers to indicate sucess with special status */
+#define	WILC_ALREADY_EXSIT	(+100)    /** The requested object already exists */
+
+/* Generic success will return 0 */
+#define WILC_SUCCESS		0       /** Generic success */
+
+/* Negative numbers to indicate failures */
+#define	WILC_FAIL                -100   /** Generic Fail */
+#define	WILC_BUSY                -101   /** Busy with another operation*/
+#define	WILC_INVALID_ARGUMENT    -102   /** A given argument is invalid*/
+#define	WILC_INVALID_STATE		-103    /** An API request would violate the Driver state machine (i.e. to start PID while not camped)*/
+#define	WILC_BUFFER_OVERFLOW     -104   /** In copy operations if the copied data is larger than the allocated buffer*/
+#define WILC_NULL_PTR		-105    /** null pointer is passed or used */
+#define	WILC_EMPTY               -107
+#define WILC_FULL				-108
+#define	WILC_TIMEOUT			-109
+#define WILC_CANCELED		-110    /** The required operation have been canceled by the user*/
+#define WILC_INVALID_FILE	-112    /** The Loaded file is corruped or having an invalid format */
+#define WILC_NOT_FOUND		-113    /** Cant find the file to load */
+#define WILC_NO_MEM		-114
+#define WILC_UNSUPPORTED_VERSION -115
+#define WILC_FILE_EOF			-116
+
+
+/* Error type */
+typedef WILC_Sint32 WILC_ErrNo;
+
+#define WILC_IS_ERR(__status__) (__status__ < WILC_SUCCESS)
+
+#define WILC_ERRORCHECK(__status__) do { \
+		if (WILC_IS_ERR(__status__)) { \
+			PRINT_ER("PRINT_ER(%d)\n", __status__);	\
+			goto ERRORHANDLER; \
+		} \
+} while (0)
+
+#define WILC_ERRORREPORT(__status__, __err__) do { \
+		PRINT_ER("PRINT_ER(%d)\n", __err__); \
+		__status__ = __err__; \
+		goto ERRORHANDLER; \
+} while (0)
+
+#define  WILC_NULLCHECK(__status__, __ptr__)	do { \
+		if (__ptr__ == WILC_NULL) { \
+			WILC_ERRORREPORT(__status__, WILC_NULL_PTR); \
+		} \
+} while (0)
+
+#define WILC_CATCH(__status__) \
+ERRORHANDLER: \
+	if (WILC_IS_ERR(__status__)) \
+
+#ifdef CONFIG_WILC_ASSERTION_SUPPORT
+
+/**
+ * @brief	prints a diagnostic message and aborts the program
+ * @param[in]   pcExpression The expression that triggered the assertion
+ * @param[in]   pcFileName The name of the current source file.
+ * @param[in]   u32LineNumber The line number in the current source file.
+ * @warning DO NOT CALL DIRECTLY. USE EQUIVALENT MACRO FUNCTION INSTEAD.
+ */
+void WILC_assert_INTERNAL(WILC_Char *pcExpression, WILC_Char *pcFileName, WILC_Uint32 u32LineNumber);
+
+#define WILC_assert(__expression__) (void)(!!(__expression__) || (WILC_assert_INTERNAL((# __expression__), __WILC_FILE__, __WILC_LINE__), 0))
+
+#else
+#define WILC_assert(__expression__) ((void)0)
+#endif
+
+#endif

drivers/staging/wilc1000/wilc_log.h

+#ifndef __WILC_LOG_H__
+#define __WILC_LOG_H__
+
+/* Errors will always get printed */
+#define WILC_ERROR(...) do {  WILC_PRINTF("(ERR)(%s:%d) ", __WILC_FUNCTION__, __WILC_LINE__); \
+			      WILC_PRINTF(__VA_ARGS__); \
+				} while (0)
+
+/* Wraning only printed if verbosity is 1 or more */
+#if (WILC_LOG_VERBOSITY_LEVEL > 0)
+#define WILC_WARN(...) do { WILC_PRINTF("(WRN)"); \
+			    WILC_PRINTF(__VA_ARGS__); \
+				} while (0)
+#else
+#define WILC_WARN(...) (0)
+#endif
+
+/* Info only printed if verbosity is 2 or more */
+#if (WILC_LOG_VERBOSITY_LEVEL > 1)
+#define WILC_INFO(...) do {  WILC_PRINTF("(INF)"); \
+			     WILC_PRINTF(__VA_ARGS__); \
+				} while (0)
+#else
+#define WILC_INFO(...) (0)
+#endif
+
+/* Debug is only printed if verbosity is 3 or more */
+#if (WILC_LOG_VERBOSITY_LEVEL > 2)
+#define WILC_DBG(...) do { WILC_PRINTF("(DBG)(%s:%d) ", __WILC_FUNCTION__, __WILC_LINE__); \
+			   WILC_PRINTF(__VA_ARGS__); \
+			} while (0)
+
+#else
+#define WILC_DBG(...) (0)
+#endif
+
+/* Function In/Out is only printed if verbosity is 4 or more */
+#if (WILC_LOG_VERBOSITY_LEVEL > 3)
+#define WILC_FN_IN do { WILC_PRINTF("(FIN) (%s:%d) \n", __WILC_FUNCTION__, __WILC_LINE__);  } while (0)
+#define WILC_FN_OUT(ret) do { WILC_PRINTF("(FOUT) (%s:%d) %d.\n", __WILC_FUNCTION__, __WILC_LINE__, (ret));  } while (0)
+#else
+#define WILC_FN_IN (0)
+#define WILC_FN_OUT(ret) (0)
+#endif
+
+
+#endif
\ No newline at end of file