update

USDK/component/common/drivers/ethernet_mii/ethernet_mii.c

@@ -0,0 +1,251 @@
+#include "rtl8195a.h"
+#include "build_info.h"
+#ifdef PLATFORM_FREERTOS
+#include "FreeRTOS.h"
+#include "task.h"
+#include "semphr.h"
+#endif
+#include "osdep_service.h"
+#include "lwip_netconf.h"
+#include "ethernet_api.h"
+#include "lwip_intf.h"
+#include "ethernet_mii.h"
+#include "platform_opts.h"
+#include "ethernet_ex_api.h"
+
+#if defined(CONFIG_MII_EN)
+
+static _sema mii_rx_sema;
+static _mutex mii_tx_mutex;
+
+extern struct netif  xnetif[NET_IF_NUM];
+
+static u8 TX_BUFFER[1518];
+static u8 RX_BUFFER[1518];
+
+static u8 *pTmpTxDesc = NULL;
+static u8 *pTmpRxDesc = NULL;
+static u8 *pTmpTxPktBuf = NULL;
+static u8 *pTmpRxPktBuf = NULL;	
+
+
+int dhcp_ethernet_mii = 1;
+int ethernet_if_default = 0;
+
+extern int lwip_init_done;
+
+static _sema mii_linkup_sema;
+
+void mii_rx_thread(void* param){
+	u32 len = 0;
+	u8* pbuf = RX_BUFFER;
+	while(1){
+		if (rtw_down_sema(&mii_rx_sema) == _FAIL){
+			DBG_8195A("%s, Take Semaphore Fail\n", __FUNCTION__);
+			goto exit;
+		}
+		// continues read the rx ring until its empty
+		while(1){
+			len = ethernet_receive();
+			if(len){
+				//DBG_8195A("mii_recv len = %d\n\r", len);
+				ethernet_read(pbuf, len);
+// calculate the time duration
+				ethernetif_mii_recv(&xnetif[NET_IF_NUM - 1], len);		
+				//__rtl_memDump_v1_00(pbuf, len, "ethernet_receive Data:");
+				//rtw_memset(pbuf, 0, len);
+			}else if(len == 0){
+				break;
+			}
+		}
+	}
+exit:
+	rtw_free_sema(&mii_rx_sema);
+	vTaskDelete(NULL);
+}
+
+void dhcp_start_mii(void* param)
+{
+	while(1)
+	{
+		if (rtw_down_sema(&mii_linkup_sema) == _FAIL){
+			DBG_8195A("%s, Take Semaphore Fail\n", __FUNCTION__);
+			break;
+		}
+    LwIP_DHCP(NET_IF_NUM - 1, DHCP_START);
+	}
+	rtw_free_sema(&mii_linkup_sema);
+	vTaskDelete(NULL);
+}
+
+
+void mii_intr_handler(u32 Event, u32 Data)
+{
+	switch(Event)
+	{
+		case ETH_TXDONE:
+			//DBG_8195A("TX Data = %d\n", Data);
+			break;
+		case ETH_RXDONE:
+			//DBG_8195A("\r\nRX Data = %d\n", Data);
+			// wake up rx thread to receive data
+			rtw_up_sema_from_isr(&mii_rx_sema);
+			break;
+		case ETH_LINKUP:
+			DBG_8195A("Link Up\n");
+			
+      if(dhcp_ethernet_mii == 1)
+			  rtw_up_sema_from_isr(&mii_linkup_sema);
+			  
+			break;
+		case ETH_LINKDOWN:
+			DBG_8195A("Link Down\n");
+			  
+			break;
+		default:
+			DBG_8195A("Unknown event!\n");
+			break;
+	}
+}
+
+void ethernet_demo(void* param){
+	u8 mac[6];
+	/* Initilaize the LwIP stack */
+	// can not init twice
+	if(!lwip_init_done)
+	  LwIP_Init();
+	DBG_8195A("LWIP Init done\n");
+
+	ethernet_irq_hook(mii_intr_handler);
+
+    if(pTmpTxDesc)
+    {
+        free(pTmpTxDesc);
+        pTmpTxDesc = NULL;
+    }
+    if(pTmpRxDesc)
+    {
+        free(pTmpRxDesc);
+        pTmpRxDesc = NULL;
+    }
+    if(pTmpTxPktBuf)
+    {
+        free(pTmpTxPktBuf);
+        pTmpTxPktBuf = NULL;
+    }
+    if(pTmpRxPktBuf)
+    {
+        free(pTmpRxPktBuf);
+        pTmpRxPktBuf = NULL;
+    }
+    
+    pTmpTxDesc = (u8 *)malloc(/*MII_TX_DESC_CNT*/MII_TX_DESC_NO * ETH_TX_DESC_SIZE);
+    pTmpRxDesc = (u8 *)malloc(/*MII_RX_DESC_CNT*/MII_RX_DESC_NO * ETH_RX_DESC_SIZE);
+    pTmpTxPktBuf = (u8 *)malloc(/*MII_TX_DESC_CNT*/MII_TX_DESC_NO * ETH_PKT_BUF_SIZE);
+    pTmpRxPktBuf = (u8 *)malloc(/*MII_RX_DESC_CNT*/MII_RX_DESC_NO * ETH_PKT_BUF_SIZE);
+    if(pTmpTxDesc == NULL || pTmpRxDesc == NULL || pTmpTxPktBuf == NULL || pTmpRxPktBuf == NULL)
+    {
+        printf("TX/RX descriptor malloc fail\n");
+        return;
+    }
+    memset(pTmpTxDesc, 0, MII_TX_DESC_NO * ETH_TX_DESC_SIZE);
+    memset(pTmpRxDesc, 0, MII_RX_DESC_NO * ETH_RX_DESC_SIZE);
+    memset(pTmpTxPktBuf, 0, MII_TX_DESC_NO * ETH_PKT_BUF_SIZE);
+    memset(pTmpRxPktBuf, 0, MII_RX_DESC_NO * ETH_PKT_BUF_SIZE);
+    //size 160        128     12288   12288            
+    
+    ethernet_set_descnum(MII_TX_DESC_NO, MII_RX_DESC_NO);
+    printf("TRX descriptor number setting done\n");
+    ethernet_trx_pre_setting(pTmpTxDesc, pTmpRxDesc, pTmpTxPktBuf, pTmpRxPktBuf);
+    printf("TRX pre setting done\n");
+
+	ethernet_init();
+#if 0
+	DBG_INFO_MSG_OFF(_DBG_MII_);  
+	DBG_WARN_MSG_OFF(_DBG_MII_);
+	DBG_ERR_MSG_ON(_DBG_MII_);
+#endif
+	/*get mac*/
+	ethernet_address(mac);
+	memcpy((void*)xnetif[NET_IF_NUM - 1].hwaddr,(void*)mac, 6);
+
+	rtw_init_sema(&mii_rx_sema,0);
+	rtw_mutex_init(&mii_tx_mutex);
+
+	if(xTaskCreate(mii_rx_thread, ((const char*)"mii_rx_th"), 1024, NULL, tskIDLE_PRIORITY+5, NULL) != pdPASS)
+		DBG_8195A("\n\r%s xTaskCreate(mii_rx_thread) failed", __FUNCTION__);
+	
+	DBG_8195A("\nEthernet_mii Init done, interface %d",NET_IF_NUM - 1);
+	
+	if(dhcp_ethernet_mii == 1)
+	  LwIP_DHCP(NET_IF_NUM - 1, DHCP_START);
+	
+	vTaskDelete(NULL);
+}
+
+void ethernet_mii_init()
+{
+	printf("\ninitializing Ethernet_mii......\n");
+  
+  // set the ethernet interface as default
+  ethernet_if_default = 1;
+  rtw_init_sema(&mii_linkup_sema,0);
+  
+	if( xTaskCreate((TaskFunction_t)dhcp_start_mii, "DHCP_MII", 1024, NULL, 2, NULL) != pdPASS) {
+		DBG_8195A("Cannot create demo task\n\r");
+	}	
+
+	if( xTaskCreate((TaskFunction_t)ethernet_demo, "ETH_DEMO", 1024, NULL, 2, NULL) != pdPASS) {
+		DBG_8195A("Cannot create demo task\n\r");
+	}
+	
+}
+
+
+void rltk_mii_recv(struct eth_drv_sg *sg_list, int sg_len){
+	struct eth_drv_sg *last_sg;
+	u8* pbuf = RX_BUFFER;
+
+	for (last_sg = &sg_list[sg_len]; sg_list < last_sg; ++sg_list) {
+		if (sg_list->buf != 0) {
+			rtw_memcpy((void *)(sg_list->buf), pbuf, sg_list->len);
+			pbuf+=sg_list->len;
+		}			 
+	}
+}
+
+
+s8 rltk_mii_send(struct eth_drv_sg *sg_list, int sg_len, int total_len){
+	int ret =0;
+	struct eth_drv_sg *last_sg;
+	u8* pdata = TX_BUFFER;
+	u8	retry_cnt = 0;
+	u32 size = 0;
+	for (last_sg = &sg_list[sg_len]; sg_list < last_sg; ++sg_list) {
+		rtw_memcpy(pdata, (void *)(sg_list->buf), sg_list->len);
+		pdata += sg_list->len;
+		size += sg_list->len;		
+	}
+	pdata = TX_BUFFER;
+	//DBG_8195A("mii_send len= %d\n\r", size);
+	rtw_mutex_get(&mii_tx_mutex);
+	while(1){
+		ret = ethernet_write(pdata, size);
+		if(ret > 0){
+			ethernet_send();
+			ret = 0;
+			break;
+		}
+		if(++retry_cnt > 3){
+			DBG_8195A("TX drop\n\r");
+			ret = -1;
+		}
+		else
+			rtw_udelay_os(1);
+	}
+	rtw_mutex_put(&mii_tx_mutex);
+
+	return ret; 	
+}
+
+#endif //CONFIG_MII_EN

USDK/component/common/drivers/ethernet_mii/ethernet_mii.h

@@ -0,0 +1,12 @@
+#ifndef __MII_ETHERNETIF_H__
+#define __MII_ETHERNETIF_H__
+
+#include "lwip_netconf.h"
+
+#define MII_TX_DESC_CNT		4
+#define MII_RX_DESC_CNT		10
+#if CONFIG_ETHERNET
+extern s8 rltk_mii_send(struct eth_drv_sg *sg_list, int sg_len, int total_len);
+extern void rltk_mii_recv(struct eth_drv_sg *sg_list, int sg_len);
+#endif
+#endif // __MII_ETHERNETIF_H__

USDK/component/common/drivers/i2s/alc5651.c

@@ -0,0 +1,196 @@
+#include <stdio.h>
+#include "PinNames.h"
+#include "basic_types.h"
+#include "diag.h" 
+#include <osdep_api.h>
+
+#include "i2c_api.h"
+#include "pinmap.h"
+
+//#define I2C_MTR_SDA			PC_4//PB_3
+//#define I2C_MTR_SCL			PC_5//PB_2
+#define I2C_MTR_SDA			PB_3
+#define I2C_MTR_SCL			PB_2
+#define I2C_BUS_CLK			100000  //hz
+
+#define I2C_ALC5651_ADDR	(0x34/2)
+
+#define RT5651_PRIV_INDEX	0x6a
+#define RT5651_PRIV_DATA	0x6c
+	 
+#if defined (__ICCARM__)
+i2c_t   alc5651_i2c;
+#else
+volatile i2c_t   alc5651_i2c;
+#define printf  DBG_8195A
+#endif
+
+static void alc5651_delay(void)
+{
+    int i;
+
+	i=10000;
+    while (i) {
+        i--;
+        asm volatile ("nop\n\t");
+    }
+}
+
+void alc5651_reg_write(unsigned int reg, unsigned int value)
+{
+	char buf[4];
+	buf[0] = (char)reg;
+	buf[1] = (char)(value>>8);
+	buf[2] = (char)(value&0xff);
+	
+	i2c_write(&alc5651_i2c, I2C_ALC5651_ADDR, &buf[0], 3, 1);
+	alc5651_delay();
+}
+
+void alc5651_reg_read(unsigned int reg, unsigned int *value)
+{
+	int tmp;
+	char *buf = (char*)&tmp;	
+	
+	buf[0] = (char)reg;
+	i2c_write(&alc5651_i2c, I2C_ALC5651_ADDR, &buf[0], 1, 1);
+	alc5651_delay();
+	
+	buf[0] = 0xaa;
+	buf[1] = 0xaa;
+	
+	i2c_read(&alc5651_i2c, I2C_ALC5651_ADDR, &buf[0], 2, 1);
+	alc5651_delay();
+	
+	*value= ((buf[0]&0xFF)<<8)|(buf[1]&0xFF); 
+}
+
+void alc5651_index_write(unsigned int reg, unsigned int value)
+{
+	alc5651_reg_write(RT5651_PRIV_INDEX, reg);
+	alc5651_reg_write(RT5651_PRIV_DATA, value);
+}
+
+void alc5651_index_read(unsigned int reg, unsigned int *value)
+{
+	alc5651_reg_write(RT5651_PRIV_INDEX, reg);
+	alc5651_reg_read(RT5651_PRIV_DATA, value);
+}
+
+void alc5651_reg_dump(void)
+{
+	int i;
+	unsigned int value;
+  
+	printf("alc5651 codec reg dump\n\r");
+	printf("------------------------\n\r");
+	for(i=0;i<=0xff;i++){
+		alc5651_reg_read(i, &value);
+		printf("%02x : %04x\n\r", i, (unsigned short)value);
+	}
+	printf("------------------------\n\r");
+}
+
+void alc5651_index_dump(void)
+{
+	int i;
+	unsigned int value;
+  
+	printf("alc5651 codec index dump\n\r");
+	printf("------------------------\n\r");
+	for(i=0;i<=0xff;i++){
+		alc5651_index_read(i, &value);
+		printf("%02x : %04x\n\r", i, (unsigned short)value);
+	}
+	printf("------------------------\n\r");
+}
+
+void alc5651_init(void)
+{
+    i2c_init(&alc5651_i2c, I2C_MTR_SDA, I2C_MTR_SCL);
+    i2c_frequency(&alc5651_i2c, I2C_BUS_CLK);
+}
+
+void alc5651_set_word_len(int len_idx)	// interface2
+{
+	// 0: 16 1: 20 2: 24 3: 8
+	unsigned int val;
+	alc5651_reg_read(0x71,&val);
+	val &= (~(0x3<<2));
+	val |= (len_idx<<2);
+	alc5651_reg_write(0x71,val);
+	alc5651_reg_read(0x70,&val);
+	val &= (~(0x3<<2));
+	val |= (len_idx<<2);
+	alc5651_reg_write(0x70,val);	
+	
+}
+
+void alc5651_init_interface1(void)
+{
+    alc5651_reg_write(0x00,0x0021);
+    alc5651_reg_write(0x63,0xE8FE);
+    alc5651_reg_write(0x61,0x5800);
+    alc5651_reg_write(0x62,0x0C00);
+    alc5651_reg_write(0x73,0x0000);
+    alc5651_reg_write(0x2A,0x4242);
+    alc5651_reg_write(0x45,0x2000);
+    alc5651_reg_write(0x02,0x4848);
+    alc5651_reg_write(0x8E,0x0019);
+    alc5651_reg_write(0x8F,0x3100);
+    alc5651_reg_write(0x91,0x0E00);
+    alc5651_index_write(0x3D,0x3E00);
+    alc5651_reg_write(0xFA,0x0011);
+    alc5651_reg_write(0x83,0x0800);
+    alc5651_reg_write(0x84,0xA000);
+    alc5651_reg_write(0xFA,0x0C11);
+    alc5651_reg_write(0x64,0x4010);
+    alc5651_reg_write(0x65,0x0C00);
+    alc5651_reg_write(0x61,0x5806);
+    alc5651_reg_write(0x62,0xCC00);
+    alc5651_reg_write(0x3C,0x004F);
+    alc5651_reg_write(0x3E,0x004F);
+    alc5651_reg_write(0x27,0x3820);
+    alc5651_reg_write(0x77,0x0000);	
+}
+
+void alc5651_init_interface2(void)
+{
+  	int reg_value=0;
+    alc5651_reg_write(0x00,0x0021);//reset all, device id 1
+	alc5651_reg_write(0x63,0xE8FE);//Power managerment control 3: 
+	//VREF1&2 on, both slow VREF, MBIAS on, MBIAS bandcap power on, L & R HP Amp on, improve HP Amp driving enabled
+	alc5651_reg_write(0x61,0x5800);//power managerment control 1:
+	//I2S2 digital interface on, Analog DACL1 & DACR1 on. 
+    alc5651_reg_write(0x62,0x0C00);//stereo1 & 2 DAC filter power on
+	alc5651_reg_write(0x73,0x0000);//ADC/DAC Clock control 1:
+	//I2S Clock Pre-Divider 1 & 2: /1.  Stereo DAC Over Sample Rate : 128Fs
+    alc5651_reg_write(0x2A,0x4242);//Stereo DAC digital mixer control
+	//Un-mute DACL2 to Stereo DAC Left & Right Mixer
+	alc5651_reg_write(0x45,0x2000);//HPOMIX: Un-mute DAC1 to HPOMIX
+	alc5651_reg_write(0x02,0x4848);//HP Output Control:
+	//Unmute HPOL, HPOR
+//    alc5651_reg_write(0x0F,0x1F1F);//INL & INR Volume Control
+//    alc5651_reg_write(0x0D,0x0800);//IN1/2 Input Control
+//    alc5651_reg_write(0x1C,0x7F7F);//Stereo1 ADC Digital Volume Control
+//    alc5651_reg_write(0x1E,0xF000);// ADC Digital Boost Gain Control
+    alc5651_reg_write(0x8E,0x0019);//HP Amp Control 1
+//	Enable HP Output, Charge Pump Power On, HP Amp All Power On
+    alc5651_reg_write(0x8F,0x3100);//HP Amp Control 2, HP Depop Mode 2
+    alc5651_reg_write(0x91,0x0E00);//HP Amp Control 3, select HP capless power mode
+    alc5651_index_write(0x3D,0x3E00);//unknown
+    alc5651_reg_write(0xFA,0x0011);//enable input clock
+    alc5651_reg_write(0x83,0x0800);//default ASRC control 1
+	alc5651_reg_write(0x84,0xA000);//ASRC control 2: I2S1 enable ASRC mode, Sterol1 DAC filter ASRC mode. 
+//	alc5651_reg_write(0xFA,0x0C11);//?  ?  ?  MX-FAh[15:4]reserved
+	alc5651_reg_write(0x64,0x4010);//power managerment control 4: 
+	//MIC BST2 Power On; MIC2 SE Mode single-end mode or line-input mode
+	alc5651_reg_write(0x65,0x0C00);//power managerment control 5:  RECMIX L & R power on
+	alc5651_reg_write(0x61,0x5806);//power managerment control 1: 
+//	I2S2 Digital Interface On, Analog DACL1, DACR1 power on; Analog ADCL, ADCR power on
+	alc5651_reg_write(0x62,0xCC00);//power managerment control 2: Stereo1&2 ADC/DAC digital filter power on
+    alc5651_reg_write(0x3C,0x004F);//RECMIXL
+    alc5651_reg_write(0x3E,0x004F);//RECMIXR
+	alc5651_reg_write(0x28,0x3030);//stereo2 ADC digital mixer control : Mute Stereo2 ADC L&R channel, ADCR
+	alc5651_reg_write(0x2F,0x0080);	//Interface DAC/ADC Data control: Select IF2 ADCDAT Data Source IF1_ADC2 
+}

USDK/component/common/drivers/sdio/realtek/sdio_host/inc/sd.h

@@ -0,0 +1,39 @@
+#ifndef _SD_DRIVER_H
+#define _SD_DRIVER_H
+
+#include "basic_types.h"
+
+#define CONFIG_SD_SDIO	1
+#define CONFIG_SD_SPI	0
+
+typedef enum
+{
+	SD_OK = 0,
+	SD_PROTECTED,
+	SD_NODISK,
+	SD_INITERR,
+	SD_ERROR,
+}SD_RESULT;
+
+typedef enum{
+	SD_CLK_LOW,		// 10.4MHz
+	SD_CLK_MID,		// 20.8MHz
+	SD_CLK_HIGH,	// 41.6MHz
+	SD_CLK_RSV,		// 5.2MHz
+}SD_CLK;
+
+SD_RESULT SD_WaitReady(void);                        
+SD_RESULT SD_Init(void);     
+SD_RESULT SD_DeInit(void);   
+SD_RESULT SD_SetCLK(SD_CLK CLK);
+
+SD_RESULT SD_Status(void);
+
+SD_RESULT SD_GetCID(u8 *cid_data);  // read sd card CID
+SD_RESULT SD_GetCSD(u8 *csd_data);  // read sd card CSD
+SD_RESULT SD_GetCapacity(u32* sector_count);    // read sd card Capacity
+
+SD_RESULT SD_ReadBlocks(u32 sector,u8 *data,u32 count); //read multi sector
+SD_RESULT SD_WriteBlocks(u32 sector,const u8 *data,u32 count);  //write multi sector
+
+#endif

USDK/component/common/drivers/sdio/realtek/sdio_host/inc/sdio_host.h

@@ -0,0 +1,43 @@
+#ifndef _SDIO_HOST_H
+#define _SDIO_HOST_H
+#include "basic_types.h"
+#include "rtl8195a_sdio_host.h"
+
+#define SDIO_HOST_BYTES_ALINGMENT	4
+
+typedef enum{
+	SDIO_INIT_NONE = -1,
+	SDIO_INIT_FAIL = 0,
+	SDIO_INIT_OK = 1,
+	SDIO_SD_NONE = 2,
+	SDIO_SD_OK = 3,
+}_sdio_init_s;
+
+extern _sdio_init_s sdio_status;
+
+typedef void (*sdio_sd_irq_handler)(void* param);
+
+
+s8 sdio_init_host(void);	// init sdio host interface
+void sdio_deinit_host(void);
+
+s8 sdio_sd_init(void);	// init sd card through sdio
+void sdio_sd_deinit(void);	//de-init sd card through sdio
+s8 sdio_sd_status(void);
+u32 sdio_sd_getCapacity(void);
+s8 sdio_sd_getProtection(void);
+s8 sdio_sd_setProtection(bool protection);
+s8 sdio_sd_getCSD(u8* CSD);
+s8 sdio_sd_isReady();
+s8 sdio_sd_setClock(SD_CLK_FREQUENCY SDCLK);
+
+
+s8 sdio_read_blocks(u32 sector, u8 *buffer, u32 count);
+s8 sdio_write_blocks(u32 sector, const u8 *buffer, u32 count);
+
+s8 sdio_sd_hook_xfer_cmp_cb(IN sdio_sd_irq_handler CallbackFun,IN VOID *param);
+s8 sdio_sd_hook_remove_cb(IN sdio_sd_irq_handler CallbackFun,IN VOID *param);
+s8 sdio_sd_hook_insert_cb(IN sdio_sd_irq_handler CallbackFun,IN VOID *param);
+s8 sdio_sd_hook_xfer_err_cb(IN sdio_sd_irq_handler CallbackFun,IN VOID *param);
+
+#endif

USDK/component/common/drivers/sdio/realtek/sdio_host/src/sd.c

@@ -0,0 +1,176 @@
+/*
+ * sd.c (disasm ds.o)
+ *
+ * RTL8710/11 pvvx 12/2016
+ */
+
+#include "rtl8195a.h"
+#ifdef CONFIG_SDIO_HOST_EN
+#include "sd.h"
+#include "sdio_host.h"
+
+#define SIZE_BLOCK_ADMA 512
+
+SemaphoreHandle_t sdWSema;
+
+void sd_xfer_done_callback(void *obj) {
+	RtlUpSema(&sdWSema);
+}
+
+void sd_xfer_err_callback(void *obj) {
+	DBG_SDIO_ERR("sd_xfer_err_callback \r\n");
+}
+
+//----- SD_WaitReady
+SD_RESULT SD_WaitReady() {
+	return SD_OK;
+}
+
+//----- SD_Init
+SD_RESULT SD_Init() {
+	SD_RESULT result;
+
+	if (sdio_sd_init() != 0)
+		result = SD_INITERR;
+	else {
+		if (sdio_sd_getProtection() != 0)
+			result = SD_PROTECTED;
+		RtlInitSema(&sdWSema, 0);
+		sdio_sd_hook_xfer_cmp_cb(sd_xfer_done_callback, 0);
+		sdio_sd_hook_xfer_err_cb(sd_xfer_err_callback, 0);
+	}
+	return result;
+}
+
+//----- SD_DeInit
+SD_RESULT SD_DeInit() {
+	sdio_sd_deinit();
+	RtlFreeSema(&sdWSema);
+	return SD_OK;
+}
+
+//----- SD_SetCLK
+SD_RESULT SD_SetCLK(SD_CLK CLK) {
+	SD_RESULT result;
+	switch (CLK) {
+	case SD_CLK_HIGH:
+		result = sdio_sd_setClock(SD_CLK_41_6MHZ);
+		break;
+	case SD_CLK_MID:
+		result = sdio_sd_setClock(SD_CLK_20_8MHZ);
+		break;
+	case SD_CLK_LOW:
+		result = sdio_sd_setClock(SD_CLK_10_4MHZ);
+		break;
+	case SD_CLK_RSV:
+		result = sdio_sd_setClock(SD_CLK_5_2MHZ);
+		break;
+	default:
+//		DBG_SDIO_INFO("clk = %d ?\n", CLK);
+		return SD_ERROR;
+	}
+	if (result)
+		return SD_ERROR;
+	return SD_OK;
+}
+
+//----- SD_Status
+SD_RESULT SD_Status() {
+	if (sdio_sd_isReady())
+		return SD_NODISK;
+	else
+		return sdio_sd_getProtection() != 0;
+}
+
+//----- SD_GetCID
+SD_RESULT SD_GetCID(u8 *cid_data) {
+	return SD_OK;
+}
+
+//----- SD_GetCSD
+SD_RESULT SD_GetCSD(u8 *csd_data) {
+	if (sdio_sd_getCSD(csd_data))
+		return SD_ERROR;
+	else
+		return SD_OK;
+}
+
+//----- SD_GetCapacity
+SD_RESULT SD_GetCapacity(uint32_t *sector_count) {
+
+	u32 sc = sdio_sd_getCapacity();
+	*sector_count = sc;
+	if (sc != 0)
+		return SD_OK;
+	else
+		return SD_ERROR;
+}
+
+//----- SD_ReadBlocks
+SD_RESULT SD_ReadBlocks(u32 sector, u8 *data, u32 count) {
+	int rd_count;
+	unsigned char * buf;
+
+	if ((u32) data & 3) {
+		buf = pvPortMalloc(SIZE_BLOCK_ADMA);
+		if (buf == NULL)
+			DBG_SDIO_ERR("Fail to malloc cache for SDIO host!\n");
+		u32 end_sector = count + sector;
+		while (sector < end_sector) {
+			rd_count = sdio_read_blocks(sector, buf, 1);
+//			rtl_printf("rd_counts = %d\n", rd_count);
+			if (rd_count == 0 && RtlDownSemaWithTimeout(&sdWSema, 1000) != 1) {
+				DBG_SDIO_ERR("SD_ReadBlocks timeout\n");
+				return SD_ERROR;
+			}
+			rtl_memcpy(data, buf, SIZE_BLOCK_ADMA);
+			sector++;
+			data += SIZE_BLOCK_ADMA;
+		}
+		vPortFree(buf);
+		if (rd_count)
+			return SD_ERROR;
+		return SD_OK;
+	} else {
+		if (sdio_read_blocks(sector, data, count) == 0) {
+			if (RtlDownSemaWithTimeout(&sdWSema, 1000) == 1)
+				return SD_OK;
+			DBG_SDIO_ERR("SD_ReadBlocks timeout\n");
+		}
+	}
+
+	return SD_ERROR;
+}
+
+//----- SD_WriteBlocks
+SD_RESULT SD_WriteBlocks(u32 sector, const u8 *data, u32 count) {
+	int wr_count;
+	unsigned char * buf;
+
+	if ((u32) data & 3) {
+		buf = pvPortMalloc(SIZE_BLOCK_ADMA);
+		if (buf == NULL)
+			DBG_SDIO_ERR("Fail to malloc cache for SDIO host!\n");
+		u32 end_sector = count + sector;
+		while (sector != end_sector) {
+			rtl_memcpy(buf, data, SIZE_BLOCK_ADMA);
+			wr_count = sdio_write_blocks(sector, buf, 1);
+			if (wr_count == 0 && RtlDownSemaWithTimeout(&sdWSema, 1000) != 1) {
+				DBG_SDIO_ERR("SD_WriteBlocks timeout\n");
+				return SD_ERROR;
+			}
+			sector++;
+			data += SIZE_BLOCK_ADMA;
+		}
+		vPortFree(buf);
+		if (wr_count == 0)
+			return SD_OK;
+	} else if (sdio_write_blocks(sector, data, count) == 0) {
+		if (RtlDownSemaWithTimeout(&sdWSema, 1000) == 1)
+			return SD_OK;
+		DBG_SDIO_ERR("SD_WriteBlocks timeout\n");
+	}
+	return SD_ERROR;
+
+}
+#endif // CONFIG_SDIO_HOST_EN

USDK/component/common/drivers/sdio/realtek/sdio_host/src/sdio_host.c

@@ -0,0 +1,408 @@
+/* 
+ * sdio_host.c (disasm sdio_host.o)
+ *
+ * RTL8710/11 pvvx 12/2016
+ */
+
+#include "rtl8195a.h"
+#ifdef CONFIG_SDIO_HOST_EN
+#include "sd.h"
+#include "sdio_host.h"
+#include "hal_sdio_host.h"
+#include "rtl8195a_sdio_host.h"
+//#include "hal_sdio.h"
+//#include "PinNames.h"
+//#include "pinmap.h"
+
+#define MAX_BUF_ADMA 64
+#define SIZE_BLOCK_ADMA 512
+//-------------------------------------------------------------------------
+// Function declarations
+//-------------------------------------------------------------------------
+// Data declarations
+sdio_sd_irq_handler xfer_done_irq_handler;
+uint32_t xfer_err_irq_data;
+uint32_t xfer_done_irq_data;
+sdio_sd_irq_handler xfer_err_irq_handler;
+_sdio_init_s sdio_status = SDIO_INIT_NONE;
+sdio_sd_irq_handler card_remove_irq_handler;
+uint32_t card_remove_irq_data;
+sdio_sd_irq_handler card_insert_irq_handler;
+uint32_t card_insert_irq_data;
+HAL_SDIO_HOST_OP HalSdioHostOp;
+s8 sd_protected = -1;
+HAL_SDIO_HOST_ADAPTER SdioHostAdapter;
+SRAM_BF_DATA_SECTION ADMA2_DESC_FMT gAdmaTbls[MAX_BUF_ADMA];
+//-------------------------------------------------------------------------
+
+void xfer_done_callback(void *param) {
+	if (xfer_done_irq_handler)
+		xfer_done_irq_handler((void *) xfer_done_irq_data);
+}
+
+void xfer_err_callback(void *param) {
+	if (xfer_err_irq_handler)
+		xfer_err_irq_handler((void *) xfer_err_irq_data);
+}
+
+void card_insert_callback(void *param) {
+#if CONFIG_DEBUG_LOG > 1 
+	rtl_printf("SD card insert\n");
+#endif
+	if (card_insert_irq_handler)
+		card_insert_irq_handler((void *) card_insert_irq_data);
+}
+
+void card_remove_callback(void *param) {
+#if CONFIG_DEBUG_LOG > 1 
+	rtl_printf("SD card removed\n");
+#endif
+	sdio_status = SDIO_SD_NONE;
+	if (card_remove_irq_handler)
+		card_remove_irq_handler((void *) card_remove_irq_data);
+}
+
+//----- sdio_init_host
+s8 sdio_init_host() {
+	s8 result;
+	HAL_Status stat;
+
+	DBG_SDIO_INFO("SDIO Init Host Begin...\n");
+	if (sdio_status > SDIO_INIT_FAIL) {
+		DBG_SDIO_INFO("SDIO Host init already.\n");
+		result = 0;
+	} else {
+		rtl_memset(&SdioHostAdapter, 0, sizeof(SdioHostAdapter));
+		HalSdioHostOpInit(&HalSdioHostOp);
+		stat = HalSdioHostOp.HalSdioHostInitHost(&SdioHostAdapter);
+		SdioHostAdapter.CardInsertCbPara = &SdioHostAdapter;
+		SdioHostAdapter.CardInsertCallBack =
+				(void (*)(void *)) card_insert_callback;
+		SdioHostAdapter.CardRemoveCbPara = &SdioHostAdapter;
+		SdioHostAdapter.CardRemoveCallBack =
+				(void (*)(void *)) card_remove_callback;
+		SdioHostAdapter.XferCompCbPara = &SdioHostAdapter;
+		SdioHostAdapter.XferCompCallback =
+				(void (*)(void *)) xfer_done_callback;
+		SdioHostAdapter.ErrorCbPara = &SdioHostAdapter;
+		SdioHostAdapter.ErrorCallback = (void (*)(void *)) xfer_err_callback;
+		if (stat == HAL_OK) {
+			sdio_status = SDIO_INIT_OK;
+			DBG_SDIO_INFO("SDIO Host init Success.\n");
+			result = 0;
+		} else {
+			sdio_status = SDIO_INIT_FAIL;
+			DBG_SDIO_ERR("SDIO Host init Fail.\n");
+			result = -1;
+		}
+	}
+	return result;
+}
+
+//-----
+void sdio_deinit_host(void) {
+	if (sdio_status > 0) {
+		HAL_Status hs = HalSdioHostOp.HalSdioHostDeInit(&SdioHostAdapter);
+		if (hs == HAL_OK) {
+			SdioHostAdapter.CardInsertCallBack = NULL;
+			SdioHostAdapter.CardRemoveCallBack = NULL;
+			sdio_status = SDIO_INIT_NONE;
+		}
+	}
+}
+
+//-----
+s8 sdio_read_blocks(u32 sector, u8 *buffer, u32 count) {
+
+	if (!count) {
+		DBG_SDIO_ERR("Parameter error, try to read %d count\n");
+		return -1;
+	}
+	if (sdio_status <= SDIO_SD_NONE) {
+		DBG_SDIO_ERR("SD card is not ready\n");
+		return -1;
+	}
+	if (count > MAX_BUF_ADMA) {
+		count = MAX_BUF_ADMA;
+		DBG_SDIO_ERR("Not enough ADMA table(maximum %d), reduce blocks count\n",
+				count);
+	}
+	rtl_memset(gAdmaTbls, 0, sizeof(ADMA2_DESC_FMT) * count);
+	if (1) {
+		ADMA2_DESC_FMT *p = gAdmaTbls;
+		u8 * pbuf = buffer;
+		int i = 0;
+		while (i < count) {
+			i++;
+			p->Addr1 = (u32) pbuf;
+			p->Len1 = SIZE_BLOCK_ADMA;
+			if (i == count) {
+				p->Attrib1.Valid = 1; // 0x23
+				p->Attrib1.End = 1;
+				p->Attrib1.Act2 = 1;
+			} else {
+				p->Attrib1.Valid = 1; // 0x21
+				p->Attrib1.Act2 = 1;
+				p->Attrib2.Valid = 1; // 0x31
+				p->Attrib2.Act1 = 1;
+				p->Attrib2.Act2 = 1;
+				p->Len2 = 0;
+				p->Addr2 = (u32) (&p[1]);
+			}
+			pbuf += SIZE_BLOCK_ADMA;
+			p++;
+		}
+		SdioHostAdapter.AdmaDescTbl = gAdmaTbls;
+	}
+	HAL_Status result = HalSdioHostOp.HalSdioHostReadBlocksDma(&SdioHostAdapter,
+			(unsigned long long) sector * SIZE_BLOCK_ADMA, count);
+	if (result) {
+		DBG_SDIO_ERR("sdio_read_blocks fail(0x%02x)\n", result);
+		return -1;
+	}
+	return 0;
+}
+
+//-----
+s8 sdio_write_blocks(uint32_t sector, const uint8_t *buffer, uint32_t count) {
+
+	if (!count) {
+		DBG_SDIO_ERR("Parameter error, try to read %d count\n");
+		return -1;
+	}
+	if (sdio_status <= SDIO_SD_NONE) {
+		DBG_SDIO_ERR("SD card is not ready\n");
+		return -1;
+	}
+	if (count > MAX_BUF_ADMA) {
+		count = MAX_BUF_ADMA;
+		DBG_SDIO_ERR("Not enough ADMA table(maximum %d), reduce blocks count\n",
+				count);
+	}
+	if (sd_protected) {
+		DBG_SDIO_ERR("SD card is write protected\n");
+		return -1;
+	}
+	rtl_memset(gAdmaTbls, 0, sizeof(ADMA2_DESC_FMT) * count);
+	if (1) {
+		ADMA2_DESC_FMT *p = gAdmaTbls;
+		u8 * pbuf = buffer;
+		int i = 0;
+		while (i < count) {
+			i++;
+			p->Addr1 = (u32) pbuf;
+			p->Len1 = SIZE_BLOCK_ADMA;
+			if (i == count) {
+				p->Attrib1.Valid = 1; // 0x23
+				p->Attrib1.End = 1;
+				p->Attrib1.Act2 = 1;
+			} else {
+				p->Attrib1.Valid = 1; // 0x21
+				p->Attrib1.Act2 = 1;
+				p->Attrib2.Valid = 1; // 0x31
+				p->Attrib2.Act1 = 1;
+				p->Attrib2.Act2 = 1;
+				p->Len2 = 0;
+				p->Addr2 = (u32) (&p[1]);
+			}
+			pbuf += SIZE_BLOCK_ADMA;
+			p++;
+		}
+		SdioHostAdapter.AdmaDescTbl = gAdmaTbls;
+	}
+	HAL_Status result = HalSdioHostOp.HalSdioHostWriteBlocksDma(
+			&SdioHostAdapter, (unsigned long long) sector * SIZE_BLOCK_ADMA,
+			count);
+	if (result != HAL_OK) {
+		DBG_SDIO_ERR("write fail(0x%02x)\n", result);
+		return -1;
+	}
+	return 0;
+}
+
+//-----
+s8 sdio_sd_init(void) {
+	if (sdio_status != SDIO_SD_OK) {
+		SdioHostAdapter.AdmaDescTbl = gAdmaTbls;
+		if (sdio_status <= SDIO_INIT_FAIL)
+			sdio_init_host();
+		if (sdio_status != SDIO_INIT_OK) {
+			return -1;
+		}
+		DBG_SDIO_INFO("Init sd card.\n");
+		if (HalSdioHostOp.HalSdioHostInitCard(&SdioHostAdapter)) {
+			return -1;
+		}
+		sdio_status = SDIO_SD_OK;
+		if (HalSdioHostOp.HalSdioHostChangeSdClock(&SdioHostAdapter,
+				SD_CLK_41_6MHZ) != HAL_OK)
+			DBG_SDIO_INFO("SD card does not support high speed.\n");
+	}
+	return 0;
+}
+
+//-----
+void sdio_sd_deinit() {
+	if (sdio_status > SDIO_SD_NONE)
+		sdio_status = SDIO_INIT_OK;
+	sdio_deinit_host(); // add pvvx (fix SD_DeInit())
+}
+
+//-----
+s8 sdio_sd_setClock(SD_CLK_FREQUENCY SDCLK) {
+	HAL_Status sta;
+	if (sdio_status <= SDIO_SD_NONE) {
+		return -1;
+	}
+	ADMA2_DESC_FMT * padma = rtw_zmalloc(sizeof(ADMA2_DESC_FMT));
+	if (!padma) {
+		DBG_SDIO_ERR("Malloc ADMA2 table fail.\n");
+		return -1;
+	}
+	DBG_SDIO_INFO("SD card set CLK %d Hz\n", PLATFORM_CLOCK/(4<<(8-SDCLK)));
+	sta = HalSdioHostOp.HalSdioHostChangeSdClock(&SdioHostAdapter, SDCLK);
+	rtw_mfree(padma, sizeof(ADMA2_DESC_FMT));
+	if (sta)
+		return -1;
+	return 0;
+}
+
+//-----
+s8 sdio_sd_setProtection(bool protection) {
+	s8 result;
+	ADMA2_DESC_FMT *padma;
+	HAL_Status hls;
+	if (sdio_status > SDIO_SD_NONE) {
+		padma = (ADMA2_DESC_FMT *) rtw_zmalloc(sizeof(ADMA2_DESC_FMT));
+		if (!padma) {
+			DBG_SDIO_ERR("Malloc ADMA2 table fail.\n");
+			return -1;
+		}
+		SdioHostAdapter.AdmaDescTbl = padma;
+		if (protection) {
+			if (sd_protected == 1)
+				goto LABEL_8;
+			hls = HalSdioHostOp.HalSdioHostSetWriteProtect(&SdioHostAdapter, 1);
+		} else {
+			if (sd_protected == 0)
+				goto LABEL_8;
+			hls = HalSdioHostOp.HalSdioHostSetWriteProtect(&SdioHostAdapter, 0);
+		}
+		if (hls) {
+			DBG_SDIO_ERR("Set SD card Protection fail.\n");
+			result = -1;
+			goto LABEL_17;
+		}
+LABEL_8:
+		sd_protected = protection;
+LABEL_7:
+		DBG_SDIO_INFO("Set SD card Protection done.\n");
+		result = 0;
+LABEL_17:
+		rtw_mfree(padma, sizeof(ADMA2_DESC_FMT));
+		return result;
+	}
+	return -1;
+}
+
+//----- sdio_sd_getProtection
+s8 sdio_sd_getProtection() {
+	s8 result;
+
+	result = sd_protected;
+	if (sd_protected != -1)
+		return result;
+	if (sdio_status <= SDIO_SD_NONE) {
+		result = -1;
+		return result;
+	}
+	if (HalSdioHostOp.HalSdioHostGetWriteProtect(&SdioHostAdapter)) {
+		DBG_SDIO_ERR("Get SD card Protection fail.\n");
+		result = -1;
+		return result;
+	}
+	if (SdioHostAdapter.IsWriteProtect)
+		DBG_SDIO_INFO("SD card is Write Protected.\n");
+	result = (s8) SdioHostAdapter.IsWriteProtect;
+	sd_protected = SdioHostAdapter.IsWriteProtect;
+	return result;
+}
+
+//----- sdio_sd_status
+s8 sdio_sd_status() {
+	s8 result;
+
+	DBG_SDIO_INFO("sdio_get_sdcard_status.\n");
+	if (sdio_status <= SDIO_SD_NONE
+			|| HalSdioHostOp.HalSdioHostGetCardStatus(&SdioHostAdapter))
+		result = -1;
+	else
+		result = SdioHostAdapter.CardCurState;
+	return result;
+}
+
+//----- sdio_sd_getCSD
+s8 sdio_sd_getCSD(u8* CSD) {
+	s8 result;
+
+	if (sdio_status <= SDIO_SD_NONE)
+		result = -1;
+	else {
+		rtl_memcpy(CSD, SdioHostAdapter.Csd, CSD_REG_LEN);
+		result = 0;
+	}
+	return result;
+}
+
+//----- sdio_sd_isReady
+s8 sdio_sd_isReady() {
+	s8 result = sdio_status - SDIO_SD_OK;
+	if (sdio_status != SDIO_SD_OK)
+		result = -1;
+	return result;
+}
+
+//----- sdio_sd_getCapacity
+u32 sdio_sd_getCapacity(void) {
+	u32 result;
+	uint8_t csd[CSD_REG_LEN];
+	if (sdio_status <= SDIO_SD_NONE)
+		result = 0; // -1;
+	else {
+		rtl_memcpy(csd, SdioHostAdapter.Csd, CSD_REG_LEN);
+		if ((csd[0] & 0xC0) == 64)
+			result = (u16) (csd[9] + 1 + (csd[8] << 8)) << 9;
+		else
+			result = (4 * csd[7] + ((u32) csd[8] >> 6) + 1
+					+ ((csd[6] & 3) << 10))
+					<< ((csd[5] & 0xF) + (csd[10] >> 7) + 2 * (csd[9] & 3) - 8);
+		result *= 2;
+	}
+	return result;
+}
+
+s8 sdio_sd_hook_insert_cb(sdio_sd_irq_handler CallbackFun, void *param) {
+	card_insert_irq_handler = CallbackFun;
+	card_insert_irq_data = (uint32_t) param;
+	return 0;
+}
+
+s8 sdio_sd_hook_remove_cb(sdio_sd_irq_handler CallbackFun, void *param) {
+	card_remove_irq_handler = CallbackFun;
+	card_remove_irq_data = (uint32_t) param;
+	return 0;
+}
+
+s8 sdio_sd_hook_xfer_cmp_cb(sdio_sd_irq_handler CallbackFun, void *param) {
+	xfer_done_irq_handler = CallbackFun;
+	xfer_done_irq_data = (uint32_t) param;
+	return 0;
+}
+
+s8 sdio_sd_hook_xfer_err_cb(sdio_sd_irq_handler CallbackFun, void *param) {
+	xfer_err_irq_handler = CallbackFun;
+	xfer_err_irq_data = (uint32_t) param;
+	return 0;
+}
+
+#endif // CONFIG_SDIO_HOST_EN

USDK/component/common/drivers/usb_class/device/class/ethernet/inc/eth_debug.h

@@ -0,0 +1,22 @@
+#ifndef _ETH_DEBUG_H_
+#define _ETH_DEBUG_H_
+
+#define ETH_DEBUG       0
+
+#if ETH_DEBUG
+#define ETH_PRINT(fmt, args...)		            printf("\n\r[%s]%s: " fmt, __FUNCTION__, ## args)
+#define ETH_ERROR(fmt, args...)		            printf("\n\r[%s]%s: " fmt, __FUNCTION__, ## args)
+#define ETH_WARM(fmt, args...)		            printf("\n\r[%s]%s: " fmt, __FUNCTION__, ## args)
+#define FUN_ENTER                                   printf("\n\r[%s ==>]\n", __func__)
+#define FUN_EXIT                                    printf("\n\r[%s <==]\n", __func__)
+#define FUN_TRACE                                   printf("\n\r[%s]:%d \n", __func__, __LINE__)
+#else
+#define ETH_PRINT(fmt, args...)
+#define ETH_ERROR(fmt, args...)		            printf("\n\r%s: " fmt,__FUNCTION__, ## args)
+#define ETH_WARM(fmt, args...)
+#define FUN_ENTER
+#define FUN_EXIT
+#define FUN_TRACE
+#endif
+
+#endif

USDK/component/common/drivers/usb_class/device/class/ethernet/inc/usb_ethernet.h

@@ -0,0 +1,358 @@
+/*
+ * Ethernet gadget driver -- with CDC and non-CDC options
+ * Builds on hardware support for a full duplex link.
+ *
+ * CDC Ethernet is the standard USB solution for sending Ethernet frames
+ * using USB.  Real hardware tends to use the same framing protocol but look
+ * different for control features.  This driver strongly prefers to use
+ * this USB-IF standard as its open-systems interoperability solution;
+ * most host side USB stacks (except from Microsoft) support it.
+ *
+ * There's some hardware that can't talk CDC.  We make that hardware
+ * implement a "minimalist" vendor-agnostic CDC core:  same framing, but
+ * link-level setup only requires activating the configuration.
+ * Linux supports it, but other host operating systems may not.
+ * (This is a subset of CDC Ethernet.)
+ *
+ * A third option is also in use.  Rather than CDC Ethernet, or something
+ * simpler, Microsoft pushes their own approach: RNDIS.  The published
+ * RNDIS specs are ambiguous and appear to be incomplete, and are also
+ * needlessly complex.
+ */
+#ifndef __USB_ETHERNET_H
+#define __USB_ETHERNET_H
+
+#include "usb.h"
+#include "usb_gadget.h"
+#include "core/inc/usb_composite.h"
+
+//#define DRIVER_DESC		"Ethernet Gadget"
+#define DRIVER_DESC		"USB Network Interface"
+#define DRIVER_VERSION		"May Day 2015"
+#define ETH_ADDR        "00E04C8196C8"
+
+static const char shortname [] = "ether";
+static const char driver_desc [] = DRIVER_DESC;
+
+#define CONFIG_USB_ETH_RNDIS 1
+
+
+#define RNDIS_VENDOR_NUM	ULINKER_ETHER_VID
+#define RNDIS_PRODUCT_NUM	ULINKER_ETHER_PID
+
+
+/* Thanks to NetChip Technologies for donating this product ID.
+ * It's for devices with only CDC Ethernet configurations.
+ */
+#define CDC_VENDOR_NUM	0x0525		/* NetChip */
+#define CDC_PRODUCT_NUM	0xa4a1		/* Linux-USB Ethernet Gadget */
+
+/* USB DRIVER HOOKUP (to the hardware driver, below us), mostly
+ * ep0 implementation:  descriptors, config management, setup().
+ * also optional class-specific notification interrupt transfer.
+ */
+
+/*
+ * DESCRIPTORS ... most are static, but strings and (full) configuration
+ * descriptors are built on demand.  For now we do either full CDC, or
+ * our simple subset, with RNDIS as an optional second configuration.
+ *
+ * RNDIS includes some CDC ACM descriptors ... like CDC Ethernet.  But
+ * the class descriptors match a modem (they're ignored; it's really just
+ * Ethernet functionality), they don't need the NOP altsetting, and the
+ * status transfer endpoint isn't optional.
+ */
+
+#define STRING_MANUFACTURER		1
+#define STRING_PRODUCT			2
+#define STRING_ETHADDR			3
+#define STRING_DATA			4
+#define STRING_CONTROL			5
+#define STRING_RNDIS_CONTROL		6
+#define STRING_CDC			7
+#define STRING_SUBSET			8
+#define STRING_RNDIS			9
+#define STRING_SERIALNUMBER		10
+
+/* holds our biggest descriptor (or RNDIS response) */
+#define USB_BUFSIZ	256
+
+#define BUFSIZ_IN	512
+#define BUFSIZ_OUT	512
+/*
+ * This device advertises one configuration, eth_config, unless RNDIS
+ * is enabled (rndis_config) on hardware supporting at least two configs.
+ *
+ * NOTE:  Controllers like superh_udc should probably be able to use
+ * an RNDIS-only configuration.
+ *
+ * FIXME define some higher-powered configurations to make it easier
+ * to recharge batteries ...
+ */
+
+//#define DEV_CONFIG_VALUE	1	/* cdc or subset */
+//#define DEV_RNDIS_CONFIG_VALUE	2	/* rndis; optional */
+#define DEV_CONFIG_VALUE	2	/* cdc or subset */
+#define DEV_RNDIS_CONFIG_VALUE	1	/* rndis; optional */
+
+
+#define	DEVSPEED	USB_SPEED_HIGH
+
+
+/* descriptors that are built on-demand */
+
+static char				manufacturer [50];
+static char				product_desc [40] = DRIVER_DESC;
+static char				serial_number [20];
+
+
+/* address that the host will use ... usually assigned at random */
+//ModifiedByJD    static char				ethaddr [2 * ETH_ALEN + 1];
+static char				ethaddr [2 * 6 + 1] = ETH_ADDR;
+
+/* static strings, in UTF-8 */
+static struct usb_string		strings [] = {
+	{ STRING_MANUFACTURER,	manufacturer, },
+	{ STRING_PRODUCT,	product_desc, },
+	{ STRING_SERIALNUMBER,	serial_number, },
+	{ STRING_DATA,		"Ethernet Data", },
+#if 1//def	DEV_CONFIG_CDC//ModifiedByJD    
+	{ STRING_CDC,		"CDC Ethernet", },
+	{ STRING_ETHADDR,	ethaddr, },
+	{ STRING_CONTROL,	"CDC Communications Control", },
+#endif
+#if 1//def	DEV_CONFIG_SUBSET//ModifiedByJD    
+	{ STRING_SUBSET,	"CDC Ethernet Subset", },
+#endif
+#if 1//def	CONFIG_USB_ETH_RNDIS//ModifiedByJD    
+	{ STRING_RNDIS,		"RNDIS", },
+	{ STRING_RNDIS_CONTROL,	"RNDIS Communications Control", },
+#endif		/* end of list */
+};
+
+static struct usb_gadget_strings	stringtab = {
+	.language	= 0x0409,	/* en-us */
+	.strings	= strings,
+};
+
+static struct usb_gadget_strings *dev_strings[] = {
+	&stringtab,
+	NULL,
+};
+
+static struct usb_device_descriptor
+device_desc = {
+	.bLength =		sizeof device_desc,
+	.bDescriptorType =	USB_DT_DEVICE,
+
+	.bcdUSB =		    (0x0200),
+
+	.bDeviceClass =		USB_CLASS_COMM,
+	.bDeviceSubClass =	0,
+	.bDeviceProtocol =	0,
+
+	.idVendor =		(CDC_VENDOR_NUM),
+	.idProduct =		(CDC_PRODUCT_NUM),
+	.iManufacturer =	STRING_MANUFACTURER,
+	.iProduct =		STRING_PRODUCT,
+	.bNumConfigurations =	1,
+};
+
+static struct usb_config_descriptor
+eth_config = {
+	.bLength =		sizeof eth_config,
+	.bDescriptorType =	USB_DT_CONFIG,
+
+	/* compute wTotalLength on the fly */
+	.bNumInterfaces =	1,
+	.bConfigurationValue =	DEV_CONFIG_VALUE,
+	.iConfiguration =	STRING_CDC,
+	.bmAttributes =		USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
+	.bMaxPower =		50,
+};
+
+static struct usb_otg_descriptor
+otg_descriptor = {
+	.bLength =		sizeof otg_descriptor,
+	.bDescriptorType =	USB_DT_OTG,
+
+	.bmAttributes =		USB_OTG_SRP,
+};
+
+
+#ifdef	CONFIG_USB_ETH_RNDIS
+
+/* RNDIS doesn't activate by changing to the "real" altsetting */
+
+static struct usb_interface_descriptor
+rndis_data_intf = {
+	.bLength =		sizeof rndis_data_intf,
+	.bDescriptorType =	USB_DT_INTERFACE,
+
+	.bInterfaceNumber =	0,
+	.bAlternateSetting =	0,
+	.bNumEndpoints =	2,
+	.bInterfaceClass =	USB_CLASS_CDC_DATA,
+	.bInterfaceSubClass =	0,
+	.bInterfaceProtocol =	0,
+	.iInterface =		STRING_DATA,
+};
+
+#endif
+
+
+static struct usb_endpoint_descriptor
+hs_source_desc = {
+	.bLength =		USB_DT_ENDPOINT_SIZE,
+	.bDescriptorType =	USB_DT_ENDPOINT,
+
+	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
+	.wMaxPacketSize =	(512),//ModifiedByJD    
+};
+
+static struct usb_endpoint_descriptor
+hs_sink_desc = {
+	.bLength =		USB_DT_ENDPOINT_SIZE,
+	.bDescriptorType =	USB_DT_ENDPOINT,
+
+	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
+	.wMaxPacketSize =	(512),//ModifiedByJD    
+};
+
+static struct usb_endpoint_descriptor
+fs_source_desc = {
+	.bLength =		USB_DT_ENDPOINT_SIZE,
+	.bDescriptorType =	USB_DT_ENDPOINT,
+
+	.bEndpointAddress =	USB_DIR_IN,
+	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
+};
+
+static struct usb_endpoint_descriptor
+fs_sink_desc = {
+	.bLength =		USB_DT_ENDPOINT_SIZE,
+	.bDescriptorType =	USB_DT_ENDPOINT,
+
+	.bEndpointAddress =	USB_DIR_OUT,
+	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
+};
+
+
+static const struct usb_descriptor_header *fs_rndis_function [] = {
+	(struct usb_descriptor_header *) &otg_descriptor,
+	/* control interface matches ACM, not Ethernet */
+#if 0//ModifiedByJD        
+	(struct usb_descriptor_header *) &rndis_control_intf,
+	(struct usb_descriptor_header *) &header_desc,
+	(struct usb_descriptor_header *) &call_mgmt_descriptor,
+	(struct usb_descriptor_header *) &acm_descriptor,
+	(struct usb_descriptor_header *) &union_desc,
+	(struct usb_descriptor_header *) &fs_status_desc,
+#endif	
+	/* data interface has no altsetting */
+	(struct usb_descriptor_header *) &rndis_data_intf,
+	(struct usb_descriptor_header *) &fs_source_desc,
+	(struct usb_descriptor_header *) &fs_sink_desc,
+	NULL,
+};
+
+
+
+
+static const struct usb_descriptor_header *fs_eth_function [11] = {
+	(struct usb_descriptor_header *) &otg_descriptor,
+#ifdef DEV_CONFIG_CDC
+	/* "cdc" mode descriptors */
+	(struct usb_descriptor_header *) &control_intf,
+	(struct usb_descriptor_header *) &header_desc,
+	(struct usb_descriptor_header *) &union_desc,
+	(struct usb_descriptor_header *) &ether_desc,
+	/* NOTE: status endpoint may need to be removed */
+	(struct usb_descriptor_header *) &fs_status_desc,
+	/* data interface, with altsetting */
+	(struct usb_descriptor_header *) &data_nop_intf,
+	(struct usb_descriptor_header *) &data_intf,
+	(struct usb_descriptor_header *) &fs_source_desc,
+	(struct usb_descriptor_header *) &fs_sink_desc,
+	NULL,
+#endif /* DEV_CONFIG_CDC */
+};
+
+#ifdef	CONFIG_USB_ETH_RNDIS
+static const struct usb_descriptor_header *hs_rndis_function [] = {
+	(struct usb_descriptor_header *) &otg_descriptor,
+	/* control interface matches ACM, not Ethernet */
+#if 0//ModifiedByJD        
+	(struct usb_descriptor_header *) &rndis_control_intf,
+	(struct usb_descriptor_header *) &header_desc,
+	(struct usb_descriptor_header *) &call_mgmt_descriptor,
+	(struct usb_descriptor_header *) &acm_descriptor,
+	(struct usb_descriptor_header *) &union_desc,
+	(struct usb_descriptor_header *) &hs_status_desc,
+#endif	
+	/* data interface has no altsetting */
+	(struct usb_descriptor_header *) &rndis_data_intf,
+	(struct usb_descriptor_header *) &hs_source_desc,
+	(struct usb_descriptor_header *) &hs_sink_desc,
+	NULL,
+};
+#endif
+
+static struct usb_config_descriptor
+rndis_config = {
+	.bLength =              sizeof rndis_config,
+	.bDescriptorType =      USB_DT_CONFIG,
+
+	/* compute wTotalLength on the fly */
+	.bNumInterfaces =       1,
+	.bConfigurationValue =  DEV_RNDIS_CONFIG_VALUE,
+	.iConfiguration =       STRING_RNDIS, 
+	.bmAttributes =		USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
+	.bMaxPower =            50,
+};
+
+static struct usb_configuration eth_configuration = {
+	.label = "eth_configuration",
+	.bConfigurationValue	= DEV_CONFIG_VALUE,
+//	.bConfigurationValue	= 1,
+	/* .iConfiguration = DYNAMIC */
+	.bmAttributes		= USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
+};
+
+
+static struct eth_dev{
+		struct usb_gadget	*gadget;
+		struct usb_request	*req;		/* for control responses */
+		/* when configured, we have one of two configs:
+		 * - source data (in to host) and sink it (out from host)
+		 * - or loop it back (out from host back in to host)
+		 */
+		u8			config;
+		struct usb_ep	*in_ep;
+		struct usb_ep	*out_ep;
+	    const struct usb_endpoint_descriptor
+					*in, *out, *status;
+	    // lock is held when accessing usb
+	    _Lock	lock;
+		
+	    struct usb_function	func;
+
+		
+
+		/*send (depends on host)*/
+		_Sema	xmit_sema;
+		xTaskHandle	xmit_task;
+		unsigned int	qlen;
+		_Mutex 	xmit_mutex;
+		_LIST	eth2wlan_list;
+		/*receive (debuf_poolpends on host)*/
+		_Sema	recv_sema;
+		xTaskHandle	recv_task;
+		_Mutex	recv_mutex;
+		_LIST	wlan2eth_list;
+};
+
+
+extern int usb_eth_init(void);
+
+#endif

USDK/component/common/drivers/usb_class/device/class/msc/inc/usbd_msc.h

@@ -0,0 +1,183 @@
+#ifndef USBD_MSC_H
+#define USBD_MSC_H
+
+#include "usb.h"
+#include "usb_gadget.h"
+#include "core/inc/usb_composite.h"
+#include "msc/inc/usbd_msc_config.h"
+
+/* config usb msc device debug inforation */
+#define USBD_MSC_DEBUG          0
+
+#if	USBD_MSC_DEBUG
+#define USBD_PRINTF(fmt, args...)		            DBG_8195A("\n\r%s: " fmt, __FUNCTION__, ## args)
+#define USBD_ERROR(fmt, args...)		            DBG_8195A("\n\r%s: " fmt, __FUNCTION__, ## args)
+#define USBD_WARN(fmt, args...)		            	DBG_8195A("\n\r%s: " fmt, __FUNCTION__, ## args)
+#define FUN_ENTER                                   DBG_8195A("\n\r%s ==>\n", __func__)
+#define FUN_EXIT                                    DBG_8195A("\n\r%s <==\n", __func__)
+#define FUN_TRACE                                   DBG_8195A("\n\r%s:%d \n", __func__, __LINE__)
+#else
+#define USBD_PRINTF(fmt, args...)
+#define USBD_ERROR(fmt, args...)		            DBG_8195A("\n\r%s: " fmt, __FUNCTION__, ## args)
+#define USBD_WARN(fmt, args...)
+#define FUN_ENTER
+#define FUN_EXIT
+#define FUN_TRACE
+#endif
+
+/* MSC Request Codes */
+#define MSC_REQUEST_RESET               0xFF
+#define MSC_REQUEST_GET_MAX_LUN         0xFE
+
+/* MSC LUN */
+#define MSC_MAX_LOGIC_UNIT_NUMBER	1
+
+enum data_direction{
+	DATA_DIR_UNKNOWN = 0,
+	DATA_DIR_FROM_HOST,
+	DATA_DIR_TO_HOST,
+	DATA_DIR_NONE
+};
+
+typedef enum _disk_type{
+	DISK_SDCARD,
+	DISK_FLASH
+}disk_type;
+
+//structure predefine
+struct msc_dev;
+struct msc_bufhd;
+
+struct msc_opts{
+	int (*disk_init)(void);
+	int (*disk_deinit)(void);
+	int (*disk_getcapacity)(u32* sectors);
+	int (*disk_read)(u32 sector,u8 *buffer,u32 count);
+	int (*disk_write)(u32 sector,const u8 *buffer,u32 count);
+};
+
+struct msc_lun {
+	unsigned int	initially_ro:1;
+	unsigned int	ro:1;
+	unsigned int	removable:1;
+	unsigned int	cdrom:1;
+	unsigned int	prevent_medium_removal:1;
+	unsigned int	registered:1;
+	unsigned int	info_valid:1;
+	unsigned int	nofua:1;
+
+	u32		sense_data;
+	u32		sense_data_info;
+	u32		unit_attention_data;
+	
+	u64	file_length;
+	unsigned int    num_sectors; /*  */
+	unsigned int	blkbits; /* Bits of logical block size
+						       of bound block device */
+	unsigned int	blksize; /* logical block size of bound block device */
+	const char	*name;		/* "lun.name" */
+
+	unsigned int	lba; // the current read and write logical block address
+	u8 is_open;
+	_mutex	lun_mutex;
+	struct msc_opts *lun_opts;
+};
+
+
+struct msc_common{
+	struct msc_dev	*mscdev;
+	
+	struct msc_lun	**luns;
+	struct msc_lun	*curlun;
+
+	struct usb_gadget	*gadget;
+	struct usb_ep		*ep0;		
+	struct usb_request	*req0;		/* for control responses */
+
+	/* scsi cbw relevant */
+	enum data_direction	data_dir;
+	u32			data_size;
+	u32			data_size_from_cmnd;
+	u32			tag;
+	u32			residue;
+	u32			usb_amount_left;
+	u8			scsi_cmnd[16]; // max command
+	u8			cmnd_size;
+	
+	u8		lun;	/* current lun*/
+	u8		nluns;
+
+	u8	nbufhd;
+	u8	nbufhd_a;
+	_list	bufhd_pool;
+	_mutex  bufhd_mutex;
+	/* bulk out cmd*/
+	_list	boc_list;
+	_mutex  boc_mutex;
+
+	/* bolk out data*/
+	_mutex  bod_mutex;
+	_list	bod_list;
+	/**/
+	struct msc_bufhd* curbh; // current buffer header
+	struct msc_bufhd* cbw_bh; // buffer header for CBW
+	struct msc_bufhd* csw_bh; // buffer header for CSW
+	
+	unsigned int		can_stall:1;
+	unsigned int		phase_error:1;
+	unsigned int		short_packet_received:1;
+	unsigned int		bad_lun_okay:1;
+	unsigned int 		running:1;
+};
+
+typedef enum _bufhd_type{
+	BUFHD_CBW = 0,
+	BUFHD_CSW,
+	BUFHD_DATA,
+}bufhd_type;
+
+struct msc_bufhd{
+	u8* buf;
+	int buf_size;
+	bufhd_type type;
+	_list  list;	
+	struct usb_request	*reqin; 	/* for bulkin responses */
+	struct usb_request	*reqout;
+};
+
+struct msc_dev{
+	struct msc_common 	*common;
+	
+	u16 		interface_number;
+	u8			config;
+
+	struct usb_ep	*in_ep;
+	struct usb_ep	*out_ep;
+	unsigned int	bulk_in_enabled:1;
+	unsigned int	bulk_out_enabled:1;
+
+    const struct usb_endpoint_descriptor
+				*in, *out, *status;
+    // lock is held when accessing usb
+	struct task_struct msc_outCmdTask;
+	struct task_struct msc_outDataTask;
+    struct usb_function	func;
+};
+
+u32 min(u32 value1,u32 value2);
+
+int usbd_msc_halt_bulk_in_endpoint(struct msc_dev *mscdev);
+void usbd_msc_put_bufhd(struct msc_common *common, struct msc_bufhd* bufhd);
+struct msc_bufhd* usbd_msc_get_bufhd(struct msc_common *common);
+int usbd_msc_bulk_in_transfer(struct msc_dev *mscdev, struct usb_request *req);
+int usbd_msc_bulk_out_transfer(struct msc_dev *mscdev, struct usb_request *req);
+
+/*
+* N_bh : number of buffer header
+* Size_bh: buffer size per buffer
+* type:msc physical disk type
+*/
+int usbd_msc_init(int N_bh, int Size_bh, disk_type type);
+void usbd_msc_deinit(void);
+
+#endif

USDK/component/common/drivers/usb_class/device/class/msc/inc/usbd_msc_config.h

@@ -0,0 +1,8 @@
+#ifndef _USBD_MSC_CONFIG_H
+#define _USBD_MSC_CONFIG_H
+
+/* config usb MSC device buffer resource */
+#define MSC_NBR_BUFHD	2 /* number of buffer header for bulk in/out data*/
+#define MSC_BUFLEN	(20*512)/* Default size of buffer length. Minmun of 512 byte*/
+
+#endif

USDK/component/common/drivers/usb_class/device/class/msc/inc/usbd_msc_desc.h

@@ -0,0 +1,196 @@
+#include "usb_ch9.h"
+#include "usb_defs.h"
+#include "usb_gadget.h"
+
+//     <i> Enable high-speed functionality (if device supports it)
+#define USBD_HS_ENABLE              1
+
+
+// define string index
+#define STRING_MANUFACTURER		1
+#define STRING_PRODUCT			2
+#define STRING_SERIALNUMBER		3
+#define STRING_INTERFACE		4
+#define STRING_MSC				5
+
+
+#define DEV_CONFIG_VALUE	1
+
+#define DRIVER_DESC		"USB Mass Storage"
+#define DRIVER_VERSION	"Feb 2016"
+
+#define MANUFACTURER 	"Realtek Singapore Semiconductor"
+
+static char	string_manufacturer [50] = MANUFACTURER;
+static char	string_product [40] = DRIVER_DESC;
+static char	string_serial [20] = "0123456789";
+
+struct usb_string		
+usbd_msc_strings [] = {
+	{ STRING_MANUFACTURER,	string_manufacturer, },        
+	{ STRING_PRODUCT,	string_product, },
+	{ STRING_SERIALNUMBER,	string_serial, },
+	{ STRING_INTERFACE,		"USB MSC Interface", },
+	{ STRING_MSC,		"USB MSC", },
+};
+
+struct usb_gadget_strings	msc_stringtab = {
+	.language	= 0x0409,	/* en-us */
+	.strings	= usbd_msc_strings,
+};
+
+struct usb_gadget_strings *dev_msc_strings[] = {
+	&msc_stringtab,
+	NULL,
+};
+
+static struct usb_device_descriptor
+usbd_msc_device_desc = {
+	.bLength =		sizeof usbd_msc_device_desc,
+	.bDescriptorType =	USB_DT_DEVICE,
+
+	.bcdUSB =		    (0x0200),
+
+	.bDeviceClass =		0x00,// define in interface descriptor
+	.bDeviceSubClass =	0x00,
+	.bDeviceProtocol =	0x00,
+
+	.bMaxPacketSize0 = 	64,	// this will be set automatically depends on ep0 setting
+	.idVendor =			0x0BDA,
+	.idProduct =		0x8195,
+//	.bcdDevice = 		,
+	.iManufacturer =	STRING_MANUFACTURER,
+	.iProduct =			STRING_PRODUCT,
+	.iSerialNumber =	STRING_SERIALNUMBER,
+	.bNumConfigurations=0x01,
+};
+#if 0
+struct usb_config_descriptor
+usbd_msc_config_desc = {
+	.bLength =		sizeof usbd_msc_config_desc,
+	.bDescriptorType =	USB_DT_CONFIG,
+
+	/* compute wTotalLength on the fly */
+	.bNumInterfaces =	1,
+	.bConfigurationValue =	DEV_CONFIG_VALUE,
+	.iConfiguration =	STRING_MSC,
+	.bmAttributes =		USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
+	.bMaxPower =		0x32,
+};
+#endif
+
+#if USBD_HS_ENABLE
+/* USB Device Qualifier Descriptor (for Full Speed) */
+static struct usb_qualifier_descriptor
+usbd_msc_qualifier_desc_FS = {
+	.bLength = sizeof usbd_msc_qualifier_desc_FS,
+	.bDescriptorType = USB_DT_DEVICE_QUALIFIER,
+	.bcdUSB = 0x0200,
+	.bDeviceClass = 0x00,
+	.bDeviceSubClass = 0x00,
+	.bDeviceProtocol = 0x00,
+	.bMaxPacketSize0 = 64,
+	.bNumConfigurations = 0x01,
+	.bRESERVED = 0x00,
+};
+
+/* USB Device Qualifier Descriptor for High Speed */
+static struct usb_qualifier_descriptor
+usbd_msc_qualifier_desc_HS = {
+	.bLength = sizeof usbd_msc_qualifier_desc_HS,
+	.bDescriptorType = USB_DT_DEVICE_QUALIFIER,
+	.bcdUSB = 0x0200,
+	.bDeviceClass = 0x00,
+	.bDeviceSubClass = 0x00,
+	.bDeviceProtocol = 0x00,
+	.bMaxPacketSize0 = 64,
+	.bNumConfigurations = 0x01,
+	.bRESERVED = 0x00,
+};
+#else
+/* USB Device Qualifier Descriptor (for Full Speed) */
+static struct usb_qualifier_descriptor
+usbd_msc_qualifier_desc_FS    = { 0 };
+
+/* USB Device Qualifier Descriptor for High Speed */
+static struct usb_qualifier_descriptor
+usbd_msc_qualifier_desc_HS = { 0 };
+#endif
+
+/* MSC Interface, Alternate Setting 0*/  
+struct usb_interface_descriptor
+usbd_msc_intf_desc = {
+	.bLength =		sizeof usbd_msc_intf_desc,
+	.bDescriptorType =	USB_DT_INTERFACE,
+
+	.bInterfaceNumber =	0x00, // this will be assign automatically
+	.bAlternateSetting =0x00,
+	.bNumEndpoints =	0x02,
+	.bInterfaceClass =	USB_CLASS_MASS_STORAGE,
+	.bInterfaceSubClass = US_SC_SCSI,
+	.bInterfaceProtocol = US_PR_BULK,
+	.iInterface =		STRING_INTERFACE,
+};
+
+/* MSC Endpoints for Low-speed/Full-speed */
+/* Endpoint, EP Bulk IN */ 
+struct usb_endpoint_descriptor
+usbd_msc_source_desc_FS = {
+	.bLength =		USB_DT_ENDPOINT_SIZE,
+	.bDescriptorType =	USB_DT_ENDPOINT,
+
+	.bEndpointAddress =	USB_DIR_IN,
+	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
+	.wMaxPacketSize =	(64), 
+	.bInterval = 0x00,
+	
+};
+/* Endpoint, EP Bulk OUT */ 
+struct usb_endpoint_descriptor
+usbd_msc_sink_desc_FS = {
+	.bLength =		USB_DT_ENDPOINT_SIZE,
+	.bDescriptorType =	USB_DT_ENDPOINT,
+
+	.bEndpointAddress =	USB_DIR_OUT,
+	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
+	.wMaxPacketSize =	(64), 
+	.bInterval = 0x00,
+};
+
+/* MSC Endpoints for High-speed */
+/* Endpoint, EP Bulk IN */ 
+struct usb_endpoint_descriptor
+usbd_msc_source_desc_HS = {
+	.bLength =		USB_DT_ENDPOINT_SIZE,
+	.bDescriptorType =	USB_DT_ENDPOINT,
+	.bEndpointAddress = USB_DIR_IN,
+	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
+	.wMaxPacketSize =	(512), 
+	.bInterval = 0x00,
+};
+
+/* Endpoint, EP Bulk OUT */ 
+struct usb_endpoint_descriptor
+usbd_msc_sink_desc_HS = {
+	.bLength =		USB_DT_ENDPOINT_SIZE,
+	.bDescriptorType =	USB_DT_ENDPOINT,
+	.bEndpointAddress = USB_DIR_OUT,
+	.bmAttributes =		USB_ENDPOINT_XFER_BULK,
+	.wMaxPacketSize =	(512),
+	.bInterval = 0x00,
+};
+
+struct usb_descriptor_header *usbd_msc_descriptors_FS [] = {
+	/* data interface has no altsetting */
+	(struct usb_descriptor_header *) &usbd_msc_intf_desc,
+	(struct usb_descriptor_header *) &usbd_msc_source_desc_FS,
+	(struct usb_descriptor_header *) &usbd_msc_sink_desc_FS,
+	NULL,
+};
+struct usb_descriptor_header *usbd_msc_descriptors_HS [] = {
+	/* data interface has no altsetting */
+	(struct usb_descriptor_header *) &usbd_msc_intf_desc,
+	(struct usb_descriptor_header *) &usbd_msc_source_desc_HS,
+	(struct usb_descriptor_header *) &usbd_msc_sink_desc_HS,
+	NULL,
+};

USDK/component/common/drivers/usb_class/device/class/msc/inc/usbd_scsi.h

@@ -0,0 +1,110 @@
+#ifndef USBD_SCSI_H
+#define USBD_SCSI_H
+#include "basic_types.h"
+#include "msc/inc/usbd_msc.h"
+
+#define MAX_COMMAND_SIZE 16
+#define MSC_MAX_LUNS	8
+
+/* SCSI Commands */
+#define SCSI_FORMAT_UNIT                            0x04
+#define SCSI_INQUIRY                                0x12
+#define SCSI_MODE_SELECT6                           0x15
+#define SCSI_MODE_SELECT10                          0x55
+#define SCSI_MODE_SENSE6                            0x1A
+#define SCSI_MODE_SENSE10                           0x5A
+#define SCSI_ALLOW_MEDIUM_REMOVAL                   0x1E
+#define SCSI_READ6                                  0x08
+#define SCSI_READ10                                 0x28
+#define SCSI_READ12                                 0xA8
+#define SCSI_READ16                                 0x88
+
+#define SCSI_READ_CAPACITY10                        0x25
+#define SCSI_READ_CAPACITY16                        0x9E
+
+#define SCSI_SYNCHRONIZE_CACHE						0x35
+#define SCSI_REQUEST_SENSE                          0x03
+#define SCSI_START_STOP_UNIT                        0x1B
+#define SCSI_TEST_UNIT_READY                        0x00
+#define SCSI_WRITE6                                 0x0A
+#define SCSI_WRITE10                                0x2A
+#define SCSI_WRITE12                                0xAA
+#define SCSI_WRITE16                                0x8A
+
+#define SCSI_VERIFY10                               0x2F
+#define SCSI_VERIFY12                               0xAF
+#define SCSI_VERIFY16                               0x8F
+
+#define SCSI_SEND_DIAGNOSTIC                        0x1D
+#define SCSI_READ_FORMAT_CAPACITIES                 0x23
+
+#define READ_FORMAT_CAPACITY_DATA_LEN               0x0C
+#define READ_CAPACITY10_DATA_LEN                    0x08
+#define MODE_SENSE10_DATA_LEN                       0x08
+#define MODE_SENSE6_DATA_LEN                        0x04
+#define REQUEST_SENSE_DATA_LEN                      0x12
+#define STANDARD_INQUIRY_DATA_LEN                   0x24
+
+/* SCSI Sense Key/Additional Sense Code/ASC Qualifier values */
+#define SS_NO_SENSE				0
+#define SS_COMMUNICATION_FAILURE		0x040800
+#define SS_INVALID_COMMAND			0x052000
+#define SS_INVALID_FIELD_IN_CDB			0x052400
+#define SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE	0x052100
+#define SS_LOGICAL_UNIT_NOT_SUPPORTED		0x052500
+#define SS_MEDIUM_NOT_PRESENT			0x023a00
+#define SS_MEDIUM_REMOVAL_PREVENTED		0x055302
+#define SS_NOT_READY_TO_READY_TRANSITION	0x062800
+#define SS_RESET_OCCURRED			0x062900
+#define SS_SAVING_PARAMETERS_NOT_SUPPORTED	0x053900
+#define SS_UNRECOVERED_READ_ERROR		0x031100
+#define SS_WRITE_ERROR				0x030c02
+#define SS_WRITE_PROTECTED			0x072700
+
+
+
+#define SK(x)		((u8) ((x) >> 16))	/* Sense Key byte, etc. */
+#define ASC(x)		((u8) ((x) >> 8))
+#define ASCQ(x)		((u8) (x))
+
+/*
+* Bulk only data structures
+*/
+
+/* command block wrapper */
+struct bulk_cb_wrap {
+	unsigned int	Signature;		/* contains 'USBC', denote bulk_cb_wrap */
+	unsigned int	Tag;			/* unique per command id */
+	unsigned int	DataTransferLength;	/* size of data for transfer */
+	unsigned char	Flags;			/* data transfer direction */
+	unsigned char	Lun;			/* LUN normally 0, (which command block is sent) */
+	unsigned char	Length;			/* length of the CDB */
+	unsigned char	CDB[16];		/* max command */
+};
+
+#define US_BULK_CB_WRAP_LEN	31
+#define US_BULK_CB_SIGN		0x43425355	/*spells out USBC */
+#define US_BULK_FLAG_IN		(1 << 7)
+#define US_BULK_FLAG_OUT	0
+
+/* command status wrapper */
+struct bulk_cs_wrap {
+	unsigned int	Signature;	/* should = 'USBS' */
+	unsigned int	Tag;		/* same as original command, echoed by the device as received */
+	unsigned int	Residue;	/* amount not transferred */
+	unsigned char	Status;		/* execute command status */
+};
+
+#define US_BULK_CS_WRAP_LEN	13
+#define US_BULK_CS_SIGN		0x53425355      /* spells out 'USBS' */
+// execute command status
+#define US_BULK_STAT_OK		0
+#define US_BULK_STAT_FAIL	1
+#define US_BULK_STAT_PHASE	2
+
+/* bulk-only class specific requests */
+#define US_BULK_RESET_REQUEST   0xff
+#define US_BULK_GET_MAX_LUN     0xfe
+
+extern int usbd_msc_receive_cbw(struct msc_dev *mscdev, struct usb_request *req);
+#endif

USDK/component/common/drivers/usb_class/device/core/inc/gadget_debug.h

@@ -0,0 +1,24 @@
+#ifndef _GADEGT_DEBUG_H_
+#define _GADGET_DEBUG_H_
+
+#include "diag.h"
+
+#define GADGET_DEBUG       0
+
+#if GADGET_DEBUG
+#define GADGET_PRINT(fmt, args...)		            DBG_8195A("\n\r[%s]: " fmt, __FUNCTION__, ## args)
+#define GADGET_ERROR(fmt, args...)		            DBG_8195A("\n\r[%s]: " fmt, __FUNCTION__, ## args)
+#define GADGET_WARN(fmt, args...)		            DBG_8195A("\n\r[%s]: " fmt, __FUNCTION__, ## args)
+#define FUN_ENTER                                   DBG_8195A("\n\r[%s ==>]\n", __func__)
+#define FUN_EXIT                                    DBG_8195A("\n\r[%s <==]\n", __func__)
+#define FUN_TRACE                                   DBG_8195A("\n\r[%s]:%d \n", __func__, __LINE__)
+#else
+#define GADGET_PRINT(fmt, args...)
+#define GADGET_ERROR(fmt, args...)		            DBG_8195A("\n\r[%s]: " fmt, __FUNCTION__, ## args)
+#define GADGET_WARN(fmt, args...)
+#define FUN_ENTER
+#define FUN_EXIT
+#define FUN_TRACE
+#endif
+
+#endif

USDK/component/common/drivers/usb_class/device/core/inc/os_wrapper.h

@@ -0,0 +1,30 @@
+#ifndef _OS_WRAPPER_H_
+#define _OS_WRAPPER_H_
+
+#include "osdep_api.h"
+
+#ifndef spinlock_t
+#define spinlock_t _Lock
+#endif
+
+#ifndef _atomic_spin_lock_irqsave
+#define _atomic_spin_lock_irqsave(p, flags) 		SaveAndCli()
+#endif
+#ifndef _atomic_spin_unlock_irqrestore
+#define _atomic_spin_unlock_irqrestore(p, flags)	RestoreFlags()
+#endif
+
+/* spin lock */
+#ifndef spin_lock_init
+	#define spin_lock_init(plock) 			RtlSpinlockInit((plock))
+#endif
+#ifndef spin_lock_free
+	#define spin_lock_free(plock) 			RtlSpinlockFree((plock))
+#endif
+#ifndef spin_lock
+	#define spin_lock(plock) 			RtlSpinlock((plock))
+#endif
+#ifndef spin_unlock
+	#define spin_unlock(plock) 			RtlSpinunlock((plock))
+#endif
+#endif

USDK/component/common/drivers/usb_class/device/core/inc/usb_composite.h

@@ -0,0 +1,398 @@
+#ifndef _USB_COMPOSITE_H_
+#define _USB_COMPOSITE_H_
+
+#include "usb_gadget.h"
+#include "usb.h"
+
+/*
+ * USB function drivers should return USB_GADGET_DELAYED_STATUS if they
+ * wish to delay the data/status stages of the control transfer till they
+ * are ready. The control transfer will then be kept from completing till
+ * all the function drivers that requested for USB_GADGET_DELAYED_STAUS
+ * invoke usb_composite_setup_continue().
+ */
+#define USB_GADGET_DELAYED_STATUS       0x7fff	/* Impossibly large value */
+
+
+/* big enough to hold our biggest descriptor */
+#define USB_COMP_EP0_BUFSIZ	1024+24
+#define	MAX_CONFIG_INTERFACES		16	/* arbitrary; max 255 */
+// predefine structure
+struct usb_composite_dev;
+struct usb_composite_driver;
+
+enum control_request_return_codes {
+ 		USBD_REQ_NOTSUPP		= 0,
+ 		USBD_REQ_HANDLED		= 1,
+ 		USBD_REQ_NEXT_CALLBACK	= 2,
+};
+
+
+/**
+ * struct usb_composite_driver - groups configurations into a gadget
+ * @name: For diagnostics, identifies the driver.
+ * @dev: Template descriptor for the device, including default device
+ *	identifiers.
+ * @strings: tables of strings, keyed by identifiers assigned during @bind
+ *	and language IDs provided in control requests. Note: The first entries
+ *	are predefined. The first entry that may be used is
+ *	USB_GADGET_FIRST_AVAIL_IDX
+ * @max_speed: Highest speed the driver supports.
+ * @needs_serial: set to 1 if the gadget needs userspace to provide
+ * 	a serial number.  If one is not provided, warning will be printed.
+ * @bind: (REQUIRED) Used to allocate resources that are shared across the
+ *	whole device, such as string IDs, and add its configurations using
+ *	@usb_add_config(). This may fail by returning a negative errno
+ *	value; it should return zero on successful initialization.
+ * @unbind: Reverses @bind; called as a side effect of unregistering
+ *	this driver.
+ * @disconnect: optional driver disconnect method
+ * @suspend: Notifies when the host stops sending USB traffic,
+ *	after function notifications
+ * @resume: Notifies configuration when the host restarts USB traffic,
+ *	before function notifications
+ * @gadget_driver: Gadget driver controlling this driver
+ *
+ * Devices default to reporting self powered operation.  Devices which rely
+ * on bus powered operation should report this in their @bind method.
+ *
+ * Before returning from @bind, various fields in the template descriptor
+ * may be overridden.  These include the idVendor/idProduct/bcdDevice values
+ * normally to bind the appropriate host side driver, and the three strings
+ * (iManufacturer, iProduct, iSerialNumber) normally used to provide user
+ * meaningful device identifiers.  (The strings will not be defined unless
+ * they are defined in @dev and @strings.)  The correct ep0 maxpacket size
+ * is also reported, as defined by the underlying controller driver.
+ */
+
+struct usb_composite_driver {
+	const char				*name;
+	const struct usb_device_descriptor	*dev;
+	struct usb_gadget_strings		**strings;
+	enum usb_device_speed			max_speed;
+	unsigned		needs_serial:1;
+
+	int			(*bind)(struct usb_composite_dev *cdev);
+	int			(*unbind)(struct usb_composite_dev *);
+
+	void			(*disconnect)(struct usb_composite_dev *);
+
+	/* global suspend hooks */
+	void			(*suspend)(struct usb_composite_dev *);
+	void			(*resume)(struct usb_composite_dev *);
+	struct usb_gadget_driver		gadget_driver;
+};
+/**
+ * struct usb_composite_device - represents one composite usb gadget
+ * @gadget: read-only, abstracts the gadget's usb peripheral controller
+ * @req: used for control responses; buffer is pre-allocated
+ * @os_desc_req: used for OS descriptors responses; buffer is pre-allocated
+ * @config: the currently active configuration
+ * @qw_sign: qwSignature part of the OS string
+ * @b_vendor_code: bMS_VendorCode part of the OS string
+ * @use_os_string: false by default, interested gadgets set it
+ * @os_desc_config: the configuration to be used with OS descriptors
+ *
+ * One of these devices is allocated and initialized before the
+ * associated device driver's bind() is called.
+ *
+ * OPEN ISSUE:  it appears that some WUSB devices will need to be
+ * built by combining a normal (wired) gadget with a wireless one.
+ * This revision of the gadget framework should probably try to make
+ * sure doing that won't hurt too much.
+ *
+ * One notion for how to handle Wireless USB devices involves:
+ * (a) a second gadget here, discovery mechanism TBD, but likely
+ *     needing separate "register/unregister WUSB gadget" calls;
+ * (b) updates to usb_gadget to include flags "is it wireless",
+ *     "is it wired", plus (presumably in a wrapper structure)
+ *     bandgroup and PHY info;
+ * (c) presumably a wireless_ep wrapping a usb_ep, and reporting
+ *     wireless-specific parameters like maxburst and maxsequence;
+ * (d) configurations that are specific to wireless links;
+ * (e) function drivers that understand wireless configs and will
+ *     support wireless for (additional) function instances;
+ * (f) a function to support association setup (like CBAF), not
+ *     necessarily requiring a wireless adapter;
+ * (g) composite device setup that can create one or more wireless
+ *     configs, including appropriate association setup support;
+ * (h) more, TBD.
+ */
+
+#define MAX_USER_CONTROL_CALLBACK	2
+
+typedef int (*user_control_callback)(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl);
+
+struct usb_composite_dev {
+	struct usb_gadget		*gadget;
+	struct usb_request		*req;
+	struct usb_request		*os_desc_req;
+
+	struct usb_configuration	*config;
+//
+//	/* OS String is a custom (yet popular) extension to the USB standard. */
+//	u8				qw_sign[OS_STRING_QW_SIGN_LEN];
+//	u8				b_vendor_code;
+//	struct usb_configuration	*os_desc_config;
+//	unsigned int			use_os_string:1;
+//
+//	/* private: */
+//	/* internals */
+	unsigned int			suspended:1;
+	struct usb_device_descriptor	desc;
+	
+	//_LIST		config_list;
+	dwc_list_link_t config_list; // by jimmy
+	//_LIST		gstring_list; 
+	dwc_list_link_t gstring_list;// by jimmy
+	
+	struct usb_composite_driver	*driver;
+//	u8				next_string_id;
+//	char				*def_manufacturer;
+//
+//	/* the gadget driver won't enable the data pullup
+//	 * while the deactivation count is nonzero.
+//	 */
+//	unsigned			deactivations;
+//
+//	/* the composite driver won't complete the control transfer's
+//	 * data/status stages till delayed_status is zero.
+//	 */
+//	int				delayed_status;
+//
+//	/* protects deactivations and delayed_status counts*/
+	_Lock			lock;
+	/* for unstandard control request handler */
+
+	user_control_callback control_cb[MAX_USER_CONTROL_CALLBACK];
+};
+
+
+#if 0
+#define container_of(p,t,n) (t*)((p)-&(((t*)0)->n))
+
+static inline struct usb_composite_driver *to_cdriver(
+		struct usb_gadget_driver *gdrv)
+{
+	return container_of(gdrv, struct usb_composite_driver, gadget_driver);
+}
+#endif
+#if 1
+/**
+ * struct usb_configuration - represents one gadget configuration
+ * @label: For diagnostics, describes the configuration.
+ * @strings: Tables of strings, keyed by identifiers assigned during @bind()
+ *	and by language IDs provided in control requests.
+ * @descriptors: Table of descriptors preceding all function descriptors.
+ *	Examples include OTG and vendor-specific descriptors.
+ * @unbind: Reverses @bind; called as a side effect of unregistering the
+ *	driver which added this configuration.
+ * @setup: Used to delegate control requests that aren't handled by standard
+ *	device infrastructure or directed at a specific interface.
+ * @bConfigurationValue: Copied into configuration descriptor.
+ * @iConfiguration: Copied into configuration descriptor.
+ * @bmAttributes: Copied into configuration descriptor.
+ * @MaxPower: Power consumtion in mA. Used to compute bMaxPower in the
+ *	configuration descriptor after considering the bus speed.
+ * @cdev: assigned by @usb_add_config() before calling @bind(); this is
+ *	the device associated with this configuration.
+ *
+ * Configurations are building blocks for gadget drivers structured around
+ * function drivers.  Simple USB gadgets require only one function and one
+ * configuration, and handle dual-speed hardware by always providing the same
+ * functionality.  Slightly more complex gadgets may have more than one
+ * single-function configuration at a given speed; or have configurations
+ * that only work at one speed.
+ *
+ * Composite devices are, by definition, ones with configurations which
+ * include more than one function.
+ *
+ * The lifecycle of a usb_configuration includes allocation, initialization
+ * of the fields described above, and calling @usb_add_config() to set up
+ * internal data and bind it to a specific device.  The configuration's
+ * @bind() method is then used to initialize all the functions and then
+ * call @usb_add_function() for them.
+ *
+ * Those functions would normally be independent of each other, but that's
+ * not mandatory.  CDC WMC devices are an example where functions often
+ * depend on other functions, with some functions subsidiary to others.
+ * Such interdependency may be managed in any way, so long as all of the
+ * descriptors complete by the time the composite driver returns from
+ * its bind() routine.
+ */
+struct usb_configuration {
+	const char			*label;
+	struct usb_gadget_strings	**strings;
+	const struct usb_descriptor_header **descriptors;
+
+	/* REVISIT:  bind() functions can be marked __init, which
+	 * makes trouble for section mismatch analysis.  See if
+	 * we can't restructure things to avoid mismatching...
+	 */
+
+	/* configuration management: unbind/setup */
+	void			(*unbind)(struct usb_configuration *);
+	int			(*setup)(struct usb_configuration *,
+					const struct usb_ctrlrequest *);
+
+	/* fields in the config descriptor */
+	u8			bConfigurationValue;
+	u8			iConfiguration;
+	u8			bmAttributes;
+	u16			MaxPower;
+
+	struct usb_composite_dev	*cdev;
+
+	/* private: */
+	/* internals */
+	//_LIST	list;
+	//_LIST	function_lists;
+	dwc_list_link_t list;
+	dwc_list_link_t function_lists; // by jimmy
+	
+	u8			next_interface_id;
+	unsigned		superspeed:1;
+	unsigned		highspeed:1;
+	unsigned		fullspeed:1;
+	struct usb_function	*interface[MAX_CONFIG_INTERFACES];
+};
+
+_LONG_CALL_ int usb_interface_id(struct usb_configuration *config,
+		struct usb_function *function);
+
+_LONG_CALL_ int usb_add_config(struct usb_composite_dev *,
+		struct usb_configuration *,
+		int (*)(struct usb_configuration *));
+
+_LONG_CALL_ void usb_remove_config(struct usb_composite_dev *,
+		struct usb_configuration *);
+
+/**
+ * struct usb_function - describes one function of a configuration
+ * @name: For diagnostics, identifies the function.
+ * @strings: tables of strings, keyed by identifiers assigned during bind()
+ *	and by language IDs provided in control requests
+ * @fs_descriptors: Table of full (or low) speed descriptors, using interface and
+ *	string identifiers assigned during @bind().  If this pointer is null,
+ *	the function will not be available at full speed (or at low speed).
+ * @hs_descriptors: Table of high speed descriptors, using interface and
+ *	string identifiers assigned during @bind().  If this pointer is null,
+ *	the function will not be available at high speed.
+ * @ss_descriptors: Table of super speed descriptors, using interface and
+ *	string identifiers assigned during @bind(). If this
+ *	pointer is null after initiation, the function will not
+ *	be available at super speed.
+ * @config: assigned when @usb_add_function() is called; this is the
+ *	configuration with which this function is associated.
+ * @os_desc_table: Table of (interface id, os descriptors) pairs. The function
+ *	can expose more than one interface. If an interface is a member of
+ *	an IAD, only the first interface of IAD has its entry in the table.
+ * @os_desc_n: Number of entries in os_desc_table
+ * @bind: Before the gadget can register, all of its functions bind() to the
+ *	available resources including string and interface identifiers used
+ *	in interface or class descriptors; endpoints; I/O buffers; and so on.
+ * @unbind: Reverses @bind; called as a side effect of unregistering the
+ *	driver which added this function.
+ * @free_func: free the struct usb_function.
+ * @mod: (internal) points to the module that created this structure.
+ * @set_alt: (REQUIRED) Reconfigures altsettings; function drivers may
+ *	initialize usb_ep.driver data at this time (when it is used).
+ *	Note that setting an interface to its current altsetting resets
+ *	interface state, and that all interfaces have a disabled state.
+ * @get_alt: Returns the active altsetting.  If this is not provided,
+ *	then only altsetting zero is supported.
+ * @disable: (REQUIRED) Indicates the function should be disabled.  Reasons
+ *	include host resetting or reconfiguring the gadget, and disconnection.
+ * @setup: Used for interface-specific control requests.
+ * @suspend: Notifies functions when the host stops sending USB traffic.
+ * @resume: Notifies functions when the host restarts USB traffic.
+ * @get_status: Returns function status as a reply to
+ *	GetStatus() request when the recipient is Interface.
+ * @func_suspend: callback to be called when
+ *	SetFeature(FUNCTION_SUSPEND) is reseived
+ *
+ * A single USB function uses one or more interfaces, and should in most
+ * cases support operation at both full and high speeds.  Each function is
+ * associated by @usb_add_function() with a one configuration; that function
+ * causes @bind() to be called so resources can be allocated as part of
+ * setting up a gadget driver.  Those resources include endpoints, which
+ * should be allocated using @usb_ep_autoconfig().
+ *
+ * To support dual speed operation, a function driver provides descriptors
+ * for both high and full speed operation.  Except in rare cases that don't
+ * involve bulk endpoints, each speed needs different endpoint descriptors.
+ *
+ * Function drivers choose their own strategies for managing instance data.
+ * The simplest strategy just declares it "static', which means the function
+ * can only be activated once.  If the function needs to be exposed in more
+ * than one configuration at a given speed, it needs to support multiple
+ * usb_function structures (one for each configuration).
+ *
+ * A more complex strategy might encapsulate a @usb_function structure inside
+ * a driver-specific instance structure to allows multiple activations.  An
+ * example of multiple activations might be a CDC ACM function that supports
+ * two or more distinct instances within the same configuration, providing
+ * several independent logical data links to a USB host.
+ */
+
+struct usb_function {
+	const char			*name;
+	struct usb_gadget_strings	**strings;
+	struct usb_descriptor_header	**fs_descriptors;
+	struct usb_descriptor_header	**hs_descriptors;
+//	struct usb_descriptor_header	**ss_descriptors;
+
+	struct usb_configuration	*config;
+
+//	struct usb_os_desc_table	*os_desc_table;
+//	unsigned			os_desc_n;
+
+	/* REVISIT:  bind() functions can be marked __init, which
+	 * makes trouble for section mismatch analysis.  See if
+	 * we can't restructure things to avoid mismatching.
+	 * Related:  unbind() may kfree() but bind() won't...
+	 */
+
+	/* configuration management:  bind/unbind */
+	int			(*bind)(struct usb_configuration *,
+					struct usb_function *);
+	void			(*unbind)(struct usb_configuration *,
+					struct usb_function *);
+	void			(*free_func)(struct usb_function *f);
+	struct module		*mod;
+
+	/* runtime state management */
+	int			(*set_alt)(struct usb_function *,
+					unsigned interface, unsigned alt);
+	int			(*get_alt)(struct usb_function *,
+					unsigned interface);
+	void			(*disable)(struct usb_function *);
+	int			(*setup)(struct usb_function *,
+					const struct usb_ctrlrequest *);
+	void			(*suspend)(struct usb_function *);
+	void			(*resume)(struct usb_function *);
+
+	/* USB 3.0 additions */
+	int			(*get_status)(struct usb_function *);
+	int			(*func_suspend)(struct usb_function *,
+						u8 suspend_opt);
+	/* private: */
+	/* internals */
+	//_LIST		list;
+	dwc_list_link_t list; // by jimmy
+//	DECLARE_BITMAP(endpoints, 32);
+//	const struct usb_function_instance *fi;
+};
+
+#endif
+extern _LONG_CALL_ int usb_add_function(struct usb_configuration *, struct usb_function *);
+extern _LONG_CALL_ void usb_remove_function(struct usb_configuration *, struct usb_function *);
+extern _LONG_CALL_ void usb_put_function(struct usb_function *);
+extern _LONG_CALL_ int usb_function_deactivate(struct usb_function *);
+extern _LONG_CALL_ int usb_function_activate(struct usb_function *);
+
+extern _LONG_CALL_ int usb_interface_id(struct usb_configuration *, struct usb_function *);
+extern _LONG_CALL_ int usb_composite_probe(struct usb_composite_driver *driver);
+extern _LONG_CALL_ int register_class_vendor_control_request_cb(struct usb_composite_dev *cdev, user_control_callback cb);
+extern _LONG_CALL_ void usb_composite_unregister(struct usb_composite_driver *driver);
+#endif

USDK/component/common/drivers/usb_class/device/core/inc/usb_config.h

@@ -0,0 +1,12 @@
+#ifndef _USB_CONFIG_H_
+#define _USB_CONFIG_H_
+
+#include "core/inc/usb_composite.h"
+
+extern _LONG_CALL_ int usb_assign_descriptors(struct usb_function *f,
+		struct usb_descriptor_header **fs,
+		struct usb_descriptor_header **hs,
+		struct usb_descriptor_header **ss);
+
+extern _LONG_CALL_ void usb_free_all_descriptors(struct usb_function *f);
+#endif

USDK/component/common/drivers/usb_class/device/core/inc/usb_transport.h

@@ -0,0 +1,5 @@
+#ifndef _USB_BOT_H
+#define _USB_BOT_H
+#include "basic_types.h"
+
+#endif

USDK/component/common/drivers/usb_class/host/storage/inc/quirks/quirks.h

@@ -0,0 +1,34 @@
+/*
+ * This file holds the definitions of quirks found in USB devices.
+ * Only quirks that affect the whole device, not an interface,
+ * belong here.
+ */
+
+#ifndef __QUIRKS_H
+#define __QUIRKS_H
+
+/* string descriptors must not be fetched using a 255-byte read */
+#define USB_QUIRK_STRING_FETCH_255		0x00000001
+
+/* device can't resume correctly so reset it instead */
+#define USB_QUIRK_RESET_RESUME			0x00000002
+
+/* device can't handle Set-Interface requests */
+#define USB_QUIRK_NO_SET_INTF			0x00000004
+
+/* device can't handle its Configuration or Interface strings */
+#define USB_QUIRK_CONFIG_INTF_STRINGS	0x00000008
+
+/* device can't be reset(e.g morph devices), don't use reset */
+#define USB_QUIRK_RESET					0x00000010
+
+/* device has more interface descriptions than the bNumInterfaces count,
+   and can't handle talking to these interfaces */
+#define USB_QUIRK_HONOR_BNUMINTERFACES	0x00000020
+
+/* device needs a pause during initialization, after we read the device
+   descriptor */
+#define USB_QUIRK_DELAY_INIT			0x00000040
+
+#endif /* __QUIRKS_H */
+

USDK/component/common/drivers/usb_class/host/storage/inc/scatterlist/scatterlist.h

@@ -0,0 +1,20 @@
+#ifndef _SCATTERLIST_H
+#define _SCATTERLIST_H
+
+struct scatterlist {
+	unsigned long   sg_magic;
+	unsigned long   page_link;
+	unsigned int    offset;
+
+	unsigned int    length;
+
+	dma_addr_t      dma_address;
+	__u32           dma_length;
+};
+
+struct sg_table {
+	struct scatterlist *sgl;	/* the list */
+	unsigned int nents;		/* number of mapped entries */
+	unsigned int orig_nents;	/* original size of list */
+};
+#endif

USDK/component/common/drivers/usb_class/host/storage/inc/scsi/dma_direction.h

@@ -0,0 +1,12 @@
+#ifndef _DMA_DIRECTION_H
+#define _DMA_DIRECTION_H
+
+enum dma_data_direction {
+         DMA_BIDIRECTIONAL = 0,
+         DMA_TO_DEVICE = 1,
+         DMA_FROM_DEVICE = 2,
+         DMA_NONE = 3,
+};
+
+#endif
+

USDK/component/common/drivers/usb_class/host/storage/inc/scsi/scsi.h

@@ -0,0 +1,585 @@
+/*
+ * This header file contains public constants and structures used by
+ * the scsi code for linux.
+ *
+ * For documentation on the OPCODES, MESSAGES, and SENSE values,
+ * please consult the SCSI standard.
+ */
+#ifndef _SCSI_SCSI_H
+#define _SCSI_SCSI_H
+
+#include "us_os_wrap_via_osdep_api.h"
+
+#define HZ 1024
+
+struct scsi_cmnd;
+
+enum scsi_timeouts {
+	SCSI_DEFAULT_EH_TIMEOUT		= 10 * HZ,
+};
+
+/*
+ * The maximum number of SG segments that we will put inside a
+ * scatterlist (unless chaining is used). Should ideally fit inside a
+ * single page, to avoid a higher order allocation.  We could define this
+ * to SG_MAX_SINGLE_ALLOC to pack correctly at the highest order.  The
+ * minimum value is 32
+ */
+#define SCSI_MAX_SG_SEGMENTS	128
+
+/*
+ * Like SCSI_MAX_SG_SEGMENTS, but for archs that have sg chaining. This limit
+ * is totally arbitrary, a setting of 2048 will get you at least 8mb ios.
+ */
+#ifdef ARCH_HAS_SG_CHAIN
+#define SCSI_MAX_SG_CHAIN_SEGMENTS	2048
+#else
+#define SCSI_MAX_SG_CHAIN_SEGMENTS	SCSI_MAX_SG_SEGMENTS
+#endif
+
+/*
+ * DIX-capable adapters effectively support infinite chaining for the
+ * protection information scatterlist
+ */
+#define SCSI_MAX_PROT_SG_SEGMENTS	0xFFFF
+
+/*
+ * Special value for scanning to specify scanning or rescanning of all
+ * possible channels, (target) ids, or luns on a given shost.
+ */
+#define SCAN_WILD_CARD	~0
+
+/*
+ *      SCSI opcodes
+ */
+
+#define TEST_UNIT_READY       0x00
+#define REZERO_UNIT           0x01
+#define REQUEST_SENSE         0x03
+#define FORMAT_UNIT           0x04
+#define READ_BLOCK_LIMITS     0x05
+#define REASSIGN_BLOCKS       0x07
+#define INITIALIZE_ELEMENT_STATUS 0x07
+#define READ_6                0x08
+#define WRITE_6               0x0a
+#define SEEK_6                0x0b
+#define READ_REVERSE          0x0f
+#define WRITE_FILEMARKS       0x10
+#define SPACE                 0x11
+#define INQUIRY               0x12
+#define RECOVER_BUFFERED_DATA 0x14
+#define MODE_SELECT           0x15
+#define RESERVE               0x16
+#define RELEASE               0x17
+#define COPY                  0x18
+#define ERASE                 0x19
+#define MODE_SENSE            0x1a
+#define START_STOP            0x1b
+#define RECEIVE_DIAGNOSTIC    0x1c
+#define SEND_DIAGNOSTIC       0x1d
+#define ALLOW_MEDIUM_REMOVAL  0x1e
+
+#define READ_FORMAT_CAPACITIES 0x23
+#define SET_WINDOW            0x24
+#define READ_CAPACITY         0x25
+#define READ_10               0x28
+#define WRITE_10              0x2a
+#define SEEK_10               0x2b
+#define POSITION_TO_ELEMENT   0x2b
+#define WRITE_VERIFY          0x2e
+#define VERIFY                0x2f
+#define SEARCH_HIGH           0x30
+#define SEARCH_EQUAL          0x31
+#define SEARCH_LOW            0x32
+#define SET_LIMITS            0x33
+#define PRE_FETCH             0x34
+#define READ_POSITION         0x34
+#define SYNCHRONIZE_CACHE     0x35
+#define LOCK_UNLOCK_CACHE     0x36
+#define READ_DEFECT_DATA      0x37
+#define MEDIUM_SCAN           0x38
+#define COMPARE               0x39
+#define COPY_VERIFY           0x3a
+#define WRITE_BUFFER          0x3b
+#define READ_BUFFER           0x3c
+#define UPDATE_BLOCK          0x3d
+#define READ_LONG             0x3e
+#define WRITE_LONG            0x3f
+#define CHANGE_DEFINITION     0x40
+#define WRITE_SAME            0x41
+#define UNMAP		      0x42
+#define READ_TOC              0x43
+#define READ_HEADER           0x44
+#define GET_EVENT_STATUS_NOTIFICATION 0x4a
+#define LOG_SELECT            0x4c
+#define LOG_SENSE             0x4d
+#define XDWRITEREAD_10        0x53
+#define MODE_SELECT_10        0x55
+#define RESERVE_10            0x56
+#define RELEASE_10            0x57
+#define MODE_SENSE_10         0x5a
+#define PERSISTENT_RESERVE_IN 0x5e
+#define PERSISTENT_RESERVE_OUT 0x5f
+#define VARIABLE_LENGTH_CMD   0x7f
+#define REPORT_LUNS           0xa0
+#define SECURITY_PROTOCOL_IN  0xa2
+#define MAINTENANCE_IN        0xa3
+#define MAINTENANCE_OUT       0xa4
+#define MOVE_MEDIUM           0xa5
+#define EXCHANGE_MEDIUM       0xa6
+#define READ_12               0xa8
+#define WRITE_12              0xaa
+#define READ_MEDIA_SERIAL_NUMBER 0xab
+#define WRITE_VERIFY_12       0xae
+#define VERIFY_12	      0xaf
+#define SEARCH_HIGH_12        0xb0
+#define SEARCH_EQUAL_12       0xb1
+#define SEARCH_LOW_12         0xb2
+#define SECURITY_PROTOCOL_OUT 0xb5
+#define READ_ELEMENT_STATUS   0xb8
+#define SEND_VOLUME_TAG       0xb6
+#define WRITE_LONG_2          0xea
+#define EXTENDED_COPY         0x83
+#define RECEIVE_COPY_RESULTS  0x84
+#define ACCESS_CONTROL_IN     0x86
+#define ACCESS_CONTROL_OUT    0x87
+#define READ_16               0x88
+#define COMPARE_AND_WRITE     0x89
+#define WRITE_16              0x8a
+#define READ_ATTRIBUTE        0x8c
+#define WRITE_ATTRIBUTE	      0x8d
+#define VERIFY_16	      0x8f
+#define SYNCHRONIZE_CACHE_16  0x91
+#define WRITE_SAME_16	      0x93
+#define SERVICE_ACTION_IN     0x9e
+/* values for service action in */
+#define	SAI_READ_CAPACITY_16  0x10
+#define SAI_GET_LBA_STATUS    0x12
+#define SAI_REPORT_REFERRALS  0x13
+/* values for VARIABLE_LENGTH_CMD service action codes
+ * see spc4r17 Section D.3.5, table D.7 and D.8 */
+#define VLC_SA_RECEIVE_CREDENTIAL 0x1800
+/* values for maintenance in */
+#define MI_REPORT_IDENTIFYING_INFORMATION 0x05
+#define MI_REPORT_TARGET_PGS  0x0a
+#define MI_REPORT_ALIASES     0x0b
+#define MI_REPORT_SUPPORTED_OPERATION_CODES 0x0c
+#define MI_REPORT_SUPPORTED_TASK_MANAGEMENT_FUNCTIONS 0x0d
+#define MI_REPORT_PRIORITY   0x0e
+#define MI_REPORT_TIMESTAMP  0x0f
+#define MI_MANAGEMENT_PROTOCOL_IN 0x10
+/* value for MI_REPORT_TARGET_PGS ext header */
+#define MI_EXT_HDR_PARAM_FMT  0x20
+/* values for maintenance out */
+#define MO_SET_IDENTIFYING_INFORMATION 0x06
+#define MO_SET_TARGET_PGS     0x0a
+#define MO_CHANGE_ALIASES     0x0b
+#define MO_SET_PRIORITY       0x0e
+#define MO_SET_TIMESTAMP      0x0f
+#define MO_MANAGEMENT_PROTOCOL_OUT 0x10
+/* values for variable length command */
+#define XDREAD_32	      0x03
+#define XDWRITE_32	      0x04
+#define XPWRITE_32	      0x06
+#define XDWRITEREAD_32	      0x07
+#define READ_32		      0x09
+#define VERIFY_32	      0x0a
+#define WRITE_32	      0x0b
+#define WRITE_SAME_32	      0x0d
+
+/* Values for T10/04-262r7 */
+#define	ATA_16		      0x85	/* 16-byte pass-thru */
+#define	ATA_12		      0xa1	/* 12-byte pass-thru */
+
+/*
+ *	SCSI command lengths
+ */
+
+#define SCSI_MAX_VARLEN_CDB_SIZE 260
+
+/* defined in T10 SCSI Primary Commands-2 (SPC2) */
+struct scsi_varlen_cdb_hdr {
+	__u8 opcode;        /* opcode always == VARIABLE_LENGTH_CMD */
+	__u8 control;
+	__u8 misc[5];
+	__u8 additional_cdb_length;         /* total cdb length - 8 */
+	__be16 service_action;
+	/* service specific data follows */
+};
+
+static inline unsigned
+scsi_varlen_cdb_length(const void *hdr)
+{
+	return ((struct scsi_varlen_cdb_hdr *)hdr)->additional_cdb_length + 8;
+}
+
+extern const unsigned char scsi_command_size_tbl[8];
+#define COMMAND_SIZE(opcode) scsi_command_size_tbl[((opcode) >> 5) & 7]
+
+static inline unsigned
+scsi_command_size(const unsigned char *cmnd)
+{
+	return (cmnd[0] == VARIABLE_LENGTH_CMD) ?
+		scsi_varlen_cdb_length(cmnd) : COMMAND_SIZE(cmnd[0]);
+}
+
+#ifdef CONFIG_ACPI
+struct acpi_bus_type;
+
+extern int
+scsi_register_acpi_bus_type(struct acpi_bus_type *bus);
+
+extern void
+scsi_unregister_acpi_bus_type(struct acpi_bus_type *bus);
+#endif
+
+/*
+ *  SCSI Architecture Model (SAM) Status codes. Taken from SAM-3 draft
+ *  T10/1561-D Revision 4 Draft dated 7th November 2002.
+ */
+#define SAM_STAT_GOOD            0x00
+#define SAM_STAT_CHECK_CONDITION 0x02
+#define SAM_STAT_CONDITION_MET   0x04
+#define SAM_STAT_BUSY            0x08
+#define SAM_STAT_INTERMEDIATE    0x10
+#define SAM_STAT_INTERMEDIATE_CONDITION_MET 0x14
+#define SAM_STAT_RESERVATION_CONFLICT 0x18
+#define SAM_STAT_COMMAND_TERMINATED 0x22	/* obsolete in SAM-3 */
+#define SAM_STAT_TASK_SET_FULL   0x28
+#define SAM_STAT_ACA_ACTIVE      0x30
+#define SAM_STAT_TASK_ABORTED    0x40
+
+/** scsi_status_is_good - check the status return.
+ *
+ * @status: the status passed up from the driver (including host and
+ *          driver components)
+ *
+ * This returns true for known good conditions that may be treated as
+ * command completed normally
+ */
+static inline int scsi_status_is_good(int status)
+{
+	/*
+	 * FIXME: bit0 is listed as reserved in SCSI-2, but is
+	 * significant in SCSI-3.  For now, we follow the SCSI-2
+	 * behaviour and ignore reserved bits.
+	 */
+	status &= 0xfe;
+	return ((status == SAM_STAT_GOOD) ||
+		(status == SAM_STAT_INTERMEDIATE) ||
+		(status == SAM_STAT_INTERMEDIATE_CONDITION_MET) ||
+		/* FIXME: this is obsolete in SAM-3 */
+		(status == SAM_STAT_COMMAND_TERMINATED));
+}
+
+/*
+ *  Status codes. These are deprecated as they are shifted 1 bit right
+ *  from those found in the SCSI standards. This causes confusion for
+ *  applications that are ported to several OSes. Prefer SAM Status codes
+ *  above.
+ */
+
+#define GOOD                 0x00
+#define CHECK_CONDITION      0x01
+#define CONDITION_GOOD       0x02
+#define BUSY                 0x04
+#define INTERMEDIATE_GOOD    0x08
+#define INTERMEDIATE_C_GOOD  0x0a
+#define RESERVATION_CONFLICT 0x0c
+#define COMMAND_TERMINATED   0x11
+#define QUEUE_FULL           0x14
+#define ACA_ACTIVE           0x18
+#define TASK_ABORTED         0x20
+
+#define STATUS_MASK          0xfe
+
+/*
+ *  SENSE KEYS
+ */
+
+#define NO_SENSE            0x00
+#define RECOVERED_ERROR     0x01
+#define NOT_READY           0x02
+#define MEDIUM_ERROR        0x03
+#define HARDWARE_ERROR      0x04
+#define ILLEGAL_REQUEST     0x05
+#define UNIT_ATTENTION      0x06
+#define DATA_PROTECT        0x07
+#define BLANK_CHECK         0x08
+#define COPY_ABORTED        0x0a
+#define ABORTED_COMMAND     0x0b
+#define VOLUME_OVERFLOW     0x0d
+#define MISCOMPARE          0x0e
+
+
+/*
+ *  DEVICE TYPES
+ *  Please keep them in 0x%02x format for $MODALIAS to work
+ */
+
+#define TYPE_DISK           0x00
+#define TYPE_TAPE           0x01
+#define TYPE_PRINTER        0x02
+#define TYPE_PROCESSOR      0x03    /* HP scanners use this */
+#define TYPE_WORM           0x04    /* Treated as ROM by our system */
+#define TYPE_ROM            0x05
+#define TYPE_SCANNER        0x06
+#define TYPE_MOD            0x07    /* Magneto-optical disk - 
+				     * - treated as TYPE_DISK */
+#define TYPE_MEDIUM_CHANGER 0x08
+#define TYPE_COMM           0x09    /* Communications device */
+#define TYPE_RAID           0x0c
+#define TYPE_ENCLOSURE      0x0d    /* Enclosure Services Device */
+#define TYPE_RBC	    0x0e
+#define TYPE_OSD            0x11
+#define TYPE_NO_LUN         0x7f
+
+/* SCSI protocols; these are taken from SPC-3 section 7.5 */
+enum scsi_protocol {
+	SCSI_PROTOCOL_FCP = 0,	/* Fibre Channel */
+	SCSI_PROTOCOL_SPI = 1,	/* parallel SCSI */
+	SCSI_PROTOCOL_SSA = 2,	/* Serial Storage Architecture - Obsolete */
+	SCSI_PROTOCOL_SBP = 3,	/* firewire */
+	SCSI_PROTOCOL_SRP = 4,	/* Infiniband RDMA */
+	SCSI_PROTOCOL_ISCSI = 5,
+	SCSI_PROTOCOL_SAS = 6,
+	SCSI_PROTOCOL_ADT = 7,	/* Media Changers */
+	SCSI_PROTOCOL_ATA = 8,
+	SCSI_PROTOCOL_UNSPEC = 0xf, /* No specific protocol */
+};
+
+/* Returns a human-readable name for the device */
+extern const char * scsi_device_type(unsigned type);
+
+/*
+ * standard mode-select header prepended to all mode-select commands
+ */
+
+struct ccs_modesel_head {
+	__u8 _r1;			/* reserved */
+	__u8 medium;		/* device-specific medium type */
+	__u8 _r2;			/* reserved */
+	__u8 block_desc_length;	/* block descriptor length */
+	__u8 density;		/* device-specific density code */
+	__u8 number_blocks_hi;	/* number of blocks in this block desc */
+	__u8 number_blocks_med;
+	__u8 number_blocks_lo;
+	__u8 _r3;
+	__u8 block_length_hi;	/* block length for blocks in this desc */
+	__u8 block_length_med;
+	__u8 block_length_lo;
+};
+
+/*
+ * ScsiLun: 8 byte LUN.
+ */
+struct scsi_lun {
+	__u8 scsi_lun[8];
+};
+
+/*
+ * The Well Known LUNS (SAM-3) in our int representation of a LUN
+ */
+#define SCSI_W_LUN_BASE 0xc100
+#define SCSI_W_LUN_REPORT_LUNS (SCSI_W_LUN_BASE + 1)
+#define SCSI_W_LUN_ACCESS_CONTROL (SCSI_W_LUN_BASE + 2)
+#define SCSI_W_LUN_TARGET_LOG_PAGE (SCSI_W_LUN_BASE + 3)
+
+static inline int scsi_is_wlun(unsigned int lun)
+{
+	return (lun & 0xff00) == SCSI_W_LUN_BASE;
+}
+
+
+/*
+ *  MESSAGE CODES
+ */
+
+#define COMMAND_COMPLETE    0x00
+#define EXTENDED_MESSAGE    0x01
+#define     EXTENDED_MODIFY_DATA_POINTER    0x00
+#define     EXTENDED_SDTR                   0x01
+#define     EXTENDED_EXTENDED_IDENTIFY      0x02    /* SCSI-I only */
+#define     EXTENDED_WDTR                   0x03
+#define     EXTENDED_PPR                    0x04
+#define     EXTENDED_MODIFY_BIDI_DATA_PTR   0x05
+#define SAVE_POINTERS       0x02
+#define RESTORE_POINTERS    0x03
+#define DISCONNECT          0x04
+#define INITIATOR_ERROR     0x05
+#define ABORT_TASK_SET      0x06
+#define MESSAGE_REJECT      0x07
+#define NOP                 0x08
+#define MSG_PARITY_ERROR    0x09
+#define LINKED_CMD_COMPLETE 0x0a
+#define LINKED_FLG_CMD_COMPLETE 0x0b
+#define TARGET_RESET        0x0c
+#define ABORT_TASK          0x0d
+#define CLEAR_TASK_SET      0x0e
+#define INITIATE_RECOVERY   0x0f            /* SCSI-II only */
+#define RELEASE_RECOVERY    0x10            /* SCSI-II only */
+#define CLEAR_ACA           0x16
+#define LOGICAL_UNIT_RESET  0x17
+#define SIMPLE_QUEUE_TAG    0x20
+#define HEAD_OF_QUEUE_TAG   0x21
+#define ORDERED_QUEUE_TAG   0x22
+#define IGNORE_WIDE_RESIDUE 0x23
+#define ACA                 0x24
+#define QAS_REQUEST         0x55
+
+/* Old SCSI2 names, don't use in new code */
+#define BUS_DEVICE_RESET    TARGET_RESET
+#define ABORT               ABORT_TASK_SET
+
+/*
+ * Host byte codes
+ */
+
+#define DID_OK          0x00	/* NO error                                */
+#define DID_NO_CONNECT  0x01	/* Couldn't connect before timeout period  */
+#define DID_BUS_BUSY    0x02	/* BUS stayed busy through time out period */
+#define DID_TIME_OUT    0x03	/* TIMED OUT for other reason              */
+#define DID_BAD_TARGET  0x04	/* BAD target.                             */
+#define DID_ABORT       0x05	/* Told to abort for some other reason     */
+#define DID_PARITY      0x06	/* Parity error                            */
+#define DID_ERROR       0x07	/* Internal error                          */
+#define DID_RESET       0x08	/* Reset by somebody.                      */
+#define DID_BAD_INTR    0x09	/* Got an interrupt we weren't expecting.  */
+#define DID_PASSTHROUGH 0x0a	/* Force command past mid-layer            */
+#define DID_SOFT_ERROR  0x0b	/* The low level driver just wish a retry  */
+#define DID_IMM_RETRY   0x0c	/* Retry without decrementing retry count  */
+#define DID_REQUEUE	0x0d	/* Requeue command (no immediate retry) also
+				 * without decrementing the retry count	   */
+#define DID_TRANSPORT_DISRUPTED 0x0e /* Transport error disrupted execution
+				      * and the driver blocked the port to
+				      * recover the link. Transport class will
+				      * retry or fail IO */
+#define DID_TRANSPORT_FAILFAST	0x0f /* Transport class fastfailed the io */
+#define DID_TARGET_FAILURE 0x10 /* Permanent target failure, do not retry on
+				 * other paths */
+#define DID_NEXUS_FAILURE 0x11  /* Permanent nexus failure, retry on other
+				 * paths might yield different results */
+#define DID_ALLOC_FAILURE 0x12  /* Space allocation on the device failed */
+#define DID_MEDIUM_ERROR  0x13  /* Medium error */
+#define DRIVER_OK       0x00	/* Driver status                           */
+
+/*
+ *  These indicate the error that occurred, and what is available.
+ */
+
+#define DRIVER_BUSY         0x01
+#define DRIVER_SOFT         0x02
+#define DRIVER_MEDIA        0x03
+#define DRIVER_ERROR        0x04
+
+#define DRIVER_INVALID      0x05
+#define DRIVER_TIMEOUT      0x06
+#define DRIVER_HARD         0x07
+#define DRIVER_SENSE	    0x08
+
+/*
+ * Internal return values.
+ */
+
+#define NEEDS_RETRY     0x2001
+#define SUCCESS         0x2002
+#define FAILED          0x2003
+#define QUEUED          0x2004
+#define SOFT_ERROR      0x2005
+#define ADD_TO_MLQUEUE  0x2006
+#define TIMEOUT_ERROR   0x2007
+#define SCSI_RETURN_NOT_HANDLED   0x2008
+#define FAST_IO_FAIL	0x2009
+
+/*
+ * Midlevel queue return values.
+ */
+#define SCSI_MLQUEUE_HOST_BUSY   0x1055
+#define SCSI_MLQUEUE_DEVICE_BUSY 0x1056
+#define SCSI_MLQUEUE_EH_RETRY    0x1057
+#define SCSI_MLQUEUE_TARGET_BUSY 0x1058
+
+/*
+ *  Use these to separate status msg and our bytes
+ *
+ *  These are set by:
+ *
+ *      status byte = set from target device
+ *      msg_byte    = return status from host adapter itself.
+ *      host_byte   = set by low-level driver to indicate status.
+ *      driver_byte = set by mid-level.
+ */
+#define status_byte(result) (((result) >> 1) & 0x7f)
+#define msg_byte(result)    (((result) >> 8) & 0xff)
+#define host_byte(result)   (((result) >> 16) & 0xff)
+#define driver_byte(result) (((result) >> 24) & 0xff)
+
+#define sense_class(sense)  (((sense) >> 4) & 0x7)
+#define sense_error(sense)  ((sense) & 0xf)
+#define sense_valid(sense)  ((sense) & 0x80)
+
+/*
+ * default timeouts
+*/
+#define FORMAT_UNIT_TIMEOUT		(2 * 60 * 60 * HZ)
+#define START_STOP_TIMEOUT		(60 * HZ)
+#define MOVE_MEDIUM_TIMEOUT		(5 * 60 * HZ)
+#define READ_ELEMENT_STATUS_TIMEOUT	(5 * 60 * HZ)
+#define READ_DEFECT_DATA_TIMEOUT	(60 * HZ )
+
+
+#define IDENTIFY_BASE       0x80
+#define IDENTIFY(can_disconnect, lun)   (IDENTIFY_BASE |\
+		     ((can_disconnect) ?  0x40 : 0) |\
+		     ((lun) & 0x07))
+
+/*
+ *  struct scsi_device::scsi_level values. For SCSI devices other than those
+ *  prior to SCSI-2 (i.e. over 12 years old) this value is (resp[2] + 1)
+ *  where "resp" is a byte array of the response to an INQUIRY. The scsi_level
+ *  variable is visible to the user via sysfs.
+ */
+
+#define SCSI_UNKNOWN    0
+#define SCSI_1          1
+#define SCSI_1_CCS      2
+#define SCSI_2          3
+#define SCSI_3          4        /* SPC */
+#define SCSI_SPC_2      5
+#define SCSI_SPC_3      6
+
+/*
+ * INQ PERIPHERAL QUALIFIERS
+ */
+#define SCSI_INQ_PQ_CON         0x00
+#define SCSI_INQ_PQ_NOT_CON     0x01
+#define SCSI_INQ_PQ_NOT_CAP     0x03
+
+
+/*
+ * Here are some scsi specific ioctl commands which are sometimes useful.
+ *
+ * Note that include/linux/cdrom.h also defines IOCTL 0x5300 - 0x5395
+ */
+
+/* Used to obtain PUN and LUN info.  Conflicts with CDROMAUDIOBUFSIZ */
+#define SCSI_IOCTL_GET_IDLUN		0x5382
+
+/* 0x5383 and 0x5384 were used for SCSI_IOCTL_TAGGED_{ENABLE,DISABLE} */
+
+/* Used to obtain the host number of a device. */
+#define SCSI_IOCTL_PROBE_HOST		0x5385
+
+/* Used to obtain the bus number for a device */
+#define SCSI_IOCTL_GET_BUS_NUMBER	0x5386
+
+/* Used to obtain the PCI location of a device */
+#define SCSI_IOCTL_GET_PCI		0x5387
+
+/* Pull a u32 out of a SCSI message (using BE SCSI conventions) */
+static inline __u32 scsi_to_u32(__u8 *ptr)
+{
+	return (ptr[0]<<24) + (ptr[1]<<16) + (ptr[2]<<8) + ptr[3];
+}
+
+#endif /* _SCSI_SCSI_H */

USDK/component/common/drivers/usb_class/host/storage/inc/scsi/scsi_cmnd.h

@@ -0,0 +1,84 @@
+#ifndef __SCSI_CMND_H_
+#define __SCSI_CMND_H_
+
+#include "us_usb.h"
+#include "us_os_wrap_via_osdep_api.h"
+#include <scsi/scsi.h>
+#include <scsi/dma_direction.h>
+#include <scatterlist/scatterlist.h>
+/**
+ * define flash block size
+ */
+#define BLOCK_SIZE					512
+
+struct scsi_data_buffer {
+	struct sg_table table;
+	unsigned char *data_buffer; /* Data buffer to store read data */
+	unsigned length;
+	int resid;
+};
+
+struct scsi_cmnd{
+	int result;		/* Status code from lower level driver */
+
+	unsigned int channel,id,lun;
+	enum dma_data_direction sc_data_direction;
+	unsigned short cmd_len;
+	unsigned length;
+	_Sema cmnd_done;
+
+	int eh_eflags;		/* Used by error handlr */
+
+	struct scsi_data_buffer sdb;
+
+	unsigned long sector;/* Sector address in LBA */
+	unsigned int count;/* Number of sectors to read */
+	void *request_buffer;
+
+	 /* These elements define the operation we are about to perform */
+#define MAX_COMMAND_SIZE	16
+	unsigned char cmnd[MAX_COMMAND_SIZE];
+
+#define SCSI_SENSE_BUFFERSIZE 	96
+	unsigned char *sense_buffer;		/* obtained by REQUEST SENSE
+						 * when CHECK CONDITION is
+						 * received on original command
+						 * (auto-sense) */
+
+	/* Low-level done function - can be used by low-level driver to point
+		 *        to completion function.  Not used by mid/upper level code. */
+	void (*scsi_done) (struct scsi_cmnd *);
+
+	unsigned underflow;	/* Return error if less than
+						   this amount is transferred */
+};
+
+static inline unsigned scsi_sg_count(struct scsi_cmnd *cmd)
+{
+	return cmd->sdb.table.nents;
+}
+
+static inline struct scatterlist *scsi_sglist(struct scsi_cmnd *cmd)
+{
+	return cmd->sdb.table.sgl;
+}
+
+static inline void scsi_set_resid(struct scsi_cmnd *cmd, int resid)
+{
+	cmd->sdb.resid = resid;
+}
+//
+static inline int scsi_get_resid(struct scsi_cmnd *cmd)
+{
+	return cmd->sdb.resid;
+}
+static inline unsigned scsi_bufflen(struct scsi_cmnd *cmd)
+{
+	return cmd->sdb.length;
+}
+
+extern int scsi_cmnd_execute(char cmnd, unsigned char * _buff,
+		unsigned long _sector, unsigned int _count);
+
+#endif
+

USDK/component/common/drivers/usb_class/host/storage/inc/scsi/scsi_eh.h

@@ -0,0 +1,52 @@
+#ifndef _SCSI_EH_H_
+#define _SCSI_EH_H_
+
+#include "scsi/scsi_cmnd.h"
+#include "dma_direction.h"
+
+#define BLK_MAX_CDB	16
+/*
+ * This is a slightly modified SCSI sense "descriptor" format header.
+ * The addition is to allow the 0x70 and 0x71 response codes. The idea
+ * is to place the salient data from either "fixed" or "descriptor" sense
+ * format into one structure to ease application processing.
+ *
+ * The original sense buffer should be kept around for those cases
+ * in which more information is required (e.g. the LBA of a MEDIUM ERROR).
+ */
+struct scsi_sense_hdr {		/* See SPC-3 section 4.5 */
+	u8 response_code;	/* permit: 0x0, 0x70, 0x71, 0x72, 0x73 */
+	u8 sense_key;
+	u8 asc;
+	u8 ascq;
+	u8 byte4;
+	u8 byte5;
+	u8 byte6;
+	u8 additional_length;	/* always 0 for fixed sense format */
+};
+
+static inline int scsi_sense_valid(struct scsi_sense_hdr *sshdr)
+{
+	if (!sshdr)
+		return 0;
+	return (sshdr->response_code & 0x70) == 0x70;
+}
+
+struct scsi_eh_save {
+	/* saved state */
+	int result;
+	enum dma_data_direction data_direction;
+	unsigned underflow;
+	unsigned char cmd_len;
+//	unsigned char prot_op;
+	unsigned char cmnd[BLK_MAX_CDB];
+	struct scsi_data_buffer sdb;
+//	struct request *next_rq;
+	/* new command support */
+	unsigned char eh_cmnd[BLK_MAX_CDB];
+//	struct scatterlist sense_sgl;
+};
+const u8 * scsi_sense_desc_find(const u8 * sense_buffer, int sb_len,
+				int desc_type);
+#endif
+

USDK/component/common/drivers/usb_class/host/storage/inc/storage.h

@@ -0,0 +1,78 @@
+#ifndef __STORAGE_H
+#define __STORAGE_H
+
+#include "us_os_wrap_via_osdep_api.h"
+/* Storage subclass codes */
+
+#define USB_SC_RBC			0x01		/* Typically, flash devices */
+#define USB_SC_8020			0x02		/* CD-ROM */
+#define USB_SC_QIC			0x03		/* QIC-157 Tapes */
+#define USB_SC_UFI			0x04		/* Floppy */
+#define USB_SC_8070			0x05		/* Removable media */
+#define USB_SC_SCSI			0x06		/* Transparent */
+#define USB_SC_LOCKABLE		0x07		/* Password-protected */
+
+#define USB_SC_ISD200		0xf0		/* ISD200 ATA */
+#define USB_SC_CYP_ATACB	0xf1		/* Cypress ATACB */
+#define USB_SC_DEVICE		0xff		/* Use device's value */
+
+/* Storage protocol codes */
+
+#define USB_PR_CBI			0x00		/* Control/Bulk/Interrupt */
+#define USB_PR_CB			0x01		/* Control/Bulk w/o interrupt */
+#define USB_PR_BULK			0x50		/* bulk only */
+#define USB_PR_UAS			0x62		/* USB Attached SCSI */
+
+#define USB_PR_USBAT		0x80		/* SCM-ATAPI bridge */
+#define USB_PR_EUSB_SDDR09	0x81		/* SCM-SCSI bridge for SDDR-09 */
+#define USB_PR_SDDR55		0x82		/* SDDR-55 (made up) */
+#define USB_PR_DPCM_USB		0xf0		/* Combination CB/SDDR09 */
+#define USB_PR_FREECOM		0xf1		/* Freecom */
+#define USB_PR_DATAFAB		0xf2		/* Datafab chipsets */
+#define USB_PR_JUMPSHOT		0xf3		/* Lexar Jumpshot */
+#define USB_PR_ALAUDA		0xf4		/* Alauda chipsets */
+#define USB_PR_KARMA		0xf5		/* Rio Karma */
+
+#define USB_PR_DEVICE		0xff		/* Use device's value */
+
+/*
+* Bulk only data structures
+*/
+
+/* command block wrapper */
+struct bulk_cb_wrap {
+	__le32	Signature;		/* contains 'USBC', denote bulk_cb_wrap */
+	__u32	Tag;			/* unique per command id */
+	__le32	DataTransferLength;	/* size of data for transfer */
+	__u8	Flags;			/* data transfer direction */
+	__u8	Lun;			/* LUN normally 0, (which command block is sent) */
+	__u8	Length;			/* length of the CDB */
+	__u8	CDB[16];		/* max command */
+};
+
+#define US_BULK_CB_WRAP_LEN	31
+#define US_BULK_CB_SIGN		0x43425355	/*spells out USBC */
+#define US_BULK_FLAG_IN		(1 << 7)
+#define US_BULK_FLAG_OUT	0
+
+/* command status wrapper */
+struct bulk_cs_wrap {
+	__le32	Signature;	/* should = 'USBS' */
+	__u32	Tag;		/* same as original command, echoed by the device as received */
+	__le32	Residue;	/* amount not transferred */
+	__u8	Status;		/* execute command status */
+};
+
+#define US_BULK_CS_WRAP_LEN	13
+#define US_BULK_CS_SIGN		0x53425355      /* spells out 'USBS' */
+// execute command status
+#define US_BULK_STAT_OK		0
+#define US_BULK_STAT_FAIL	1
+#define US_BULK_STAT_PHASE	2
+
+/* bulk-only class specific requests */
+#define US_BULK_RESET_REQUEST   0xff
+#define US_BULK_GET_MAX_LUN     0xfe
+
+#endif
+

USDK/component/common/drivers/usb_class/host/storage/inc/transport.h

@@ -0,0 +1,102 @@
+/* Driver for USB Mass Storage compliant devices
+ * Transport Functions Header File
+ *
+ * Current development and maintenance by:
+ *   (c) 1999, 2000 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
+ *
+ * This driver is based on the 'USB Mass Storage Class' document. This
+ * describes in detail the protocol used to communicate with such
+ * devices.  Clearly, the designers had SCSI and ATAPI commands in
+ * mind when they created this document.  The commands are all very
+ * similar to commands in the SCSI-II and ATAPI specifications.
+ *
+ * It is important to note that in a number of cases this class
+ * exhibits class-specific exemptions from the USB specification.
+ * Notably the usage of NAK, STALL and ACK differs from the norm, in
+ * that they are used to communicate wait, failed and OK on commands.
+ *
+ * Also, for certain devices, the interrupt endpoint is used to convey
+ * status of a command.
+ *
+ * Please see http://www.one-eyed-alien.net/~mdharm/linux-usb for more
+ * information about this driver.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * 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.,
+ * 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef _US_TRANSPORT_H_
+#define _US_TRANSPORT_H_
+#if 0
+#include <linux/blkdev.h>
+#endif
+/*
+ * usb_stor_bulk_transfer_xxx() return codes, in order of severity
+ */
+
+#define USB_STOR_XFER_GOOD	0	/* good transfer                 */
+#define USB_STOR_XFER_SHORT	1	/* transferred less than expected */
+#define USB_STOR_XFER_STALLED	2	/* endpoint stalled              */
+#define USB_STOR_XFER_LONG	3	/* device tried to send too much */
+#define USB_STOR_XFER_ERROR	4	/* transfer died in the middle   */
+
+/*
+ * Transport return codes
+ */
+
+#define USB_STOR_TRANSPORT_GOOD	   0   /* Transport good, command good	   */
+#define USB_STOR_TRANSPORT_FAILED  1   /* Transport good, command failed   */
+#define USB_STOR_TRANSPORT_NO_SENSE 2  /* Command failed, no auto-sense    */
+#define USB_STOR_TRANSPORT_ERROR   3   /* Transport bad (i.e. device dead) */
+
+/*
+ * We used to have USB_STOR_XFER_ABORTED and USB_STOR_TRANSPORT_ABORTED
+ * return codes.  But now the transport and low-level transfer routines
+ * treat an abort as just another error (-ENOENT for a cancelled URB).
+ * It is up to the invoke_transport() function to test for aborts and
+ * distinguish them from genuine communication errors.
+ */
+
+/*
+ * CBI accept device specific command
+ */
+#define US_CBI_ADSC		0
+
+//extern int usb_stor_CB_transport(struct scsi_cmnd *, struct us_data*);
+//extern int usb_stor_CB_reset(struct us_data*);
+//
+//extern int usb_stor_Bulk_transport(struct scsi_cmnd *, struct us_data*);
+//extern int usb_stor_Bulk_max_lun(struct us_data*);
+//extern int usb_stor_Bulk_reset(struct us_data*);
+//
+//extern void usb_stor_invoke_transport(struct scsi_cmnd *, struct us_data*);
+//extern void usb_stor_stop_transport(struct us_data*);
+
+//extern int usb_stor_control_msg(struct us_data *us, unsigned int pipe,
+//		u8 request, u8 requesttype, u16 value, u16 index,
+//		void *data, u16 size, int timeout);
+//extern int usb_stor_clear_halt(struct us_data *us, unsigned int pipe);
+//
+//extern int usb_stor_ctrl_transfer(struct us_data *us, unsigned int pipe,
+//		u8 request, u8 requesttype, u16 value, u16 index,
+//		void *data, u16 size);
+//extern int usb_stor_bulk_transfer_buf(struct us_data *us, unsigned int pipe,
+//		void *buf, unsigned int length, unsigned int *act_len);
+//extern int usb_stor_bulk_transfer_sg(struct us_data *us, unsigned int pipe,
+//		void *buf, unsigned int length, int use_sg, int *residual);
+//extern int usb_stor_bulk_srb(struct us_data* us, unsigned int pipe,
+//		struct scsi_cmnd* srb);
+//
+//extern int usb_stor_port_reset(struct us_data *us);
+#endif

USDK/component/common/drivers/usb_class/host/storage/inc/unusual_usbat.h

@@ -0,0 +1,32 @@
+#ifndef __UNUSUAL_USBAT_H
+#define __UNUSUAL_USBAT_H
+
+#if defined(CONFIG_USB_STORAGE_USBAT) || \
+		defined(CONFIG_USB_STORAGE_USBAT_MODULE)
+
+UNUSUAL_DEV(  0x03f0, 0x0207, 0x0001, 0x0001,
+		"HP",
+		"CD-Writer+ 8200e",
+		USB_SC_8070, USB_PR_USBAT, init_usbat_cd, 0),
+
+UNUSUAL_DEV(  0x03f0, 0x0307, 0x0001, 0x0001,
+		"HP",
+		"CD-Writer+ CD-4e",
+		USB_SC_8070, USB_PR_USBAT, init_usbat_cd, 0),
+
+UNUSUAL_DEV(  0x04e6, 0x1010, 0x0000, 0x9999,
+		"Shuttle/SCM",
+		"USBAT-02",
+		USB_SC_SCSI, USB_PR_USBAT, init_usbat_flash,
+		US_FL_SINGLE_LUN),
+
+UNUSUAL_DEV(  0x0781, 0x0005, 0x0005, 0x0005,
+		"Sandisk",
+		"ImageMate SDDR-05b",
+		USB_SC_SCSI, USB_PR_USBAT, init_usbat_flash,
+		US_FL_SINGLE_LUN),
+
+#endif /* defined(CONFIG_USB_STORAGE_USBAT) || ... */
+
+#endif
+

USDK/component/common/drivers/usb_class/host/storage/inc/us_debug.h

@@ -0,0 +1,26 @@
+#ifndef _US_DEBUG_H_
+#define _US_DEBUG_H_
+
+#include "diag.h"
+
+
+#define US_DEBUG    0
+#define US_DRIVER	"US_DRIVER"
+
+#if US_DEBUG
+#define US_INFO(fmt, args...)		            DBG_8195A("\n\r[%s]%s: " fmt, US_DRIVER, __FUNCTION__, ## args)
+#define US_ERR(fmt, args...)		            DBG_8195A("\n\r[%s]%s: " fmt, US_DRIVER,__FUNCTION__, ## args)
+#define US_WARN(fmt, args...)		            DBG_8195A("\n\r[%s]%s: " fmt, US_DRIVER,__FUNCTION__, ## args)
+#define FUN_ENTER                               DBG_8195A("\n\r[%s]%s ==>\n", US_DRIVER,__FUNCTION__)
+#define FUN_EXIT                                DBG_8195A("\n\r[%s]%s <==\n", US_DRIVER,__FUNCTION__)
+#define FUN_TRACE                               DBG_8195A("\n\r[%s]%s:%d \n", US_DRIVER,__FUNCTION__, __LINE__)
+#else
+#define US_INFO(fmt, args...)
+#define US_ERR(fmt, args...)		            DBG_8195A("\n\r[%s]%s: " fmt, US_DRIVER,__FUNCTION__, ## args)
+#define US_WARN(fmt, args...)
+#define FUN_ENTER
+#define FUN_EXIT
+#define FUN_TRACE
+#endif
+
+#endif /* _US_DEBUG_H_ */

USDK/component/common/drivers/usb_class/host/storage/inc/us_initializers.h

@@ -0,0 +1,14 @@
+#include "usb.h"
+#include "transport.h"
+
+/* This places the Shuttle/SCM USB<->SCSI bridge devices in multi-target
+ * mode */
+int usb_stor_euscsi_init(struct us_data *us);
+
+/* This function is required to activate all four slots on the UCR-61S2B
+ * flash reader */
+int usb_stor_ucr61s2b_init(struct us_data *us);
+
+/* This places the HUAWEI E220 devices in multi-port mode */
+int usb_stor_huawei_e220_init(struct us_data *us);
+

USDK/component/common/drivers/usb_class/host/storage/inc/us_intf.h

@@ -0,0 +1,34 @@
+#ifndef __US_INTF_H_
+#define __US_INTF_H_
+
+#include "basic_types.h"
+
+typedef enum
+{
+  MSC_OK = 0,
+  MSC_NOT_READY,
+  MSC_W_PROTECT,
+  MSC_ERROR,
+}MSC_RESULT;
+
+extern MSC_RESULT	us_init(void);
+extern MSC_RESULT	us_isready (void);
+
+extern MSC_RESULT 	us_getStatus(void);
+extern MSC_RESULT	us_getmaxlun (u8* lun_num);
+extern MSC_RESULT	us_unitisready (u8 lun);
+
+extern MSC_RESULT	us_inquiry (u8 *pbuf);
+
+extern MSC_RESULT	us_getcap(u32 *last_blk_addr, u32 *block_size);
+
+extern MSC_RESULT	us_read_blocks( u8 *pbuf, u32 sector, u32 count);
+
+extern MSC_RESULT	us_write_blocks( const u8 *pbuf, u32 sector, u32 count);
+
+
+// indicate usb storage driver status
+extern bool USB_STORAGE_READY;
+
+#endif
+

USDK/component/common/drivers/usb_class/host/storage/inc/us_os_wrap_via_osdep_api.h

@@ -0,0 +1,313 @@
+/*
+ * umsc_os_wrap_via_osdep_api.h
+ *
+ *  Created on: Sep 5, 2014
+ *      Author: jimmysqf
+ */
+
+#ifndef US_OS_WRAP_VIA_OSDEP_API_H_
+#define US_OS_WRAP_VIA_OSDEP_API_H_
+
+#include "basic_types.h"
+#include "osdep_api.h"
+
+#define GFP_KERNEL		1
+#define GFP_ATOMIC		1
+
+
+typedef unsigned int gfp_t;
+
+/* misc items */
+#ifndef ssize_t
+#define ssize_t SSIZE_T
+#endif
+#ifndef size_t
+#define size_t SIZE_T
+#endif
+
+#ifndef __user
+#define __user
+#endif
+
+#ifndef loff_t
+#define loff_t long
+#endif
+#ifndef __u8
+#define __u8 	u8
+#endif
+#ifndef __u16
+#define __u16	u16
+#endif
+#ifndef __u32
+#define __u32	u32
+#endif
+#ifndef __u64
+#define __u64	u64
+#endif
+#ifndef __s8
+#define __s8	s8
+#endif
+#ifndef __s16
+#define __s16	s16
+#endif
+#ifndef __s32
+#define __s32	s32
+#endif
+#ifndef __s64
+#define __s64	s64
+#endif
+
+typedef __u16 __le16;
+typedef __u16 __be16;
+typedef __u32 __le32;
+typedef __u32 __be32;
+typedef __u64 __le64;
+typedef __u64 __be64;
+typedef __u16 __sum16;
+typedef __u32 __wsum;
+
+
+#ifndef cpu_to_le32
+
+#define cpu_to_le32(x)	rtk_cpu_to_le32(x)
+#endif
+#ifndef le32_to_cpu
+
+#define le32_to_cpu(x)	rtk_le32_to_cpu(x)
+#endif
+#ifndef cpu_to_le16
+
+#define cpu_to_le16(x)	rtk_cpu_to_le16(x)
+#endif
+#ifndef le16_to_cpu
+
+#define le16_to_cpu(x)	rtk_le16_to_cpu(x)
+#endif
+#ifndef cpu_to_be32
+
+#define cpu_to_be32(x)	rtk_cpu_to_be32(x)
+#endif
+#ifndef be32_to_cpu
+
+#define be32_to_cpu(x)	rtk_be32_to_cpu(x)
+#endif
+#ifndef cpu_to_be16
+
+#define cpu_to_be16(x)	rtk_cpu_to_be16(x)
+#endif
+#ifndef be16_to_cpu
+
+#define be16_to_cpu(x)	rtk_be16_to_cpu(x)
+#endif
+
+#ifndef DIV_ROUND_UP
+#define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
+#endif
+#ifndef BITS_PER_LONG
+#define BITS_PER_LONG (32)
+#endif
+#ifndef BITS_PER_LONG_LONG
+#define BITS_PER_LONG_LONG (32)
+#endif
+#ifndef BIT
+#define BIT(nr)                 (1UL << (nr))
+#endif
+#ifndef BIT_ULL
+#define BIT_ULL(nr)             (1ULL << (nr))
+#endif
+#ifndef BIT_MASK
+#define BIT_MASK(nr)            (1UL << ((nr) % BITS_PER_LONG))
+#endif
+#ifndef BIT_WORD
+#define BIT_WORD(nr)            ((nr) / BITS_PER_LONG)
+#endif
+#ifndef BIT_ULL_MASK
+#define BIT_ULL_MASK(nr)        (1ULL << ((nr) % BITS_PER_LONG_LONG))
+#endif
+#ifndef BIT_ULL_WORD
+#define BIT_ULL_WORD(nr)        ((nr) / BITS_PER_LONG_LONG)
+#endif
+#ifndef BITS_PER_BYTE
+#define BITS_PER_BYTE           (8)
+#endif
+#ifndef BITS_TO_LONGS
+#define BITS_TO_LONGS(nr)       DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
+#endif
+
+#ifndef min
+#define min(x, y) ((x) < (y) ? (x) : (y))
+#endif
+#ifndef max
+#define max(x, y) ((x) > (y) ? (x) : (y))
+#endif
+
+#ifndef min_t
+#define min_t(type, x, y) ({                    \
+         type __min1 = (x);                      \
+         type __min2 = (y);                      \
+         __min1 < __min2 ? __min1 : __min2; })
+#endif
+#ifndef max_t
+#define max_t(type, x, y) ({                    \
+         type __max1 = (x);                      \
+         type __max2 = (y);                      \
+         __max1 > __max2 ? __max1 : __max2; })
+#endif
+
+/**
+ * container_of - cast a member of a structure out to the containing structure
+ * @p(ptr):        the pointer to the member.
+ * @t(type):       the type of the container struct this is embedded in.
+ * @m(member):     the name of the member within the struct.
+ *
+ */
+#ifndef container_of
+	#define container_of(ptr, type, member) \
+        ((type *)((char *)(ptr)-(SIZE_T)(&((type *)0)->member)))
+#endif
+
+/**
+ * test_bit - Determine whether a bit is set
+ * @nr: bit number to test
+ * @addr: Address to start counting from
+ */
+static inline int test_bit(int nr, const volatile unsigned long *addr)
+{
+        return ((1UL << (nr & 31)) & (addr[nr >> 5])) != 0;
+}
+/**
+* set_bit - Atomically set a bit in memory
+* @nr: the bit to set
+* @addr: the address to start counting from
+*
+* This function is atomic and may not be reordered.  See __set_bit()
+* if you do not require the atomic guarantees.
+*
+* Note: there are no guarantees that this function will not be reordered
+* on non x86 architectures, so if you are writing portable code,
+* make sure not to rely on its reordering guarantees.
+*
+* Note that @nr may be almost arbitrarily large; this function is not
+* restricted to acting on a single-word quantity.
+*/
+static inline void set_bit(int nr, volatile unsigned long *addr)
+{
+	unsigned long mask = BIT_MASK(nr);
+	unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
+
+	SaveAndCli();
+	*p  |= mask;
+	RestoreFlags();
+}
+
+/**
+* clear_bit - Clears a bit in memory
+* @nr: Bit to clear
+* @addr: Address to start counting from
+*
+* clear_bit() is atomic and may not be reordered.  However, it does
+* not contain a memory barrier, so if it is used for locking purposes,
+* you should call smp_mb__before_clear_bit() and/or smp_mb__after_clear_bit()
+* in order to ensure changes are visible on other processors.
+*/
+static inline void clear_bit(int nr, volatile unsigned long *addr)
+{
+	unsigned long mask = BIT_MASK(nr);
+	unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
+
+	SaveAndCli();
+	*p &= ~mask;
+	RestoreFlags();
+}
+
+/**
+* change_bit - Toggle a bit in memory
+* @nr: Bit to change
+* @addr: Address to start counting from
+*
+* change_bit() is atomic and may not be reordered. It may be
+* reordered on other architectures than x86.
+* Note that @nr may be almost arbitrarily large; this function is not
+* restricted to acting on a single-word quantity.
+*/
+static inline void change_bit(int nr, volatile unsigned long *addr)
+{
+	unsigned long mask = BIT_MASK(nr);
+	unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
+
+	SaveAndCli();
+	*p ^= mask;
+	RestoreFlags();
+}
+
+/**
+* test_and_set_bit - Set a bit and return its old value
+* @nr: Bit to set
+* @addr: Address to count from
+*
+* This operation is atomic and cannot be reordered.
+* It may be reordered on other architectures than x86.
+* It also implies a memory barrier.
+*/
+static inline int test_and_set_bit(int nr, volatile unsigned long *addr)
+{
+	unsigned long mask = BIT_MASK(nr);
+	unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
+	unsigned long old;
+	
+	SaveAndCli();
+	old = *p;
+	*p = old | mask;
+	RestoreFlags();
+	return (old & mask) != 0;
+}
+
+/**
+* test_and_clear_bit - Clear a bit and return its old value
+* @nr: Bit to clear
+* @addr: Address to count from
+*
+* This operation is atomic and cannot be reordered.
+* It can be reorderdered on other architectures other than x86.
+* It also implies a memory barrier.
+*/
+static inline int test_and_clear_bit(int nr, volatile unsigned long *addr)
+{
+	unsigned long mask = BIT_MASK(nr);
+	unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
+	unsigned long old;
+	
+	SaveAndCli();
+	old = *p;
+	*p = old & ~mask;
+	RestoreFlags();
+
+	return (old & mask) != 0;
+}
+/**
+* test_and_change_bit - Change a bit and return its old value
+* @nr: Bit to change
+* @addr: Address to count from
+*
+* This operation is atomic and cannot be reordered.
+* It also implies a memory barrier.
+*/
+static inline int test_and_change_bit(int nr, volatile unsigned long *addr)
+{
+	unsigned long mask = BIT_MASK(nr);
+	unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);
+	unsigned long old;
+	
+	SaveAndCli();
+	old = *p;
+	*p = old ^ mask;
+	RestoreFlags();
+
+	return (old & mask) != 0;
+}
+
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
+#endif
+
+#endif /* US_OS_WRAP_VIA_OSDEP_API_H_ */

USDK/component/common/drivers/usb_class/host/storage/inc/us_scsi.h

@@ -0,0 +1,19 @@
+#ifndef _US_SCSI_H
+#define _US_SCSI_H
+
+/**
+ * define transfer length
+ */
+#define TRANS_LEN_READ_10			512
+#define TRANS_LEN_WRITE_10			512
+#define TRANS_LEN_INQUIRY			36
+#define TRANS_LEN_TEST_UNIT_READY	0
+#define TRANS_LEN_READ_CAPACITY_10	8
+#define TRANS_LEN_READ_CAPACITY_16	12
+#define TRANS_LEN_REQUEST_SENSE		18
+#define TRANS_LEN_MODE_SENSE		192
+
+extern int scsi_cmnd_execute(char cmnd, unsigned char * _buff,
+						unsigned long _sector, unsigned int _count);
+
+#endif

USDK/component/common/drivers/usb_class/host/storage/inc/us_strings.h

@@ -0,0 +1,28 @@
+#ifndef _US_STRINGS_H
+#define _US_STRINGS_H
+/* description of the sense key values */
+static const char * const snstext[] = {
+	"No Sense",	    /* 0: There is no sense information */
+	"Recovered Error",  /* 1: The last command completed successfully
+				  but used error correction */
+	"Not Ready",	    /* 2: The addressed target is not ready */
+	"Medium Error",	    /* 3: Data error detected on the medium */
+	"Hardware Error",   /* 4: Controller or device failure */
+	"Illegal Request",  /* 5: Error in request */
+	"Unit Attention",   /* 6: Removable medium was changed, or
+				  the target has been reset, or ... */
+	"Data Protect",	    /* 7: Access to the data is blocked */
+	"Blank Check",	    /* 8: Reached unexpected written or unwritten
+				  region of the medium */
+	"Vendor Specific(9)",
+	"Copy Aborted",	    /* A: COPY or COMPARE was aborted */
+	"Aborted Command",  /* B: The target aborted the command */
+	"Equal",	    /* C: A SEARCH DATA command found data equal,
+				  reserved in SPC-4 rev 36 */
+	"Volume Overflow",  /* D: Medium full with still data to be written */
+	"Miscompare",	    /* E: Source data and data on the medium
+				  do not agree */
+	"Completed",	    /* F: command completed sense data reported,
+				  may occur for successful command */
+};
+#endif

USDK/component/common/drivers/usb_class/host/storage/inc/us_transport.h

@@ -0,0 +1,67 @@
+/* Driver for USB Mass Storage compliant devices
+ * Transport Functions Header File
+ */
+
+#ifndef _US_TRANSPORT_H_
+#define _US_TRANSPORT_H_
+
+/*
+ * usb_stor_bulk_transfer_xxx() return codes, in order of severity
+ */
+
+#define USB_STOR_XFER_GOOD	0	/* good transfer                 */
+#define USB_STOR_XFER_SHORT	1	/* transferred less than expected */
+#define USB_STOR_XFER_STALLED	2	/* endpoint stalled              */
+#define USB_STOR_XFER_LONG	3	/* device tried to send too much */
+#define USB_STOR_XFER_ERROR	4	/* transfer died in the middle   */
+
+/*
+ * Transport return codes
+ */
+
+#define USB_STOR_TRANSPORT_GOOD	   0   /* Transport good, command good	   */
+#define USB_STOR_TRANSPORT_FAILED  1   /* Transport good, command failed   */
+#define USB_STOR_TRANSPORT_NO_SENSE 2  /* Command failed, no auto-sense    */
+#define USB_STOR_TRANSPORT_ERROR   3   /* Transport bad (i.e. device dead) */
+
+/*
+ * We used to have USB_STOR_XFER_ABORTED and USB_STOR_TRANSPORT_ABORTED
+ * return codes.  But now the transport and low-level transfer routines
+ * treat an abort as just another error (-ENOENT for a cancelled URB).
+ * It is up to the invoke_transport() function to test for aborts and
+ * distinguish them from genuine communication errors.
+ */
+
+/*
+ * CBI accept device specific command
+ */
+#define US_CBI_ADSC		0
+
+//extern int usb_stor_CB_transport(struct scsi_cmnd *, struct us_data*);
+//extern int usb_stor_CB_reset(struct us_data*);
+//
+//extern int usb_stor_Bulk_transport(struct scsi_cmnd *, struct us_data*);
+//extern int usb_stor_Bulk_max_lun(struct us_data*);
+//extern int usb_stor_Bulk_reset(struct us_data*);
+//
+//extern void usb_stor_invoke_transport(struct scsi_cmnd *, struct us_data*);
+//extern void usb_stor_stop_transport(struct us_data*);
+
+//extern int usb_stor_control_msg(struct us_data *us, unsigned int pipe,
+//		u8 request, u8 requesttype, u16 value, u16 index,
+//		void *data, u16 size, int timeout);
+//extern int usb_stor_clear_halt(struct us_data *us, unsigned int pipe);
+//
+//extern int usb_stor_ctrl_transfer(struct us_data *us, unsigned int pipe,
+//		u8 request, u8 requesttype, u16 value, u16 index,
+//		void *data, u16 size);
+//extern int usb_stor_bulk_transfer_buf(struct us_data *us, unsigned int pipe,
+//		void *buf, unsigned int length, unsigned int *act_len);
+//extern int usb_stor_bulk_transfer_sg(struct us_data *us, unsigned int pipe,
+//		void *buf, unsigned int length, int use_sg, int *residual);
+//extern int usb_stor_bulk_srb(struct us_data* us, unsigned int pipe,
+//		struct scsi_cmnd* srb);
+//
+//extern int usb_stor_port_reset(struct us_data *us);
+#endif
+

USDK/component/common/drivers/usb_class/host/storage/inc/us_usb.h

@@ -0,0 +1,245 @@
+#ifndef _US_USB_H_
+#define _US_USB_H_
+
+#include "usb.h"
+#include "us_os_wrap_via_osdep_api.h"
+#include "us_debug.h"
+//#include "sg.h"
+
+struct us_data;
+struct scsi_cmnd;
+
+#define CONFIG_SG	0
+#define CONFIG_DMA	0
+
+/*
+ * Unusual device list definitions 
+ */
+
+struct us_unusual_dev {
+	const char* vendorName;
+	const char* productName;
+	__u8  useProtocol;
+	__u8  useTransport;
+	int (*initFunction)(struct us_data *);
+};
+
+/* Flag definitions: these entries are static */
+#define US_FL_SINGLE_LUN      0x00000001 /* allow access to only LUN 0	    */
+//#define US_FL_MODE_XLATE      0          /* [no longer used]                */
+#define US_FL_NEED_OVERRIDE   0x00000004 /* unusual_devs entry is necessary */
+//#define US_FL_IGNORE_SER      0		 /* [no longer used]		    */
+#define US_FL_SCM_MULT_TARG   0x00000020 /* supports multiple targets	    */
+#define US_FL_FIX_INQUIRY     0x00000040 /* INQUIRY response needs faking   */
+#define US_FL_FIX_CAPACITY    0x00000080 /* READ CAPACITY response too big  */
+#define US_FL_IGNORE_RESIDUE  0x00000100 /* reported residue is wrong	    */
+#define US_FL_BULK32          0x00000200 /* Uses 32-byte CBW length         */
+
+
+/* Dynamic bitflag definitions (us->dflags): used in set_bit() etc. */
+#define US_FLIDX_URB_ACTIVE	0	/* current_urb is in use    */
+#define US_FLIDX_SG_ACTIVE	1	/* current_sg is in use     */
+#define US_FLIDX_ABORTING	2	/* abort is in progress     */
+#define US_FLIDX_DISCONNECTING	3	/* disconnect in progress   */
+#define US_FLIDX_RESETTING	4	/* device reset in progress */
+#define US_FLIDX_TIMED_OUT	5	/* SCSI midlayer timed out  */
+#define US_FLIDX_SCAN_PENDING	6	/* scanning not yet done    */
+#define US_FLIDX_REDO_READ10	7	/* redo READ(10) command    */
+#define US_FLIDX_READ10_WORKED	8	/* previous READ(10) succeeded */
+
+#define USB_STOR_STRING_LEN 32
+
+/*
+ * We provide a DMA-mapped I/O buffer for use with small USB transfers.
+ * It turns out that CB[I] needs a 12-byte buffer and Bulk-only needs a
+ * 31-byte buffer.  But Freecom needs a 64-byte buffer, so that's the
+ * size we'll allocate.
+ */
+
+#define US_IOBUF_SIZE		64	/* Size of the DMA-mapped I/O buffer */
+#define US_SENSE_SIZE		18	/* Size of the autosense data buffer */
+
+typedef int (*trans_cmnd)(struct scsi_cmnd *, struct us_data*);
+typedef int (*trans_reset)(struct us_data*);
+typedef void (*proto_cmnd)(struct scsi_cmnd*, struct us_data*);
+typedef void (*extra_data_destructor)(void *);	/* extra data destructor */
+typedef void (*pm_hook)(struct us_data *, int);	/* power management hook */
+
+#define US_SUSPEND	0
+#define US_RESUME	1
+
+/* we allocate one of these for every device that we remember */
+struct us_data {
+	/* The device we're working with
+	 * It's important to note:
+	 *    (o) you must hold dev_mutex to change pusb_dev
+	 */
+	_Mutex		dev_mutex;
+	struct usb_device	*pusb_dev;	 /* this usb_device */
+	struct usb_interface	*pusb_intf;	 /* this interface */
+	struct us_unusual_dev   *unusual_dev;	 /* device-filter entry     */
+	unsigned long		fflags;		 /* fixed flags from filter */
+	unsigned long		dflags;		 /* dynamic atomic bitflags */
+	unsigned int		send_bulk_pipe;	 /* cached pipe values */
+	unsigned int		recv_bulk_pipe;
+	unsigned int		send_ctrl_pipe;
+	unsigned int		recv_ctrl_pipe;
+	unsigned int		recv_intr_pipe;
+
+	/* information about the device */
+	char			*transport_name;
+	char			*protocol_name;
+	__le32			bcs_signature;
+	u8			subclass;
+	u8			protocol;
+	u8			max_lun;  // max number of logical unit (0,1,2,3...)
+
+	u8			ifnum;		 /* interface number   */
+	u8			ep_bInterval;	 /* interrupt interval */ 
+
+	/* function pointers for this device */
+	trans_cmnd		transport;	 /* transport function	   */
+	trans_reset		transport_reset; /* transport device reset */
+	proto_cmnd		proto_handler;	 /* protocol handler	   */
+
+	/* SCSI interfaces */
+	struct scsi_cmnd	*srb;		 /* current srb		*/
+	unsigned int		tag;		 /* current dCBWTag	*/
+
+	/* control and bulk communications data */
+	struct urb		*current_urb;	 /* USB requests	 */
+	struct usb_ctrlrequest	*cr;		 /* control requests	 */
+//	struct usb_sg_request	current_sg;	 /* scatter-gather req.  */
+	unsigned char		*iobuf;		 /* I/O buffer		 */
+	dma_addr_t		iobuf_dma;	 /* buffer DMA addresses */
+
+	xTaskHandle ctl_task; /*the control task handle*/
+
+	/* mutual exclusion and synchronization structures */
+	_Sema cmnd_ready;	 /* to sleep thread on	    */
+	_Mutex	notify;		 /* thread begin/end	    */
+
+	unsigned no_sg_constraint:1;	/* no sg constraint */
+	unsigned sg_tablesize;		/* 0 or largest number of sg list entries */
+
+	/* subdriver information */
+	void			*extra;		 /* Any extra data          */
+};
+
+/* Convert between us_data and the corresponding Scsi_Host */
+//static inline struct Scsi_Host *us_to_host(struct us_data *us) {
+//	return container_of((void *) us, struct Scsi_Host, hostdata);
+//}
+//static inline struct us_data *host_to_us(struct Scsi_Host *host) {
+//	return (struct us_data *) host->hostdata;
+//}
+
+/* Function to fill an inquiry response. See usb.c for details */
+extern void fill_inquiry_response(struct us_data *us,
+	unsigned char *data, unsigned int data_len);
+
+/* The scsi_lock() and scsi_unlock() macros protect the sm_state and the
+ * single queue element srb for write access */
+//#define scsi_unlock(host)	spin_unlock_irq(host->host_lock)
+//#define scsi_lock(host)		spin_lock_irq(host->host_lock)
+
+#define scsi_unlock(host)	spin_unlock(host->host_lock)
+#define scsi_lock(host)		spin_lock(host->host_lock)
+
+/* General routines provided by the usb-storage standard core */
+#ifdef CONFIG_PM
+extern int usb_stor_suspend(struct usb_interface *iface, pm_message_t message);
+extern int usb_stor_resume(struct usb_interface *iface);
+extern int usb_stor_reset_resume(struct usb_interface *iface);
+#else
+#define usb_stor_suspend	NULL
+#define usb_stor_resume		NULL
+#define usb_stor_reset_resume	NULL
+#endif
+
+extern int usb_stor_pre_reset(struct usb_interface *iface);
+extern int usb_stor_post_reset(struct usb_interface *iface);
+
+extern int usb_stor_probe1(struct us_data *us,
+		struct usb_interface *intf,
+		const struct usb_device_id *id,
+		struct us_unusual_dev *unusual_dev);
+extern int usb_stor_probe2(struct us_data *us);
+extern void usb_stor_disconnect(struct usb_interface *intf);
+
+extern void usb_stor_adjust_quirks(struct usb_device *dev,
+		unsigned long *fflags);
+
+// the follow definition should be prot to usb.h for other usb device
+
+
+/* USB autosuspend and autoresume */
+
+#ifdef CONFIG_PM_RUNTIME
+extern void usb_enable_autosuspend(struct usb_device *udev);
+extern void usb_disable_autosuspend(struct usb_device *udev);
+
+extern int usb_autopm_get_interface(struct usb_interface *intf);
+extern void usb_autopm_put_interface(struct usb_interface *intf);
+extern int usb_autopm_get_interface_async(struct usb_interface *intf);
+extern void usb_autopm_put_interface_async(struct usb_interface *intf);
+extern void usb_autopm_get_interface_no_resume(struct usb_interface *intf);
+extern void usb_autopm_put_interface_no_suspend(struct usb_interface *intf);
+
+static inline void usb_mark_last_busy(struct usb_device *udev)
+{
+	pm_runtime_mark_last_busy(&udev->dev);
+}
+
+#else
+
+static inline int usb_enable_autosuspend(struct usb_device *udev)
+{ return 0; }
+static inline int usb_disable_autosuspend(struct usb_device *udev)
+{ return 0; }
+
+static inline int usb_autopm_get_interface(struct usb_interface *intf)
+{ return 0; }
+static inline int usb_autopm_get_interface_async(struct usb_interface *intf)
+{ return 0; }
+
+static inline void usb_autopm_put_interface(struct usb_interface *intf)
+{ }
+static inline void usb_autopm_put_interface_async(struct usb_interface *intf)
+{ }
+static inline void usb_autopm_get_interface_no_resume(
+		struct usb_interface *intf)
+{ }
+static inline void usb_autopm_put_interface_no_suspend(
+		struct usb_interface *intf)
+{ }
+static inline void usb_mark_last_busy(struct usb_device *udev)
+{ }
+#endif
+
+/* USB port reset for device reinitialization */
+extern int usb_reset_device(struct usb_device *dev);
+extern void usb_queue_reset_device(struct usb_interface *dev);
+
+extern void *usb_alloc_coherent(struct usb_device *dev, size_t size,
+	gfp_t mem_flags, dma_addr_t *dma);
+extern void usb_free_coherent(struct usb_device *dev, size_t size,
+	void *addr, dma_addr_t dma);
+
+
+// copy from transport.h
+extern int usb_stor_CB_transport(struct scsi_cmnd *, struct us_data*);
+extern int usb_stor_CB_reset(struct us_data*);
+extern int usb_stor_Bulk_transport(struct scsi_cmnd *, struct us_data*);
+extern int usb_stor_Bulk_max_lun(struct us_data*);
+extern int usb_stor_Bulk_reset(struct us_data*);
+
+extern void usb_stor_invoke_transport(struct scsi_cmnd *, struct us_data*);
+extern void usb_stor_stop_transport(struct us_data*);
+
+// copy form protocol.h
+extern void usb_stor_transparent_scsi_command(struct scsi_cmnd* srb, struct us_data* );
+
+extern unsigned char usb_stor_sense_invalidCDB[18];
+
+#endif

USDK/component/common/drivers/usb_class/host/storage/inc/us_usual.h

@@ -0,0 +1,37 @@
+#ifndef __US_USUAL_H
+#define __US_USUAL_H
+
+#include "usb.h"
+#include "storage.h"
+
+#define US_FL_SINGLE_LUN			0x00000001/* allow access to only LUN 0 */
+//#define US_FL_NEED_OVERRIDE		0x00000002/* unusual_devs entry is necessary */
+//#define US_FL_SCM_MULT_TARG		0x00000004/* supports multiple targets */
+//#define US_FL_FIX_INQUIRY			0x00000008/* INQUIRY response needs faking */
+//#define US_FL_FIX_CAPACITY			0x00000010/* READ CAPACITY response too big */
+//#define US_FL_IGNORE_RESIDUE		0x00000020/* reported residue is wrong */
+//#define US_FL_BULK32				0x00000040/* Uses 32-byte CBW length */
+#define US_FL_NOT_LOCKABLE			0x00000080/* PREVENT/ALLOW not supported */
+#define US_FL_GO_SLOW				0x00000100/* Need delay after Command phase */
+#define US_FL_NO_WP_DETECT			0x00000200/* Don't check for write-protect */
+#define US_FL_MAX_SECTORS_64		0x00000400/* Sets max_sectors to 64    */
+#define US_FL_IGNORE_DEVICE			0x00000800/* Don't claim device */
+#define US_FL_CAPACITY_HEURISTICS	0x00001000/* sometimes sizes is too big */
+#define US_FL_MAX_SECTORS_MIN		0x00002000/* Sets max_sectors to arch min */
+#define US_FL_BULK_IGNORE_TAG		0x00004000/* Ignore tag mismatch in bulk operations */
+#define US_FL_SANE_SENSE		    0x00008000/* Sane Sense (> 18 bytes) */
+#define US_FL_CAPACITY_OK			0x00010000/* READ CAPACITY response is correct */
+#define US_FL_BAD_SENSE				0x00020000/* Bad Sense (never more than 18 bytes) */
+#define US_FL_NO_READ_DISC_INFO 	0x00040000/* cannot handle READ_DISC_INFO */
+#define US_FL_NO_READ_CAPACITY_16	0x00080000/* cannot handle READ_CAPACITY_16*/
+#define US_FL_INITIAL_READ10		0x00100000/* Initial READ(10) (and others) must be retried */
+#define US_FL_WRITE_CACHE			0x00200000/* Write Cache status is not available */
+#define US_FL_NEEDS_CAP16			0x00400000/* cannot handle READ_CAPACITY_10 */
+#define US_FL_IGNORE_UAS			0x00800000/* Device advertises UAS but it is broken */
+#define US_FL_BROKEN_FUA			0x01000000/* Cannot handle FUA in WRITE or READ CDBs */
+
+extern int usb_usual_ignore_device(struct usb_interface *intf);
+extern struct usb_device_id usb_storage_usb_ids[];
+
+#endif /* __US_USUAL_H */
+

USDK/component/common/drivers/usb_class/host/uvc/inc/mjpeg/mjpeg_api.h

@@ -0,0 +1,41 @@
+#ifndef _MJPEG_API_H
+#define _MJPEG_API_H
+
+
+/* memory disk type */
+typedef enum _medium_type{
+	medium_SD,
+	medium_USB,
+	medium_FLASH,
+	medium_CACHE
+}medium_type;
+
+/* time unit*/
+typedef enum _time_unit{
+	unit_HR,  // hour
+	unit_MIN, // minute
+	unit_SEC, //second
+}time_unit;
+
+typedef struct _mjpeg_cache{
+	unsigned char* addr;
+	int size;
+}mjpeg_cache;
+
+struct mjpeg_context{
+	/* mjpeg size*/
+	int width;//frame width
+    int height;//frame height
+	/* */
+	medium_type disktype;
+	time_unit timeunit;
+	int interval;
+	unsigned char* name;
+	unsigned char is_periodic;
+	/* store mjpeg in a RAM cache */
+	mjpeg_cache cache;
+};
+
+int mjpeg_get(struct mjpeg_context *context);
+
+#endif

USDK/component/common/drivers/usb_class/host/uvc/inc/uapi_uvcvideo.h

@@ -0,0 +1,71 @@
+#ifndef __LINUX_UVCVIDEO_H_
+#define __LINUX_UVCVIDEO_H_
+#if 0
+#include <linux/ioctl.h>
+#include <linux/types.h>
+#endif
+#include "uvc_os_wrap_via_osdep_api.h"
+/*
+ * Dynamic controls
+ */
+
+/* Data types for UVC control data */
+#define UVC_CTRL_DATA_TYPE_RAW		0
+#define UVC_CTRL_DATA_TYPE_SIGNED	1
+#define UVC_CTRL_DATA_TYPE_UNSIGNED	2
+#define UVC_CTRL_DATA_TYPE_BOOLEAN	3
+#define UVC_CTRL_DATA_TYPE_ENUM		4
+#define UVC_CTRL_DATA_TYPE_BITMASK	5
+
+/* Control flags */
+#define UVC_CTRL_FLAG_SET_CUR		(1 << 0)
+#define UVC_CTRL_FLAG_GET_CUR		(1 << 1)
+#define UVC_CTRL_FLAG_GET_MIN		(1 << 2)
+#define UVC_CTRL_FLAG_GET_MAX		(1 << 3)
+#define UVC_CTRL_FLAG_GET_RES		(1 << 4)
+#define UVC_CTRL_FLAG_GET_DEF		(1 << 5)
+/* Control should be saved at suspend and restored at resume. */
+#define UVC_CTRL_FLAG_RESTORE		(1 << 6)
+/* Control can be updated by the camera. */
+#define UVC_CTRL_FLAG_AUTO_UPDATE	(1 << 7)
+
+#define UVC_CTRL_FLAG_GET_RANGE \
+	(UVC_CTRL_FLAG_GET_CUR | UVC_CTRL_FLAG_GET_MIN | \
+	 UVC_CTRL_FLAG_GET_MAX | UVC_CTRL_FLAG_GET_RES | \
+	 UVC_CTRL_FLAG_GET_DEF)
+
+struct uvc_menu_info {
+	__u32 value;
+	__u8 name[32];
+};
+
+struct uvc_xu_control_mapping {
+	__u32 id;
+	__u8 name[32];
+	__u8 entity[16];
+	__u8 selector;
+
+	__u8 size;
+	__u8 offset;
+	__u32 v4l2_type;
+	__u32 data_type;
+
+	struct uvc_menu_info __user *menu_info;
+	__u32 menu_count;
+
+	__u32 reserved[4];
+};
+
+struct uvc_xu_control_query {
+	__u8 unit;
+	__u8 selector;
+	__u8 query;		/* Video Class-Specific Request Code, */
+				/* defined in linux/usb/video.h A.8.  */
+	__u16 size;
+	__u8 __user *data;
+};
+
+#define UVCIOC_CTRL_MAP		_IOWR('u', 0x20, struct uvc_xu_control_mapping)
+#define UVCIOC_CTRL_QUERY	_IOWR('u', 0x21, struct uvc_xu_control_query)
+
+#endif

USDK/component/common/drivers/usb_class/host/uvc/inc/uvc_intf.h

@@ -0,0 +1,55 @@
+#ifndef _UVC_INTF_H_
+#define _UVC_INTF_H_
+
+enum uvc_format_type{
+      UVC_FORMAT_MJPEG = 1,
+      UVC_FORMAT_H264 = 2,
+      UVC_FORMAT_UNKNOWN = -1,
+};
+
+typedef enum uvc_format_type uvc_fmt_t;
+
+struct uvc_context
+{
+      uvc_fmt_t fmt_type; //video format type
+      int width;//video frame width
+      int height;//video frame height
+      int frame_rate;//video frame rate
+      int compression_ratio;//compression format video compression ratio
+};
+
+#define USER_CTRL_SATURATION  1
+
+struct uvc_user_ctrl
+{
+      u32 ctrl_id;
+      s32 ctrl_value;
+};
+
+struct uvc_buf_context
+{
+      int index; //index of internal uvc buffer
+      unsigned char *data; //address of uvc data
+      int len; //length of uvc data
+      u32 timestamp; //timestamp
+};
+
+int uvc_stream_init(void); //entry function to start uvc
+void uvc_stream_free(void); // free streaming resources
+int uvc_is_stream_ready(void); // return true if uvc device is initialized successfully
+int uvc_is_stream_on(void); //return true if uvc device is streaming now
+int uvc_is_stream_off(void); //return true if uvc device is free already
+int uvc_stream_on(void); //enable camera streaming
+void uvc_stream_off(void); //disable camera streaming
+int uvc_set_param(uvc_fmt_t fmt_type, int *width, int *height, int *frame_rate, int *compression_ratio);//set camera streaming video parameters:video format, resolution and frame rate.
+int uvc_get_user_ctrl(struct uvc_user_ctrl *user_ctrl);
+int uvc_set_user_ctrl(struct uvc_user_ctrl *user_ctrl);
+int uvc_buf_check(struct uvc_buf_context *b); //check if uvc_buf_context is legal (return 0 is legal otherwise -1)
+int uvc_dqbuf(struct uvc_buf_context *b); //dequeue internal buffer & get internal buffer info
+int uvc_qbuf(struct uvc_buf_context *b); //queue internal buffer
+int is_pure_thru_on(void);  //return 1 if pure throughput test mode is on otherwise return 0
+void uvc_pure_thru_on(void); //turn on pure uvc throughput test mode (i.e. no decoding is involved)
+void uvc_dec_thru_on(void); //turn on uvc throughput test mode with uvc payload decoding
+void uvc_thru_off(void);    //turn off uvc throughput log service
+
+#endif

USDK/component/common/drivers/usb_class/host/uvc/inc/uvc_os_wrap_via_osdep_api.h

@@ -0,0 +1,573 @@
+#ifndef _UVC_OSDEP_WRAP_H_
+#define _UVC_OSDEP_WRAP_H_
+
+//#include "rtl_utility.h"
+#include "platform/platform_stdlib.h"
+#include "basic_types.h"
+#include "osdep_api.h"
+#include "usb_defs.h"
+
+#include "errno.h"
+#include "dlist.h"
+
+
+
+#define UVC_LAYER_DEBUG  0
+#if     UVC_LAYER_DEBUG
+#define UVC_PRINTF(fmt, args...)	printf("\n\r%s: " fmt, __FUNCTION__, ## args)
+#define UVC_ERROR(fmt, args...)		printf("\n\r%s: " fmt, __FUNCTION__, ## args)
+#define FUN_ENTER                      	//printf("\n\r%s ==>\n", __func__)
+#define FUN_EXIT                        //printf("\n\r%s <==\n", __func__)
+#define FUN_TRACE                       //printf("\n\r%s:%d \n", __func__, __LINE__)
+#else
+#define UVC_PRINTF(fmt, args...)
+#define UVC_ERROR(fmt, args...)		printf("\n\r%s: " fmt, __FUNCTION__, ## args)
+#define FUN_ENTER
+#define FUN_EXIT
+#define FUN_TRACE
+#endif
+
+/* add by Ian -- define uvc task priority */
+#define UVC_TASK_PRIORITY       2
+
+#ifndef __u8
+#define __u8 	u8
+#endif
+#ifndef __u16
+#define __u16	u16
+#endif
+#ifndef __u32
+#define __u32	u32
+#endif
+#ifndef __u64
+#define __u64	u64
+#endif
+#ifndef __s8
+#define __s8	s8
+#endif
+#ifndef __s16
+#define __s16	s16
+#endif
+#ifndef __s32
+#define __s32	s32
+#endif
+#ifndef __s64
+#define __s64	s64
+#endif
+
+#ifndef gfp_t
+#define gfp_t	u32
+#endif
+
+#define ALIGN(x, a, type_of_x)	(((x) + ((type_of_x)(a) - 1)) & ~((type_of_x)(a) - 1))
+
+#ifndef IS_ALIGNED
+#define IS_ALIGNED(x, a, type_of_x)		(((x) & ((type_of_x)(a) - 1)) == 0)
+#endif
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
+#endif 
+
+#ifndef BITS_PER_LONG
+#define BITS_PER_LONG (32)
+#endif
+#ifndef BITS_PER_LONG_LONG
+#define BITS_PER_LONG_LONG (32)
+#endif
+
+/* Atomic integer operations */
+#ifndef atomic_set
+	#define atomic_set(v, i)		RTL_ATOMIC_SET((v), (i))
+#endif
+#ifndef atomic_read
+	#define atomic_read(v)			RTL_ATOMIC_READ((v))
+#endif
+#ifndef atomic_add
+	#define atomic_add(v, i)		RTL_ATOMIC_ADD((v), (i))
+#endif
+#ifndef atomic_sub
+	#define atomic_sub(v, i)		RTL_ATOMIC_SUB((v), (i))
+#endif
+#ifndef atomic_inc
+	#define atomic_inc(v)			RTL_ATOMIC_INC((v))
+#endif
+#ifndef atomic_dec
+	#define atomic_dec(v)			RTL_ATOMIC_DEC((v))
+#endif         
+
+#ifndef MEDIA_PAD_FL_SINK
+#define MEDIA_PAD_FL_SINK               (1 << 0)
+#endif
+#ifndef MEDIA_PAD_FL_SOURCE
+#define MEDIA_PAD_FL_SOURCE             (1 << 1)
+#endif
+#ifndef MEDIA_PAD_FL_MUST_CONNECT
+#define MEDIA_PAD_FL_MUST_CONNECT       (1 << 2)
+#endif
+
+static inline u16 __get_unaligned_le16(const u8 *p)
+{
+         return p[0] | p[1] << 8;
+}
+
+static inline u32 __get_unaligned_le32(const u8 *p)
+{
+         return p[0] | p[1] << 8 | p[2] << 16 | p[3] << 24;
+}
+ 
+static inline u64 __get_unaligned_le64(const u8 *p)
+{
+         return (u64)__get_unaligned_le32(p + 4) << 32 |
+                __get_unaligned_le32(p);
+}
+ 
+static inline void __put_unaligned_le16(u16 val, u8 *p)
+{
+         *p++ = val;
+         *p++ = val >> 8;
+}
+ 
+static inline void __put_unaligned_le32(u32 val, u8 *p)
+{
+         __put_unaligned_le16(val >> 16, p + 2);
+         __put_unaligned_le16(val, p);
+}
+ 
+static inline void __put_unaligned_le64(u64 val, u8 *p)
+{
+         __put_unaligned_le32(val >> 32, p + 4);
+         __put_unaligned_le32(val, p);
+}
+ 
+static inline u16 get_unaligned_le16(const void *p)
+{
+         return __get_unaligned_le16((const u8 *)p);
+}
+ 
+static inline u32 get_unaligned_le32(const void *p)
+{
+         return __get_unaligned_le32((const u8 *)p);
+}
+ 
+static inline u64 get_unaligned_le64(const void *p)
+{
+         return __get_unaligned_le64((const u8 *)p);
+}
+ 
+static inline void put_unaligned_le16(u16 val, void *p)
+{
+         __put_unaligned_le16(val, p);
+}
+ 
+static inline void put_unaligned_le32(u32 val, void *p)
+{
+         __put_unaligned_le32(val, p);
+}
+ 
+static inline void put_unaligned_le64(u64 val, void *p)
+{
+         __put_unaligned_le64(val, p);
+}
+ 
+/**
+* kmemdup - duplicate region of memory
+*
+* @src: memory region to duplicate
+* @len: memory region length
+* @gfp: GFP mask to use
+*/
+static inline void *kmemdup(const void *src, size_t len, gfp_t gfp)
+{
+         void *p;
+ 
+         //p = kmalloc_track_caller(len, gfp);
+	 //p = kmalloc(len, gfp);
+         p = malloc(len);
+	 if (p)
+                 memcpy(p, src, len);
+         return p;
+}
+#ifndef __force
+#define __force        __attribute__((force))
+#endif
+
+#if 0
+typedef __u16 __bitwise __le16;
+typedef __u16 __bitwise __be16;
+typedef __u32 __bitwise __le32;
+typedef __u32 __bitwise __be32;
+typedef __u64 __bitwise __le64;
+typedef __u64 __bitwise __be64; 
+typedef __u16 __bitwise __sum16;
+typedef __u32 __bitwise __wsum;
+#endif
+//edit by Ian -- remove duplicated definitions
+#if 0
+typedef __u16 __le16;
+typedef __u16 __be16;
+typedef __u32 __le32;
+typedef __u32 __be32;
+typedef __u64 __le64;
+typedef __u64 __be64; 
+typedef __u16 __sum16;
+typedef __u32 __wsum;
+#endif
+
+#ifndef __le16
+#define __le16 __u16
+#endif
+#ifndef __be16
+#define __be16 __u16
+#endif
+#ifndef __le32
+#define __le32 __u32
+#endif
+#ifndef __be32
+#define __be32 __u32
+#endif
+static inline __u32 le32_to_cpup(const __le32 *p)
+{
+        //return (__force __u32)*p;
+	return (__u32)*p;
+}
+static inline __u16 le16_to_cpup(const __le16 *p)
+{
+        //return (__force __u16)*p;
+	return (__u16)*p;
+}
+
+
+/* Endian macros */
+#ifndef htonl
+#define htonl(x)	rtk_cpu_to_be32(x)
+#endif
+          
+#ifndef ntohl
+#define ntohl(x)	rtk_be32_to_cpu(x)
+#endif
+
+#ifndef htons
+#define htons(x)	rtk_cpu_to_be16(x)
+#endif
+
+#ifndef ntohs
+#define ntohs(x)	rtk_be16_to_cpu(x)
+#endif
+
+#ifndef cpu_to_le32
+#define cpu_to_le32(x)	rtk_cpu_to_le32(x)
+#endif
+
+#ifndef le32_to_cpu
+#define le32_to_cpu(x)	rtk_le32_to_cpu(x)
+#endif
+
+#ifndef cpu_to_le16
+#define cpu_to_le16(x)	rtk_cpu_to_le16(x)
+#endif
+
+#ifndef le16_to_cpu
+#define le16_to_cpu(x)	rtk_le16_to_cpu(x)
+#endif
+
+#ifndef cpu_to_be32
+#define cpu_to_be32(x)	rtk_cpu_to_be32(x)
+#endif
+  
+#ifndef be32_to_cpu
+#define be32_to_cpu(x)	rtk_be32_to_cpu(x)
+#endif
+        
+#ifndef cpu_to_be16
+#define cpu_to_be16(x)	rtk_cpu_to_be16(x)
+#endif
+
+#ifndef be16_to_cpu
+#define be16_to_cpu(x)	rtk_be16_to_cpu(x)
+#endif
+
+/* Parameters used to convert the timespec values: */
+#ifndef MSEC_PER_SEC
+#define MSEC_PER_SEC    1000L
+#endif
+#ifndef USEC_PER_MSEC
+#define USEC_PER_MSEC   1000L
+#endif
+#ifndef NSEC_PER_USEC
+#define NSEC_PER_USEC   1000L
+#endif
+#ifndef NSEC_PER_MSEC
+#define NSEC_PER_MSEC   1000000L
+#endif
+#ifndef USEC_PER_SEC
+#define USEC_PER_SEC    1000000L
+#endif
+#ifndef NSEC_PER_SEC
+#define NSEC_PER_SEC    1000000000L
+#endif
+#ifndef FSEC_PER_SEC
+#define FSEC_PER_SEC    1000000000000000LL
+#endif
+#ifndef TIME_T_MAX
+#define TIME_T_MAX      (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
+#endif
+
+#ifndef __GFP_WAIT
+#define __GFP_WAIT             					(0x10u)
+#endif
+#ifndef __GFP_HIGH
+#define __GFP_HIGH             					(0x20u)
+#endif
+#ifndef __GFP_IO
+#define __GFP_IO               					(0x40u)
+#endif
+#ifndef __GFP_FS
+#define __GFP_FS               					(0x80u)
+#endif
+#ifndef GFP_NOIO
+#define GFP_NOIO 						(0x10u)
+#endif
+#ifndef __GFP_NOWARN
+#define __GFP_NOWARN          					(0x200u)
+#endif
+#ifndef GFP_KERNEL
+#define GFP_KERNEL	(__GFP_WAIT | __GFP_IO | __GFP_FS)
+#endif
+
+#ifndef copy_from_user
+#define copy_from_user(to, from, sz) _memcpy((to), (from), (sz))
+#endif
+#ifndef copy_to_user
+#define copy_to_user(to, from, sz)   _memcpy((to), (from), (sz))
+#endif
+
+typedef u32             compat_caddr_t; //used for compatibility in uvc_v4l2.c
+
+/**
+* strlcpy - Copy a %NUL terminated string into a sized buffer
+* @dest: Where to copy the string to
+* @src: Where to copy the string from
+* @size: size of destination buffer
+*
+* Compatible with *BSD: the result is always a valid
+* NUL-terminated string that fits in the buffer (unless,
+* of course, the buffer size is zero). It does not pad
+* out the result like strncpy() does.
+*/
+#ifndef __GNUC__
+static inline size_t strlcpy(char *dest, const char *src, size_t size)
+{
+         size_t ret = _strlen(src);
+ 
+         if (size) {
+                 size_t len = (ret >= size) ? size - 1 : ret;
+                 memcpy(dest, src, len);
+                 dest[len] = '\0';
+         }
+         return ret;
+}
+#endif
+
+/**
+* clamp - return a value clamped to a given range with strict typechecking
+* @val: current value
+* @min: minimum allowable value
+* @max: maximum allowable value
+*
+* This macro does strict typechecking of min/max to make sure they are of the
+* same type as val.  See the unnecessary pointer comparisons.
+*/
+
+#ifndef clamp
+#define clamp(new_val, val, min, max, type) do{           \
+         type __val = (val);              	\
+         type __min = (min);              	\
+         type __max = (max);              	\
+         (void) (&__val == &__min);             \
+         (void) (&__val == &__max);             \
+         __val = (__val < __min) ? __min: __val;  \
+         new_val = (__val > __max) ? __max: __val; }while(0)
+#endif
+
+/*
+ * Compile time versions of __arch_hweightN()
+ */
+#ifndef __const_hweight8
+#define __const_hweight8(w)             \
+       ( (!!((w) & (1ULL << 0))) +       \
+         (!!((w) & (1ULL << 1))) +       \
+         (!!((w) & (1ULL << 2))) +       \
+         (!!((w) & (1ULL << 3))) +       \
+         (!!((w) & (1ULL << 4))) +       \
+         (!!((w) & (1ULL << 5))) +       \
+         (!!((w) & (1ULL << 6))) +       \
+         (!!((w) & (1ULL << 7))) )
+#endif
+#ifndef hweight8
+#define hweight8(w)  __const_hweight8(w)
+#endif
+#ifndef BITMAP_LAST_WORD_MASK
+#define BITMAP_LAST_WORD_MASK(nbits)                                    \
+(                                                                       \
+         ((nbits) % BITS_PER_LONG) ?                                     \
+                 (1UL<<((nbits) % BITS_PER_LONG))-1 : ~0UL               \
+)
+#endif
+/**
+  * hweightN - returns the hamming weight of a N-bit word
+  * @x: the word to weigh
+  *
+  * The Hamming Weight of a number is the total number of bits set in it.
+  */ 
+static inline unsigned int hweight32(unsigned int w)
+{
+         unsigned int res = w - ((w >> 1) & 0x55555555);
+         res = (res & 0x33333333) + ((res >> 2) & 0x33333333);
+         res = (res + (res >> 4)) & 0x0F0F0F0F;
+         res = res + (res >> 8);
+         return (res + (res >> 16)) & 0x000000FF;
+}
+ 
+static inline unsigned long hweight64(__u64 w)
+{
+#if BITS_PER_LONG == 32
+         return hweight32((unsigned int)(w >> 32)) + hweight32((unsigned int)w);
+#elif BITS_PER_LONG == 64
+         __u64 res = w - ((w >> 1) & 0x5555555555555555ul);
+         res = (res & 0x3333333333333333ul) + ((res >> 2) & 0x3333333333333333ul);
+         res = (res + (res >> 4)) & 0x0F0F0F0F0F0F0F0Ful;
+         res = res + (res >> 8);
+         res = res + (res >> 16);
+         return (res + (res >> 32)) & 0x00000000000000FFul;
+#endif
+}
+
+
+static inline unsigned long hweight_long(unsigned long w)
+{
+         return sizeof(w) == 4 ? hweight32(w) : hweight64(w);
+}
+
+static inline int __bitmap_weight(const unsigned long *bitmap, int bits)
+{
+         int k, w = 0, lim = bits/BITS_PER_LONG;
+ 
+         for (k = 0; k < lim; k++)
+                 w += hweight_long(bitmap[k]);
+ 
+         if (bits % BITS_PER_LONG)
+                 w += hweight_long(bitmap[k] & BITMAP_LAST_WORD_MASK(bits));
+ 
+         return w;
+}
+
+static inline int bitmap_weight(const unsigned long *src, int nbits)
+{
+ //        if (small_const_nbits(nbits))
+ //               return hweight_long(*src & BITMAP_LAST_WORD_MASK(nbits));
+         return __bitmap_weight(src, nbits);
+}
+
+/**
+  * memweight - count the total number of bits set in memory area
+  * @ptr: pointer to the start of the area
+  * @bytes: the size of the area
+  */
+static inline size_t memweight(const void *ptr, size_t bytes)
+{
+         size_t ret = 0;
+         size_t longs;
+         const unsigned char *bitmap = ptr;
+  
+          for (; bytes > 0 && ((unsigned long)bitmap) % sizeof(long);
+                          bytes--, bitmap++)
+                  ret += hweight8(*bitmap);
+  
+          longs = bytes / sizeof(long);
+          if (longs) {
+                  //BUG_ON(longs >= INT_MAX / BITS_PER_LONG);
+                  ret += bitmap_weight((unsigned long *)bitmap, longs * BITS_PER_LONG);
+                  bytes -= longs * sizeof(long);
+                  bitmap += longs * sizeof(long);
+          }
+          /*
+           * The reason that this last loop is distinct from the preceding
+           * bitmap_weight() call is to compute 1-bits in the last region smaller
+           * than sizeof(long) properly on big-endian systems.
+           */
+          for (; bytes > 0; bytes--, bitmap++)
+                  ret += hweight8(*bitmap);
+  
+          return ret;
+}
+
+ /**
+  * strlcat - Append a length-limited, %NUL-terminated string to another
+  * @dest: The string to be appended to
+* @src: The string to append to it
+* @count: The size of the destination buffer.
+*/
+#ifndef __GNUC__
+static inline size_t strlcat(char *dest, const char *src, size_t count)
+{
+         size_t dsize = _strlen(dest);
+         size_t len = _strlen(src);
+         size_t res = dsize + len;
+ 
+         /* This would be a bug */
+         //BUG_ON(dsize >= count);
+ 
+         dest += dsize;
+         count -= dsize;
+         if (len >= count)
+                 len = count-1;
+         memcpy(dest, src, len);
+         dest[len] = 0;
+         return res;
+}
+#endif
+
+/**
+ * atomic_dec_and_test - decrement and test
+ * @v: pointer of type atomic_t
+ *
+ * Atomically decrements @v by 1 and
+ * returns true if the result is 0, or false for all other
+ * cases.
+ */
+static inline int atomic_dec_and_test(atomic_t *v)
+{
+	atomic_dec(v);
+	if (v->counter == 0)
+		return TRUE;
+	else
+		return FALSE;
+}
+
+/**
+ * kcalloc - allocate memory for an array. The memory is set to zero.
+ * @n: number of elements.
+ * @size: element size.
+ * @flags: the type of memory to allocate (see kmalloc).
+ */
+static inline void *kcalloc(size_t n, size_t size, gfp_t flags)
+{
+         return RtlZmalloc(((n) * (size)));
+}
+
+#ifndef GFP_ATOMIC
+#define GFP_ATOMIC	GFP_KERNEL
+#endif
+#ifndef offsetof
+#define offsetof(s,m) (size_t)&(((s *)0)->m)
+#endif
+
+//enum linux kernel version
+#ifndef   KERNEL_VERSION
+#define   KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
+#endif
+#ifndef LINUX_VERSION_CODE
+#define LINUX_VERSION_CODE KERNEL_VERSION(3, 12, 0)
+#endif
+
+#endif //_UVC_OSDEP_WRAP_H_

USDK/component/common/drivers/usb_class/host/uvc/inc/uvcvideo.h

@@ -0,0 +1,774 @@
+#ifndef _USB_VIDEO_H_
+#define _USB_VIDEO_H_
+#if 0
+#ifndef __KERNEL__
+#error "The uvcvideo.h header is deprecated, use linux/uvcvideo.h instead."
+#endif /* __KERNEL__ */
+
+#include <linux/kernel.h>
+#include <linux/poll.h>
+#endif
+
+#include "usb.h"
+#include "video.h"
+#include "uvcvideo.h"
+
+#include "videodev2.h"
+#include "media-device.h"
+#include "v4l2-device.h"
+#include "v4l2-event.h"
+#include "v4l2-fh.h"
+#include "videobuf2-core.h"
+
+
+
+/* --------------------------------------------------------------------------
+ * UVC constants
+ */
+
+#define UVC_TERM_INPUT			0x0000
+#define UVC_TERM_OUTPUT			0x8000
+#define UVC_TERM_DIRECTION(term)	((term)->type & 0x8000)
+
+#define UVC_ENTITY_TYPE(entity)		((entity)->type & 0x7fff)
+#define UVC_ENTITY_IS_UNIT(entity)	(((entity)->type & 0xff00) == 0)
+#define UVC_ENTITY_IS_TERM(entity)	(((entity)->type & 0xff00) != 0)
+#define UVC_ENTITY_IS_ITERM(entity) \
+	(UVC_ENTITY_IS_TERM(entity) && \
+	((entity)->type & 0x8000) == UVC_TERM_INPUT)
+#define UVC_ENTITY_IS_OTERM(entity) \
+	(UVC_ENTITY_IS_TERM(entity) && \
+	((entity)->type & 0x8000) == UVC_TERM_OUTPUT)
+
+
+/* ------------------------------------------------------------------------
+ * GUIDs
+ */
+#define UVC_GUID_UVC_CAMERA \
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}
+#define UVC_GUID_UVC_OUTPUT \
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}
+#define UVC_GUID_UVC_MEDIA_TRANSPORT_INPUT \
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03}
+#define UVC_GUID_UVC_PROCESSING \
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01}
+#define UVC_GUID_UVC_SELECTOR \
+	{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02}
+
+#define UVC_GUID_FORMAT_MJPEG \
+	{ 'M',  'J',  'P',  'G', 0x00, 0x00, 0x10, 0x00, \
+	 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+#define UVC_GUID_FORMAT_YUY2 \
+	{ 'Y',  'U',  'Y',  '2', 0x00, 0x00, 0x10, 0x00, \
+	 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+#define UVC_GUID_FORMAT_YUY2_ISIGHT \
+	{ 'Y',  'U',  'Y',  '2', 0x00, 0x00, 0x10, 0x00, \
+	 0x80, 0x00, 0x00, 0x00, 0x00, 0x38, 0x9b, 0x71}
+#define UVC_GUID_FORMAT_NV12 \
+	{ 'N',  'V',  '1',  '2', 0x00, 0x00, 0x10, 0x00, \
+	 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+#define UVC_GUID_FORMAT_YV12 \
+	{ 'Y',  'V',  '1',  '2', 0x00, 0x00, 0x10, 0x00, \
+	 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+#define UVC_GUID_FORMAT_I420 \
+	{ 'I',  '4',  '2',  '0', 0x00, 0x00, 0x10, 0x00, \
+	 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+#define UVC_GUID_FORMAT_UYVY \
+	{ 'U',  'Y',  'V',  'Y', 0x00, 0x00, 0x10, 0x00, \
+	 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+#define UVC_GUID_FORMAT_Y800 \
+	{ 'Y',  '8',  '0',  '0', 0x00, 0x00, 0x10, 0x00, \
+	 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+#define UVC_GUID_FORMAT_Y8 \
+	{ 'Y',  '8',  ' ',  ' ', 0x00, 0x00, 0x10, 0x00, \
+	 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+#define UVC_GUID_FORMAT_Y10 \
+	{ 'Y',  '1',  '0',  ' ', 0x00, 0x00, 0x10, 0x00, \
+	 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+#define UVC_GUID_FORMAT_Y12 \
+	{ 'Y',  '1',  '2',  ' ', 0x00, 0x00, 0x10, 0x00, \
+	 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+#define UVC_GUID_FORMAT_Y16 \
+	{ 'Y',  '1',  '6',  ' ', 0x00, 0x00, 0x10, 0x00, \
+	 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+#define UVC_GUID_FORMAT_BY8 \
+	{ 'B',  'Y',  '8',  ' ', 0x00, 0x00, 0x10, 0x00, \
+	 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+#define UVC_GUID_FORMAT_RGBP \
+	{ 'R',  'G',  'B',  'P', 0x00, 0x00, 0x10, 0x00, \
+	 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+#define UVC_GUID_FORMAT_M420 \
+	{ 'M',  '4',  '2',  '0', 0x00, 0x00, 0x10, 0x00, \
+	 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+
+#define UVC_GUID_FORMAT_H264 \
+	{ 'H',  '2',  '6',  '4', 0x00, 0x00, 0x10, 0x00, \
+	 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+/* edit by Ian -- patch for GEO add two new guids*/
+#define UVC_GUID_FORMAT_MPEG \
+	{ 'M',  'P',  'E',  'G', 0x00, 0x00, 0x10, 0x00, \
+	 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+#define UVC_GUID_FORMAT_MUX \
+	{ 'M',  'U',  'X',  0x00, 0x00, 0x00, 0x10, 0x00, \
+	 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
+/* ------------------------------------------------------------------------
+ * Driver specific constants.
+ */
+
+#define DRIVER_VERSION		"1.1.1"
+
+/* Number of isochronous URBs. */
+#define UVC_URBS		2
+/* Maximum number of packets per URB. */
+#define UVC_MAX_PACKETS		32
+/* Maximum number of video buffers. */
+#define UVC_MAX_VIDEO_BUFFERS	8
+/* Maximum status buffer size in bytes of interrupt URB. */
+#define UVC_MAX_STATUS_SIZE	16
+
+//modified by Ian
+#define UVC_REQBUF_SIZE         (150000)
+
+#define UVC_CTRL_CONTROL_TIMEOUT	300
+#define UVC_CTRL_STREAMING_TIMEOUT	5000
+
+/* Maximum allowed number of control mappings per device */
+#define UVC_MAX_CONTROL_MAPPINGS	1024
+#define UVC_MAX_CONTROL_MENU_ENTRIES	32
+
+/* Devices quirks */
+#define UVC_QUIRK_STATUS_INTERVAL	0x00000001
+#define UVC_QUIRK_PROBE_MINMAX		0x00000002
+#define UVC_QUIRK_PROBE_EXTRAFIELDS	0x00000004
+#define UVC_QUIRK_BUILTIN_ISIGHT	0x00000008
+#define UVC_QUIRK_STREAM_NO_FID		0x00000010
+#define UVC_QUIRK_IGNORE_SELECTOR_UNIT	0x00000020
+#define UVC_QUIRK_FIX_BANDWIDTH		0x00000080
+#define UVC_QUIRK_PROBE_DEF		0x00000100
+#define UVC_QUIRK_RESTRICT_FRAME_RATE	0x00000200
+
+/* Format flags */
+#define UVC_FMT_FLAG_COMPRESSED		0x00000001
+#define UVC_FMT_FLAG_STREAM		0x00000002
+
+/* ------------------------------------------------------------------------
+ * Structures.
+ */
+
+struct uvc_device;
+
+/* TODO: Put the most frequently accessed fields at the beginning of
+ * structures to maximize cache efficiency.
+ */
+struct uvc_control_info {
+	struct list_head mappings;
+	__u8 entity[16];
+	__u8 index;	/* Bit index in bmControls */
+	__u8 selector;
+
+	__u16 size;
+	__u32 flags;
+};
+
+struct uvc_control_mapping {
+	struct list_head list;
+	struct list_head ev_subs;
+
+	__u32 id;
+	__u8 name[32];
+	__u8 entity[16];
+	__u8 selector;
+
+	__u8 size;
+	__u8 offset;
+	enum v4l2_ctrl_type v4l2_type;
+	__u32 data_type;
+
+	struct uvc_menu_info *menu_info;
+	__u32 menu_count;
+
+	__u32 master_id;
+	__s32 master_manual;
+	__u32 slave_ids[2];
+
+	__s32 (*get) (struct uvc_control_mapping *mapping, __u8 query,
+		      const __u8 *data);
+	void (*set) (struct uvc_control_mapping *mapping, __s32 value,
+		     __u8 *data);
+};
+
+struct uvc_control {
+	struct uvc_entity *entity;
+	struct uvc_control_info info;
+
+	__u8 index;	/* Used to match the uvc_control entry with a
+			   uvc_control_info. */
+	__u8 dirty:1,
+	     loaded:1,
+	     modified:1,
+	     cached:1,
+	     initialized:1;
+
+	__u8 *uvc_data;
+};
+
+struct uvc_format_desc {
+	char *name;
+	__u8 guid[16];
+	__u32 fcc;
+};
+
+/* The term 'entity' refers to both UVC units and UVC terminals.
+ *
+ * The type field is either the terminal type (wTerminalType in the terminal
+ * descriptor), or the unit type (bDescriptorSubtype in the unit descriptor).
+ * As the bDescriptorSubtype field is one byte long, the type value will
+ * always have a null MSB for units. All terminal types defined by the UVC
+ * specification have a non-null MSB, so it is safe to use the MSB to
+ * differentiate between units and terminals as long as the descriptor parsing
+ * code makes sure terminal types have a non-null MSB.
+ *
+ * For terminals, the type's most significant bit stores the terminal
+ * direction (either UVC_TERM_INPUT or UVC_TERM_OUTPUT). The type field should
+ * always be accessed with the UVC_ENTITY_* macros and never directly.
+ */
+
+#define UVC_ENTITY_FLAG_DEFAULT		(1 << 0)
+
+struct uvc_entity {
+	struct list_head list;		/* Entity as part of a UVC device. */
+	struct list_head chain;		/* Entity as part of a video device
+					 * chain. */
+	unsigned int flags;
+
+	__u8 id;
+	__u16 type;
+	char name[64];
+
+	/* Media controller-related fields. */
+	struct video_device *vdev;
+	struct v4l2_subdev subdev;
+	unsigned int num_pads;
+	unsigned int num_links;
+	struct media_pad *pads;
+
+	union {
+		struct {
+			__u16 wObjectiveFocalLengthMin;
+			__u16 wObjectiveFocalLengthMax;
+			__u16 wOcularFocalLength;
+			__u8  bControlSize;
+			__u8  *bmControls;
+		} camera;
+
+		struct {
+			__u8  bControlSize;
+			__u8  *bmControls;
+			__u8  bTransportModeSize;
+			__u8  *bmTransportModes;
+		} media;
+#if 0
+		struct {
+		} output;
+#endif
+		struct {
+			__u16 wMaxMultiplier;
+			__u8  bControlSize;
+			__u8  *bmControls;
+			__u8  bmVideoStandards;
+		} processing;
+#if 0
+		struct {
+		} selector;
+#endif
+		struct {
+			__u8  guidExtensionCode[16];
+			__u8  bNumControls;
+			__u8  bControlSize;
+			__u8  *bmControls;
+			__u8  *bmControlsType;
+		} extension;
+	};
+
+	__u8 bNrInPins;
+	__u8 *baSourceID;
+
+	unsigned int ncontrols;
+	struct uvc_control *controls;
+};
+
+// total (27)-> 28 Bytes
+struct uvc_frame {
+	__u8  bFrameIndex;
+	__u8  bmCapabilities;
+	__u16 wWidth;
+	__u16 wHeight;
+	__u32 dwMinBitRate;
+	__u32 dwMaxBitRate;
+	__u32 dwMaxVideoFrameBufferSize;
+	__u8  bFrameIntervalType;
+	__u32 dwDefaultFrameInterval;
+	__u32 *dwFrameInterval;
+};
+
+// total 52 Bytes
+struct uvc_format {
+	__u8 type;
+	__u8 index;
+	__u8 bpp;
+	__u8 colorspace;
+	__u32 fcc;
+	__u32 flags;
+
+	char name[32];
+
+	unsigned int nframes;
+	struct uvc_frame *frame;
+};
+
+struct uvc_streaming_header {
+	__u8 bNumFormats;
+	__u8 bEndpointAddress;
+	__u8 bTerminalLink;
+	__u8 bControlSize;
+	__u8 *bmaControls;
+	/* The following fields are used by input headers only. */
+	__u8 bmInfo;
+	__u8 bStillCaptureMethod;
+	__u8 bTriggerSupport;
+	__u8 bTriggerUsage;
+};
+
+enum uvc_buffer_state {
+	UVC_BUF_STATE_IDLE	= 0,
+	UVC_BUF_STATE_QUEUED	= 1,
+	UVC_BUF_STATE_ACTIVE	= 2,
+	UVC_BUF_STATE_READY	= 3,
+	UVC_BUF_STATE_DONE	= 4,
+	UVC_BUF_STATE_ERROR	= 5,
+};
+
+struct uvc_buffer {
+	struct vb2_buffer buf;
+	struct list_head queue;
+	_Mutex mutex;
+	enum uvc_buffer_state state;
+	unsigned int error;
+
+	void *mem;
+	unsigned int length;
+	unsigned int bytesused;
+
+	u32 pts;
+};
+
+#define UVC_QUEUE_DISCONNECTED		(1 << 0)
+#define UVC_QUEUE_DROP_CORRUPTED	(1 << 1)
+
+struct uvc_video_queue {
+	struct vb2_queue queue;
+	//struct mutex mutex;			/* Protects queue */
+	_Mutex mutex;
+	unsigned int flags;
+	unsigned int buf_used;
+
+	//spinlock_t irqlock;			/* Protects irqqueue */
+	//_LOCK_T irqlock;
+	_Mutex irqlock;
+	struct list_head irqqueue;
+};
+
+struct uvc_video_chain {
+	struct uvc_device *dev;
+	struct list_head list;
+
+	struct list_head entities;		/* All entities */
+	struct uvc_entity *processing;		/* Processing unit */
+	struct uvc_entity *selector;		/* Selector unit */
+
+	//struct mutex ctrl_mutex;		/* Protects ctrl.info */
+	_Mutex ctrl_mutex;
+
+	struct v4l2_prio_state prio;		/* V4L2 priority state */
+	u32 caps;				/* V4L2 chain-wide caps */
+};
+
+struct uvc_stats_frame {
+	unsigned int size;		/* Number of bytes captured */
+	unsigned int first_data;	/* Index of the first non-empty packet */
+
+	unsigned int nb_packets;	/* Number of packets */
+	unsigned int nb_empty;		/* Number of empty packets */
+	unsigned int nb_invalid;	/* Number of packets with an invalid header */
+	unsigned int nb_errors;		/* Number of packets with the error bit set */
+
+	unsigned int nb_pts;		/* Number of packets with a PTS timestamp */
+	unsigned int nb_pts_diffs;	/* Number of PTS differences inside a frame */
+	unsigned int last_pts_diff;	/* Index of the last PTS difference */
+	bool has_initial_pts;		/* Whether the first non-empty packet has a PTS */
+	bool has_early_pts;		/* Whether a PTS is present before the first non-empty packet */
+	u32 pts;			/* PTS of the last packet */
+
+	unsigned int nb_scr;		/* Number of packets with a SCR timestamp */
+	unsigned int nb_scr_diffs;	/* Number of SCR.STC differences inside a frame */
+	u16 scr_sof;			/* SCR.SOF of the last packet */
+	u32 scr_stc;			/* SCR.STC of the last packet */
+};
+
+struct uvc_stats_stream {
+	//struct timespec start_ts;	/* Stream start timestamp */
+	//struct timespec stop_ts;	/* Stream stop timestamp */
+	u32 start_ts;	
+	u32 stop_ts;	
+
+
+	unsigned int nb_frames;		/* Number of frames */
+
+	unsigned int nb_packets;	/* Number of packets */
+	unsigned int nb_empty;		/* Number of empty packets */
+	unsigned int nb_invalid;	/* Number of packets with an invalid header */
+	unsigned int nb_errors;		/* Number of packets with the error bit set */
+
+	unsigned int nb_pts_constant;	/* Number of frames with constant PTS */
+	unsigned int nb_pts_early;	/* Number of frames with early PTS */
+	unsigned int nb_pts_initial;	/* Number of frames with initial PTS */
+
+	unsigned int nb_scr_count_ok;	/* Number of frames with at least one SCR per non empty packet */
+	unsigned int nb_scr_diffs_ok;	/* Number of frames with varying SCR.STC */
+	unsigned int scr_sof_count;	/* STC.SOF counter accumulated since stream start */
+	unsigned int scr_sof;		/* STC.SOF of the last packet */
+	unsigned int min_sof;		/* Minimum STC.SOF value */
+	unsigned int max_sof;		/* Maximum STC.SOF value */
+};
+
+struct uvc_streaming {
+	struct list_head list;
+	struct uvc_device *dev;
+	struct video_device *vdev;
+	struct uvc_video_chain *chain;
+	atomic_t active;
+
+	struct usb_interface *intf;
+	int intfnum;
+	__u16 maxpsize;
+
+	struct uvc_streaming_header header;
+	enum v4l2_buf_type type;
+
+	unsigned int nformats;
+	struct uvc_format *format;
+
+	struct uvc_streaming_control ctrl;
+	struct uvc_format *def_format;
+	struct uvc_format *cur_format;
+	struct uvc_frame *cur_frame;
+	/* Protect access to ctrl, cur_format, cur_frame and hardware video
+	 * probe control.
+	 */
+	//struct mutex mutex;
+	_Mutex mutex;
+
+	/* Buffers queue. */
+	unsigned int frozen : 1;
+	struct uvc_video_queue queue;
+	void (*decode) (struct urb *urb, struct uvc_streaming *video,
+			struct uvc_buffer *buf);
+
+	/* Context data used by the bulk completion handler. */
+	struct {
+		__u8 header[256];
+		unsigned int header_size;
+		int skip_payload;
+		__u32 payload_size;
+		__u32 max_payload_size;
+	} bulk;
+
+	struct urb *urb[UVC_URBS];
+	char *urb_buffer[UVC_URBS];
+	dma_addr_t urb_dma[UVC_URBS];
+	unsigned int urb_size;
+
+
+
+
+
+
+	__u32 sequence;
+	__u8 last_fid;
+
+	/* debugfs */
+	//struct dentry *debugfs_dir;
+	struct {
+		struct uvc_stats_frame frame;
+		struct uvc_stats_stream stream;
+	} stats;
+
+	/* Timestamps support. */
+	struct uvc_clock {
+		struct uvc_clock_sample {
+			u32 dev_stc;
+			u16 dev_sof;
+			//struct timespec host_ts;
+			u32 host_ts; //change to tick
+			u16 host_sof;
+		} *samples;
+
+		unsigned int head;
+		unsigned int count;
+		unsigned int size;
+
+		u16 last_sof;
+		u16 sof_offset;
+
+		//spinlock_t lock;
+		_Lock lock;
+	} clock;
+};
+
+enum uvc_device_state {
+	UVC_DEV_DISCONNECTED = 1,
+};
+
+struct uvc_device {
+	struct usb_device *udev;
+	struct usb_interface *intf;
+	unsigned long warnings;
+	__u32 quirks;
+	int intfnum;
+	char name[32];
+
+	enum uvc_device_state state;
+	//struct mutex lock;		/* Protects users */
+	_Mutex lock;
+	unsigned int users;
+	atomic_t nmappings;
+
+	/* Video control interface */
+#ifdef CONFIG_MEDIA_CONTROLLER
+	struct media_device mdev;
+#endif
+	struct v4l2_device vdev;
+	__u16 uvc_version;
+	__u32 clock_frequency;
+
+	struct list_head entities;	// VC_EXTENSION_UNIT ->VC_INPUT_TERMINAL ->VC_PROCESSING_UNIT ->VC_OUTPUT_TERMINAL
+	struct list_head chains;
+
+	/* Video Streaming interfaces */
+	struct list_head streams;
+	atomic_t nstreams;
+
+	/* Status Interrupt Endpoint */
+	struct usb_host_endpoint *int_ep;
+	struct urb *int_urb;
+	__u8 *status;
+	//struct input_dev *input;
+	char input_phys[64];
+};
+
+enum uvc_handle_state {
+	UVC_HANDLE_PASSIVE	= 0,
+	UVC_HANDLE_ACTIVE	= 1,
+};
+
+/* uvc file handle */
+struct uvc_fh {
+	struct v4l2_fh vfh;
+	struct uvc_video_chain *chain;
+	struct uvc_streaming *stream;
+	enum uvc_handle_state state;
+};
+#if 0
+/* uvc_driver = usb_driver for interface 
+ * - identifies USB interface driver to usbcore
+ */
+struct uvc_driver {
+	struct usb_driver driver;
+};
+#endif
+
+/* ------------------------------------------------------------------------
+ * Debugging, printing and logging
+ */
+
+#define UVC_TRACE_PROBE		(1 << 0)
+#define UVC_TRACE_DESCR		(1 << 1)
+#define UVC_TRACE_CONTROL	(1 << 2)
+#define UVC_TRACE_FORMAT	(1 << 3)
+#define UVC_TRACE_CAPTURE	(1 << 4)
+#define UVC_TRACE_CALLS		(1 << 5)
+#define UVC_TRACE_IOCTL		(1 << 6)
+#define UVC_TRACE_FRAME		(1 << 7)
+#define UVC_TRACE_SUSPEND	(1 << 8)
+#define UVC_TRACE_STATUS	(1 << 9)
+#define UVC_TRACE_VIDEO		(1 << 10)
+#define UVC_TRACE_STATS		(1 << 11)
+#define UVC_TRACE_CLOCK		(1 << 12)
+
+#define UVC_WARN_MINMAX		0
+#define UVC_WARN_PROBE_DEF	1
+#define UVC_WARN_XU_GET_RES	2
+
+extern unsigned int uvc_clock_param;
+extern unsigned int uvc_no_drop_param;
+extern unsigned int uvc_trace_param;
+extern unsigned int uvc_timeout_param;
+
+#if 0
+#define uvc_trace(flag, msg...) \
+	do { \
+		if (uvc_trace_param & flag) \
+			printk(KERN_DEBUG "uvcvideo: " msg); \
+	} while (0)
+
+#define uvc_warn_once(dev, warn, msg...) \
+	do { \
+		if (!test_and_set_bit(warn, &dev->warnings)) \
+			printk(KERN_INFO "uvcvideo: " msg); \
+	} while (0)
+
+#define uvc_printk(level, msg...) \
+	printk(level "uvcvideo: " msg)
+#endif
+
+/* --------------------------------------------------------------------------
+ * Internal functions.
+ */
+
+/* Core driver */
+extern struct uvc_driver uvc_driver;
+
+extern struct uvc_entity *uvc_entity_by_id(struct uvc_device *dev, int id);
+
+/* Video buffers queue management. */
+extern int uvc_queue_init(struct uvc_video_queue *queue,
+		enum v4l2_buf_type type, int drop_corrupted);
+extern int uvc_alloc_buffers(struct uvc_video_queue *queue,
+		struct v4l2_requestbuffers *rb);
+extern void uvc_free_buffers(struct uvc_video_queue *queue);
+extern int uvc_query_buffer(struct uvc_video_queue *queue,
+		struct v4l2_buffer *v4l2_buf);
+extern int uvc_queue_buffer(struct uvc_video_queue *queue,
+		struct v4l2_buffer *v4l2_buf);
+extern int uvc_dequeue_buffer(struct uvc_video_queue *queue,
+		struct v4l2_buffer *v4l2_buf, int nonblocking);
+extern int uvc_queue_enable(struct uvc_video_queue *queue, int enable);
+extern void uvc_queue_cancel(struct uvc_video_queue *queue, int disconnect);
+extern struct uvc_buffer *uvc_queue_next_buffer(struct uvc_video_queue *queue,
+		struct uvc_buffer *buf);
+extern int uvc_queue_mmap(struct uvc_video_queue *queue);
+#if 0
+extern unsigned int uvc_queue_poll(struct uvc_video_queue *queue,
+		struct file *file, poll_table *wait);
+#endif
+
+#ifndef CONFIG_MMU
+extern unsigned long uvc_queue_get_unmapped_area(struct uvc_video_queue *queue,
+		unsigned long pgoff);
+#endif
+
+extern int uvc_queue_allocated(struct uvc_video_queue *queue);
+static inline int uvc_queue_streaming(struct uvc_video_queue *queue)
+{
+	return vb2_is_streaming(&queue->queue);
+}
+
+/* V4L2 interface */
+extern const struct v4l2_file_operations uvc_fops;
+
+/* Media controller */
+extern int uvc_mc_register_entities(struct uvc_video_chain *chain);
+extern void uvc_mc_cleanup_entity(struct uvc_entity *entity);
+
+/* Video */
+extern int uvc_video_init(struct uvc_streaming *stream);
+extern int uvc_video_suspend(struct uvc_streaming *stream);
+extern int uvc_video_resume(struct uvc_streaming *stream, int reset);
+extern int uvc_video_enable(struct uvc_streaming *stream, int enable);
+extern int uvc_probe_video(struct uvc_streaming *stream,
+		struct uvc_streaming_control *probe);
+/* edit by Ian -- patch for GEO */
+extern int uvc_commit_video(struct uvc_streaming *stream,
+		struct uvc_streaming_control *probe);
+
+extern int uvc_query_ctrl(struct uvc_device *dev, __u8 query, __u8 unit,
+		__u8 intfnum, __u8 cs, void *data, __u16 size);
+/* edit by Ian -- disable uvc clock api*/
+#if 0
+void uvc_video_clock_update(struct uvc_streaming *stream,
+			    struct v4l2_buffer *v4l2_buf,
+			    struct uvc_buffer *buf);
+#endif
+/* Status */
+//#define UVC_STATUS_EN
+#ifdef UVC_STATUS_EN
+extern int uvc_status_init(struct uvc_device *dev);
+extern void uvc_status_cleanup(struct uvc_device *dev);
+extern int uvc_status_start(struct uvc_device *dev, gfp_t flags);
+extern void uvc_status_stop(struct uvc_device *dev);
+#endif
+
+/* Controls */
+extern const struct v4l2_subscribed_event_ops uvc_ctrl_sub_ev_ops;
+
+extern int uvc_query_v4l2_ctrl(struct uvc_video_chain *chain,
+		struct v4l2_queryctrl *v4l2_ctrl);
+extern int uvc_query_v4l2_menu(struct uvc_video_chain *chain,
+		struct v4l2_querymenu *query_menu);
+
+extern int uvc_ctrl_add_mapping(struct uvc_video_chain *chain,
+		const struct uvc_control_mapping *mapping);
+extern int uvc_ctrl_init_device(struct uvc_device *dev);
+extern void uvc_ctrl_cleanup_device(struct uvc_device *dev);
+extern int uvc_ctrl_resume_device(struct uvc_device *dev);
+extern int uvc_ctrl_begin(struct uvc_video_chain *chain);
+extern int __uvc_ctrl_commit(struct uvc_fh *handle, int rollback,
+			const struct v4l2_ext_control *xctrls,
+			unsigned int xctrls_count);
+static inline int uvc_ctrl_commit(struct uvc_fh *handle,
+			const struct v4l2_ext_control *xctrls,
+			unsigned int xctrls_count)
+{
+	return __uvc_ctrl_commit(handle, 0, xctrls, xctrls_count);
+}
+static inline int uvc_ctrl_rollback(struct uvc_fh *handle)
+{
+	return __uvc_ctrl_commit(handle, 1, NULL, 0);
+}
+
+extern int uvc_ctrl_get(struct uvc_video_chain *chain,
+		struct v4l2_ext_control *xctrl);
+extern int uvc_ctrl_set(struct uvc_video_chain *chain,
+		struct v4l2_ext_control *xctrl);
+
+//edit by Ian -- remove uvc_xu_ctrl_query declaration
+//extern int uvc_xu_ctrl_query(struct uvc_video_chain *chain, struct uvc_xu_control_query *xqry);
+
+/* Utility functions */
+extern void uvc_simplify_fraction(uint32_t *numerator, uint32_t *denominator,
+		unsigned int n_terms, unsigned int threshold);
+extern uint32_t uvc_fraction_to_interval(uint32_t numerator,
+		uint32_t denominator);
+extern struct usb_host_endpoint *uvc_find_endpoint(
+		struct usb_host_interface *alts, __u8 epaddr);
+
+/* Quirks support */
+void uvc_video_decode_isight(struct urb *urb, struct uvc_streaming *stream,
+		struct uvc_buffer *buf);
+
+/* debugfs and statistics */
+#if 0
+int uvc_debugfs_init(void);
+void uvc_debugfs_cleanup(void);
+int uvc_debugfs_init_stream(struct uvc_streaming *stream);
+void uvc_debugfs_cleanup_stream(struct uvc_streaming *stream);
+
+size_t uvc_video_stats_dump(struct uvc_streaming *stream, char *buf,
+			    size_t size);
+#endif
+#endif

USDK/component/common/drivers/usb_class/host/uvc/inc/video.h

@@ -0,0 +1,726 @@
+/*
+ * USB Video Class definitions.
+ *
+ * Copyright (C) 2009 Laurent Pinchart <laurent.pinchart@skynet.be>
+ *
+ * This file holds USB constants and structures defined by the USB Device
+ * Class Definition for Video Devices. Unless otherwise stated, comments
+ * below reference relevant sections of the USB Video Class 1.1 specification
+ * available at
+ *
+ * http://www.usb.org/developers/devclass_docs/USB_Video_Class_1_1.zip
+ */
+
+#ifndef __LINUX_USB_VIDEO_H
+#define __LINUX_USB_VIDEO_H
+#if 0
+#include <linux/types.h>
+#endif
+#include "uvc_os_wrap_via_osdep_api.h"
+
+/* --------------------------------------------------------------------------
+ * UVC constants
+ */
+
+/* A.2. Video Interface Subclass Codes */
+#define UVC_SC_UNDEFINED				0x00
+#define UVC_SC_VIDEOCONTROL				0x01
+#define UVC_SC_VIDEOSTREAMING				0x02
+#define UVC_SC_VIDEO_INTERFACE_COLLECTION		0x03
+
+/* A.3. Video Interface Protocol Codes */
+#define UVC_PC_PROTOCOL_UNDEFINED			0x00
+
+/* A.5. Video Class-Specific VC Interface Descriptor Subtypes */
+#define UVC_VC_DESCRIPTOR_UNDEFINED			0x00
+#define UVC_VC_HEADER					0x01
+#define UVC_VC_INPUT_TERMINAL				0x02
+#define UVC_VC_OUTPUT_TERMINAL				0x03
+#define UVC_VC_SELECTOR_UNIT				0x04
+#define UVC_VC_PROCESSING_UNIT				0x05
+#define UVC_VC_EXTENSION_UNIT				0x06
+
+/* A.6. Video Class-Specific VS Interface Descriptor Subtypes */
+#define UVC_VS_UNDEFINED				0x00
+#define UVC_VS_INPUT_HEADER				0x01
+#define UVC_VS_OUTPUT_HEADER				0x02
+#define UVC_VS_STILL_IMAGE_FRAME			0x03
+#define UVC_VS_FORMAT_UNCOMPRESSED			0x04
+#define UVC_VS_FRAME_UNCOMPRESSED			0x05
+#define UVC_VS_FORMAT_MJPEG				0x06
+#define UVC_VS_FRAME_MJPEG				0x07
+#define UVC_VS_FORMAT_MPEG2TS				0x0a
+#define UVC_VS_FORMAT_DV				0x0c
+#define UVC_VS_COLORFORMAT				0x0d
+#define UVC_VS_FORMAT_FRAME_BASED			0x10
+#define UVC_VS_FRAME_FRAME_BASED			0x11
+#define UVC_VS_FORMAT_STREAM_BASED			0x12
+
+/* A.7. Video Class-Specific Endpoint Descriptor Subtypes */
+#define UVC_EP_UNDEFINED				0x00
+#define UVC_EP_GENERAL					0x01
+#define UVC_EP_ENDPOINT					0x02
+#define UVC_EP_INTERRUPT				0x03
+
+/* A.8. Video Class-Specific Request Codes */
+#define UVC_RC_UNDEFINED				0x00
+#define UVC_SET_CUR					0x01
+#define UVC_GET_CUR					0x81
+#define UVC_GET_MIN					0x82
+#define UVC_GET_MAX					0x83
+#define UVC_GET_RES					0x84
+#define UVC_GET_LEN					0x85
+#define UVC_GET_INFO					0x86
+#define UVC_GET_DEF					0x87
+
+/* A.9.1. VideoControl Interface Control Selectors */
+#define UVC_VC_CONTROL_UNDEFINED			0x00
+#define UVC_VC_VIDEO_POWER_MODE_CONTROL			0x01
+#define UVC_VC_REQUEST_ERROR_CODE_CONTROL		0x02
+
+/* A.9.2. Terminal Control Selectors */
+#define UVC_TE_CONTROL_UNDEFINED			0x00
+
+/* A.9.3. Selector Unit Control Selectors */
+#define UVC_SU_CONTROL_UNDEFINED			0x00
+#define UVC_SU_INPUT_SELECT_CONTROL			0x01
+
+/* A.9.4. Camera Terminal Control Selectors */
+#define UVC_CT_CONTROL_UNDEFINED			0x00
+#define UVC_CT_SCANNING_MODE_CONTROL			0x01
+#define UVC_CT_AE_MODE_CONTROL				0x02
+#define UVC_CT_AE_PRIORITY_CONTROL			0x03
+#define UVC_CT_EXPOSURE_TIME_ABSOLUTE_CONTROL		0x04
+#define UVC_CT_EXPOSURE_TIME_RELATIVE_CONTROL		0x05
+#define UVC_CT_FOCUS_ABSOLUTE_CONTROL			0x06
+#define UVC_CT_FOCUS_RELATIVE_CONTROL			0x07
+#define UVC_CT_FOCUS_AUTO_CONTROL			0x08
+#define UVC_CT_IRIS_ABSOLUTE_CONTROL			0x09
+#define UVC_CT_IRIS_RELATIVE_CONTROL			0x0a
+#define UVC_CT_ZOOM_ABSOLUTE_CONTROL			0x0b
+#define UVC_CT_ZOOM_RELATIVE_CONTROL			0x0c
+#define UVC_CT_PANTILT_ABSOLUTE_CONTROL			0x0d
+#define UVC_CT_PANTILT_RELATIVE_CONTROL			0x0e
+#define UVC_CT_ROLL_ABSOLUTE_CONTROL			0x0f
+#define UVC_CT_ROLL_RELATIVE_CONTROL			0x10
+#define UVC_CT_PRIVACY_CONTROL				0x11
+
+/* A.9.5. Processing Unit Control Selectors */
+#define UVC_PU_CONTROL_UNDEFINED			0x00
+#define UVC_PU_BACKLIGHT_COMPENSATION_CONTROL		0x01
+#define UVC_PU_BRIGHTNESS_CONTROL			0x02
+#define UVC_PU_CONTRAST_CONTROL				0x03
+#define UVC_PU_GAIN_CONTROL				0x04
+#define UVC_PU_POWER_LINE_FREQUENCY_CONTROL		0x05
+#define UVC_PU_HUE_CONTROL				0x06
+#define UVC_PU_SATURATION_CONTROL			0x07
+#define UVC_PU_SHARPNESS_CONTROL			0x08
+#define UVC_PU_GAMMA_CONTROL				0x09
+#define UVC_PU_WHITE_BALANCE_TEMPERATURE_CONTROL	0x0a
+#define UVC_PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL	0x0b
+#define UVC_PU_WHITE_BALANCE_COMPONENT_CONTROL		0x0c
+#define UVC_PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL	0x0d
+#define UVC_PU_DIGITAL_MULTIPLIER_CONTROL		0x0e
+#define UVC_PU_DIGITAL_MULTIPLIER_LIMIT_CONTROL		0x0f
+#define UVC_PU_HUE_AUTO_CONTROL				0x10
+#define UVC_PU_ANALOG_VIDEO_STANDARD_CONTROL		0x11
+#define UVC_PU_ANALOG_LOCK_STATUS_CONTROL		0x12
+
+/* A.9.7. VideoStreaming Interface Control Selectors */
+#define UVC_VS_CONTROL_UNDEFINED			0x00
+#define UVC_VS_PROBE_CONTROL				0x01
+#define UVC_VS_COMMIT_CONTROL				0x02
+#define UVC_VS_STILL_PROBE_CONTROL			0x03
+#define UVC_VS_STILL_COMMIT_CONTROL			0x04
+#define UVC_VS_STILL_IMAGE_TRIGGER_CONTROL		0x05
+#define UVC_VS_STREAM_ERROR_CODE_CONTROL		0x06
+#define UVC_VS_GENERATE_KEY_FRAME_CONTROL		0x07
+#define UVC_VS_UPDATE_FRAME_SEGMENT_CONTROL		0x08
+#define UVC_VS_SYNC_DELAY_CONTROL			0x09
+
+/* B.1. USB Terminal Types */
+#define UVC_TT_VENDOR_SPECIFIC				0x0100
+#define UVC_TT_STREAMING				0x0101
+
+/* B.2. Input Terminal Types */
+#define UVC_ITT_VENDOR_SPECIFIC				0x0200
+#define UVC_ITT_CAMERA					0x0201
+#define UVC_ITT_MEDIA_TRANSPORT_INPUT			0x0202
+
+/* B.3. Output Terminal Types */
+#define UVC_OTT_VENDOR_SPECIFIC				0x0300
+#define UVC_OTT_DISPLAY					0x0301
+#define UVC_OTT_MEDIA_TRANSPORT_OUTPUT			0x0302
+
+/* B.4. External Terminal Types */
+#define UVC_EXTERNAL_VENDOR_SPECIFIC			0x0400
+#define UVC_COMPOSITE_CONNECTOR				0x0401
+#define UVC_SVIDEO_CONNECTOR				0x0402
+#define UVC_COMPONENT_CONNECTOR				0x0403
+
+/* 2.4.2.2. Status Packet Type */
+#define UVC_STATUS_TYPE_CONTROL				1
+#define UVC_STATUS_TYPE_STREAMING			2
+
+/* 2.4.3.3. Payload Header Information */
+#define UVC_STREAM_EOH					(1 << 7)
+#define UVC_STREAM_ERR					(1 << 6)
+#define UVC_STREAM_STI					(1 << 5)
+#define UVC_STREAM_RES					(1 << 4)
+#define UVC_STREAM_SCR					(1 << 3)
+#define UVC_STREAM_PTS					(1 << 2)
+#define UVC_STREAM_EOF					(1 << 1)
+#define UVC_STREAM_FID					(1 << 0)
+
+/* 4.1.2. Control Capabilities */
+#define UVC_CONTROL_CAP_GET				(1 << 0)
+#define UVC_CONTROL_CAP_SET				(1 << 1)
+#define UVC_CONTROL_CAP_DISABLED			(1 << 2)
+#define UVC_CONTROL_CAP_AUTOUPDATE			(1 << 3)
+#define UVC_CONTROL_CAP_ASYNCHRONOUS			(1 << 4)
+
+/* ------------------------------------------------------------------------
+ * UVC structures
+ */
+
+/* All UVC descriptors have these 3 fields at the beginning */
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_begin.h"
+#endif
+RTW_PACK_STRUCT_BEGIN
+struct uvc_descriptor_header {
+	__u8  bLength;
+	__u8  bDescriptorType;
+	__u8  bDescriptorSubType;
+} //__attribute__((packed));
+RTW_PACK_STRUCT_STRUCT;
+RTW_PACK_STRUCT_END
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_end.h"
+#endif
+
+/* 3.7.2. Video Control Interface Header Descriptor */
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_begin.h"
+#endif
+RTW_PACK_STRUCT_BEGIN
+struct uvc_header_descriptor {
+	__u8  bLength;
+	__u8  bDescriptorType;
+	__u8  bDescriptorSubType;
+	__u16 bcdUVC;
+	__u16 wTotalLength;
+	__u32 dwClockFrequency;
+	__u8  bInCollection;
+	__u8  baInterfaceNr[];
+} //__attribute__((__packed__));
+RTW_PACK_STRUCT_STRUCT;
+RTW_PACK_STRUCT_END
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_end.h"
+#endif
+
+#define UVC_DT_HEADER_SIZE(n)				(12+(n))
+
+#define UVC_HEADER_DESCRIPTOR(n) \
+	uvc_header_descriptor_##n
+
+#define DECLARE_UVC_HEADER_DESCRIPTOR(n)		\
+struct UVC_HEADER_DESCRIPTOR(n) {			\
+	__u8  bLength;					\
+	__u8  bDescriptorType;				\
+	__u8  bDescriptorSubType;			\
+	__u16 bcdUVC;					\
+	__u16 wTotalLength;				\
+	__u32 dwClockFrequency;				\
+	__u8  bInCollection;				\
+	__u8  baInterfaceNr[n];				\
+} __attribute__ ((packed))
+
+/* 3.7.2.1. Input Terminal Descriptor */
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_begin.h"
+#endif
+RTW_PACK_STRUCT_BEGIN
+struct uvc_input_terminal_descriptor {
+	__u8  bLength;
+	__u8  bDescriptorType;
+	__u8  bDescriptorSubType;
+	__u8  bTerminalID;
+	__u16 wTerminalType;
+	__u8  bAssocTerminal;
+	__u8  iTerminal;
+} //__attribute__((__packed__));
+RTW_PACK_STRUCT_STRUCT;
+RTW_PACK_STRUCT_END
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_end.h"
+#endif
+
+#define UVC_DT_INPUT_TERMINAL_SIZE			8
+
+/* 3.7.2.2. Output Terminal Descriptor */
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_begin.h"
+#endif
+RTW_PACK_STRUCT_BEGIN
+struct uvc_output_terminal_descriptor {
+	__u8  bLength;
+	__u8  bDescriptorType;
+	__u8  bDescriptorSubType;
+	__u8  bTerminalID;
+	__u16 wTerminalType;
+	__u8  bAssocTerminal;
+	__u8  bSourceID;
+	__u8  iTerminal;
+} //__attribute__((__packed__));
+RTW_PACK_STRUCT_STRUCT;
+RTW_PACK_STRUCT_END
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_end.h"
+#endif
+
+#define UVC_DT_OUTPUT_TERMINAL_SIZE			9
+
+/* 3.7.2.3. Camera Terminal Descriptor */
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_begin.h"
+#endif
+RTW_PACK_STRUCT_BEGIN
+struct uvc_camera_terminal_descriptor {
+	__u8  bLength;
+	__u8  bDescriptorType;
+	__u8  bDescriptorSubType;
+	__u8  bTerminalID;
+	__u16 wTerminalType;
+	__u8  bAssocTerminal;
+	__u8  iTerminal;
+	__u16 wObjectiveFocalLengthMin;
+	__u16 wObjectiveFocalLengthMax;
+	__u16 wOcularFocalLength;
+	__u8  bControlSize;
+	__u8  bmControls[3];
+} //__attribute__((__packed__));
+RTW_PACK_STRUCT_STRUCT;
+RTW_PACK_STRUCT_END
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_end.h"
+#endif
+
+#define UVC_DT_CAMERA_TERMINAL_SIZE(n)			(15+(n))
+
+/* 3.7.2.4. Selector Unit Descriptor */
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_begin.h"
+#endif
+RTW_PACK_STRUCT_BEGIN
+struct uvc_selector_unit_descriptor {
+	__u8  bLength;
+	__u8  bDescriptorType;
+	__u8  bDescriptorSubType;
+	__u8  bUnitID;
+	__u8  bNrInPins;
+//	__u8  baSourceID[0];
+        __u8 * baSourceID;
+	__u8  iSelector;
+} //__attribute__((__packed__));
+RTW_PACK_STRUCT_STRUCT;
+RTW_PACK_STRUCT_END
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_end.h"
+#endif
+
+#define UVC_DT_SELECTOR_UNIT_SIZE(n)			(6+(n))
+
+#define UVC_SELECTOR_UNIT_DESCRIPTOR(n)	\
+	uvc_selector_unit_descriptor_##n
+
+#define DECLARE_UVC_SELECTOR_UNIT_DESCRIPTOR(n)	\
+struct UVC_SELECTOR_UNIT_DESCRIPTOR(n) {		\
+	__u8  bLength;					\
+	__u8  bDescriptorType;				\
+	__u8  bDescriptorSubType;			\
+	__u8  bUnitID;					\
+	__u8  bNrInPins;				\
+	__u8  baSourceID[n];				\
+	__u8  iSelector;				\
+} __attribute__ ((packed))
+
+/* 3.7.2.5. Processing Unit Descriptor */
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_begin.h"
+#endif
+RTW_PACK_STRUCT_BEGIN
+struct uvc_processing_unit_descriptor {
+	__u8  bLength;
+	__u8  bDescriptorType;
+	__u8  bDescriptorSubType;
+	__u8  bUnitID;
+	__u8  bSourceID;
+	__u16 wMaxMultiplier;
+	__u8  bControlSize;
+	__u8  bmControls[2];
+	__u8  iProcessing;
+} //__attribute__((__packed__));
+RTW_PACK_STRUCT_STRUCT;
+RTW_PACK_STRUCT_END
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_end.h"
+#endif
+
+#define UVC_DT_PROCESSING_UNIT_SIZE(n)			(9+(n))
+
+/* 3.7.2.6. Extension Unit Descriptor */
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_begin.h"
+#endif
+RTW_PACK_STRUCT_BEGIN
+struct uvc_extension_unit_descriptor {
+	__u8  bLength;
+	__u8  bDescriptorType;
+	__u8  bDescriptorSubType;
+	__u8  bUnitID;
+	__u8  guidExtensionCode[16];
+	__u8  bNumControls;
+	__u8  bNrInPins;
+//	__u8  baSourceID[0];
+        __u8 * baSourceID;
+	__u8  bControlSize;
+//	__u8  bmControls[0];
+        __u8 * bmControls;
+	__u8  iExtension;
+} //__attribute__((__packed__));
+RTW_PACK_STRUCT_STRUCT;
+RTW_PACK_STRUCT_END
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_end.h"
+#endif
+
+#define UVC_DT_EXTENSION_UNIT_SIZE(p, n)		(24+(p)+(n))
+
+#define UVC_EXTENSION_UNIT_DESCRIPTOR(p, n) \
+	uvc_extension_unit_descriptor_##p_##n
+
+#define DECLARE_UVC_EXTENSION_UNIT_DESCRIPTOR(p, n)	\
+struct UVC_EXTENSION_UNIT_DESCRIPTOR(p, n) {		\
+	__u8  bLength;					\
+	__u8  bDescriptorType;				\
+	__u8  bDescriptorSubType;			\
+	__u8  bUnitID;					\
+	__u8  guidExtensionCode[16];			\
+	__u8  bNumControls;				\
+	__u8  bNrInPins;				\
+	__u8  baSourceID[p];				\
+	__u8  bControlSize;				\
+	__u8  bmControls[n];				\
+	__u8  iExtension;				\
+} __attribute__ ((packed))
+
+/* 3.8.2.2. Video Control Interrupt Endpoint Descriptor */
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_begin.h"
+#endif
+RTW_PACK_STRUCT_BEGIN
+struct uvc_control_endpoint_descriptor {
+	__u8  bLength;
+	__u8  bDescriptorType;
+	__u8  bDescriptorSubType;
+	__u16 wMaxTransferSize;
+} //__attribute__((__packed__));
+RTW_PACK_STRUCT_STRUCT;
+RTW_PACK_STRUCT_END
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_end.h"
+#endif
+
+#define UVC_DT_CONTROL_ENDPOINT_SIZE			5
+
+/* 3.9.2.1. Input Header Descriptor */
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_begin.h"
+#endif
+RTW_PACK_STRUCT_BEGIN
+struct uvc_input_header_descriptor {
+	__u8  bLength;
+	__u8  bDescriptorType;
+	__u8  bDescriptorSubType;
+	__u8  bNumFormats;
+	__u16 wTotalLength;
+	__u8  bEndpointAddress;
+	__u8  bmInfo;
+	__u8  bTerminalLink;
+	__u8  bStillCaptureMethod;
+	__u8  bTriggerSupport;
+	__u8  bTriggerUsage;
+	__u8  bControlSize;
+	__u8  bmaControls[];
+} //__attribute__((__packed__));
+RTW_PACK_STRUCT_STRUCT;
+RTW_PACK_STRUCT_END
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_end.h"
+#endif
+
+#define UVC_DT_INPUT_HEADER_SIZE(n, p)			(13+(n*p))
+
+#define UVC_INPUT_HEADER_DESCRIPTOR(n, p) \
+	uvc_input_header_descriptor_##n_##p
+
+#define DECLARE_UVC_INPUT_HEADER_DESCRIPTOR(n, p)	\
+struct UVC_INPUT_HEADER_DESCRIPTOR(n, p) {		\
+	__u8  bLength;					\
+	__u8  bDescriptorType;				\
+	__u8  bDescriptorSubType;			\
+	__u8  bNumFormats;				\
+	__u16 wTotalLength;				\
+	__u8  bEndpointAddress;				\
+	__u8  bmInfo;					\
+	__u8  bTerminalLink;				\
+	__u8  bStillCaptureMethod;			\
+	__u8  bTriggerSupport;				\
+	__u8  bTriggerUsage;				\
+	__u8  bControlSize;				\
+	__u8  bmaControls[p][n];			\
+} __attribute__ ((packed))
+
+/* 3.9.2.2. Output Header Descriptor */
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_begin.h"
+#endif
+RTW_PACK_STRUCT_BEGIN
+struct uvc_output_header_descriptor {
+	__u8  bLength;
+	__u8  bDescriptorType;
+	__u8  bDescriptorSubType;
+	__u8  bNumFormats;
+	__u16 wTotalLength;
+	__u8  bEndpointAddress;
+	__u8  bTerminalLink;
+	__u8  bControlSize;
+	__u8  bmaControls[];
+} //__attribute__((__packed__));
+RTW_PACK_STRUCT_STRUCT;
+RTW_PACK_STRUCT_END
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_end.h"
+#endif
+
+#define UVC_DT_OUTPUT_HEADER_SIZE(n, p)			(9+(n*p))
+
+#define UVC_OUTPUT_HEADER_DESCRIPTOR(n, p) \
+	uvc_output_header_descriptor_##n_##p
+
+#define DECLARE_UVC_OUTPUT_HEADER_DESCRIPTOR(n, p)	\
+struct UVC_OUTPUT_HEADER_DESCRIPTOR(n, p) {		\
+	__u8  bLength;					\
+	__u8  bDescriptorType;				\
+	__u8  bDescriptorSubType;			\
+	__u8  bNumFormats;				\
+	__u16 wTotalLength;				\
+	__u8  bEndpointAddress;				\
+	__u8  bTerminalLink;				\
+	__u8  bControlSize;				\
+	__u8  bmaControls[p][n];			\
+} __attribute__ ((packed))
+
+/* 3.9.2.6. Color matching descriptor */
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_begin.h"
+#endif
+RTW_PACK_STRUCT_BEGIN
+struct uvc_color_matching_descriptor {
+	__u8  bLength;
+	__u8  bDescriptorType;
+	__u8  bDescriptorSubType;
+	__u8  bColorPrimaries;
+	__u8  bTransferCharacteristics;
+	__u8  bMatrixCoefficients;
+} //__attribute__((__packed__));
+RTW_PACK_STRUCT_STRUCT;
+RTW_PACK_STRUCT_END
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_end.h"
+#endif
+
+#define UVC_DT_COLOR_MATCHING_SIZE			6
+
+/* 4.3.1.1. Video Probe and Commit Controls */
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_begin.h"
+#endif
+RTW_PACK_STRUCT_BEGIN
+struct uvc_streaming_control {
+	__u16 bmHint;
+	__u8  bFormatIndex;
+	__u8  bFrameIndex;
+	__u32 dwFrameInterval;
+	__u16 wKeyFrameRate;
+	__u16 wPFrameRate;
+	__u16 wCompQuality;
+	__u16 wCompWindowSize;
+	__u16 wDelay;
+	__u32 dwMaxVideoFrameSize;
+	__u32 dwMaxPayloadTransferSize;
+	__u32 dwClockFrequency;
+	__u8  bmFramingInfo;
+	__u8  bPreferedVersion;
+	__u8  bMinVersion;
+	__u8  bMaxVersion;
+} //__attribute__((__packed__));
+RTW_PACK_STRUCT_STRUCT;
+RTW_PACK_STRUCT_END
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_end.h"
+#endif
+
+/* Uncompressed Payload - 3.1.1. Uncompressed Video Format Descriptor */
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_begin.h"
+#endif
+RTW_PACK_STRUCT_BEGIN
+struct uvc_format_uncompressed {
+	__u8  bLength;
+	__u8  bDescriptorType;
+	__u8  bDescriptorSubType;
+	__u8  bFormatIndex;
+	__u8  bNumFrameDescriptors;
+	__u8  guidFormat[16];
+	__u8  bBitsPerPixel;
+	__u8  bDefaultFrameIndex;
+	__u8  bAspectRatioX;
+	__u8  bAspectRatioY;
+	__u8  bmInterfaceFlags;
+	__u8  bCopyProtect;
+} //__attribute__((__packed__));
+RTW_PACK_STRUCT_STRUCT;
+RTW_PACK_STRUCT_END
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_end.h"
+#endif
+
+#define UVC_DT_FORMAT_UNCOMPRESSED_SIZE			27
+
+/* Uncompressed Payload - 3.1.2. Uncompressed Video Frame Descriptor */
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_begin.h"
+#endif
+RTW_PACK_STRUCT_BEGIN
+struct uvc_frame_uncompressed {
+	__u8  bLength;
+	__u8  bDescriptorType;
+	__u8  bDescriptorSubType;
+	__u8  bFrameIndex;
+	__u8  bmCapabilities;
+	__u16 wWidth;
+	__u16 wHeight;
+	__u32 dwMinBitRate;
+	__u32 dwMaxBitRate;
+	__u32 dwMaxVideoFrameBufferSize;
+	__u32 dwDefaultFrameInterval;
+	__u8  bFrameIntervalType;
+	__u32 dwFrameInterval[];
+} //__attribute__((__packed__));
+RTW_PACK_STRUCT_STRUCT;
+RTW_PACK_STRUCT_END
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_end.h"
+#endif
+
+#define UVC_DT_FRAME_UNCOMPRESSED_SIZE(n)		(26+4*(n))
+
+#define UVC_FRAME_UNCOMPRESSED(n) \
+	uvc_frame_uncompressed_##n
+
+#define DECLARE_UVC_FRAME_UNCOMPRESSED(n)		\
+struct UVC_FRAME_UNCOMPRESSED(n) {			\
+	__u8  bLength;					\
+	__u8  bDescriptorType;				\
+	__u8  bDescriptorSubType;			\
+	__u8  bFrameIndex;				\
+	__u8  bmCapabilities;				\
+	__u16 wWidth;					\
+	__u16 wHeight;					\
+	__u32 dwMinBitRate;				\
+	__u32 dwMaxBitRate;				\
+	__u32 dwMaxVideoFrameBufferSize;		\
+	__u32 dwDefaultFrameInterval;			\
+	__u8  bFrameIntervalType;			\
+	__u32 dwFrameInterval[n];			\
+} __attribute__ ((packed))
+
+/* MJPEG Payload - 3.1.1. MJPEG Video Format Descriptor */
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_begin.h"
+#endif
+RTW_PACK_STRUCT_BEGIN
+struct uvc_format_mjpeg {
+	__u8  bLength;
+	__u8  bDescriptorType;
+	__u8  bDescriptorSubType;
+	__u8  bFormatIndex;
+	__u8  bNumFrameDescriptors;
+	__u8  bmFlags;
+	__u8  bDefaultFrameIndex;
+	__u8  bAspectRatioX;
+	__u8  bAspectRatioY;
+	__u8  bmInterfaceFlags;
+	__u8  bCopyProtect;
+} //__attribute__((__packed__));
+RTW_PACK_STRUCT_STRUCT;
+RTW_PACK_STRUCT_END
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_end.h"
+#endif
+
+#define UVC_DT_FORMAT_MJPEG_SIZE			11
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_begin.h"
+#endif
+RTW_PACK_STRUCT_BEGIN
+/* MJPEG Payload - 3.1.2. MJPEG Video Frame Descriptor */
+
+struct uvc_frame_mjpeg {
+	__u8  bLength;
+	__u8  bDescriptorType;
+	__u8  bDescriptorSubType;
+	__u8  bFrameIndex;
+	__u8  bmCapabilities;
+	__u16 wWidth;
+	__u16 wHeight;
+	__u32 dwMinBitRate;
+	__u32 dwMaxBitRate;
+	__u32 dwMaxVideoFrameBufferSize;
+	__u32 dwDefaultFrameInterval;
+	__u8  bFrameIntervalType;
+	__u32 dwFrameInterval[];
+} //__attribute__((__packed__));
+RTW_PACK_STRUCT_STRUCT;
+RTW_PACK_STRUCT_END
+#ifdef RTW_PACK_STRUCT_USE_INCLUDES
+#  include "pack_end.h"
+#endif
+
+#define UVC_DT_FRAME_MJPEG_SIZE(n)			(26+4*(n))
+
+#define UVC_FRAME_MJPEG(n) \
+	uvc_frame_mjpeg_##n
+
+#define DECLARE_UVC_FRAME_MJPEG(n)			\
+struct UVC_FRAME_MJPEG(n) {				\
+	__u8  bLength;					\
+	__u8  bDescriptorType;				\
+	__u8  bDescriptorSubType;			\
+	__u8  bFrameIndex;				\
+	__u8  bmCapabilities;				\
+	__u16 wWidth;					\
+	__u16 wHeight;					\
+	__u32 dwMinBitRate;				\
+	__u32 dwMaxBitRate;				\
+	__u32 dwMaxVideoFrameBufferSize;		\
+	__u32 dwDefaultFrameInterval;			\
+	__u8  bFrameIntervalType;			\
+	__u32 dwFrameInterval[n];			\
+} __attribute__ ((packed))
+
+#endif /* __LINUX_USB_VIDEO_H */
+

USDK/component/common/drivers/wlan/realtek/include/HalPwrSeqCmd.h

@@ -0,0 +1,136 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef __HALPWRSEQCMD_H__
+#define __HALPWRSEQCMD_H__
+
+/*---------------------------------------------*/
+//3 The value of cmd: 4 bits
+/*---------------------------------------------*/
+#define PWR_CMD_READ			0x00
+     // offset: the read register offset
+     // msk: the mask of the read value
+     // value: N/A, left by 0
+     // note: dirver shall implement this function by read & msk
+
+#define PWR_CMD_WRITE			0x01
+     // offset: the read register offset
+     // msk: the mask of the write bits
+     // value: write value
+     // note: driver shall implement this cmd by read & msk after write
+
+#define PWR_CMD_POLLING			0x02
+     // offset: the read register offset
+     // msk: the mask of the polled value
+     // value: the value to be polled, masked by the msd field.
+     // note: driver shall implement this cmd by
+     // do{
+     // if( (Read(offset) & msk) == (value & msk) )
+     // break;
+     // } while(not timeout);
+
+#define PWR_CMD_DELAY			0x03
+     // offset: the value to delay
+     // msk: N/A
+     // value: the unit of delay, 0: us, 1: ms
+
+#define PWR_CMD_END				0x04
+     // offset: N/A
+     // msk: N/A
+     // value: N/A
+
+/*---------------------------------------------*/
+//3 The value of base: 4 bits
+/*---------------------------------------------*/
+   // define the base address of each block
+#define PWR_BASEADDR_MAC		0x00
+#define PWR_BASEADDR_USB		0x01
+#define PWR_BASEADDR_PCIE		0x02
+#define PWR_BASEADDR_SDIO		0x03
+
+/*---------------------------------------------*/
+//3 The value of interface_msk: 4 bits
+/*---------------------------------------------*/
+#define	PWR_INTF_SDIO_MSK		BIT(0)
+#define	PWR_INTF_USB_MSK		BIT(1)
+#define	PWR_INTF_PCI_MSK		BIT(2)
+#define	PWR_INTF_ALL_MSK		(BIT(0)|BIT(1)|BIT(2)|BIT(3))
+
+/*---------------------------------------------*/
+//3 The value of fab_msk: 4 bits
+/*---------------------------------------------*/
+#define	PWR_FAB_TSMC_MSK		BIT(0)
+#define	PWR_FAB_UMC_MSK			BIT(1)
+#define	PWR_FAB_ALL_MSK			(BIT(0)|BIT(1)|BIT(2)|BIT(3))
+
+/*---------------------------------------------*/
+//3 The value of cut_msk: 8 bits
+/*---------------------------------------------*/
+#define	PWR_CUT_TESTCHIP_MSK	BIT(0)
+#define	PWR_CUT_A_MSK			BIT(1)
+#define	PWR_CUT_B_MSK			BIT(2)
+#define	PWR_CUT_C_MSK			BIT(3)
+#define	PWR_CUT_D_MSK			BIT(4)
+#define	PWR_CUT_E_MSK			BIT(5)
+#define	PWR_CUT_F_MSK			BIT(6)
+#define	PWR_CUT_G_MSK			BIT(7)
+#define	PWR_CUT_ALL_MSK			0xFF
+
+
+typedef enum _PWRSEQ_CMD_DELAY_UNIT_
+{
+	PWRSEQ_DELAY_US,
+	PWRSEQ_DELAY_MS,
+} PWRSEQ_DELAY_UNIT;
+
+typedef struct _WL_PWR_CFG_
+{
+	u16 offset;
+	u8 cut_msk;
+	u8 fab_msk:4;
+	u8 interface_msk:4;
+	u8 base:4;
+	u8 cmd:4;
+	u8 msk;
+	u8 value;
+} WLAN_PWR_CFG, *PWLAN_PWR_CFG;
+
+
+#define GET_PWR_CFG_OFFSET(__PWR_CMD)		__PWR_CMD.offset
+#define GET_PWR_CFG_CUT_MASK(__PWR_CMD)		__PWR_CMD.cut_msk
+#define GET_PWR_CFG_FAB_MASK(__PWR_CMD)		__PWR_CMD.fab_msk
+#define GET_PWR_CFG_INTF_MASK(__PWR_CMD)	__PWR_CMD.interface_msk
+#define GET_PWR_CFG_BASE(__PWR_CMD)			__PWR_CMD.base
+#define GET_PWR_CFG_CMD(__PWR_CMD)			__PWR_CMD.cmd
+#define GET_PWR_CFG_MASK(__PWR_CMD)			__PWR_CMD.msk
+#define GET_PWR_CFG_VALUE(__PWR_CMD)		__PWR_CMD.value
+
+
+//================================================================================
+//	Prototype of protected function.
+//================================================================================
+u8 HalPwrSeqCmdParsing(
+	_adapter *		padapter,
+	u8				CutVersion,
+	u8				FabVersion,
+	u8				InterfaceType,
+	WLAN_PWR_CFG	PwrCfgCmd[]);
+
+#endif
+

USDK/component/common/drivers/wlan/realtek/include/HalVerDef.h

@@ -0,0 +1,178 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef __HAL_VERSION_DEF_H__
+#define __HAL_VERSION_DEF_H__
+
+#ifndef TRUE
+#define TRUE 	_TRUE	
+#endif
+#ifndef FALSE
+#define FALSE	_FALSE
+#endif
+
+// HAL_IC_TYPE_E
+typedef enum tag_HAL_IC_Type_Definition
+{
+	CHIP_8192S	=	0,
+	CHIP_8188C	=	1,
+	CHIP_8192C	=	2,
+	CHIP_8192D	=	3,
+	CHIP_8723A	=	4,
+	CHIP_8188E	=	5,
+	CHIP_8812	=	6,
+	CHIP_8821	=	7,
+	CHIP_8723B 	=	8,
+	CHIP_8192E 	=	9,
+	CHIP_8195A =	10,
+	CHIP_8710B =    11,
+	CHIP_8188F = 	12,
+}HAL_IC_TYPE_E;
+
+//HAL_CHIP_TYPE_E
+typedef enum tag_HAL_CHIP_Type_Definition
+{
+	TEST_CHIP 		=	0,
+	NORMAL_CHIP 	=	1,
+	FPGA			=	2,
+}HAL_CHIP_TYPE_E;
+
+//HAL_CUT_VERSION_E
+typedef enum tag_HAL_Cut_Version_Definition
+{
+	A_CUT_VERSION 		=	0,
+	B_CUT_VERSION 		=	1,
+	C_CUT_VERSION 		=	2,
+	D_CUT_VERSION 		=	3,
+	E_CUT_VERSION 		=	4,
+	F_CUT_VERSION 		=	5,
+	G_CUT_VERSION 		=	6,
+	H_CUT_VERSION 		=	7,	
+	I_CUT_VERSION 		=	8,
+	J_CUT_VERSION 		=	9,
+	K_CUT_VERSION 		=	10,
+}HAL_CUT_VERSION_E;
+
+// HAL_Manufacturer
+typedef enum tag_HAL_Manufacturer_Version_Definition
+{
+	CHIP_VENDOR_TSMC 	=	0,
+	CHIP_VENDOR_UMC 	=	1,
+	CHIP_VENDOR_SMIC 	=	2,
+}HAL_VENDOR_E;
+
+typedef enum tag_HAL_RF_Type_Definition
+{
+	RF_TYPE_1T1R 	=	0,
+	RF_TYPE_1T2R 	=	1,
+	RF_TYPE_2T2R	=	2,
+	RF_TYPE_2T3R	=	3,
+	RF_TYPE_2T4R	=	4,
+	RF_TYPE_3T3R	=	5,
+	RF_TYPE_3T4R	=	6,
+	RF_TYPE_4T4R	=	7,
+}HAL_RF_TYPE_E;
+
+typedef	struct tag_HAL_VERSION
+{
+	HAL_IC_TYPE_E		ICType;
+	HAL_CHIP_TYPE_E		ChipType;
+	HAL_CUT_VERSION_E	CUTVersion;
+	HAL_VENDOR_E		VendorType;
+	HAL_RF_TYPE_E		RFType;	
+	u8					ROMVer;
+}HAL_VERSION,*PHAL_VERSION;
+
+//VERSION_8192C			VersionID;
+//HAL_VERSION			VersionID;
+
+// Get element
+#define GET_CVID_IC_TYPE(version)			((HAL_IC_TYPE_E)((version).ICType)	)
+#define GET_CVID_CHIP_TYPE(version)			((HAL_CHIP_TYPE_E)((version).ChipType)	)
+#define GET_CVID_RF_TYPE(version)			((HAL_RF_TYPE_E)((version).RFType))
+#define GET_CVID_MANUFACTUER(version)		((HAL_VENDOR_E)((version).VendorType))
+#define GET_CVID_CUT_VERSION(version)		((HAL_CUT_VERSION_E)((version).CUTVersion))
+#define GET_CVID_ROM_VERSION(version)		(((version).ROMVer) & ROM_VERSION_MASK)
+
+//----------------------------------------------------------------------------
+//Common Macro. --
+//----------------------------------------------------------------------------
+//HAL_VERSION VersionID
+
+// HAL_IC_TYPE_E
+#define IS_81XXC(version)				(((GET_CVID_IC_TYPE(version) == CHIP_8192C)||(GET_CVID_IC_TYPE(version) == CHIP_8188C))? TRUE : FALSE)
+#define IS_8723_SERIES(version)			((GET_CVID_IC_TYPE(version) == CHIP_8723A)? TRUE : FALSE)
+#define IS_92D(version)					((GET_CVID_IC_TYPE(version) == CHIP_8192D)? TRUE : FALSE)
+#define IS_8188E(version)					((GET_CVID_IC_TYPE(version) == CHIP_8188E)? TRUE : FALSE)
+#define IS_8192E(version)					((GET_CVID_IC_TYPE(version) == CHIP_8192E)? TRUE : FALSE)
+#define IS_8812_SERIES(version)			((GET_CVID_IC_TYPE(version) == CHIP_8812)? TRUE : FALSE)
+#define IS_8821_SERIES(version)			((GET_CVID_IC_TYPE(version) == CHIP_8821)? TRUE : FALSE)
+#define IS_8723B_SERIES(version)			((GET_CVID_IC_TYPE(version) == CHIP_8723B)? TRUE : FALSE)
+#define IS_8710B_SERIES(version)			((GET_CVID_IC_TYPE(version) == CHIP_8710B)? TRUE : FALSE)
+#define IS_8188F(version)					((GET_CVID_IC_TYPE(version) == CHIP_8188F)? TRUE : FALSE)
+
+//HAL_CHIP_TYPE_E
+#define IS_TEST_CHIP(version)			((GET_CVID_CHIP_TYPE(version)==TEST_CHIP)? TRUE: FALSE)
+#define IS_NORMAL_CHIP(version)			((GET_CVID_CHIP_TYPE(version)==NORMAL_CHIP)? TRUE: FALSE)
+
+//HAL_CUT_VERSION_E
+#define IS_A_CUT(version)				((GET_CVID_CUT_VERSION(version) == A_CUT_VERSION) ? TRUE : FALSE)
+#define IS_B_CUT(version)				((GET_CVID_CUT_VERSION(version) == B_CUT_VERSION) ? TRUE : FALSE)
+#define IS_C_CUT(version)				((GET_CVID_CUT_VERSION(version) == C_CUT_VERSION) ? TRUE : FALSE)
+#define IS_D_CUT(version)				((GET_CVID_CUT_VERSION(version) == D_CUT_VERSION) ? TRUE : FALSE)
+#define IS_E_CUT(version)				((GET_CVID_CUT_VERSION(version) == E_CUT_VERSION) ? TRUE : FALSE)
+#define IS_I_CUT(version)				((GET_CVID_CUT_VERSION(version) == I_CUT_VERSION) ? TRUE : FALSE)
+#define IS_J_CUT(version)				((GET_CVID_CUT_VERSION(version) == J_CUT_VERSION) ? TRUE : FALSE)
+#define IS_K_CUT(version)				((GET_CVID_CUT_VERSION(version) == K_CUT_VERSION) ? TRUE : FALSE)
+
+//HAL_VENDOR_E
+#define IS_CHIP_VENDOR_TSMC(version)	((GET_CVID_MANUFACTUER(version) == CHIP_VENDOR_TSMC)? TRUE: FALSE)
+#define IS_CHIP_VENDOR_UMC(version)	((GET_CVID_MANUFACTUER(version) == CHIP_VENDOR_UMC)? TRUE: FALSE)
+#define IS_CHIP_VENDOR_SMIC(version)	((GET_CVID_MANUFACTUER(version) == CHIP_VENDOR_SMIC)? TRUE: FALSE)
+
+//HAL_RF_TYPE_E
+#define IS_1T1R(version)					((GET_CVID_RF_TYPE(version) == RF_TYPE_1T1R)? TRUE : FALSE )
+#define IS_1T2R(version)					((GET_CVID_RF_TYPE(version) == RF_TYPE_1T2R)? TRUE : FALSE)
+#define IS_2T2R(version)					((GET_CVID_RF_TYPE(version) == RF_TYPE_2T2R)? TRUE : FALSE)
+
+
+//----------------------------------------------------------------------------
+//Chip version Macro. --
+//----------------------------------------------------------------------------
+#define IS_81XXC_TEST_CHIP(version)		((IS_81XXC(version) && (!IS_NORMAL_CHIP(version)))? TRUE: FALSE)
+
+#define IS_92C_SERIAL(version)   					((IS_81XXC(version) && IS_2T2R(version)) ? TRUE : FALSE)
+#define IS_81xxC_VENDOR_UMC_A_CUT(version)	(IS_81XXC(version)?(IS_CHIP_VENDOR_UMC(version) ? (IS_A_CUT(version) ? TRUE : FALSE) : FALSE): FALSE)
+#define IS_81xxC_VENDOR_UMC_B_CUT(version)	(IS_81XXC(version)?(IS_CHIP_VENDOR_UMC(version) ? (IS_B_CUT(version) ? TRUE : FALSE) : FALSE): FALSE)
+#define IS_81xxC_VENDOR_UMC_C_CUT(version)	(IS_81XXC(version)?(IS_CHIP_VENDOR_UMC(version) ? (IS_C_CUT(version) ? TRUE : FALSE) : FALSE): FALSE)
+
+#define IS_NORMAL_CHIP92D(version)		(( IS_92D(version))?((GET_CVID_CHIP_TYPE(version)==NORMAL_CHIP)? TRUE: FALSE):FALSE)
+
+#define IS_92D_SINGLEPHY(version)		((IS_92D(version)) ? (IS_2T2R(version) ? TRUE: FALSE) : FALSE)
+#define IS_92D_C_CUT(version)			((IS_92D(version)) ? (IS_C_CUT(version) ? TRUE : FALSE) : FALSE)
+#define IS_92D_D_CUT(version)			((IS_92D(version)) ? (IS_D_CUT(version) ? TRUE : FALSE) : FALSE)
+#define IS_92D_E_CUT(version)			((IS_92D(version)) ? (IS_E_CUT(version) ? TRUE : FALSE) : FALSE)
+
+#define IS_8723A_A_CUT(version)				((IS_8723_SERIES(version)) ? ( IS_A_CUT(version)?TRUE : FALSE) : FALSE)
+#define IS_8723A_B_CUT(version)				((IS_8723_SERIES(version)) ? ( IS_B_CUT(version)?TRUE : FALSE) : FALSE)
+
+#define IS_VENDOR_8188E_I_CUT_SERIES(_Adapter)		((IS_8188E(GET_HAL_DATA(_Adapter)->VersionID)) ? ((GET_CVID_CUT_VERSION(GET_HAL_DATA(_Adapter)->VersionID) >= I_CUT_VERSION) ? TRUE : FALSE) : FALSE)
+
+#endif
+

USDK/component/common/drivers/wlan/realtek/include/autoconf.h

@@ -0,0 +1,515 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef WLANCONFIG_H
+#define WLANCONFIG_H
+
+/*
+ * Include user defined options first. Anything not defined in these files
+ * will be set to standard values. Override anything you dont like!
+ */
+#if defined(CONFIG_PLATFORM_8195A) || defined(CONFIG_PLATFORM_8711B) || defined(CONFIG_HARDWARE_8188F)
+#include "platform_opts.h"
+#endif
+
+#if defined(CONFIG_PLATFORM_8195A) || defined(CONFIG_PLATFORM_8711B)
+#define CONFIG_PLATFORM_AMEBA_X
+#endif
+
+#if !defined(CONFIG_PLATFORM_AMEBA_X)
+#define PLATFORM_FREERTOS 	1
+#define CONFIG_GSPI_HCI
+#else
+#define CONFIG_LX_HCI
+#endif
+
+#ifndef CONFIG_INIC_EN
+#define CONFIG_INIC_EN 0 //For iNIC project
+#endif
+
+#if CONFIG_INIC_EN
+#define CONFIG_LWIP_LAYER    0
+#endif
+
+#define CONFIG_LITTLE_ENDIAN
+#define CONFIG_80211N_HT 
+//#define CONFIG_RECV_REORDERING_CTRL
+#define RTW_NOTCH_FILTER 0
+#define CONFIG_EMBEDDED_FWIMG
+#define CONFIG_PHY_SETTING_WITH_ODM
+#if !defined(CONFIG_PLATFORM_AMEBA_X)
+#define CONFIG_ODM_REFRESH_RAMASK
+#define HAL_MAC_ENABLE 1
+#define HAL_BB_ENABLE 1
+#define HAL_RF_ENABLE 1
+#endif
+#if defined(CONFIG_PLATFORM_AMEBA_X)
+/* Patch when dynamic mechanism is not ready */
+//#define CONFIG_DM_PATCH
+#endif
+
+//#define CONFIG_DEBUG
+//#define CONFIG_DEBUG_RTL871X
+#if defined(CONFIG_PLATFORM_AMEBA_X)
+	#define CONFIG_MEM_MONITOR	MEM_MONITOR_SIMPLE
+	#define WLAN_INTF_DBG		0 
+	//#define CONFIG_DEBUG_DYNAMIC
+	//#define DBG_TX 1
+	//#define DBG_XMIT_BUF 1
+	//#define DBG_XMIT_BUF_EXT 1
+	#define DBG_TX_DROP_FRAME
+#else
+	#define CONFIG_MEM_MONITOR	MEM_MONITOR_LEAK
+	//#define CONFIG_TRACE_SKB
+	//#define WLAN_INTF_DBG
+#endif // CONFIG_PLATFORM_AMEBA_X
+
+//#define CONFIG_DONT_CARE_TP
+//#define CONFIG_HIGH_TP
+//#define CONFIG_MEMORY_ACCESS_ALIGNED
+#ifndef PLATFORM_CMSIS_RTOS  // unsupported feature
+#define CONFIG_POWER_SAVING
+#endif
+#ifdef CONFIG_POWER_SAVING
+	#define CONFIG_IPS
+	#define CONFIG_LPS
+	//#define CONFIG_LPS_LCLK
+	#define CONFIG_LPS_32K
+	#define TDMA_POWER_SAVING
+	#define CONFIG_WAIT_PS_ACK
+#endif
+
+#define BAD_MIC_COUNTERMEASURE 1
+#define DEFRAGMENTATION 1
+
+#define WIFI_LOGO_CERTIFICATION 0
+#if WIFI_LOGO_CERTIFICATION
+    #define RX_AGGREGATION 1
+	#define RX_AMSDU 1
+#else
+    #define RX_AGGREGATION 0
+	#define RX_AMSDU 0
+#endif
+
+#if defined(CONFIG_PLATFORM_AMEBA_X)
+	#if !defined(CONFIG_PLATFORM_8711B)
+	 #ifndef CONFIG_USE_TCM_HEAP
+		#define CONFIG_USE_TCM_HEAP 1					/* USE TCM HEAP */
+	 #endif
+	#endif
+	#define CONFIG_RECV_TASKLET_THREAD
+	#define CONFIG_XMIT_TASKLET_THREAD
+#else
+	#define CONFIG_XMIT_THREAD_MODE
+#endif // CONFIG_PLATFORM_AMEBA_X
+//#define CONFIG_RECV_THREAD_MODE				/* Wlan IRQ Polling  Mode*/
+//#define CONFIG_ISR_THREAD_MODE_POLLING		/* Wlan IRQ Polling  Mode*/
+
+//1 Chris
+#ifndef CONFIG_SDIO_HCI
+#define CONFIG_ISR_THREAD_MODE_INTERRUPT	/* Wlan IRQ Interrupt  Mode*/
+#endif
+
+#if defined(CONFIG_ISR_THREAD_MODE_POLLING) && defined(CONFIG_ISR_THREAD_MODE_INTERRUPT)
+#error "CONFIG_ISR_THREAD_MODE_POLLING and CONFIG_ISR_THREAD_MODE_INTERRUPT are mutually exclusive. "
+#endif
+
+#if defined(CONFIG_PLATFORM_AMEBA_X)
+/* CRC DMEM optimized mode consume 1k less SRM memory consumption */
+#define CRC_IMPLEMENTATION_MODE CRC_IMPLEMENTATION_DMEM_OPTIMIZED
+#endif
+
+/* AES DMEM optimized mode comsume 10k less memory compare to 
+     IMEM optimized mode AES_IMPLEMENTATION_IMEM_OPTIMIZED */
+#define AES_IMPLEMENTATION_MODE AES_IMPLEMENTATION_DMEM_OPTIMIZED
+
+#define USE_SKB_AS_XMITBUF	1
+#if defined(CONFIG_PLATFORM_AMEBA_X)
+#define USE_XMIT_EXTBUFF	1
+#else
+#define USE_XMIT_EXTBUFF	0
+#endif
+#define USE_MUTEX_FOR_SPINLOCK	1
+
+// remove function to reduce code
+#define NOT_SUPPORT_5G
+#define NOT_SUPPORT_RF_MULTIPATH
+#define NOT_SUPPORT_VHT
+#define NOT_SUPPORT_40M
+#define NOT_SUPPORT_80M
+#ifndef CONFIG_PLATFORM_8711B
+#define NOT_SUPPORT_BBSWING
+#endif
+#define NOT_SUPPORT_OLD_CHANNEL_PLAN
+#define NOT_SUPPORT_BT
+
+#define CONFIG_WIFI_SPEC	0
+#define CONFIG_FAKE_EFUSE	0
+#if CONFIG_FAKE_EFUSE
+	#define FAKE_CHIPID		CHIPID_8710BN
+#endif
+
+#define CONFIG_AUTO_RECONNECT 1
+#define ENABLE_HWPDN_PIN
+#define SUPPORT_SCAN_BUF	1
+#if !defined(CONFIG_PLATFORM_AMEBA_X)
+#define BE_I_CUT			1
+#endif
+
+/* For WPA2 */
+#define CONFIG_INCLUDE_WPA_PSK
+#ifdef CONFIG_INCLUDE_WPA_PSK
+#define CONFIG_MULTIPLE_WPA_STA
+//#define CONFIG_WPA2_PREAUTH
+#define PSK_SUPPORT_TKIP	1
+#endif
+//#define AP_PSK_SUPPORT_TKIP
+
+/* For promiscuous mode */
+#define CONFIG_PROMISC
+
+#define PROMISC_DENY_PAIRWISE	0
+
+/* For Simple Link */
+#ifndef CONFIG_INCLUDE_SIMPLE_CONFIG
+//#define CONFIG_INCLUDE_SIMPLE_CONFIG 1
+#endif
+
+// for probe request with custom vendor specific IE
+#define CONFIG_CUSTOM_IE
+
+#if !defined(CONFIG_PLATFORM_AMEBA_X)
+/* For multicast */
+#define CONFIG_MULTICAST
+#endif
+
+/* For STA+AP Concurrent MODE */
+#define CONFIG_CONCURRENT_MODE
+#ifdef CONFIG_CONCURRENT_MODE
+  #if defined(CONFIG_PLATFORM_8195A)
+    #define CONFIG_RUNTIME_PORT_SWITCH
+  #endif
+  #if defined(CONFIG_HARDWARE_8188F)
+  #define NET_IF_NUM 2
+  #else
+  #define NET_IF_NUM ((CONFIG_ETHERNET) + (CONFIG_WLAN) + 1)
+  #endif
+#else
+  #if defined(CONFIG_HARDWARE_8188F)
+  #define NET_IF_NUM 1
+  #else
+  #define NET_IF_NUM ((CONFIG_ETHERNET) + (CONFIG_WLAN))
+  #endif
+#endif
+
+
+/****************** For EAP auth configurations *******************/
+#define CONFIG_TLS	0
+#define CONFIG_PEAP	0
+#define CONFIG_TTLS	0
+
+// DO NOT change the below config of EAP
+#ifdef PRE_CONFIG_EAP
+#define CONFIG_TLS	1
+#define CONFIG_PEAP	1
+#define CONFIG_TTLS	1
+#endif
+
+// enable 1X code in lib_wlan as default (increase 380 bytes)
+#ifndef PLATFORM_CMSIS_RTOS  // unsupported feature
+#define CONFIG_EAP
+#endif
+#if CONFIG_TLS || CONFIG_PEAP || CONFIG_TTLS
+#define EAP_REMOVE_UNUSED_CODE 1
+#endif	     
+	     
+#define EAP_SSL_VERIFY_SERVER
+
+#if CONFIG_TLS
+#define EAP_SSL_VERIFY_CLIENT
+#endif
+
+#if CONFIG_TTLS
+#define EAP_MSCHAPv2
+#define EAP_TTLS_MSCHAPv2
+//#define EAP_TTLS_EAP
+//#define EAP_TTLS_MSCHAP
+//#define EAP_TTLS_PAP
+//#define EAP_TTLS_CHAP
+#endif
+/****************** End of EAP configurations *******************/
+
+/* For WPS and P2P */
+#define CONFIG_WPS
+#if 0
+#define CONFIG_WPS_AP
+#define CONFIG_P2P_NEW
+#if (!defined(SUPPORT_SCAN_BUF)||!defined(CONFIG_WPS_AP)) && defined(CONFIG_P2P_NEW)
+#error "If CONFIG_P2P_NEW, need to SUPPORT_SCAN_BUF"
+#endif
+#endif
+
+#define CONFIG_NEW_SIGNAL_STAT_PROCESS
+#define CONFIG_SKIP_SIGNAL_SCALE_MAPPING
+
+/* For AP_MODE */
+#define CONFIG_AP_MODE
+extern unsigned char g_user_ap_sta_num;
+#define USER_AP_STA_NUM g_user_ap_sta_num
+#if defined(CONFIG_PLATFORM_AMEBA_X)
+#define AP_STA_NUM	3	//2014/10/27 modify to 3
+#define USE_DEDICATED_BCN_TX	0
+#if USE_DEDICATED_BCN_TX
+#error "WLAN driver for Ameba should not enable USE_DEDICATED_BCN_TX"
+#endif
+#else
+extern unsigned int g_ap_sta_num;
+#define AP_STA_NUM 3//g_ap_sta_num
+#endif
+#ifdef CONFIG_AP_MODE
+#if defined(CONFIG_PLATFORM_8195A)  
+	 //softap sent qos null0 polling client alive or not
+	#define CONFIG_AP_POLLING_CLIENT_ALIVE 
+#endif
+	#define CONFIG_NATIVEAP_MLME
+#if defined(CONFIG_PLATFORM_AMEBA_X)
+	#define CONFIG_INTERRUPT_BASED_TXBCN
+#endif
+	#ifdef CONFIG_INTERRUPT_BASED_TXBCN
+		//#define CONFIG_INTERRUPT_BASED_TXBCN_EARLY_INT
+		#define CONFIG_INTERRUPT_BASED_TXBCN_BCN_OK_ERR
+	#endif
+//	#define CONFIG_GK_REKEY
+#if !defined(CONFIG_PLATFORM_AMEBA_X)
+	#define USE_DEDICATED_BCN_TX	1
+#endif
+#if CONFIG_INIC_EN
+//	#define REPORT_STA_EVENT //useless
+#endif
+#else
+#if !defined(CONFIG_PLATFORM_AMEBA_X)
+	#define USE_DEDICATED_BCN_TX	0
+#endif
+#endif
+
+#if defined(CONFIG_AP_MODE) && defined(CONFIG_GK_REKEY) && !defined(CONFIG_MULTIPLE_WPA_STA)
+#error "If CONFIG_GK_REKEY when CONFIG_AP_MODE, need to CONFIG_MULTIPLE_WPA_STA"
+#endif
+
+#if !defined(CONFIG_PLATFORM_AMEBA_X)
+#if !defined(CONFIG_AP_MODE) && defined(CONFIG_CONCURRENT_MODE)
+#error "If CONFIG_CONCURRENT_MODEE, need to CONFIG_AP_MODE"
+#endif
+#endif
+
+/* For efuse or flash config */
+#if defined(CONFIG_PLATFORM_AMEBA_X)
+	#define CONFIG_RW_PHYSICAL_EFUSE			0	// Mask efuse user blocks
+	#define CONFIG_HIDE_PROTECT_EFUSE			1
+	#define CONFIG_ADAPTOR_INFO_CACHING_FLASH	1
+	#define CHECK_FLASH_VALID_MASK				1
+	#define CHECK_EFUSE_VALID_MASK				1
+	/* For K-free */
+//	#if !defined(CONFIG_PLATFORM_8711B)
+		#define CONFIG_RF_GAIN_OFFSET
+//	#endif
+#endif	// CONFIG_PLATFORM_AMEBA_X
+
+/* For MP_MODE */
+//#define CONFIG_MP_INCLUDED
+#ifdef CONFIG_MP_INCLUDED
+	#define MP_DRIVER		1
+	#define CONFIG_MP_IWPRIV_SUPPORT
+//	#define HAL_EFUSE_MEMORY
+	#if defined(CONFIG_PLATFORM_AMEBA_X)
+		#define MP_REG_TEST
+	#endif
+#else
+	#define MP_DRIVER		0
+	#if defined(CONFIG_PLATFORM_8195A)
+		//Control wifi mcu function
+		#define CONFIG_LITTLE_WIFI_MCU_FUNCTION_THREAD
+		#define CONFIG_ODM_REFRESH_RAMASK
+	#endif
+#endif // #ifdef CONFIG_MP_INCLUDED
+
+#if defined(CONFIG_PLATFORM_AMEBA_X)
+	#if defined(CONFIG_PLATFORM_8195A)
+		#undef CONFIG_RTL8195A
+		#define CONFIG_RTL8195A
+	#endif
+	#if defined(CONFIG_PLATFORM_8711B)
+		#ifndef CONFIG_RTL8711B 
+			#define CONFIG_RTL8711B
+		#endif
+		#undef CONFIG_ADAPTOR_INFO_CACHING_FLASH
+		#define CONFIG_ADAPTOR_INFO_CACHING_FLASH 0
+		//#undef CONFIG_EAP
+		//#undef CONFIG_IPS
+		#define CONFIG_8710B_MOVE_TO_ROM
+		#define CONFIG_EFUSE_SEPARATE
+		#define CONFIG_MOVE_PSK_TO_ROM
+		#define CONFIG_WOWLAN
+		#define CONFIG_TRAFFIC_PROTECT
+	#endif
+#elif defined(CONFIG_HARDWARE_8188F)
+#define CONFIG_RTL8188F
+#else
+#define CONFIG_RTL8188E
+#endif
+#define RTL8192C_SUPPORT 0
+#define RTL8192CE_SUPPORT 0
+#define RTL8192CU_SUPPORT 0
+#define RTL8192D_SUPPORT 0
+#define RTL8192DE_SUPPORT 0
+#define RTL8192DU_SUPPORT 0
+#define RTL8723A_SUPPORT 0
+#define RTL8723AU_SUPPORT 0
+#define RTL8723AS_SUPPORT 0
+#define RTL8192E_SUPPORT 0
+#define RTL8812A_SUPPORT 0
+#define RTL8821A_SUPPORT 0
+#define RTL8723B_SUPPORT 0
+#define RTL8195A_SUPPORT 0
+#define RTL8188E_SUPPORT 0
+#define RTL8188F_SUPPORT 0
+#define RTL8711B_SUPPORT 0
+#if defined(CONFIG_PLATFORM_8195A)
+#undef RTL8195A_SUPPORT
+#define RTL8195A_SUPPORT 1
+#elif defined(CONFIG_PLATFORM_8711B)
+#undef RTL8711B_SUPPORT
+#define RTL8711B_SUPPORT 1
+#elif defined(CONFIG_HARDWARE_8188F)
+#undef	RTL8188F_SUPPORT
+#define RTL8188F_SUPPORT 1
+#else
+#undef RTL8188E_SUPPORT
+#define RTL8188E_SUPPORT 1
+#endif
+
+#define TEST_CHIP_SUPPORT 0
+
+#define RTL8188E_FOR_TEST_CHIP 0
+#define RTL8188E_FPGA_TRUE_PHY_VERIFICATION 0
+
+// for Debug message
+#define DBG 0
+#if defined(CONFIG_PLATFORM_AMEBA_X)
+#if(DBG == 0)
+	#define ROM_E_RTW_MSG 1
+	/* For DM debug*/
+	// BB
+	#define DBG_RX_INFO 1
+	#define DBG_TX_RATE 1			// DebugComponents: bit9
+	#define DBG_DM_RA 1				// DebugComponents: bit9
+	#define DBG_DM_DIG 1			// DebugComponents: bit0
+	#define DBG_DM_ADAPTIVITY 1		// DebugComponents: bit16
+	// RF
+	#define DBG_PWR_TRACKING 1		// DebugComponents: bit24
+	#define DBG_RF_IQK 1			// DebugComponents: bit26
+	// Common
+	#define DBG_PWR_INDEX 1			// DebugComponents: bit30
+#endif
+#endif
+
+/* For DM support */
+#if defined(CONFIG_RTL8188F)
+#define RATE_ADAPTIVE_SUPPORT 0
+#elif defined(CONFIG_PLATFORM_8711B)
+#define RATE_ADAPTIVE_SUPPORT 1
+#define CONFIG_ODM_REFRESH_RAMASK
+#else
+#define RATE_ADAPTIVE_SUPPORT 1
+#endif
+// adaptivity
+#define RTW_ADAPTIVITY_EN_DISABLE			0
+#define RTW_ADAPTIVITY_EN_ENABLE			1
+#define CONFIG_RTW_ADAPTIVITY_EN			RTW_ADAPTIVITY_EN_DISABLE
+#define RTW_ADAPTIVITY_MODE_NORMAL			0
+#define RTW_ADAPTIVITY_MODE_CARRIER_SENSE	1
+#define CONFIG_RTW_ADAPTIVITY_MODE			RTW_ADAPTIVITY_MODE_CARRIER_SENSE
+#define CONFIG_RTW_ADAPTIVITY_DML			0
+
+
+#if defined(CONFIG_PLATFORM_AMEBA_X)
+	#define CONFIG_POWER_TRAINING_WIL 0 // in RA
+#else
+	#define POWER_BY_RATE_SUPPORT 0
+#endif
+
+#if defined(CONFIG_PLATFORM_AMEBA_X)
+#define RTL8195A_FOR_TEST_CHIP 0
+
+//#define CONFIG_WIFI_TEST 1
+//#define CONFIG_MAC_LOOPBACK_DRIVER 1
+//#define CONFIG_WLAN_HAL_TEST 1
+//#define SKB_PRE_ALLOCATE_TX 1
+#define SKB_PRE_ALLOCATE_RX	0
+#define TX_CHECK_DSEC_ALWAYS 1
+#define CONFIG_DBG_DISABLE_RDU_INTERRUPT
+//#define CONFIG_WLAN_HAL_RX_TASK
+#if (SKB_PRE_ALLOCATE_RX == 1)
+	#define EXCHANGE_LXBUS_RX_SKB 0
+#endif
+#ifdef CONFIG_FPGA
+	//Enable mac loopback for test mode (Ameba)
+	#define CONFIG_TWO_MAC_DRIVER // for test mode
+#endif
+
+#ifdef ENABLE_MAC_LB_FOR_TEST_MODE
+	#define CONFIG_SUDO_PHY_SETTING
+	#define INT_HANDLE_IN_ISR 1
+	#define CONFIG_LWIP_LAYER 0
+	#define CONFIG_WLAN_HAL_TEST
+	#define CONFIG_WLAN_HAL_RX_TASK
+	#define CONFIG_MAC_LOOPBACK_DRIVER_RTL8711B 1
+	#define HAL_MAC_ENABLE 1
+	#define CONFIG_TWO_MAC_TEST_MODE 
+	#define DISABLE_BB_RF 1
+#else
+	//#define CONFIG_TWO_MAC_DRIVER //for mornal driver; two mac
+	#ifdef CONFIG_TWO_MAC_DRIVER
+		#define CONFIG_SUDO_PHY_SETTING
+		#define HAL_MAC_ENABLE 1
+		#define DISABLE_BB_RF 1
+	#else
+		#define HAL_MAC_ENABLE 1
+		#define HAL_BB_ENABLE 1
+		#define HAL_RF_ENABLE 1
+		#define DISABLE_BB_RF 0
+	#endif
+	//#define INT_HANDLE_IN_ISR 1
+#endif
+#endif // CONFIG_PLATFORM_AMEBA_X
+
+#ifndef CONFIG_LWIP_LAYER
+#define CONFIG_LWIP_LAYER 1
+#endif
+#define CONFIG_MAC_ADDRESS 0
+//fast reconnection
+//#define CONFIG_FAST_RECONNECTION 1
+#if defined(CONFIG_INIC_EN)&&(CONFIG_INIC_EN==1)
+#define CONFIG_RECV_REORDERING_CTRL //enable reordering for iNIC high throughput
+#undef RX_AGGREGATION
+#define RX_AGGREGATION 1
+#undef NOT_SUPPORT_40M
+#undef CONFIG_CONCURRENT_MODE
+#endif
+#endif //WLANCONFIG_H

USDK/component/common/drivers/wlan/realtek/include/byteorder/generic.h

@@ -0,0 +1,223 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef _LINUX_BYTEORDER_GENERIC_H
+#define _LINUX_BYTEORDER_GENERIC_H
+
+/*
+ * linux/byteorder_generic.h
+ * Generic Byte-reordering support
+ *
+ * Francois-Rene Rideau <fare@tunes.org> 19970707
+ *    gathered all the good ideas from all asm-foo/byteorder.h into one file,
+ *    cleaned them up.
+ *    I hope it is compliant with non-GCC compilers.
+ *    I decided to put __BYTEORDER_HAS_U64__ in byteorder.h,
+ *    because I wasn't sure it would be ok to put it in types.h
+ *    Upgraded it to 2.1.43
+ * Francois-Rene Rideau <fare@tunes.org> 19971012
+ *    Upgraded it to 2.1.57
+ *    to please Linus T., replaced huge #ifdef's between little/big endian
+ *    by nestedly #include'd files.
+ * Francois-Rene Rideau <fare@tunes.org> 19971205
+ *    Made it to 2.1.71; now a facelift:
+ *    Put files under include/linux/byteorder/
+ *    Split swab from generic support.
+ *
+ * TODO:
+ *   = Regular kernel maintainers could also replace all these manual
+ *    byteswap macros that remain, disseminated among drivers,
+ *    after some grep or the sources...
+ *   = Linus might want to rename all these macros and files to fit his taste,
+ *    to fit his personal naming scheme.
+ *   = it seems that a few drivers would also appreciate
+ *    nybble swapping support...
+ *   = every architecture could add their byteswap macro in asm/byteorder.h
+ *    see how some architectures already do (i386, alpha, ppc, etc)
+ *   = cpu_to_beXX and beXX_to_cpu might some day need to be well
+ *    distinguished throughout the kernel. This is not the case currently,
+ *    since little endian, big endian, and pdp endian machines needn't it.
+ *    But this might be the case for, say, a port of Linux to 20/21 bit
+ *    architectures (and F21 Linux addict around?).
+ */
+
+/*
+ * The following macros are to be defined by <asm/byteorder.h>:
+ *
+ * Conversion of long and short int between network and host format
+ *	ntohl(__u32 x)
+ *	ntohs(__u16 x)
+ *	htonl(__u32 x)
+ *	htons(__u16 x)
+ * It seems that some programs (which? where? or perhaps a standard? POSIX?)
+ * might like the above to be functions, not macros (why?).
+ * if that's true, then detect them, and take measures.
+ * Anyway, the measure is: define only ___ntohl as a macro instead,
+ * and in a separate file, have
+ * unsigned long inline ntohl(x){return ___ntohl(x);}
+ *
+ * The same for constant arguments
+ *	__constant_ntohl(__u32 x)
+ *	__constant_ntohs(__u16 x)
+ *	__constant_htonl(__u32 x)
+ *	__constant_htons(__u16 x)
+ *
+ * Conversion of XX-bit integers (16- 32- or 64-)
+ * between native CPU format and little/big endian format
+ * 64-bit stuff only defined for proper architectures
+ *	cpu_to_[bl]eXX(__uXX x)
+ *	[bl]eXX_to_cpu(__uXX x)
+ *
+ * The same, but takes a pointer to the value to convert
+ *	cpu_to_[bl]eXXp(__uXX x)
+ *	[bl]eXX_to_cpup(__uXX x)
+ *
+ * The same, but change in situ
+ *	cpu_to_[bl]eXXs(__uXX x)
+ *	[bl]eXX_to_cpus(__uXX x)
+ *
+ * See asm-foo/byteorder.h for examples of how to provide
+ * architecture-optimized versions
+ *
+ */
+
+
+#if defined(PLATFORM_LINUX) || defined(PLATFORM_WINDOWS) || defined(PLATFORM_MPIXEL) || defined(PLATFORM_FREEBSD) || defined(PLATFORM_ECOS) || defined(PLATFORM_FREERTOS) || defined (PLATFORM_CMSIS_RTOS)
+/*
+ * inside the kernel, we can use nicknames;
+ * outside of it, we must avoid POSIX namespace pollution...
+ */
+
+//TODO
+#if 0
+
+#define cpu_to_le64 __cpu_to_le64
+#define le64_to_cpu __le64_to_cpu
+
+#endif	//#if 0
+
+#define cpu_to_le32 __cpu_to_le32
+#define le32_to_cpu __le32_to_cpu
+#define cpu_to_le16 __cpu_to_le16
+#define le16_to_cpu __le16_to_cpu
+#define cpu_to_be64 __cpu_to_be64
+#define be64_to_cpu __be64_to_cpu
+#define cpu_to_be32 __cpu_to_be32
+#define be32_to_cpu __be32_to_cpu
+#define cpu_to_be16 __cpu_to_be16
+#define be16_to_cpu __be16_to_cpu
+#define cpu_to_le64p __cpu_to_le64p
+#define le64_to_cpup __le64_to_cpup
+#define cpu_to_le32p __cpu_to_le32p
+#define le32_to_cpup __le32_to_cpup
+#define cpu_to_le16p __cpu_to_le16p
+#define le16_to_cpup __le16_to_cpup
+#define cpu_to_be64p __cpu_to_be64p
+#define be64_to_cpup __be64_to_cpup
+#define cpu_to_be32p __cpu_to_be32p
+#define be32_to_cpup __be32_to_cpup
+#define cpu_to_be16p __cpu_to_be16p
+#define be16_to_cpup __be16_to_cpup
+#define cpu_to_le64s __cpu_to_le64s
+#define le64_to_cpus __le64_to_cpus
+#define cpu_to_le32s __cpu_to_le32s
+#define le32_to_cpus __le32_to_cpus
+#define cpu_to_le16s __cpu_to_le16s
+#define le16_to_cpus __le16_to_cpus
+#define cpu_to_be64s __cpu_to_be64s
+#define be64_to_cpus __be64_to_cpus
+#define cpu_to_be32s __cpu_to_be32s
+#define be32_to_cpus __be32_to_cpus
+#define cpu_to_be16s __cpu_to_be16s
+#define be16_to_cpus __be16_to_cpus
+#endif
+
+//TODO
+#if 0
+
+/*
+ * Handle ntohl and suches. These have various compatibility
+ * issues - like we want to give the prototype even though we
+ * also have a macro for them in case some strange program
+ * wants to take the address of the thing or something..
+ *
+ * Note that these used to return a "long" in libc5, even though
+ * long is often 64-bit these days.. Thus the casts.
+ *
+ * They have to be macros in order to do the constant folding
+ * correctly - if the argument passed into a inline function
+ * it is no longer constant according to gcc..
+ */
+
+#undef ntohl
+#undef ntohs
+#undef htonl
+#undef htons
+
+/*
+ * Do the prototypes. Somebody might want to take the
+ * address or some such sick thing..
+ */
+#if defined(PLATFORM_LINUX) || (defined (__GLIBC__) && __GLIBC__ >= 2)
+extern __u32			ntohl(__u32);
+extern __u32			htonl(__u32);
+#else //defined(PLATFORM_LINUX) || (defined (__GLIBC__) && __GLIBC__ >= 2)
+#ifndef PLATFORM_FREEBSD
+extern unsigned long int	ntohl(unsigned long int);
+extern unsigned long int	htonl(unsigned long int);
+#endif
+#endif
+#ifndef PLATFORM_FREEBSD
+extern unsigned short int	ntohs(unsigned short int);
+extern unsigned short int	htons(unsigned short int);
+#endif
+
+#if defined(__GNUC__) && (__GNUC__ >= 2) && defined(__OPTIMIZE__) ||  defined(PLATFORM_MPIXEL)
+
+#define ___htonl(x) __cpu_to_be32(x)
+#define ___htons(x) __cpu_to_be16(x)
+#define ___ntohl(x) __be32_to_cpu(x)
+#define ___ntohs(x) __be16_to_cpu(x)
+
+#if defined(PLATFORM_LINUX) || (defined (__GLIBC__) && __GLIBC__ >= 2)
+#define htonl(x) ___htonl(x)
+#define ntohl(x) ___ntohl(x)
+#else
+#define htonl(x) ((unsigned long)___htonl(x))
+#define ntohl(x) ((unsigned long)___ntohl(x))
+#endif
+#define htons(x) ___htons(x)
+#define ntohs(x) ___ntohs(x)
+
+#endif /* OPTIMIZE */
+
+
+#if defined (PLATFORM_WINDOWS)
+
+#define htonl(x) __cpu_to_be32(x)
+#define ntohl(x) __be32_to_cpu(x)
+#define htons(x) __cpu_to_be16(x)
+#define ntohs(x) __be16_to_cpu(x)
+
+#endif
+
+#endif	//#if 0
+
+#endif /* _LINUX_BYTEORDER_GENERIC_H */
+

USDK/component/common/drivers/wlan/realtek/include/byteorder/little_endian.h

@@ -0,0 +1,97 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef _LINUX_BYTEORDER_LITTLE_ENDIAN_H
+#define _LINUX_BYTEORDER_LITTLE_ENDIAN_H
+
+#ifndef __LITTLE_ENDIAN
+#define __LITTLE_ENDIAN 1234
+#endif
+#ifndef __LITTLE_ENDIAN_BITFIELD
+#define __LITTLE_ENDIAN_BITFIELD
+#endif
+
+#include <byteorder/swab.h>
+
+#ifndef __constant_htonl
+
+//TODO
+#if 0
+
+#define __constant_htonl(x) ___constant_swab32((x))
+#define __constant_ntohl(x) ___constant_swab32((x))
+#define __constant_htons(x) ___constant_swab16((x))
+#define __constant_ntohs(x) ___constant_swab16((x))
+#define __constant_cpu_to_le64(x) ((__u64)(x))
+#define __constant_le64_to_cpu(x) ((__u64)(x))
+#define __constant_cpu_to_le32(x) ((__u32)(x))
+#define __constant_le32_to_cpu(x) ((__u32)(x))
+#define __constant_cpu_to_le16(x) ((__u16)(x))
+#define __constant_le16_to_cpu(x) ((__u16)(x))
+#define __constant_cpu_to_be64(x) ___constant_swab64((x))
+#define __constant_be64_to_cpu(x) ___constant_swab64((x))
+#define __constant_cpu_to_be32(x) ___constant_swab32((x))
+#define __constant_be32_to_cpu(x) ___constant_swab32((x))
+#define __constant_cpu_to_be16(x) ___constant_swab16((x))
+#define __constant_be16_to_cpu(x) ___constant_swab16((x))
+#define __cpu_to_le64(x) ((__u64)(x))
+#define __le64_to_cpu(x) ((__u64)(x))
+
+#endif	//#if 0
+
+#define __cpu_to_le32(x) ((__u32)(x))
+#define __le32_to_cpu(x) ((__u32)(x))
+#define __cpu_to_le16(x) ((__u16)(x))
+#define __le16_to_cpu(x) ((__u16)(x))
+#define __cpu_to_be64(x) __swab64((x))
+#define __be64_to_cpu(x) __swab64((x))
+#define __cpu_to_be32(x) __swab32((x))
+#define __be32_to_cpu(x) __swab32((x))
+#define __cpu_to_be16(x) __swab16((x))
+#define __be16_to_cpu(x) __swab16((x))
+#define __cpu_to_le64p(x) (*(__u64*)(x))
+#define __le64_to_cpup(x) (*(__u64*)(x))
+#define __cpu_to_le32p(x) (*(__u32*)(x))
+#define __le32_to_cpup(x) (*(__u32*)(x))
+#define __cpu_to_le16p(x) (*(__u16*)(x))
+#define __le16_to_cpup(x) (*(__u16*)(x))
+#define __cpu_to_be64p(x) __swab64p((x))
+#define __be64_to_cpup(x) __swab64p((x))
+#define __cpu_to_be32p(x) __swab32p((x))
+#define __be32_to_cpup(x) __swab32p((x))
+#define __cpu_to_be16p(x) __swab16p((x))
+#define __be16_to_cpup(x) __swab16p((x))
+#define __cpu_to_le64s(x) do {} while (0)
+#define __le64_to_cpus(x) do {} while (0)
+#define __cpu_to_le32s(x) do {} while (0)
+#define __le32_to_cpus(x) do {} while (0)
+#define __cpu_to_le16s(x) do {} while (0)
+#define __le16_to_cpus(x) do {} while (0)
+#define __cpu_to_be64s(x) __swab64s((x))
+#define __be64_to_cpus(x) __swab64s((x))
+#define __cpu_to_be32s(x) __swab32s((x))
+#define __be32_to_cpus(x) __swab32s((x))
+#define __cpu_to_be16s(x) __swab16s((x))
+#define __be16_to_cpus(x) __swab16s((x))
+#endif	// __constant_htonl
+
+#include <byteorder/generic.h>
+
+#endif /* _LINUX_BYTEORDER_LITTLE_ENDIAN_H */
+

USDK/component/common/drivers/wlan/realtek/include/byteorder/swab.h

@@ -0,0 +1,145 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef _LINUX_BYTEORDER_SWAB_H
+#define _LINUX_BYTEORDER_SWAB_H
+/*
+#if !defined(CONFIG_PLATFORM_MSTAR_TITANIA12) && 	!defined(PLATFORM_ECOS) && \
+		!defined(CONFIG_PLATFORM_8195A)
+*/
+#if !defined(CONFIG_PLATFORM_MSTAR_TITANIA12) && !defined(PLATFORM_ECOS)
+
+#if !defined(PLATFORM_FREERTOS) && !defined (PLATFORM_CMSIS_RTOS)
+#ifndef __u16
+typedef unsigned short __u16;
+#endif
+
+#ifndef __u32
+typedef unsigned int	__u32;
+#endif
+
+#ifndef __u8
+typedef unsigned char __u8;
+#endif
+
+#ifndef __u64
+typedef unsigned long long	__u64;	
+#endif
+#endif
+__inline static __u16  ___swab16(__u16 x)
+{
+	__u16 __x = x; 
+	return 
+	((__u16)( 
+		(((__u16)(__x) & (__u16)0x00ffU) << 8) |
+		(((__u16)(__x) & (__u16)0xff00U) >> 8) ));
+
+}
+
+__inline static __u32  ___swab32(__u32 x)
+{
+	__u32 __x = (x);
+	return ((__u32)(
+		(((__u32)(__x) & (__u32)0x000000ffUL) << 24) |
+		(((__u32)(__x) & (__u32)0x0000ff00UL) <<  8) |
+		(((__u32)(__x) & (__u32)0x00ff0000UL) >>  8) |
+		(((__u32)(__x) & (__u32)0xff000000UL) >> 24) ));
+}
+
+__inline static __u64  ___swab64(__u64 x)
+{
+	__u64 __x = (x);
+	
+	return 
+	((__u64)( \
+		(__u64)(((__u64)(__x) & (__u64)0x00000000000000ffULL) << 56) | \
+		(__u64)(((__u64)(__x) & (__u64)0x000000000000ff00ULL) << 40) | \
+		(__u64)(((__u64)(__x) & (__u64)0x0000000000ff0000ULL) << 24) | \
+		(__u64)(((__u64)(__x) & (__u64)0x00000000ff000000ULL) <<  8) | \
+	        (__u64)(((__u64)(__x) & (__u64)0x000000ff00000000ULL) >>  8) | \
+		(__u64)(((__u64)(__x) & (__u64)0x0000ff0000000000ULL) >> 24) | \
+		(__u64)(((__u64)(__x) & (__u64)0x00ff000000000000ULL) >> 40) | \
+		(__u64)(((__u64)(__x) & (__u64)0xff00000000000000ULL) >> 56) )); \
+}
+#endif // CONFIG_PLATFORM_MSTAR_TITANIA12
+
+#ifndef __arch__swab16
+__inline static __u16 __arch__swab16(__u16 x)
+{
+	return ___swab16(x);
+}
+
+#endif
+
+#ifndef __arch__swab32
+__inline static __u32 __arch__swab32(__u32 x)
+{
+	__u32 __tmp = (x) ; 
+	return ___swab32(__tmp);
+}
+#endif
+
+#ifndef __arch__swab64
+
+__inline static __u64 __arch__swab64(__u64 x)
+{
+	__u64 __tmp = (x) ; 
+	return ___swab64(__tmp);
+}
+
+
+#endif
+
+#ifndef __swab16
+#define __swab16(x) __fswab16(x)
+#define __swab32(x) __fswab32(x)
+#define __swab64(x) __fswab64(x)
+#endif	// __swab16
+
+#ifdef PLATFORM_FREEBSD
+__inline static __u16 __fswab16(__u16 x)
+#else
+__inline static __u16 __fswab16(__u16 x)
+#endif //PLATFORM_FREEBSD
+{
+	return __arch__swab16(x);
+}
+#ifdef PLATFORM_FREEBSD
+__inline static __u32 __fswab32(__u32 x)
+#else
+__inline static __u32 __fswab32(__u32 x)
+#endif //PLATFORM_FREEBSD
+{
+	return __arch__swab32(x);
+}
+
+#if defined(PLATFORM_LINUX) || defined(PLATFORM_WINDOWS)
+#define swab16 __swab16
+#define swab32 __swab32
+#define swab64 __swab64
+#define swab16p __swab16p
+#define swab32p __swab32p
+#define swab64p __swab64p
+#define swab16s __swab16s
+#define swab32s __swab32s
+#define swab64s __swab64s
+#endif
+
+#endif /* _LINUX_BYTEORDER_SWAB_H */
+

USDK/component/common/drivers/wlan/realtek/include/drv_conf.h

@@ -0,0 +1,106 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef __DRV_CONF_H__
+#define __DRV_CONF_H__
+
+#include "autoconf.h"
+#if ((RTL8195A_SUPPORT==1) || (RTL8711B_SUPPORT==1))
+#include "platform_autoconf.h"
+#endif
+
+#if defined (PLATFORM_LINUX) && defined (PLATFORM_WINDOWS)
+
+#error "Shall be Linux or Windows, but not both!\n"
+
+#endif
+
+//Older Android kernel doesn't has CONFIG_ANDROID defined,
+//add this to force CONFIG_ANDROID defined
+#ifdef CONFIG_PLATFORM_ANDROID
+#define CONFIG_ANDROID
+#endif
+
+#ifdef CONFIG_ANDROID
+//Some Android build will restart the UI while non-printable ascii is passed
+//between java and c/c++ layer (JNI). We force CONFIG_VALIDATE_SSID
+//for Android here. If you are sure there is no risk on your system about this,
+//mask this macro define to support non-printable ascii ssid.
+//#define CONFIG_VALIDATE_SSID
+#ifdef CONFIG_PLATFORM_ARM_SUNxI
+	#ifdef CONFIG_VALIDATE_SSID
+		#undef CONFIG_VALIDATE_SSID
+	#endif
+#endif
+
+//Android expect dbm as the rx signal strength unit
+#define CONFIG_SIGNAL_DISPLAY_DBM
+#endif
+
+#if defined(CONFIG_HAS_EARLYSUSPEND) && defined (CONFIG_RESUME_IN_WORKQUEUE)
+	#warning "You have CONFIG_HAS_EARLYSUSPEND enabled in your system, we disable CONFIG_RESUME_IN_WORKQUEUE automatically"
+	#undef CONFIG_RESUME_IN_WORKQUEUE
+#endif
+
+#if defined(CONFIG_ANDROID_POWER) && defined (CONFIG_RESUME_IN_WORKQUEUE)
+	#warning "You have CONFIG_ANDROID_POWER enabled in your system, we disable CONFIG_RESUME_IN_WORKQUEUE automatically"
+	#undef CONFIG_RESUME_IN_WORKQUEUE
+#endif
+
+#ifdef CONFIG_RESUME_IN_WORKQUEUE //this can be removed, because there is no case for this...
+	#if !defined( CONFIG_WAKELOCK) && !defined(CONFIG_ANDROID_POWER)
+	#error "enable CONFIG_RESUME_IN_WORKQUEUE without CONFIG_WAKELOCK or CONFIG_ANDROID_POWER will suffer from the danger of wifi's unfunctionality..."
+	#error "If you still want to enable CONFIG_RESUME_IN_WORKQUEUE in this case, mask this preprossor checking and GOOD LUCK..."
+	#endif
+#endif
+
+//About USB VENDOR REQ
+#if defined(CONFIG_USB_VENDOR_REQ_BUFFER_PREALLOC) && !defined(CONFIG_USB_VENDOR_REQ_MUTEX) 
+	#warning "define CONFIG_USB_VENDOR_REQ_MUTEX for CONFIG_USB_VENDOR_REQ_BUFFER_PREALLOC automatically"
+	#define CONFIG_USB_VENDOR_REQ_MUTEX
+#endif
+#if defined(CONFIG_VENDOR_REQ_RETRY) &&  !defined(CONFIG_USB_VENDOR_REQ_MUTEX)
+	#warning "define CONFIG_USB_VENDOR_REQ_MUTEX for CONFIG_VENDOR_REQ_RETRY automatically"
+	#define CONFIG_USB_VENDOR_REQ_MUTEX
+#endif
+
+#ifndef CONFIG_RTW_ADAPTIVITY_EN
+	#define CONFIG_RTW_ADAPTIVITY_EN 0
+#endif
+
+#ifndef CONFIG_RTW_ADAPTIVITY_MODE
+	#define CONFIG_RTW_ADAPTIVITY_MODE 0
+#endif
+
+#ifndef CONFIG_RTW_ADAPTIVITY_DML
+	#define CONFIG_RTW_ADAPTIVITY_DML 0
+#endif
+
+#ifndef CONFIG_RTW_ADAPTIVITY_DC_BACKOFF
+	#define CONFIG_RTW_ADAPTIVITY_DC_BACKOFF 4
+#endif
+
+#ifndef CONFIG_RTW_NHM_EN
+	#define CONFIG_RTW_NHM_EN 0
+#endif
+
+//#include <rtl871x_byteorder.h>
+
+#endif // __DRV_CONF_H__
+

USDK/component/common/drivers/wlan/realtek/include/drv_types.h

@@ -0,0 +1,863 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+/*-------------------------------------------------------------------------------
+
+	For type defines and data structure defines
+
+--------------------------------------------------------------------------------*/
+
+
+#ifndef __DRV_TYPES_H__
+#define __DRV_TYPES_H__
+
+#include <drv_conf.h>
+
+
+#ifdef PLATFORM_OS_XP
+#include <drv_types_xp.h>
+#endif
+
+#ifdef PLATFORM_OS_CE
+#include <drv_types_ce.h>
+#endif
+
+#ifdef PLATFORM_LINUX
+#include <drv_types_linux.h>
+#endif
+
+
+#if defined (__ICCARM__)
+#define _PACKED         __packed
+#define _WEAK           __weak
+#else
+#define _PACKED         __attribute__ ((packed))
+#define _WEAK           __attribute__ ((weak))
+#endif
+
+// Assign memory sectinon usage
+#if defined(CONFIG_PLATFORM_8195A) || defined(CONFIG_PLATFORM_8711B)
+#include <section_config.h>
+//#include "rtl_utility_ram.h"
+#include "platform/platform_stdlib.h"
+#else
+#define SRAM_BD_DATA_SECTION
+#define WLAN_ROM_TEXT_SECTION
+#define WLAN_ROM_DATA_SECTION
+#define _LONG_CALL_     
+#endif
+
+#ifdef CONFIG_TRACE_SKB
+#define SKBLIST_ALL								0xFFFFFFFF
+// receive
+#define	SKBLIST_RECVBUF_MASK					0x0000000F
+#define	SKBLIST_RECVBUF							0x00000001
+#define	SKBLIST_RECVBUF_FREEQUEUE				0x00000002
+#define	SKBLIST_RECVBUF_PENDINGQUEUE			0x00000004
+
+#define	SKBLIST_RECVFRAME_MASK					0x000000F0
+#define	SKBLIST_RECVFRAME						0x00000010
+#define	SKBLIST_RECVFRAME_FREEQUEUE				0x00000020
+#define	SKBLIST_RECVFRAME_SWDECQUEUE			0x00000040
+#ifdef CONFIG_RECV_REORDERING_CTRL
+#define	SKBLIST_RECVFRAME_REORDERQUEUE			0x00000080
+#endif
+
+// transmit
+#define	SKBLIST_XMITBUF_MASK					0x0000FF00
+#define	SKBLIST_XMITBUF							0x00000100
+#define	SKBLIST_XMITEXTBUF						0x00000200
+#define	SKBLIST_XMITBUF_FREEQUEUE				0x00000400
+#define	SKBLIST_XMITEXTBUF_FREEQUEUE			0x00000800
+#define	SKBLIST_XMITBUF_PENDINGQUEUE			0x00001000
+#ifdef CONFIG_SDIO_TX_MULTI_QUEUE
+#define	SKBLIST_XMITBUF_PENDING0QUEUE			0x00002000
+#define	SKBLIST_XMITBUF_PENDING1QUEUE			0x00004000
+#define	SKBLIST_XMITBUF_PENDING2QUEUE			0x00008000
+#endif
+
+#define	SKBLIST_XMITFRAME_MASK					0x0FFF0000
+#define	SKBLIST_XMITFRAME						0x00010000
+#define	SKBLIST_XMITFRAME_FREEQUEUE				0x00020000
+#define	SKBLIST_XMITFRAME_SLEEPQUEUE			0x00040000
+#define	SKBLIST_XMITFRAME_VOQUEUE				0x00100000
+#define	SKBLIST_XMITFRAME_VIQUEUE				0x00200000
+#define	SKBLIST_XMITFRAME_BEQUEUE				0x00400000
+#define	SKBLIST_XMITFRAME_BKQUEUE				0x00800000
+#define	SKBLIST_XMITFRAME_BMQUEUE				0x01000000
+
+#define	SKBLIST_POOL							0x10000000
+#endif
+
+enum _NIC_VERSION {
+
+	RTL8711_NIC,
+	RTL8712_NIC,
+	RTL8713_NIC,
+	RTL8716_NIC
+
+};
+
+typedef struct _ADAPTER _adapter, ADAPTER,*PADAPTER;
+
+#include "wireless.h"
+#include <netdev.h>
+#include <osdep_service.h>
+#include <rtw_byteorder.h>
+#include <rtw_io.h>
+#include <hci_spec.h>
+
+#include <wifi.h>
+
+#ifdef CONFIG_80211N_HT
+#include <rtw_ht.h>
+#endif
+
+#include <wlan_basic_types.h>
+#include <rtw_intfs.h>
+//#include <hal_pg.h>
+#include <wlan_bssdef.h>
+#include <rtw_cmd.h>
+#include <rtw_xmit.h>
+#include <rtw_recv.h>
+#include <hal_com.h>
+#include <rtw_qos.h>
+#ifdef CONFIG_INCLUDE_WPA_PSK
+#include <rtw_psk.h>
+#endif
+#include <rtw_security.h>
+#include <rom_rtw_security.h>
+#include <rtw_pwrctrl.h>
+#include <rtw_eeprom.h>
+#include <sta_info.h>
+#include <rtw_mlme.h>
+#include <rtw_debug.h>
+#include <ieee80211.h>
+#include <rom_ieee80211.h>
+#include <rtw_ioctl_set.h>
+#include <rtw_rf.h>
+#include <rtw_event.h>
+#include <rtw_led.h>
+#include <rtw_mlme_ext.h>
+#ifdef CONFIG_P2P_NEW
+#include <rtw_p2p.h>
+#endif
+//#include <rtw_tdls.h>
+#include <rtw_ap.h>
+#include <rtw_efuse.h>
+
+#include <osdep_intf.h>
+
+#include <hci_intfs.h>
+
+#ifdef CONFIG_WAPI_SUPPORT
+#include <rtw_wapi.h>
+#endif
+
+#ifdef CONFIG_DRVEXT_MODULE
+#include <drvext_api.h>
+#endif
+
+#ifdef CONFIG_MP_INCLUDED
+#include <rtw_mp.h>
+#endif
+
+#ifdef CONFIG_BR_EXT
+#include <rtw_br_ext.h>
+#endif	// CONFIG_BR_EXT
+
+#ifdef CONFIG_IOCTL_CFG80211
+	#include "ioctl_cfg80211.h"
+#endif //CONFIG_IOCTL_CFG80211
+
+#define SPEC_DEV_ID_NONE BIT(0)
+#define SPEC_DEV_ID_DISABLE_HT BIT(1)
+#define SPEC_DEV_ID_ENABLE_PS BIT(2)
+#define SPEC_DEV_ID_RF_CONFIG_1T1R BIT(3)
+#define SPEC_DEV_ID_RF_CONFIG_2T2R BIT(4)
+#define SPEC_DEV_ID_ASSIGN_IFNAME BIT(5)
+
+struct specific_device_id{
+
+	u32		flags;
+
+	u16		idVendor;
+	u16		idProduct;
+
+};
+
+struct registry_priv
+{
+	u8	chip_version;
+//	u8	rfintfs;
+//	u8	lbkmode;
+	u8	hci;
+	NDIS_802_11_SSID	ssid;
+//	u8	network_mode;	//infra, ad-hoc, auto
+	u8	channel;//ad-hoc support requirement
+	u8	wireless_mode;//A, B, G, auto
+	u8 	scan_mode;//active, passive
+//	u8	radio_enable;
+//	u8	preamble;//long, short, auto
+	u8	vrtl_carrier_sense;//Enable, Disable, Auto
+	u8	vcs_type;//RTS/CTS, CTS-to-self
+	u16	rts_thresh;
+//	u8	adhoc_tx_pwr;
+	u8	soft_ap;
+	u8	power_mgnt;
+	u8 	ps_enable;
+	u8	ips_mode;
+	u8	smart_ps;
+//	u8	long_retry_lmt;
+//	u8	short_retry_lmt;
+//	u16	busy_thresh;
+//	u8	ack_policy;
+	u8	mp_mode;
+	u8	software_encrypt;
+	u8	software_decrypt;
+	#ifdef CONFIG_TX_EARLY_MODE
+	u8   	early_mode;
+	#endif
+	u8	acm_method;
+	  //UAPSD
+	u8	wmm_enable;
+	u8	uapsd_enable;
+//	u8	uapsd_max_sp;
+//	u8	uapsd_acbk_en;
+//	u8	uapsd_acbe_en;
+//	u8	uapsd_acvi_en;
+//	u8	uapsd_acvo_en;
+
+//	WLAN_BSSID_EX    dev_network;
+	u32  beacon_period;
+
+#ifdef CONFIG_80211N_HT
+	u8	ht_enable;
+#if !defined(NOT_SUPPORT_40M)
+	u8	cbw40_enable;
+#endif
+	u8	ampdu_enable;//for tx
+	u8 	rx_stbc;
+	u8	ampdu_amsdu;//A-MPDU Supports A-MSDU is permitted
+#endif
+	//u8	lowrate_two_xmit;
+
+	u8	rf_config ;
+//	u8	low_power ;
+	u8	power_percentage_idx;
+
+	u8	wifi_spec;// !turbo_mode
+
+	u8	channel_plan;
+#ifdef CONFIG_BT_COEXIST
+	u8	btcoex;
+	u8	bt_iso;
+	u8	bt_sco;
+	u8	bt_ampdu;
+#endif
+#if RX_AGGREGATION 
+	BOOLEAN	bAcceptAddbaReq;
+#endif
+//	u8	antdiv_cfg;
+//	u8	antdiv_type;
+
+#ifdef CONFIG_AUTOSUSPEND
+	u8	usbss_enable;//0:disable,1:enable
+#endif
+#ifdef SUPPORT_HW_RFOFF_DETECTED
+	u8	hwpdn_mode;//0:disable,1:enable,2:decide by EFUSE config
+	u8	hwpwrp_detect;//0:disable,1:enable
+#endif
+#ifdef CONFIG_SUPPORT_HW_WPS_PBC
+	u8	hw_wps_pbc;//0:disable,1:enable
+#endif
+
+#ifdef CONFIG_ADAPTOR_INFO_CACHING_FILE
+	char	adaptor_info_caching_file_path[PATH_LENGTH_MAX];
+#endif
+
+#ifdef CONFIG_LAYER2_ROAMING
+	u8	max_roaming_times; // the max number driver will try to roaming
+#endif
+
+#ifdef CONFIG_IOL
+	bool 	force_iol; //enable iol without other concern
+#endif
+
+#ifdef CONFIG_80211D
+	u8 	enable80211d;
+#endif
+
+	u8 	ifname[16];
+	u8 	if2name[16];
+	
+#if (RTW_NOTCH_FILTER != 0)
+	u8 	notch_filter;
+#endif
+
+#ifdef CONFIG_SPECIAL_SETTING_FOR_FUNAI_TV
+	u8 	force_ant;//0 normal,1 main,2 aux
+	u8 	force_igi;//0 normal
+#endif
+
+	//define for tx power adjust
+	u8	RegEnableTxPowerLimit;
+	u8	RegEnableTxPowerByRate;
+#ifdef CONFIG_RF_GAIN_OFFSET
+	u8	RegEnableKFree;
+#endif
+	u8	RegPowerBase;
+	u8	RegPwrTblSel;
+
+	u8 adaptivity_en;
+	u8 adaptivity_mode;
+	u8 adaptivity_dml;
+	u8 adaptivity_dc_backoff;
+	s8 adaptivity_th_l2h_ini;
+//	u8 nhm_en;
+};
+
+//For registry parameters
+#define RGTRY_OFT(field) ((u32)FIELD_OFFSET(struct registry_priv,field))
+#define RGTRY_SZ(field)   sizeof(((struct registry_priv*) 0)->field)
+#define BSSID_OFT(field) ((u32)FIELD_OFFSET(WLAN_BSSID_EX,field))
+#define BSSID_SZ(field)   sizeof(((PWLAN_BSSID_EX) 0)->field)
+
+#define MAX_CONTINUAL_URB_ERR 4
+
+#ifdef CONFIG_CONCURRENT_MODE
+#define is_primary_adapter(adapter) (adapter->adapter_type == PRIMARY_ADAPTER)
+#define get_iface_type(adapter) (adapter->iface_type)
+#else
+#define is_primary_adapter(adapter) (1)
+#define get_iface_type(adapter) (IFACE_PORT0)
+#endif
+
+enum _IFACE_TYPE {
+	IFACE_PORT0, //mapping to port0 for C/D series chips
+	IFACE_PORT1, //mapping to port1 for C/D series chip
+	MAX_IFACE_PORT,
+};
+
+enum _ADAPTER_TYPE {
+	PRIMARY_ADAPTER,
+	SECONDARY_ADAPTER,
+	MAX_ADAPTER,
+};
+
+struct dvobj_priv
+{
+	void *if1;
+#ifdef CONFIG_CONCURRENT_MODE	
+	void *if2;
+#endif
+
+	//For 92D, DMDP have 2 interface.
+	//u8	InterfaceNumber;
+	//u8	NumInterfaces;
+#ifdef CONFIG_CONCURRENT_MODE
+	void *padapters[MAX_IFACE_PORT];
+	u8 iface_nums; // total number of ifaces used runtime
+#endif
+	//In /Out Pipe information
+	//int	RtInPipe[2];
+	u8	RtOutPipe[3];//int	RtOutPipe[3];
+	u8	Queue2Pipe[HW_QUEUE_ENTRY];//for out pipe mapping
+
+	//u8	irq_alloc;
+
+/*-------- below is for SDIO INTERFACE --------*/
+#if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
+	//
+	// SDIO ISR Related
+	//
+	u32 sdio_himr;
+
+	//
+	// SDIO Tx FIFO related.
+	//
+	// HIQ, MID, LOW, PUB free pages; padapter->xmitpriv.free_txpg
+	u8  SdioTxFIFOFreePage[TX_FREE_PG_QUEUE];
+	_lock SdioTxFIFOFreePageLock;
+
+	//
+	// SDIO Rx FIFO related.
+	//
+	u16 SdioRxFIFOSize;
+
+#ifdef INTF_DATA
+	INTF_DATA intf_data;
+#endif
+#endif //CONFIG_SDIO_HCI
+
+/*-------- below is for USB INTERFACE --------*/
+
+#ifdef CONFIG_USB_HCI
+
+	u8	irq_alloc; 
+	u8	nr_endpoint;
+	u8	ishighspeed;
+	u8	RtNumInPipes;
+	u8	RtNumOutPipes;
+	int	ep_num[5]; //endpoint number
+
+	int	RegUsbSS;
+
+	_sema	usb_suspend_sema;
+
+#ifdef CONFIG_USB_VENDOR_REQ_MUTEX
+	_mutex  usb_vendor_req_mutex;
+#endif
+
+#ifdef CONFIG_USB_VENDOR_REQ_BUFFER_PREALLOC
+	u8 * usb_alloc_vendor_req_buf;
+	u8 * usb_vendor_req_buf;
+#endif
+
+#ifdef PLATFORM_WINDOWS
+	//related device objects
+	PDEVICE_OBJECT	pphysdevobj;//pPhysDevObj;
+	PDEVICE_OBJECT	pfuncdevobj;//pFuncDevObj;
+	PDEVICE_OBJECT	pnextdevobj;//pNextDevObj;
+
+	u8	nextdevstacksz;//unsigned char NextDeviceStackSize;	//= (CHAR)CEdevice->pUsbDevObj->StackSize + 1;
+
+	//urb for control diescriptor request
+
+#ifdef PLATFORM_OS_XP
+	struct _URB_CONTROL_DESCRIPTOR_REQUEST descriptor_urb;
+	PUSB_CONFIGURATION_DESCRIPTOR	pconfig_descriptor;//UsbConfigurationDescriptor;
+#endif
+
+#ifdef PLATFORM_OS_CE
+	WCHAR			active_path[MAX_ACTIVE_REG_PATH];	// adapter regpath
+	USB_EXTENSION	usb_extension;
+
+	_nic_hdl		pipehdls_r8192c[0x10];
+#endif
+
+	u32	config_descriptor_len;//u32 UsbConfigurationDescriptorLength;
+#endif//PLATFORM_WINDOWS
+
+#ifdef PLATFORM_LINUX
+	struct usb_interface *pusbintf;
+	struct usb_device *pusbdev;
+#endif//PLATFORM_LINUX
+
+#ifdef PLATFORM_FREEBSD
+	struct usb_interface *pusbintf;
+	struct usb_device *pusbdev;
+#endif//PLATFORM_FREEBSD
+	ATOMIC_T continual_urb_error;
+#endif//CONFIG_USB_HCI
+
+/*-------- below is for PCIE INTERFACE --------*/
+
+#ifdef CONFIG_PCI_HCI
+	u8	irq_alloc; 
+
+#ifdef PLATFORM_LINUX
+	struct pci_dev *ppcidev;
+
+	//PCI MEM map
+	unsigned long	pci_mem_end;	/* shared mem end	*/
+	unsigned long	pci_mem_start;	/* shared mem start	*/
+
+	//PCI IO map
+	unsigned long	pci_base_addr;	/* device I/O address	*/
+
+	//PciBridge
+	struct pci_priv	pcipriv;
+
+	u16	irqline;
+	u8	irq_enabled;
+	RT_ISR_CONTENT	isr_content;
+	_lock	irq_th_lock;
+
+	//ASPM
+	u8	const_pci_aspm;
+	u8	const_amdpci_aspm;
+	u8	const_hwsw_rfoff_d3;
+	u8	const_support_pciaspm;
+	// pci-e bridge */
+	u8 	const_hostpci_aspm_setting;
+	// pci-e device */
+	u8 	const_devicepci_aspm_setting;
+	u8 	b_support_aspm; // If it supports ASPM, Offset[560h] = 0x40, otherwise Offset[560h] = 0x00.
+	u8	b_support_backdoor;
+	u8 bdma64;
+#endif//PLATFORM_LINUX
+
+#if defined(PLATFORM_FREERTOS) || defined (PLATFORM_CMSIS_RTOS)
+	u8	irq_enabled;
+	_lock	irq_th_lock;
+#endif //PLATFORM_FREERTOS
+
+#endif//CONFIG_PCI_HCI
+
+#ifdef CONFIG_LX_HCI
+	u8	irq_alloc; 
+#if defined(PLATFORM_FREERTOS) || defined (PLATFORM_CMSIS_RTOS)
+	u8	irq_enabled;
+	_lock	irq_th_lock;
+#endif //PLATFORM_FREERTOS
+#endif
+
+};
+
+#ifdef PLATFORM_LINUX
+static struct device *dvobj_to_dev(struct dvobj_priv *dvobj)
+{
+	/* todo: get interface type from dvobj and the return the dev accordingly */
+#ifdef RTW_DVOBJ_CHIP_HW_TYPE
+#endif
+
+#ifdef CONFIG_USB_HCI
+	return &dvobj->pusbintf->dev;
+#endif
+#ifdef CONFIG_SDIO_HCI
+	return &dvobj->intf_data.func->dev;
+#endif
+#ifdef CONFIG_GSPI_HCI
+	return &dvobj->intf_data.func->dev;
+#endif
+#ifdef CONFIG_PCI_HCI
+	return &dvobj->ppcidev->dev;
+#endif
+}
+#endif
+
+#ifdef CONFIG_CONCURRENT_MODE
+struct co_data_priv{
+
+	//george@20120518
+	//current operating channel/bw/ch_offset
+	//save the correct ch/bw/ch_offset whatever the inputted values are
+	//when calling set_channel_bwmode() at concurrent mode
+	//for debug check or reporting to layer app (such as wpa_supplicant for nl80211)
+	u8 co_ch;
+	u8 co_bw;
+	u8 co_ch_offset;
+	u8 rsvd;
+
+};
+#endif //CONFIG_CONCURRENT_MODE
+
+typedef enum _DRIVER_STATE{
+	DRIVER_NORMAL = 0,
+	DRIVER_DISAPPEAR = 1,
+	DRIVER_REPLACE_DONGLE = 2,
+}DRIVER_STATE;
+
+#ifdef CONFIG_INTEL_PROXIM
+struct proxim {
+	bool proxim_support;
+	bool proxim_on;
+
+	void *proximity_priv;
+	int (*proxim_rx)(_adapter *padapter,
+		union recv_frame *precv_frame);
+	u8	(*proxim_get_var)(_adapter* padapter, u8 type);
+};
+#endif	//CONFIG_INTEL_PROXIM
+
+#ifdef CONFIG_MAC_LOOPBACK_DRIVER
+typedef struct loopbackdata
+{
+	_sema	sema;
+	_thread_hdl_ lbkthread;
+	u8 bstop;
+	u32 cnt;
+	u16 size;
+	u16 txsize;
+	u8 txbuf[0x8000];
+	u16 rxsize;
+	u8 rxbuf[0x8000];
+	u8 msg[100];
+
+}LOOPBACKDATA, *PLOOPBACKDATA;
+#endif
+
+struct _ADAPTER{
+#ifdef CONFIG_EASY_REPLACEMENT
+	int	DriverState;// for disable driver using module, use dongle to replace module.
+	int	bDongle;//build-in module or external dongle
+
+#endif
+#ifdef PLATFORM_LINUX
+	int	pid[3];//process id from UI, 0:wps, 1:hostapd, 2:dhcpcd
+#endif	
+
+#ifdef CONFIG_PROC_DEBUG
+	u16 	chip_type;
+#endif
+
+	u16	HardwareType;
+	u16	interface_type;//USB,SDIO,SPI,PCI
+	u32	work_mode; //STA, AP, STA+AP, PROMISC, P2P
+
+	struct	dvobj_priv	*dvobj;
+	struct	mlme_priv	mlmepriv;
+	struct	mlme_ext_priv	mlmeextpriv;
+	struct	cmd_priv	cmdpriv;
+	struct	evt_priv	evtpriv;
+	//struct	io_queue	*pio_queue;
+	struct 	io_priv	iopriv;
+	struct	xmit_priv	xmitpriv;
+	struct	recv_priv	recvpriv;
+	struct	sta_priv	stapriv;
+	struct	security_priv	securitypriv;
+	struct	registry_priv	registrypriv;
+	struct	pwrctrl_priv	pwrctrlpriv;
+	struct 	eeprom_priv eeprompriv;
+//TODO
+//	struct	led_priv	ledpriv;
+
+
+#ifdef CONFIG_MP_INCLUDED
+       struct	mp_priv	mppriv;
+#endif
+
+#ifdef CONFIG_DRVEXT_MODULE
+	struct	drvext_priv	drvextpriv;
+#endif
+
+#if defined(CONFIG_HOSTAPD_MLME) && defined (CONFIG_AP_MODE)
+	struct	hostapd_priv	*phostapdpriv;
+#endif
+
+#ifdef CONFIG_IOCTL_CFG80211
+#ifdef CONFIG_P2P
+	struct cfg80211_wifidirect_info	cfg80211_wdinfo;
+#endif //CONFIG_P2P
+#endif //CONFIG_IOCTL_CFG80211
+
+#ifdef CONFIG_P2P_NEW
+	struct wifidirect_info	wdinfo;
+#endif //CONFIG_P2P
+
+#ifdef CONFIG_TDLS
+	struct tdls_info	tdlsinfo;
+#endif //CONFIG_TDLS
+
+#ifdef CONFIG_WAPI_SUPPORT
+	u8	WapiSupport;
+	RT_WAPI_T	wapiInfo;
+#endif
+
+
+#ifdef CONFIG_WFD
+	struct wifi_display_info wfd_info;
+#endif //CONFIG_WFD
+
+	PVOID		HalData;
+	u32 		hal_data_sz;
+	struct hal_ops	HalFunc;
+
+	s32	bDriverStopped;
+	s32	bSurpriseRemoved;
+	s32	bCardDisableWOHSM;
+	u8	RxStop;	//Used to stop rx thread as early as possible
+
+	u32	IsrContent;
+	u32	ImrContent;
+
+	u8	EepromAddressSize;
+	u8	hw_init_completed;
+	u8	bDriverIsGoingToUnload;
+	u8	init_adpt_in_progress;
+	u8	bMpDriver;
+
+#ifdef CONFIG_AP_MODE
+	u8	bForwardingDisabled;
+#endif
+
+#if defined(CONFIG_EVENT_THREAD_MODE)
+	_thread_hdl_	evtThread;
+#endif
+#if defined(CONFIG_ISR_THREAD_MODE_POLLING) || defined(CONFIG_ISR_THREAD_MODE_INTERRUPT)
+	struct task_struct	isrThread;
+#endif
+	struct task_struct	cmdThread;
+#ifdef CONFIG_XMIT_THREAD_MODE
+	struct task_struct	xmitThread;
+#endif
+#if defined(CONFIG_RECV_THREAD_MODE)
+	struct task_struct	recvThread;
+#endif
+#ifdef CONFIG_RECV_TASKLET_THREAD
+	struct task_struct	recvtasklet_thread;
+#endif
+#ifdef CONFIG_XMIT_TASKLET_THREAD
+#ifdef PLATFORM_LINUX
+	struct tasklet_struct xmit_tasklet;
+#else
+	struct task_struct	xmittasklet_thread;
+#endif
+#endif
+#ifdef CONFIG_SDIO_XMIT_THREAD
+	struct task_struct	SdioXmitThread;
+#endif //CONFIG_XMIT_TASKLET_THREAD
+
+
+#if !defined(PLATFORM_LINUX) && !defined(PLATFORM_ECOS) && !defined(PLATFORM_FREERTOS) && !defined(PLATFORM_CMSIS_RTOS)
+	NDIS_STATUS (*dvobj_init)(struct dvobj_priv *dvobj);
+	void (*dvobj_deinit)(struct dvobj_priv *dvobj);
+#endif
+
+	void (*intf_start)(_adapter * adapter);
+	void (*intf_stop)(_adapter * adapter);
+
+#ifdef PLATFORM_WINDOWS
+	_nic_hdl		hndis_adapter;//hNdisAdapter(NDISMiniportAdapterHandle);
+	_nic_hdl		hndis_config;//hNdisConfiguration;
+	NDIS_STRING fw_img;
+
+	u32	NdisPacketFilter;
+	u8	MCList[MAX_MCAST_LIST_NUM][6];
+	u32	MCAddrCount;
+#endif //end of PLATFORM_WINDOWS
+
+#ifdef PLATFORM_ECOS
+	_nic_hdl pnetdev;
+	int bup;
+	struct net_device_stats stats;
+#endif	//#ifdef PLATFORM_ECOS
+
+#if defined(PLATFORM_FREERTOS) || defined (PLATFORM_CMSIS_RTOS)
+	_nic_hdl	pnetdev;
+	int		bup;
+	struct net_device_stats stats;
+#endif	//#ifdef PLATFORM_FREERTOS
+
+#ifdef PLATFORM_LINUX
+	_nic_hdl pnetdev;
+
+	// used by rtw_rereg_nd_name related function
+	struct rereg_nd_name_data {
+		_nic_hdl old_pnetdev;
+		char old_ifname[IFNAMSIZ];
+		u8 old_ips_mode;
+		u8 old_bRegUseLed;
+	} rereg_nd_name_priv;
+
+	int bup;
+	struct net_device_stats stats;
+	struct iw_statistics iwstats;
+	struct proc_dir_entry *dir_dev;// for proc directory
+
+#ifdef CONFIG_IOCTL_CFG80211
+	struct wireless_dev *rtw_wdev;
+#endif //CONFIG_IOCTL_CFG80211
+
+#endif //end of PLATFORM_LINUX
+
+#ifdef PLATFORM_FREEBSD
+	_nic_hdl pifp;
+	int bup;
+	_lock glock;
+#endif //PLATFORM_FREEBSD
+	u8 net_closed;
+
+	u8 bFWReady;
+	//u8 bBTFWReady;
+	//u8 bReadPortCancel;
+	//u8 bWritePortCancel;
+	u8 bLinkInfoDump;
+	u8 bRxRSSIDisplay;
+#ifdef CONFIG_AUTOSUSPEND
+	u8	bDisableAutosuspend;
+#endif
+
+	_adapter *pbuddy_adapter;
+
+	_mutex *hw_init_mutex;
+#if defined(CONFIG_CONCURRENT_MODE) 
+	u8 isprimary; //is primary adapter or not
+	u8 adapter_type;
+	u8 iface_type; //interface port type
+
+	//for global synchronization
+	_mutex *ph2c_fwcmd_mutex;
+	_mutex *psetch_mutex;
+	_mutex *psetbw_mutex;
+
+	struct co_data_priv *pcodatapriv;//data buffer shared among interfaces
+#endif
+
+#ifdef CONFIG_BR_EXT
+	_lock					br_ext_lock;
+	//unsigned int			macclone_completed;
+	struct nat25_network_db_entry	*nethash[NAT25_HASH_SIZE];
+	int				pppoe_connection_in_progress;
+	unsigned char			pppoe_addr[MACADDRLEN];
+	unsigned char			scdb_mac[MACADDRLEN];
+	unsigned char			scdb_ip[4];
+	struct nat25_network_db_entry	*scdb_entry;
+	unsigned char			br_mac[MACADDRLEN];
+	unsigned char			br_ip[4];
+
+	struct br_ext_info		ethBrExtInfo;
+#endif	// CONFIG_BR_EXT
+
+#ifdef CONFIG_INTEL_PROXIM
+	/* intel Proximity, should be alloc mem
+	 * in intel Proximity module and can only
+	 * be used in intel Proximity mode */
+	struct proxim proximity;
+#endif	//CONFIG_INTEL_PROXIM
+
+#ifdef CONFIG_MAC_LOOPBACK_DRIVER
+	PLOOPBACKDATA ploopback;
+#endif
+
+        u8    fix_rate;
+#ifdef CONFIG_CAC_TEST
+	unsigned char     in_cta_test;
+#endif
+	/* This flag is used to dynamically enabling debug message if
+	  	certain sympton happen. Use iwpriv command to enable it */
+#if defined(CONFIG_DEBUG_DYNAMIC)	
+	u8	debug_level;
+#endif
+
+};
+
+#define adapter_to_dvobj(adapter) (adapter->dvobj)
+#define adapter_to_pwrctl(adapter) (&adapter->pwrctrlpriv)
+
+int rtw_handle_dualmac(_adapter *adapter, bool init);
+
+__inline static u8 *myid(struct eeprom_priv *peepriv)
+{
+	return (peepriv->mac_addr);
+}
+
+#if 0 //#if (CONFIG_LWIP_LAYER == 0)
+// For FPGA test program
+#define _htons(x) (x)
+#define _htons(x) (x)
+#define _htons(x) (x)
+#define _htons(x) (x)
+#endif
+
+//fast reconnection function prototype
+typedef int (*init_done_ptr)(void);
+#endif //__DRV_TYPES_H__
+

USDK/component/common/drivers/wlan/realtek/include/ethernet.h

@@ -0,0 +1,42 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+/*! \file */ 
+#ifndef __INC_ETHERNET_H
+#define __INC_ETHERNET_H
+
+#define ETHERNET_ADDRESS_LENGTH				6		//!< Ethernet Address Length
+#define ETHERNET_HEADER_SIZE				14		//!< Ethernet Header Length
+#define LLC_HEADER_SIZE						6		//!< LLC Header Length
+#define TYPE_LENGTH_FIELD_SIZE				2		//!< Type/Length Size
+#define MINIMUM_ETHERNET_PACKET_SIZE		60		//!< Minimum Ethernet Packet Size
+#define MAXIMUM_ETHERNET_PACKET_SIZE		1514	//!< Maximum Ethernet Packet Size
+
+#define RT_ETH_IS_MULTICAST(_pAddr)	((((u8 *)(_pAddr))[0]&0x01)!=0)		//!< Is Multicast Address?
+#define RT_ETH_IS_BROADCAST(_pAddr)	(										\
+											((u8 *)(_pAddr))[0]==0xff	&& 		\
+											((u8 *)(_pAddr))[1]==0xff	&&		\
+											((u8 *)(_pAddr))[2]==0xff	&&		\
+											((u8 *)(_pAddr))[3]==0xff	&&		\
+											((u8 *)(_pAddr))[4]==0xff	&&		\
+											((u8 *)(_pAddr))[5]==0xff		)	//!< Is Broadcast Address?
+
+
+#endif // #ifndef __INC_ETHERNET_H
+

USDK/component/common/drivers/wlan/realtek/include/hal_com.h

@@ -0,0 +1,287 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef __HAL_COMMON_H__
+#define __HAL_COMMON_H__
+
+#include "HalVerDef.h"
+#include "hal_pg.h"
+#include "hal_intf.h"
+#include "hal_phy.h"
+#include "hal_phy_reg.h"
+#include "hal_com_reg.h"
+#include "hal_com_phycfg.h"
+
+//----------------------------------------------------------------------------
+//       Rate Definition
+//----------------------------------------------------------------------------
+//CCK
+#define	RATR_1M					0x00000001
+#define	RATR_2M					0x00000002
+#define	RATR_55M					0x00000004
+#define	RATR_11M					0x00000008
+//OFDM 		
+#define	RATR_6M					0x00000010
+#define	RATR_9M					0x00000020
+#define	RATR_12M					0x00000040
+#define	RATR_18M					0x00000080
+#define	RATR_24M					0x00000100
+#define	RATR_36M					0x00000200
+#define	RATR_48M					0x00000400
+#define	RATR_54M					0x00000800
+//MCS 1 Spatial Stream	
+#define	RATR_MCS0					0x00001000
+#define	RATR_MCS1					0x00002000
+#define	RATR_MCS2					0x00004000
+#define	RATR_MCS3					0x00008000
+#define	RATR_MCS4					0x00010000
+#define	RATR_MCS5					0x00020000
+#define	RATR_MCS6					0x00040000
+#define	RATR_MCS7					0x00080000
+//MCS 2 Spatial Stream
+#define	RATR_MCS8					0x00100000
+#define	RATR_MCS9					0x00200000
+#define	RATR_MCS10					0x00400000
+#define	RATR_MCS11					0x00800000
+#define	RATR_MCS12					0x01000000
+#define	RATR_MCS13					0x02000000
+#define	RATR_MCS14					0x04000000
+#define	RATR_MCS15					0x08000000
+
+//CCK
+#define RATE_1M						BIT(0)
+#define RATE_2M						BIT(1)
+#define RATE_5_5M					BIT(2)
+#define RATE_11M					BIT(3)
+//OFDM 
+#define RATE_6M						BIT(4)
+#define RATE_9M						BIT(5)
+#define RATE_12M					BIT(6)
+#define RATE_18M					BIT(7)
+#define RATE_24M					BIT(8)
+#define RATE_36M					BIT(9)
+#define RATE_48M					BIT(10)
+#define RATE_54M					BIT(11)
+//MCS 1 Spatial Stream
+#define RATE_MCS0					BIT(12)
+#define RATE_MCS1					BIT(13)
+#define RATE_MCS2					BIT(14)
+#define RATE_MCS3					BIT(15)
+#define RATE_MCS4					BIT(16)
+#define RATE_MCS5					BIT(17)
+#define RATE_MCS6					BIT(18)
+#define RATE_MCS7					BIT(19)
+//MCS 2 Spatial Stream
+#define RATE_MCS8					BIT(20)
+#define RATE_MCS9					BIT(21)
+#define RATE_MCS10					BIT(22)
+#define RATE_MCS11					BIT(23)
+#define RATE_MCS12					BIT(24)
+#define RATE_MCS13					BIT(25)
+#define RATE_MCS14					BIT(26)
+#define RATE_MCS15					BIT(27)
+
+// ALL CCK Rate
+#define	RATE_ALL_CCK				RATR_1M|RATR_2M|RATR_55M|RATR_11M 
+#define	RATE_ALL_OFDM_AG			RATR_6M|RATR_9M|RATR_12M|RATR_18M|RATR_24M|\
+									RATR_36M|RATR_48M|RATR_54M	
+#define	RATE_ALL_OFDM_1SS			RATR_MCS0|RATR_MCS1|RATR_MCS2|RATR_MCS3 |\
+									RATR_MCS4|RATR_MCS5|RATR_MCS6	|RATR_MCS7	
+#define	RATE_ALL_OFDM_2SS			RATR_MCS8|RATR_MCS9	|RATR_MCS10|RATR_MCS11|\
+									RATR_MCS12|RATR_MCS13|RATR_MCS14|RATR_MCS15
+
+/*------------------------------ Tx Desc definition Macro ------------------------*/ 
+//#pragma mark -- Tx Desc related definition. --
+//----------------------------------------------------------------------------
+//-----------------------------------------------------------
+//	Rate
+//-----------------------------------------------------------
+// CCK Rates, TxHT = 0
+#define DESC_RATE1M				0x00
+#define DESC_RATE2M				0x01
+#define DESC_RATE5_5M				0x02
+#define DESC_RATE11M				0x03
+
+// OFDM Rates, TxHT = 0
+#define DESC_RATE6M				0x04
+#define DESC_RATE9M				0x05
+#define DESC_RATE12M				0x06
+#define DESC_RATE18M				0x07
+#define DESC_RATE24M				0x08
+#define DESC_RATE36M				0x09
+#define DESC_RATE48M				0x0a
+#define DESC_RATE54M				0x0b
+
+// MCS Rates, TxHT = 1
+#define DESC_RATEMCS0				0x0c
+#define DESC_RATEMCS1				0x0d
+#define DESC_RATEMCS2				0x0e
+#define DESC_RATEMCS3				0x0f
+#define DESC_RATEMCS4				0x10
+#define DESC_RATEMCS5				0x11
+#define DESC_RATEMCS6				0x12
+#define DESC_RATEMCS7				0x13
+#define DESC_RATEMCS8				0x14
+#define DESC_RATEMCS9				0x15
+#define DESC_RATEMCS10				0x16
+#define DESC_RATEMCS11				0x17
+#define DESC_RATEMCS12				0x18
+#define DESC_RATEMCS13				0x19
+#define DESC_RATEMCS14				0x1a
+#define DESC_RATEMCS15				0x1b
+#define DESC_RATEMCS16				0x1C
+#define DESC_RATEMCS17				0x1D
+#define DESC_RATEMCS18				0x1E
+#define DESC_RATEMCS19				0x1F
+#define DESC_RATEMCS20				0x20
+#define DESC_RATEMCS21				0x21
+#define DESC_RATEMCS22				0x22
+#define DESC_RATEMCS23				0x23
+#define DESC_RATEMCS24				0x24
+#define DESC_RATEMCS25				0x25
+#define DESC_RATEMCS26				0x26
+#define DESC_RATEMCS27				0x27
+#define DESC_RATEMCS28				0x28
+#define DESC_RATEMCS29				0x29
+#define DESC_RATEMCS30				0x2A
+#define DESC_RATEMCS31				0x2B
+
+#define DESC_RATEVHTSS1MCS0		0x2c
+#define DESC_RATEVHTSS1MCS1		0x2d
+#define DESC_RATEVHTSS1MCS2		0x2e
+#define DESC_RATEVHTSS1MCS3		0x2f
+#define DESC_RATEVHTSS1MCS4		0x30
+#define DESC_RATEVHTSS1MCS5		0x31
+#define DESC_RATEVHTSS1MCS6		0x32
+#define DESC_RATEVHTSS1MCS7		0x33
+#define DESC_RATEVHTSS1MCS8		0x34
+#define DESC_RATEVHTSS1MCS9		0x35
+#define DESC_RATEVHTSS2MCS0		0x36
+#define DESC_RATEVHTSS2MCS1		0x37
+#define DESC_RATEVHTSS2MCS2		0x38
+#define DESC_RATEVHTSS2MCS3		0x39
+#define DESC_RATEVHTSS2MCS4		0x3a
+#define DESC_RATEVHTSS2MCS5		0x3b
+#define DESC_RATEVHTSS2MCS6		0x3c
+#define DESC_RATEVHTSS2MCS7		0x3d
+#define DESC_RATEVHTSS2MCS8		0x3e
+#define DESC_RATEVHTSS2MCS9		0x3f
+#define DESC_RATEVHTSS3MCS0		0x40
+#define DESC_RATEVHTSS3MCS1		0x41
+#define DESC_RATEVHTSS3MCS2		0x42
+#define DESC_RATEVHTSS3MCS3		0x43
+#define DESC_RATEVHTSS3MCS4		0x44
+#define DESC_RATEVHTSS3MCS5		0x45
+#define DESC_RATEVHTSS3MCS6		0x46
+#define DESC_RATEVHTSS3MCS7		0x47
+#define DESC_RATEVHTSS3MCS8		0x48
+#define DESC_RATEVHTSS3MCS9		0x49
+#define DESC_RATEVHTSS4MCS0		0x4A
+#define DESC_RATEVHTSS4MCS1		0x4B
+#define DESC_RATEVHTSS4MCS2		0x4C
+#define DESC_RATEVHTSS4MCS3		0x4D
+#define DESC_RATEVHTSS4MCS4		0x4E
+#define DESC_RATEVHTSS4MCS5		0x4F
+#define DESC_RATEVHTSS4MCS6		0x50
+#define DESC_RATEVHTSS4MCS7		0x51
+#define DESC_RATEVHTSS4MCS8		0x52
+#define DESC_RATEVHTSS4MCS9		0x53
+										
+typedef enum _FIRMWARE_SOURCE {
+	FW_SOURCE_IMG_FILE = 0,
+	FW_SOURCE_HEADER_FILE = 1,		//from header file
+} FIRMWARE_SOURCE, *PFIRMWARE_SOURCE;
+
+// BK, BE, VI, VO, HCCA, MANAGEMENT, COMMAND, HIGH, BEACON.
+//#define MAX_TX_QUEUE		9
+
+#define TX_SELE_HQ			BIT(0)		// High Queue
+#define TX_SELE_LQ			BIT(1)		// Low Queue
+#define TX_SELE_NQ			BIT(2)		// Normal Queue
+#define TX_SELE_EQ			BIT(3)		// Extern Queue
+
+#define PageNum_128(_Len)		(u32)(((_Len)>>7) + ((_Len)&0x7F ? 1:0))
+#define PageNum_256(_Len)		(u32)(((_Len)>>8) + ((_Len)&0xFF ? 1:0))
+#define PageNum_512(_Len)		(u32)(((_Len)>>9) + ((_Len)&0x1FF ? 1:0))
+#define PageNum(_Len, _Size)		(u32)(((_Len)/(_Size)) + ((_Len)&((_Size) - 1) ? 1:0))
+
+#define	DYNAMIC_FUNC_DISABLE		(0x0)
+#define DYNAMIC_ALL_FUNC_ENABLE		0xFFFFFFF
+
+void dump_chip_info(HAL_VERSION	ChipVersion);
+
+
+u8	//return the final channel plan decision
+hal_com_get_channel_plan(
+	IN	PADAPTER	padapter,
+	IN	u8			hw_channel_plan,	//channel plan from HW (efuse/eeprom)
+	IN	u8			sw_channel_plan,	//channel plan from SW (registry/module param)
+	IN	u8			def_channel_plan,	//channel plan used when the former two is invalid
+	IN	BOOLEAN		AutoLoadFail
+	);
+
+u8	MRateToHwRate(u8 rate);
+
+void	HalSetBrateCfg(
+	IN PADAPTER		Adapter,
+	IN u8			*mBratesOS,
+	OUT u16			*pBrateCfg);
+
+BOOLEAN
+Hal_MappingOutPipe(
+	IN	PADAPTER	pAdapter,
+	IN	u8		NumOutPipe
+	);
+
+BOOLEAN
+HAL_IsLegalChannel(
+	IN	_adapter *	Adapter,
+	IN	u32			Channel
+	);
+
+void hal_init_macaddr(_adapter *adapter);
+void SetHwReg(PADAPTER padapter, u8 variable, u8 *val);
+void GetHwReg(PADAPTER padapter, u8 variable, u8 *val);
+
+#if defined (CONFIG_RTL8188F) || defined (CONFIG_RTL8711B)
+typedef enum _RT_MEDIA_STATUS {
+	RT_MEDIA_DISCONNECT = 0,
+	RT_MEDIA_CONNECT       = 1
+} RT_MEDIA_STATUS;
+
+
+void GetHalODMVar(	
+	PADAPTER				Adapter,
+	HAL_ODM_VARIABLE		eVariable,
+	PVOID					pValue1,
+	PVOID					pValue2);
+
+void SetHalODMVar(
+	PADAPTER				Adapter,
+	HAL_ODM_VARIABLE		eVariable,
+	PVOID					pValue1,
+	BOOLEAN					bSet);
+
+u8 SetHalDefVar(_adapter *adapter, HAL_DEF_VARIABLE variable, void *value);
+u8 GetHalDefVar(_adapter *adapter, HAL_DEF_VARIABLE variable, void *value);
+void rtw_hal_wow_enable(_adapter *adapter);
+void rtw_hal_wow_disable(_adapter *adapter);
+#endif
+#endif //__HAL_COMMON_H__
+

USDK/component/common/drivers/wlan/realtek/include/hal_com_phycfg.h

@@ -0,0 +1,288 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef __HAL_COM_PHYCFG_H__
+#define __HAL_COM_PHYCFG_H__
+
+#define		PathA                     			0x0	// Useless
+#define		PathB                     			0x1
+#define		PathC                     			0x2
+#define		PathD                     			0x3
+
+typedef enum _RATE_SECTION {
+	CCK = 0,
+	OFDM,
+	HT_MCS0_MCS7,
+	HT_MCS8_MCS15,
+	HT_MCS16_MCS23,
+	HT_MCS24_MCS31,
+	VHT_1SSMCS0_1SSMCS9,
+	VHT_2SSMCS0_2SSMCS9,
+	VHT_3SSMCS0_3SSMCS9,
+	VHT_4SSMCS0_4SSMCS9,
+} RATE_SECTION;
+
+typedef enum _RF_TX_NUM {
+	RF_1TX = 0,
+	RF_2TX,
+	RF_3TX,
+	RF_4TX,
+	RF_MAX_TX_NUM,
+	RF_TX_NUM_NONIMPLEMENT,
+} RF_TX_NUM;
+
+#define MAX_POWER_INDEX 		0x3F
+
+typedef enum _REGULATION_TXPWR_LMT {
+	TXPWR_LMT_FCC = 0,
+	TXPWR_LMT_MKK = 1,
+	TXPWR_LMT_ETSI = 2,
+	TXPWR_LMT_WW = 3, // WW13, The mininum of ETSI,MKK
+	TXPWR_LMT_GL = 4, // Global, The mininum of ETSI,MKK,FCC
+	TXPWR_LMT_MAX_REGULATION_NUM = 5
+} REGULATION_TXPWR_LMT;
+
+/*------------------------------Define structure----------------------------*/ 
+typedef struct _BB_REGISTER_DEFINITION{
+	u32 rfintfs;			// set software control: 
+						//		0x870~0x877[8 bytes]
+							
+	u32 rfintfo; 			// output data: 
+						//		0x860~0x86f [16 bytes]
+							
+	u32 rfintfe; 			// output enable: 
+						//		0x860~0x86f [16 bytes]
+							
+	u32 rf3wireOffset;	// LSSI data:
+						//		0x840~0x84f [16 bytes]
+
+	u32 rfHSSIPara2; 	// wire parameter control2 : 
+						//		0x824~0x827,0x82c~0x82f, 0x834~0x837, 0x83c~0x83f [16 bytes]
+								
+	u32 rfLSSIReadBack; 	//LSSI RF readback data SI mode
+						//		0x8a0~0x8af [16 bytes]
+
+	u32 rfLSSIReadBackPi; 	//LSSI RF readback data PI mode 0x8b8-8bc for Path A and B
+
+}BB_REGISTER_DEFINITION_T, *PBB_REGISTER_DEFINITION_T;
+
+
+//----------------------------------------------------------------------
+s32
+phy_TxPwrIdxToDbm(
+	IN	PADAPTER		Adapter,
+	IN	WIRELESS_MODE	WirelessMode,
+	IN	u8				TxPwrIdx	
+	);
+
+u8
+PHY_GetTxPowerByRateBase(
+	IN	PADAPTER		Adapter,
+	IN	u8				Band,
+	IN	u8				RfPath,
+	IN	u8				TxNum,
+	IN	RATE_SECTION	RateSection
+	);
+
+u8
+PHY_GetRateSectionIndexOfTxPowerByRate(
+	IN	PADAPTER	pAdapter,
+	IN	u32			RegAddr,
+	IN	u32			BitMask
+	);
+
+VOID
+PHY_GetRateValuesOfTxPowerByRate(
+	IN	PADAPTER	pAdapter,
+	IN	u32			RegAddr,
+	IN	u32			BitMask,
+	IN	u32			Value,
+	OUT	u8*			RateIndex,
+	OUT	s8*			PwrByRateVal,
+	OUT	u8*			RateNum
+	);
+
+u8
+PHY_GetRateIndexOfTxPowerByRate(
+	IN	u8	Rate
+	);
+
+VOID 
+PHY_SetTxPowerIndexByRateSection(
+	IN	PADAPTER		pAdapter,
+	IN	u8				RFPath,	
+	IN	u8				Channel,
+	IN	u8				RateSection
+	);
+
+s8
+PHY_GetTxPowerByRate( 
+	IN	PADAPTER	pAdapter, 
+	IN	u8			Band, 
+	IN	u8			RFPath, 
+	IN	u8			TxNum, 
+	IN	u8			RateIndex
+	);
+
+VOID
+PHY_SetTxPowerByRate( 
+	IN	PADAPTER	pAdapter, 
+	IN	u8			Band, 
+	IN	u8			RFPath, 
+	IN	u8			TxNum, 
+	IN	u8			Rate,
+	IN	s8			Value
+	);
+
+VOID
+PHY_SetTxPowerLevelByPath(
+	IN	PADAPTER	Adapter,
+	IN	u8			channel,
+	IN	u8			path
+	);
+
+VOID 
+PHY_SetTxPowerIndexByRateArray(
+	IN	PADAPTER		pAdapter,
+	IN	u8				RFPath,
+	IN	CHANNEL_WIDTH	BandWidth,	
+	IN	u8				Channel,
+	IN	u8*				Rates,
+	IN	u8				RateArraySize
+	);
+
+VOID
+PHY_InitTxPowerByRate(
+	IN	PADAPTER	pAdapter
+	);
+
+VOID
+PHY_StoreTxPowerByRate(
+	IN	PADAPTER	pAdapter,
+	IN	u32			Band,
+	IN	u32			RfPath,
+	IN	u32			TxNum,
+	IN	u32			RegAddr,
+	IN	u32			BitMask,
+	IN	u32			Data
+	);
+
+VOID
+PHY_TxPowerByRateConfiguration(
+	IN  PADAPTER			pAdapter
+	);
+
+u8
+PHY_GetTxPowerIndexBase(
+	IN	PADAPTER		pAdapter,
+	IN	u8				RFPath,
+	IN	u8				Rate,	
+	IN	CHANNEL_WIDTH	BandWidth,	
+	IN	u8				Channel,
+	OUT PBOOLEAN		bIn24G
+	);
+
+s8
+PHY_GetTxPowerLimit(
+	IN	PADAPTER		Adapter,
+	IN	u32				RegPwrTblSel,
+	IN	BAND_TYPE		Band,
+	IN	CHANNEL_WIDTH	Bandwidth,
+	IN	u8				RfPath,
+	IN	u8				DataRate,
+	IN	u8				Channel
+	);
+
+VOID
+PHY_SetTxPowerLimit(
+	IN	PADAPTER			Adapter,
+	IN	u8					Regulation,
+	IN	u8					Band,
+	IN	u8					Bandwidth,
+	IN	u8					RateSection,
+	IN	u8					RfPath,
+	IN	u8					Channel,
+	IN	u8					PowerLimit
+	);
+
+VOID 
+PHY_ConvertTxPowerLimitToPowerIndex(
+	IN	PADAPTER			Adapter
+	);
+
+VOID
+PHY_InitTxPowerLimit(
+	IN	PADAPTER			Adapter
+	);
+
+s8
+PHY_GetTxPowerTrackingOffset( 
+	PADAPTER	pAdapter,
+	u8			Rate,
+	u8			RFPath
+	);
+
+u8
+PHY_GetTxPowerIndex(
+	IN	PADAPTER			pAdapter,
+	IN	u8					RFPath,
+	IN	u8					Rate,	
+	IN	CHANNEL_WIDTH		BandWidth,	
+	IN	u8					Channel
+	);
+
+VOID
+PHY_SetTxPowerIndex(
+	IN	PADAPTER		pAdapter,
+	IN	u32				PowerIndex,
+	IN	u8				RFPath,	
+	IN	u8				Rate
+	);
+
+#ifdef CONFIG_LOAD_PHY_PARA_FROM_FILE
+#define MAX_PARA_FILE_BUF_LEN	25600
+
+#define LOAD_MAC_PARA_FILE				BIT0
+#define LOAD_BB_PARA_FILE					BIT1
+#define LOAD_BB_PG_PARA_FILE				BIT2
+#define LOAD_BB_MP_PARA_FILE				BIT3
+#define LOAD_RF_PARA_FILE					BIT4
+#define LOAD_RF_TXPWR_TRACK_PARA_FILE	BIT5
+#define LOAD_RF_TXPWR_LMT_PARA_FILE		BIT6
+
+int phy_ConfigMACWithParaFile(IN PADAPTER	Adapter, IN char*	pFileName);
+
+int phy_ConfigBBWithParaFile(IN PADAPTER	Adapter, IN char*	pFileName, IN u32	ConfigType);
+
+int phy_ConfigBBWithPgParaFile(IN PADAPTER	Adapter, IN char*	pFileName);
+
+int phy_ConfigBBWithMpParaFile(IN PADAPTER	Adapter, IN char*	pFileName);
+
+int PHY_ConfigRFWithParaFile(IN	PADAPTER	Adapter, IN char*	pFileName, IN u8	eRFPath);
+
+int PHY_ConfigRFWithTxPwrTrackParaFile(IN PADAPTER	Adapter, IN char*	pFileName);
+
+int PHY_ConfigRFWithPowerLimitTableParaFile(IN PADAPTER	Adapter, IN char*	pFileName);
+
+void phy_free_filebuf(_adapter *padapter);
+#endif //CONFIG_LOAD_PHY_PARA_FROM_FILE
+
+
+#endif //__HAL_COMMON_H__
+

USDK/component/common/drivers/wlan/realtek/include/hal_intf.h

@@ -0,0 +1,666 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef __HAL_INTF_H__
+#define __HAL_INTF_H__
+
+enum RTL871X_HCI_TYPE {
+	RTW_PCIE	= BIT0,
+	RTW_USB 	= BIT1,
+	RTW_SDIO	= BIT2,
+	RTW_GSPI	= BIT3,
+	RTW_LXBUS	= BIT4,
+};
+
+enum _CHIP_TYPE {
+
+	NULL_CHIP_TYPE,	
+	RTL8188C_8192C,
+	RTL8192D,
+	RTL8723A,
+	RTL8188E,
+	RTL8192E,
+	RTL8812,
+	RTL8821, //RTL8811
+	RTL8723B,
+	RTL8195A_SOC,
+	RTL8711B_SOC,
+	RTL8188F,
+	MAX_CHIP_TYPE
+};
+
+
+typedef enum _HW_VARIABLES{
+	HW_VAR_MEDIA_STATUS,
+	HW_VAR_MEDIA_STATUS1,
+	HW_VAR_SET_OPMODE,
+	HW_VAR_MAC_ADDR,
+	HW_VAR_BSSID,
+	HW_VAR_INIT_RTS_RATE,
+	HW_VAR_BASIC_RATE,
+	HW_VAR_TXPAUSE,
+	HW_VAR_BCN_FUNC,
+	HW_VAR_CORRECT_TSF,
+	HW_VAR_CHECK_BSSID,
+	HW_VAR_MLME_DISCONNECT,
+	HW_VAR_MLME_SITESURVEY,
+	HW_VAR_MLME_JOIN,
+	HW_VAR_ON_RCR_AM,
+	HW_VAR_OFF_RCR_AM,
+	HW_VAR_BEACON_INTERVAL,
+	HW_VAR_SLOT_TIME,
+	HW_VAR_RESP_SIFS,
+	HW_VAR_ACK_PREAMBLE,
+	HW_VAR_SEC_CFG,
+	HW_VAR_SEC_DK_CFG,
+#if !defined(CONFIG_LX_HCI)
+	HW_VAR_BCN_VALID,
+#endif
+	HW_VAR_RF_TYPE,
+	HW_VAR_DM_FLAG,
+	HW_VAR_DM_FUNC_OP,
+	HW_VAR_DM_FUNC_SET,
+	HW_VAR_DM_FUNC_CLR,
+	HW_VAR_CAM_EMPTY_ENTRY,
+	HW_VAR_CAM_INVALID_ALL,
+	HW_VAR_CAM_WRITE,
+	HW_VAR_CAM_READ,
+	HW_VAR_AC_PARAM_VO,
+	HW_VAR_AC_PARAM_VI,
+	HW_VAR_AC_PARAM_BE,
+	HW_VAR_AC_PARAM_BK,
+	HW_VAR_ACM_CTRL,
+	HW_VAR_AMPDU_MIN_SPACE,
+	HW_VAR_AMPDU_FACTOR,
+	HW_VAR_RXDMA_AGG_PG_TH,
+	HW_VAR_SET_RPWM,
+	HW_VAR_GET_RPWM,
+	HW_VAR_CPWM,
+	HW_VAR_H2C_FW_PWRMODE,
+	HW_VAR_H2C_PS_TUNE_PARAM,
+	HW_VAR_H2C_FW_JOINBSSRPT,
+	HW_VAR_FWLPS_RF_ON,
+	HW_VAR_H2C_FW_P2P_PS_OFFLOAD,
+	HW_VAR_TDLS_WRCR,
+	HW_VAR_TDLS_INIT_CH_SEN,
+	HW_VAR_TDLS_RS_RCR,
+	HW_VAR_TDLS_DONE_CH_SEN,
+	HW_VAR_INITIAL_GAIN,
+	HW_VAR_TRIGGER_GPIO_0,
+#if !defined(NOT_SUPPORT_BT)
+	HW_VAR_BT_SET_COEXIST,
+	HW_VAR_BT_ISSUE_DELBA,	
+#endif
+	HW_VAR_CURRENT_ANTENNA,
+	HW_VAR_ANTENNA_DIVERSITY_LINK,
+	HW_VAR_ANTENNA_DIVERSITY_SELECT,
+	HW_VAR_SWITCH_EPHY_WoWLAN,
+	HW_VAR_EFUSE_USAGE,
+	HW_VAR_EFUSE_BYTES,
+#if !defined(NOT_SUPPORT_BT)
+	HW_VAR_EFUSE_BT_USAGE,
+	HW_VAR_EFUSE_BT_BYTES,
+#endif
+	HW_VAR_FIFO_CLEARN_UP,
+	HW_VAR_RESTORE_HW_SEQ,
+	HW_VAR_HCI_SUS_STATE,
+	HW_VAR_CHECK_TXBUF,
+	HW_VAR_APFM_ON_MAC, //Auto FSM to Turn On, include clock, isolation, power control for MAC only
+	// The valid upper nav range for the HW updating, if the true value is larger than the upper range, the HW won't update it.
+	// Unit in microsecond. 0 means disable this function.
+#ifdef CONFIG_WOWLAN
+	HW_VAR_WOWLAN,
+	HW_VAR_WAKEUP_REASON,
+	HW_VAR_RPWM_TOG,
+#endif
+#ifdef CONFIG_GPIO_WAKEUP
+	HW_SET_GPIO_WL_CTRL,
+#endif
+	HW_VAR_NAV_UPPER,
+	HW_VAR_C2H_HANDLE,
+	HW_VAR_RPT_TIMER_SETTING,
+	HW_VAR_TX_RPT_MAX_MACID,	
+	HW_VAR_H2C_MEDIA_STATUS_RPT,
+	HW_VAR_CHK_HI_QUEUE_EMPTY,
+	HW_VAR_DL_BCN_SEL,
+	HW_VAR_PORT_SWITCH,
+//	HW_VAR_DO_IQK,
+	HW_VAR_DM_IN_LPS,
+	HW_VAR_SET_REQ_FW_PS,
+	HW_VAR_FW_PS_STATE,
+	HW_VAR_DL_RSVD_PAGE,
+	HW_VAR_MACID_SLEEP,
+	HW_VAR_MACID_WAKEUP,
+	HW_VAR_DUMP_MAC_QUEUE_INFO,
+	HW_VAR_ASIX_IOT,
+#ifdef CONFIG_PROMISC
+	HW_VAR_PROMISC,
+#endif
+}HW_VARIABLES;
+
+typedef enum _HAL_DEF_VARIABLE{
+	HAL_DEF_UNDERCORATEDSMOOTHEDPWDB,
+	HAL_DEF_IS_SUPPORT_ANT_DIV,
+	HAL_DEF_CURRENT_ANTENNA,
+	HAL_DEF_DRVINFO_SZ,
+	HAL_DEF_MAX_RECVBUF_SZ,
+	HAL_DEF_RX_PACKET_OFFSET,
+//	HAL_DEF_DBG_DUMP_RXPKT,//for dbg
+	HAL_DEF_RX_DMA_SZ_WOW,
+	HAL_DEF_RX_DMA_SZ,
+	HAL_DEF_RX_PAGE_SIZE,
+	HAL_DEF_DBG_DM_FUNC,//for dbg
+	HAL_DEF_RA_DECISION_RATE,
+	HAL_DEF_RA_SGI,
+	HAL_DEF_PT_PWR_STATUS,
+	HW_VAR_MAX_RX_AMPDU_FACTOR,
+	HW_DEF_RA_INFO_DUMP,
+	HAL_DEF_DBG_DUMP_TXPKT,
+	HW_DEF_ODM_DBG_FLAG,
+	HW_DEF_ODM_DBG_LEVEL,
+	HAL_DEF_TX_PAGE_SIZE,
+	HAL_DEF_TX_PAGE_BOUNDARY,
+	HAL_DEF_MACID_SLEEP, // Support for MACID sleep
+	HAL_DEF_DBG_RX_INFO_DUMP,
+}HAL_DEF_VARIABLE;
+
+typedef enum _HAL_ODM_VARIABLE{
+	HAL_ODM_STA_INFO,	
+//	HAL_ODM_P2P_STATE,
+//	HAL_ODM_WIFI_DISPLAY_STATE,
+	HAL_ODM_DBG_FLAG,
+//	HAL_ODM_DBG_LEVEL,
+	HAL_ODM_RX_INFO_DUMP,
+	HAL_ODM_NOISE_MONITOR,
+	HAL_ODM_REGULATION,
+}HAL_ODM_VARIABLE;
+
+typedef enum _HAL_INTF_PS_FUNC{
+	HAL_USB_SELECT_SUSPEND,
+	HAL_MAX_ID,
+}HAL_INTF_PS_FUNC;
+
+typedef s32 (*c2h_id_filter)(u8 *c2h_evt);
+
+struct hal_ops {
+	u32	(*hal_power_on)(_adapter *padapter);
+	u32	(*hal_init)(_adapter *padapter);
+	u32	(*hal_deinit)(_adapter *padapter);
+
+	void	(*free_hal_data)(_adapter *padapter);
+
+	u32	(*inirp_init)(_adapter *padapter);
+	u32	(*inirp_deinit)(_adapter *padapter);
+	void	(*irp_reset)(_adapter *padapter);
+
+	s32	(*init_xmit_priv)(_adapter *padapter);
+	void	(*free_xmit_priv)(_adapter *padapter);
+	
+	s32	(*init_recv_priv)(_adapter *padapter);
+	void	(*free_recv_priv)(_adapter *padapter);
+
+	void (*update_txdesc)(struct xmit_frame *pxmitframe, u8 *pbuf);
+
+	void	(*InitSwLeds)(_adapter *padapter);
+	void	(*DeInitSwLeds)(_adapter *padapter);
+
+	void	(*dm_init)(_adapter *padapter);
+	void	(*dm_deinit)(_adapter *padapter);
+	void	(*read_chip_version)(_adapter *padapter);
+
+	void	(*init_default_value)(_adapter *padapter);
+
+	void	(*intf_chip_configure)(_adapter *padapter);
+
+	void	(*read_adapter_info)(_adapter *padapter);
+
+	void	(*enable_interrupt)(_adapter *padapter);
+	void	(*disable_interrupt)(_adapter *padapter);
+
+	s32		(*interrupt_handler)(_adapter *padapter);
+//pvvx	void	(*clear_interrupt)(_adapter *padapter); // нету в SDK !
+	
+#ifdef CONFIG_WOWLAN
+	void	(*disable_interrupt_but_cpwm2)(_adapter *padapter);
+	void (*hal_set_wowlan_fw)(_adapter *adapter, u8 sleep);
+#endif //CONFIG_WOWLAN
+
+	void	(*set_bwmode_handler)(_adapter *padapter, CHANNEL_WIDTH Bandwidth, u8 Offset);
+	void	(*set_channel_handler)(_adapter *padapter, u8 channel);
+	void	(*set_chnl_bw_handler)(_adapter *padapter, u8 channel, CHANNEL_WIDTH Bandwidth, u8 Offset40, u8 Offset80);
+
+	void	(*hal_dm_watchdog)(_adapter *padapter);
+#if 0
+	void	(*hal_dm_watchdog_in_lps)(_adapter *padapter);
+#endif
+	void	(*SetHwRegHandler)(_adapter *padapter, u8	variable,u8* val);
+	void	(*GetHwRegHandler)(_adapter *padapter, u8	variable,u8* val);
+
+	u8	(*GetHalDefVarHandler)(_adapter *padapter, HAL_DEF_VARIABLE eVariable, PVOID pValue);
+	u8	(*SetHalDefVarHandler)(_adapter *padapter, HAL_DEF_VARIABLE eVariable, PVOID pValue);
+
+	void	(*GetHalODMVarHandler)(_adapter *padapter, HAL_ODM_VARIABLE eVariable, PVOID pValue1,BOOLEAN bSet);
+	void	(*SetHalODMVarHandler)(_adapter *padapter, HAL_ODM_VARIABLE eVariable, PVOID pValue1,BOOLEAN bSet);
+
+	void	(*UpdateRAMaskHandler)(_adapter *padapter, u32 mac_id, u8 rssi_level);
+#if 0
+	void	(*SetBeaconRelatedRegistersHandler)(_adapter *padapter);
+#endif
+
+	void	(*Add_RateATid)(_adapter *padapter, u32 bitmap, u8 *arg, u8 rssi_level);
+#ifdef CONFIG_CONCURRENT_MODE	
+	void	(*clone_haldata)(_adapter *dst_padapter, _adapter *src_padapter);
+#endif
+
+	void	(*run_thread)(_adapter *padapter);
+	void	(*cancel_thread)(_adapter *padapter);
+
+
+#ifdef CONFIG_ANTENNA_DIVERSITY
+	u8	(*AntDivBeforeLinkHandler)(_adapter *padapter);
+	void	(*AntDivCompareHandler)(_adapter *padapter, WLAN_BSSID_EX *dst, WLAN_BSSID_EX *src);
+#endif
+#if 0
+	u8	(*interface_ps_func)(_adapter *padapter,HAL_INTF_PS_FUNC efunc_id, u8* val);
+#endif
+	s32	(*hal_xmit)(_adapter *padapter, struct xmit_frame *pxmitframe);
+	s32 (*mgnt_xmit)(_adapter *padapter, struct xmit_frame *pmgntframe);
+
+	u32	(*read_bbreg)(_adapter *padapter, u32 RegAddr, u32 BitMask);
+	void	(*write_bbreg)(_adapter *padapter, u32 RegAddr, u32 BitMask, u32 Data);
+	u32	(*read_rfreg)(_adapter *padapter, u32 eRFPath, u32 RegAddr, u32 BitMask);
+	void	(*write_rfreg)(_adapter *padapter, u32 eRFPath, u32 RegAddr, u32 BitMask, u32 Data);
+
+#ifdef CONFIG_HOSTAPD_MLME
+	s32	(*hostap_mgnt_xmit_entry)(_adapter *padapter, _pkt *pkt);
+#endif
+
+	void (*EfusePowerSwitch)(_adapter *padapter, u8 bWrite, u8 PwrState);
+	void (*ReadEFuse)(_adapter *padapter, u8 efuseType, u16 _offset, u16 _size_byte, u8 *pbuf, BOOLEAN bPseudoTest);
+	void (*EFUSEGetEfuseDefinition)(_adapter *padapter, u8 efuseType, u8 type, void *pOut, BOOLEAN bPseudoTest);
+	u16	(*EfuseGetCurrentSize)(_adapter *padapter, u8 efuseType, BOOLEAN bPseudoTest);
+#if 0
+	int 	(*Efuse_PgPacketRead)(_adapter *padapter, u8 offset, u8 *data, BOOLEAN bPseudoTest);
+#endif
+	int 	(*Efuse_PgPacketWrite)(_adapter *padapter, u8 offset, u8 word_en, u8 *data, BOOLEAN bPseudoTest);
+	u8	(*Efuse_WordEnableDataWrite)(_adapter *padapter, u16 efuse_addr, u8 word_en, u8 *data, BOOLEAN bPseudoTest);
+#if !defined(NOT_SUPPORT_BT)
+	BOOLEAN	(*Efuse_PgPacketWrite_BT)(_adapter *padapter, u8 offset, u8 word_en, u8 *data, BOOLEAN bPseudoTest);
+#endif
+	
+#ifdef DBG_CONFIG_ERROR_DETECT
+	void (*sreset_init_value)(_adapter *padapter);
+	void (*sreset_reset_value)(_adapter *padapter);		
+	void (*silentreset)(_adapter *padapter);
+	void (*sreset_xmit_status_check)(_adapter *padapter);
+	void (*sreset_linked_status_check) (_adapter *padapter);
+	u8 (*sreset_get_wifi_status)(_adapter *padapter);
+#endif
+
+#ifdef CONFIG_IOL
+	int (*IOL_exec_cmds_sync)(_adapter *padapter, struct xmit_frame *xmit_frame, u32 max_wating_ms);
+#endif
+
+#if 0//def CONFIG_XMIT_THREAD_MODE
+	s32 (*xmit_thread_handler)(_adapter *padapter);
+#endif
+	void (*recv_tasklet) (void *padapter);
+
+#if 0
+	void (*hal_notch_filter)(_adapter * adapter, bool enable);
+	void (*hal_reset_security_engine)(_adapter * adapter);
+#endif	
+	s32 (*fill_h2c_cmd)(PADAPTER, u8 ElementID, u32 CmdLen, u8 *pCmdBuffer);
+	void (*fill_fake_txdesc)(PADAPTER, u8 *pDesc, u32 BufferLen,
+			u8 IsPsPoll, u8 IsBTQosNull, u8 bDataFrame);
+	u8 (*hal_get_tx_buff_rsvd_page_num)(_adapter *adapter, bool wowlan);
+};
+
+typedef	enum _RT_EEPROM_TYPE{
+	EEPROM_93C46,
+	EEPROM_93C56,
+	EEPROM_BOOT_EFUSE,
+}RT_EEPROM_TYPE,*PRT_EEPROM_TYPE;
+
+#define USB_HIGH_SPEED_BULK_SIZE	512
+#define USB_FULL_SPEED_BULK_SIZE	64
+
+#define RF_CHANGE_BY_INIT	0
+#define RF_CHANGE_BY_IPS 	BIT28
+#define RF_CHANGE_BY_PS 	BIT29
+#define RF_CHANGE_BY_HW 	BIT30
+#define RF_CHANGE_BY_SW 	BIT31
+
+typedef enum _HARDWARE_TYPE{
+	HARDWARE_TYPE_RTL8180,
+	HARDWARE_TYPE_RTL8185,
+	HARDWARE_TYPE_RTL8187,
+	HARDWARE_TYPE_RTL8188,
+	HARDWARE_TYPE_RTL8190P,
+	HARDWARE_TYPE_RTL8192E,
+	HARDWARE_TYPE_RTL819xU,
+	HARDWARE_TYPE_RTL8192SE,
+	HARDWARE_TYPE_RTL8192SU,
+	HARDWARE_TYPE_RTL8192CE,
+	HARDWARE_TYPE_RTL8192CU,
+	HARDWARE_TYPE_RTL8192DE,
+	HARDWARE_TYPE_RTL8192DU,
+	HARDWARE_TYPE_RTL8723AE,
+	HARDWARE_TYPE_RTL8723AU,
+	HARDWARE_TYPE_RTL8723AS,
+	HARDWARE_TYPE_RTL8188EE,
+	HARDWARE_TYPE_RTL8188EU,
+	HARDWARE_TYPE_RTL8188ES,
+//	NEW_GENERATION_IC
+	HARDWARE_TYPE_RTL8192EE,
+	HARDWARE_TYPE_RTL8192EU,
+	HARDWARE_TYPE_RTL8192ES,
+	HARDWARE_TYPE_RTL8812E,
+	HARDWARE_TYPE_RTL8812AU,
+	HARDWARE_TYPE_RTL8811AU,
+	HARDWARE_TYPE_RTL8821E,
+	HARDWARE_TYPE_RTL8821U,
+	HARDWARE_TYPE_RTL8821S,
+	HARDWARE_TYPE_RTL8723BE,
+	HARDWARE_TYPE_RTL8723BU,
+	HARDWARE_TYPE_RTL8723BS,
+	HARDWARE_TYPE_RTL8195A,
+	HARDWARE_TYPE_RTL8711B,
+	HARDWARE_TYPE_RTL8188FE,
+	HARDWARE_TYPE_RTL8188FU,
+	HARDWARE_TYPE_RTL8188FS,
+	
+	HARDWARE_TYPE_MAX,
+}HARDWARE_TYPE;
+
+#define IS_NEW_GENERATION_IC(_Adapter)	(((_adapter *)_Adapter)->HardwareType >=HARDWARE_TYPE_RTL8192EE)
+//
+// RTL8192C Series
+//
+#define IS_HARDWARE_TYPE_8192CE(_Adapter)	(((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8192CE)
+#define IS_HARDWARE_TYPE_8192CU(_Adapter)	(((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8192CU)
+#define	IS_HARDWARE_TYPE_8192C(_Adapter)			\
+(IS_HARDWARE_TYPE_8192CE(_Adapter) || IS_HARDWARE_TYPE_8192CU(_Adapter))
+
+//
+// RTL8192D Series
+//
+#define IS_HARDWARE_TYPE_8192DE(_Adapter)	(((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8192DE)
+#define IS_HARDWARE_TYPE_8192DU(_Adapter)	(((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8192DU)
+#define	IS_HARDWARE_TYPE_8192D(_Adapter)			\
+(IS_HARDWARE_TYPE_8192DE(_Adapter) || IS_HARDWARE_TYPE_8192DU(_Adapter))
+
+//
+// RTL8723A Series
+//
+#define IS_HARDWARE_TYPE_8723AE(_Adapter)	(((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8723AE)
+#define IS_HARDWARE_TYPE_8723AU(_Adapter)	(((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8723AU)
+#define IS_HARDWARE_TYPE_8723AS(_Adapter)	(((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8723AS)
+#define	IS_HARDWARE_TYPE_8723A(_Adapter)	\
+(IS_HARDWARE_TYPE_8723AE(_Adapter) || IS_HARDWARE_TYPE_8723AU(_Adapter) || IS_HARDWARE_TYPE_8723AS(_Adapter))
+//
+// RTL8188E Series
+//
+#define IS_HARDWARE_TYPE_8188EE(_Adapter)	(((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8188EE)
+#define IS_HARDWARE_TYPE_8188EU(_Adapter)	(((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8188EU)
+#define IS_HARDWARE_TYPE_8188ES(_Adapter)	(((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8188ES)
+#define	IS_HARDWARE_TYPE_8188E(_Adapter)	\
+(IS_HARDWARE_TYPE_8188EE(_Adapter) || IS_HARDWARE_TYPE_8188EU(_Adapter) || IS_HARDWARE_TYPE_8188ES(_Adapter))
+//
+//RTL8188F Series
+//
+#define IS_HARDWARE_TYPE_8188FE(_Adapter)	(((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8188FE)
+#define IS_HARDWARE_TYPE_8188FU(_Adapter)	(((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8188EU)
+#define IS_HARDWARE_TYPE_8188FS(_Adapter)	(((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8188FS)
+#define IS_HARDWARE_TYPE_8188F(_Adapter)	\
+(IS_HARDWARE_TYPE_8188FE(_Adapter) || IS_HARDWARE_TYPE_8188FU(_Adapter) || IS_HARDWARE_TYPE_8188FS(_Adapter))
+//
+// RTL8812 Series
+//
+#define IS_HARDWARE_TYPE_8812E(_Adapter)		(((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8812E)
+#define IS_HARDWARE_TYPE_8812AU(_Adapter)	(((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8812AU)
+#define IS_HARDWARE_TYPE_8812(_Adapter)			\
+(IS_HARDWARE_TYPE_8812E(_Adapter) || IS_HARDWARE_TYPE_8812AU(_Adapter))
+
+// RTL8821 Series
+#define IS_HARDWARE_TYPE_8821E(_Adapter)		(((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8821E)
+#define IS_HARDWARE_TYPE_8821U(_Adapter)		(((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8821U ||\
+	              								 ((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8811AU)
+#define IS_HARDWARE_TYPE_8821S(_Adapter)		(((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8821S)
+#define IS_HARDWARE_TYPE_8821(_Adapter)			\
+(IS_HARDWARE_TYPE_8821E(_Adapter) || IS_HARDWARE_TYPE_8821U(_Adapter)|| IS_HARDWARE_TYPE_8821S(_Adapter))
+
+#define IS_HARDWARE_TYPE_JAGUAR(_Adapter)		\
+(IS_HARDWARE_TYPE_8812(_Adapter) || IS_HARDWARE_TYPE_8821(_Adapter))
+
+//RTL8192E Series
+#define IS_HARDWARE_TYPE_8192EE(_Adapter)		(((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8192EE)
+#define IS_HARDWARE_TYPE_8192EU(_Adapter)		(((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8192EU)
+#define IS_HARDWARE_TYPE_8192ES(_Adapter)		(((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8192ES)
+
+#define IS_HARDWARE_TYPE_8192E(_Adapter)		\
+(IS_HARDWARE_TYPE_8192EE(_Adapter) || IS_HARDWARE_TYPE_8192EU(_Adapter) ||IS_HARDWARE_TYPE_8192ES(_Adapter))
+
+#define IS_HARDWARE_TYPE_8723BE(_Adapter)		(((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8723BE)
+#define IS_HARDWARE_TYPE_8723BU(_Adapter)		(((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8723BU)
+#define IS_HARDWARE_TYPE_8723BS(_Adapter)		(((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8723BS)
+
+
+#define IS_HARDWARE_TYPE_8723B(_Adapter) \
+	(IS_HARDWARE_TYPE_8723BE(_Adapter) || IS_HARDWARE_TYPE_8723BU(_Adapter) ||IS_HARDWARE_TYPE_8723BS(_Adapter))
+
+#define IS_HARDWARE_TYPE_8195A(_Adapter)		(((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8195A)
+
+#define IS_HARDWARE_TYPE_8711B(_Adapter)		(((_adapter *)_Adapter)->HardwareType==HARDWARE_TYPE_RTL8711B)
+
+typedef struct eeprom_priv EEPROM_EFUSE_PRIV, *PEEPROM_EFUSE_PRIV;
+#define GET_EEPROM_EFUSE_PRIV(adapter) (&adapter->eeprompriv)
+#define is_boot_from_eeprom(adapter) (adapter->eeprompriv.EepromOrEfuse)
+
+//TODO
+
+#ifdef CONFIG_WOWLAN
+typedef enum _wowlan_subcode{
+	WOWLAN_PATTERN_MATCH	= 1,
+	WOWLAN_MAGIC_PACKET		= 2,
+	WOWLAN_UNICAST			= 3,
+	WOWLAN_SET_PATTERN		= 4,
+	WOWLAN_DUMP_REG			= 5,
+	WOWLAN_ENABLE			= 6,
+	WOWLAN_DISABLE			= 7,
+	WOWLAN_STATUS			= 8,
+	WOWLAN_DEBUG_RELOAD_FW	= 9,
+	WOWLAN_DEBUG_1			=10,
+	WOWLAN_DEBUG_2			=11
+}wowlan_subcode;
+
+struct wowlan_ioctl_param{
+	unsigned int subcode;
+	unsigned int subcode_value;
+	unsigned int wakeup_reason;
+	unsigned int len;
+	unsigned char pattern[0];
+};
+
+#define Rx_Pairwisekey			0x01
+#define Rx_GTK					0x02
+#define Rx_DisAssoc				0x04
+#define Rx_DeAuth				0x08
+#define FWDecisionDisconnect	0x10
+#define Rx_MagicPkt				0x21
+#define Rx_UnicastPkt			0x22
+#define Rx_PatternPkt			0x23
+#endif // CONFIG_WOWLAN
+
+void rtw_hal_def_value_init(_adapter *padapter);
+
+void	rtw_hal_free_data(_adapter *padapter);
+
+void rtw_hal_dm_init(_adapter *padapter);
+void rtw_hal_dm_deinit(_adapter *padapter);
+#if 0
+void rtw_hal_sw_led_init(_adapter *padapter);
+void rtw_hal_sw_led_deinit(_adapter *padapter);
+#endif
+u32 rtw_hal_power_on(_adapter *padapter);
+uint rtw_hal_init(_adapter *padapter);
+uint rtw_hal_deinit(_adapter *padapter);
+void rtw_hal_stop(_adapter *padapter);
+void rtw_hal_set_hwreg(PADAPTER padapter, u8 variable, u8 *val);
+void rtw_hal_get_hwreg(PADAPTER padapter, u8 variable, u8 *val);
+
+void rtw_hal_chip_configure(_adapter *padapter);
+void rtw_hal_read_chip_info(_adapter *padapter);
+void rtw_hal_read_chip_version(_adapter *padapter);
+
+u8 rtw_hal_set_def_var(_adapter *padapter, HAL_DEF_VARIABLE eVariable, PVOID pValue);
+u8 rtw_hal_get_def_var(_adapter *padapter, HAL_DEF_VARIABLE eVariable, PVOID pValue);
+
+void rtw_hal_set_odm_var(_adapter *padapter, HAL_ODM_VARIABLE eVariable, PVOID pValue1,BOOLEAN bSet);
+void	rtw_hal_get_odm_var(_adapter *padapter, HAL_ODM_VARIABLE eVariable, PVOID pValue1,BOOLEAN bSet);
+	
+void rtw_hal_enable_interrupt(_adapter *padapter);
+void rtw_hal_disable_interrupt(_adapter *padapter);
+void rtw_hal_clear_interrupt(_adapter *padapter);
+#ifdef CONFIG_WOWLAN
+void rtw_hal_disable_interrupt_but_cpwm2(_adapter *padapter);
+#endif
+
+u32	rtw_hal_inirp_init(_adapter *padapter);
+u32	rtw_hal_inirp_deinit(_adapter *padapter);
+
+void	rtw_hal_irp_reset(_adapter *padapter);
+#if 0
+u8	rtw_hal_intf_ps_func(_adapter *padapter,HAL_INTF_PS_FUNC efunc_id, u8* val);
+#endif
+s32	rtw_hal_xmit(_adapter *padapter, struct xmit_frame *pxmitframe);
+s32	rtw_hal_mgnt_xmit(_adapter *padapter, struct xmit_frame *pmgntframe);
+
+s32	rtw_hal_init_xmit_priv(_adapter *padapter);
+void	rtw_hal_free_xmit_priv(_adapter *padapter);
+
+#if 1
+s32	rtw_hal_init_recv_priv(_adapter *padapter);
+void	rtw_hal_free_recv_priv(_adapter *padapter);
+#endif
+
+void rtw_hal_update_ra_mask(struct sta_info *psta, u8 rssi_level);
+void	rtw_hal_add_ra_tid(_adapter *padapter, u32 bitmap, u8 *arg, u8 rssi_level);
+void	rtw_hal_clone_data(_adapter *dst_padapter, _adapter *src_padapter);
+#ifdef CONFIG_LITTLE_WIFI_MCU_FUNCTION_THREAD
+void	rtw_hal_start_thread(_adapter *padapter);
+void	rtw_hal_stop_thread(_adapter *padapter);
+#endif
+void rtw_hal_bcn_related_reg_setting(_adapter *padapter);
+
+u32	rtw_hal_read_bbreg(_adapter *padapter, u32 RegAddr, u32 BitMask);
+void	rtw_hal_write_bbreg(_adapter *padapter, u32 RegAddr, u32 BitMask, u32 Data);
+u32	rtw_hal_read_rfreg(_adapter *padapter, u32 eRFPath, u32 RegAddr, u32 BitMask);
+void	rtw_hal_write_rfreg(_adapter *padapter, u32 eRFPath, u32 RegAddr, u32 BitMask, u32 Data);
+
+s32	rtw_hal_interrupt_handler(_adapter *padapter);
+
+void	rtw_hal_set_bwmode(_adapter *padapter, CHANNEL_WIDTH Bandwidth, u8 Offset);
+void	rtw_hal_set_chan(_adapter *padapter, u8 channel);
+void	rtw_hal_set_chnl_bw(_adapter *padapter, u8 channel, CHANNEL_WIDTH Bandwidth, u8 Offset40, u8 Offset80);
+void	rtw_hal_dm_watchdog(_adapter *padapter);
+#if 1
+void rtw_hal_update_txdesc(_adapter  *padapter, struct xmit_frame *pxmitframe, u8 *pbuf);
+#endif
+s32 rtw_hal_fill_h2c_cmd(PADAPTER padapter, u8 ElementID, u32 CmdLen, u8 *pCmdBuffer);
+
+void rtw_hal_fill_fake_txdesc(_adapter* padapter, u8* pDesc, u32 BufferLen,
+		u8 IsPsPoll, u8 IsBTQosNull, u8 bDataFrame);
+
+u8 rtw_hal_get_txbuff_rsvd_page_num(_adapter *padapter, bool wowlan);
+
+
+void rtw_hal_set_wowlan_fw(_adapter *padapter, u8 sleep);
+
+
+c2h_id_filter rtw_hal_c2h_id_filter_ccx(_adapter *padapter);
+
+s32 rtw_hal_c2h_handler(_adapter *padapter, u8 *c2h_evt);
+
+
+#ifdef CONFIG_ANTENNA_DIVERSITY
+u8	rtw_hal_antdiv_before_linked(_adapter *padapter);
+void	rtw_hal_antdiv_rssi_compared(_adapter *padapter, WLAN_BSSID_EX *dst, WLAN_BSSID_EX *src);
+#endif
+
+#ifdef CONFIG_HOSTAPD_MLME
+s32	rtw_hal_hostap_mgnt_xmit_entry(_adapter *padapter, _pkt *pkt);
+#endif
+
+#ifdef DBG_CONFIG_ERROR_DETECT
+void rtw_hal_sreset_init(_adapter *padapter);
+void rtw_hal_sreset_reset(_adapter *padapter);	
+void rtw_hal_sreset_reset_value(_adapter *padapter);
+void rtw_hal_sreset_xmit_status_check(_adapter *padapter);
+void rtw_hal_sreset_linked_status_check (_adapter *padapter);
+u8   rtw_hal_sreset_get_wifi_status(_adapter *padapter);
+#endif
+
+#ifdef CONFIG_IOL
+int rtw_hal_iol_cmd(ADAPTER *adapter, struct xmit_frame *xmit_frame, u32 max_wating_ms, u32 bndy_cnt)
+#endif
+
+#if 0//def CONFIG_XMIT_THREAD_MODE
+s32 rtw_hal_xmit_thread_handler(_adapter *padapter);
+#endif
+
+s32	rtw_hal_recv_tasklet(_adapter *padapter);
+#if (RTW_NOTCH_FILTER != 0)
+void rtw_hal_notch_filter(_adapter * adapter, bool enable);
+#endif
+#if 0
+void rtw_hal_reset_security_engine(_adapter * adapter);
+#endif
+
+void decide_chip_type_by_device_id(_adapter *padapter);
+
+
+#ifdef CONFIG_RTL8723A
+void rtl8723as_set_hal_ops(PADAPTER padapter);
+#define hal_set_hal_ops(__adapter) rtl8723as_set_hal_ops(__adapter)
+#endif
+
+#ifdef CONFIG_RTL8188E
+u32 rtl8188e_set_hal_ops(PADAPTER padapter);
+#define hal_set_hal_ops(__adapter) rtl8188e_set_hal_ops(__adapter)
+#endif
+
+#ifdef CONFIG_RTL8188F
+u32 rtl8188fs_set_hal_ops(PADAPTER padapter);
+#define hal_set_hal_ops(__adapter) rtl8188fs_set_hal_ops(__adapter)
+#endif
+
+#ifdef CONFIG_RTL8195A
+u32 rtl8195ab_set_hal_ops(_adapter * padapter);
+#define hal_set_hal_ops rtl8195ab_set_hal_ops
+#define hal_interuupt_recognized InterruptRecognized8195a
+#elif defined(CONFIG_RTL8711B)
+u32 rtl8711bb_set_hal_ops(_adapter * padapter);
+#define hal_set_hal_ops rtl8711bb_set_hal_ops
+#define hal_interuupt_recognized InterruptRecognized8711b
+#endif
+
+
+#endif //__HAL_INTF_H__
+

USDK/component/common/drivers/wlan/realtek/include/hal_pg.h

@@ -0,0 +1,81 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+
+#ifndef __HAL_PG_H__
+#define __HAL_PG_H__
+
+#include <autoconf.h>
+
+//
+// For VHT series TX power by rate table.
+// VHT TX power by rate off setArray = 
+// Band:-2G&5G = 0 / 1
+// RF: at most 4*4 = ABCD=0/1/2/3
+// CCK=0 OFDM=1/2 HT-MCS 0-15=3/4/56 VHT=7/8/9/10/11			
+//
+#define PPG_BB_GAIN_2G_TX_OFFSET_MASK	0x0F
+#define PPG_BB_GAIN_2G_TXB_OFFSET_MASK	0xF0
+
+#define PPG_BB_GAIN_5G_TX_OFFSET_MASK	0x1F
+#define PPG_THERMAL_OFFSET_MASK			0x1F
+#define KFREE_BB_GAIN_2G_TX_OFFSET(_ppg_v) (((_ppg_v) == PPG_BB_GAIN_2G_TX_OFFSET_MASK) ? 0 : (((_ppg_v) & 0x01) ? ((_ppg_v) >> 1) : (-((_ppg_v) >> 1))))
+#define KFREE_THERMAL_OFFSET(_ppg_v) (((_ppg_v) == PPG_THERMAL_OFFSET_MASK) ? 0 : (((_ppg_v) & 0x01) ? ((_ppg_v) >> 1) : (-((_ppg_v) >> 1))))
+
+
+
+#if defined(NOT_SUPPORT_5G)
+#define TX_PWR_BY_RATE_NUM_BAND			1
+#else
+#define TX_PWR_BY_RATE_NUM_BAND			2
+#endif
+
+#if defined(NOT_SUPPORT_RF_MULTIPATH) && defined(NOT_SUPPORT_VHT)
+#define TX_PWR_BY_RATE_NUM_RF			1
+#define TX_PWR_BY_RATE_NUM_RATE			20 // CCK 1M~11M, OFDM 6M~54M, MCS0~7
+#else
+#define TX_PWR_BY_RATE_NUM_RF			4
+#define TX_PWR_BY_RATE_NUM_RATE			84
+#endif
+
+#if defined(NOT_SUPPORT_RF_MULTIPATH)
+#define MAX_RF_PATH					1
+#define MAX_TX_COUNT				1
+#else
+#define MAX_RF_PATH					2	// Max 4 for ss larger than 2
+#define MAX_TX_COUNT				4	//It must always set to 4, otherwise read efuse table secquence will be wrong.
+#endif
+#define	MAX_CHNL_GROUP_24G		6 		// ch1~2, ch3~5, ch6~8,ch9~11,ch12~13,CH 14 total three groups
+#define	MAX_CHNL_GROUP_5G		14
+
+typedef struct _TxPowerInfo24G{
+	u8 IndexCCK_Base[MAX_RF_PATH][MAX_CHNL_GROUP_24G];
+	u8 IndexBW40_Base[MAX_RF_PATH][MAX_CHNL_GROUP_24G];
+	//If only one tx, only BW20 and OFDM are used.
+	s8 OFDM_Diff[MAX_RF_PATH][MAX_TX_COUNT];
+	s8 BW20_Diff[MAX_RF_PATH][MAX_TX_COUNT];
+#if !defined(NOT_SUPPORT_RF_MULTIPATH)
+	s8 CCK_Diff[MAX_RF_PATH][MAX_TX_COUNT];	
+	s8 BW40_Diff[MAX_RF_PATH][MAX_TX_COUNT];
+#endif
+}TxPowerInfo24G, *PTxPowerInfo24G;
+
+#endif
+
+

USDK/component/common/drivers/wlan/realtek/include/hal_phy.h

@@ -0,0 +1,99 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef __HAL_PHY_H__
+#define __HAL_PHY_H__
+
+#define	RF6052_MAX_TX_PWR			0x3F
+#define	RF6052_MAX_REG_88E			0xFF
+#define	RF6052_MAX_REG_92C			0x7F
+
+#define	RF6052_MAX_REG	\
+		(RF6052_MAX_REG_88E > RF6052_MAX_REG_92C) ? RF6052_MAX_REG_88E: RF6052_MAX_REG_92C
+
+#define GET_RF6052_REAL_MAX_REG(_Adapter)	\
+		IS_HARDWARE_TYPE_8188E(_Adapter) ? RF6052_MAX_REG_88E : RF6052_MAX_REG_92C
+
+#define	RF6052_MAX_PATH				2
+
+/*--------------------------Define Parameters-------------------------------*/
+typedef enum _BAND_TYPE{
+	BAND_ON_2_4G = 0,
+	BAND_ON_5G,
+	BAND_ON_BOTH,
+	BANDMAX
+}BAND_TYPE,*PBAND_TYPE;
+
+typedef	enum _RF_TYPE{
+	RF_TYPE_MIN = 0, 	// 0
+	RF_8225=1,			// 1 11b/g RF for verification only
+	RF_8256=2,			// 2 11b/g/n 
+	RF_8258=3,			// 3 11a/b/g/n RF
+	RF_6052=4,			// 4 11b/g/n RF
+	RF_PSEUDO_11N=5,	// 5, It is a temporality RF. 
+	RF_TYPE_MAX
+}RF_TYPE_E,*PRF_TYPE_E;
+
+typedef enum _RF_PATH{
+	RF_PATH_A = 0,
+	RF_PATH_B,
+	RF_PATH_C,
+	RF_PATH_D
+}RF_PATH, *PRF_PATH;
+
+#define	TX_1S			0			
+#define	TX_2S			1			
+#define	TX_3S			2			
+#define	TX_4S			3
+
+typedef enum _BaseBand_Config_Type{
+	BaseBand_Config_PHY_REG = 0,			//Radio Path A
+	BaseBand_Config_AGC_TAB = 1,			//Radio Path B
+	BaseBand_Config_AGC_TAB_2G = 2,
+	BaseBand_Config_AGC_TAB_5G = 3,	
+	BaseBand_Config_PHY_REG_PG
+}BaseBand_Config_Type, *PBaseBand_Config_Type;
+
+typedef enum _WIRELESS_MODE {
+	WIRELESS_MODE_UNKNOWN = 0x00,
+	WIRELESS_MODE_A = 0x01,
+	WIRELESS_MODE_B = 0x02,
+	WIRELESS_MODE_G = 0x04,
+	WIRELESS_MODE_AUTO = 0x08,
+	WIRELESS_MODE_N_24G = 0x10,
+	WIRELESS_MODE_N_5G = 0x20,
+	WIRELESS_MODE_AC_5G = 0x40,
+	WIRELESS_MODE_AC_24G  = 0x80,
+	WIRELESS_MODE_AC_ONLY  = 0x100,
+} WIRELESS_MODE;
+
+typedef struct RF_Shadow_Compare_Map {
+	// Shadow register value
+	u32		Value;
+	// Compare or not flag
+	u8		Compare;
+	// Record If it had ever modified unpredicted
+	u8		ErrorOrNot;
+	// Recorver Flag
+	u8		Recorver;
+	//
+	u8		Driver_Write;
+}RF_SHADOW_T;
+
+#endif //__HAL_PHY_H__

USDK/component/common/drivers/wlan/realtek/include/hal_phy_reg.h

@@ -0,0 +1,31 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef __HAL_PHY_REG_H__
+#define __HAL_PHY_REG_H__
+
+//for PutRFRegsetting & GetRFRegSetting BitMask
+//#if (RTL92SE_FPGA_VERIFY == 1)
+//#define 		bRFRegOffsetMask	0xfff		
+//#else
+#define 		bRFRegOffsetMask	0xfffff
+//#endif
+
+#endif //__HAL_PHY_REG_H__
+

USDK/component/common/drivers/wlan/realtek/include/if_ether.h

@@ -0,0 +1,115 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+ 
+#ifndef _LINUX_IF_ETHER_H
+#define _LINUX_IF_ETHER_H
+
+/*
+ *	IEEE 802.3 Ethernet magic constants.  The frame sizes omit the preamble
+ *	and FCS/CRC (frame check sequence). 
+ */
+
+#define ETH_ALEN	6		/* Octets in one ethernet addr	 */
+#define ETH_HLEN	14		/* Total octets in header.	 */
+#define ETH_ZLEN	60		/* Min. octets in frame sans FCS */
+#define ETH_DATA_LEN	1500		/* Max. octets in payload	 */
+#define ETH_FRAME_LEN	1514		/* Max. octets in frame sans FCS */
+
+/*
+ *	These are the defined Ethernet Protocol ID's.
+ */
+
+#define ETH_P_LOOP	0x0060		/* Ethernet Loopback packet	*/
+#define ETH_P_PUP	0x0200		/* Xerox PUP packet		*/
+#define ETH_P_PUPAT	0x0201		/* Xerox PUP Addr Trans packet	*/
+#define ETH_P_IP	0x0800		/* Internet Protocol packet	*/
+#define ETH_P_X25	0x0805		/* CCITT X.25			*/
+#define ETH_P_ARP	0x0806		/* Address Resolution packet	*/
+#define	ETH_P_BPQ	0x08FF		/* G8BPQ AX.25 Ethernet Packet	[ NOT AN OFFICIALLY REGISTERED ID ] */
+#define ETH_P_IEEEPUP	0x0a00		/* Xerox IEEE802.3 PUP packet */
+#define ETH_P_IEEEPUPAT	0x0a01		/* Xerox IEEE802.3 PUP Addr Trans packet */
+#define ETH_P_DEC       0x6000          /* DEC Assigned proto           */
+#define ETH_P_DNA_DL    0x6001          /* DEC DNA Dump/Load            */
+#define ETH_P_DNA_RC    0x6002          /* DEC DNA Remote Console       */
+#define ETH_P_DNA_RT    0x6003          /* DEC DNA Routing              */
+#define ETH_P_LAT       0x6004          /* DEC LAT                      */
+#define ETH_P_DIAG      0x6005          /* DEC Diagnostics              */
+#define ETH_P_CUST      0x6006          /* DEC Customer use             */
+#define ETH_P_SCA       0x6007          /* DEC Systems Comms Arch       */
+#define ETH_P_RARP      0x8035		/* Reverse Addr Res packet	*/
+#define ETH_P_ATALK	0x809B		/* Appletalk DDP		*/
+#define ETH_P_AARP	0x80F3		/* Appletalk AARP		*/
+#define ETH_P_8021Q	0x8100          /* 802.1Q VLAN Extended Header  */
+#define ETH_P_IPX	0x8137		/* IPX over DIX			*/
+#define ETH_P_IPV6	0x86DD		/* IPv6 over bluebook		*/
+#define ETH_P_PPP_DISC	0x8863		/* PPPoE discovery messages     */
+#define ETH_P_PPP_SES	0x8864		/* PPPoE session messages	*/
+#define ETH_P_ATMMPOA	0x884c		/* MultiProtocol Over ATM	*/
+#define ETH_P_ATMFATE	0x8884		/* Frame-based ATM Transport
+					 * over Ethernet
+					 */
+
+/*
+ *	Non DIX types. Won't clash for 1500 types.
+ */
+ 
+#define ETH_P_802_3	0x0001		/* Dummy type for 802.3 frames  */
+#define ETH_P_AX25	0x0002		/* Dummy protocol id for AX.25  */
+#define ETH_P_ALL	0x0003		/* Every packet (be careful!!!) */
+#define ETH_P_802_2	0x0004		/* 802.2 frames 		*/
+#define ETH_P_SNAP	0x0005		/* Internal only		*/
+#define ETH_P_DDCMP     0x0006          /* DEC DDCMP: Internal only     */
+#define ETH_P_WAN_PPP   0x0007          /* Dummy type for WAN PPP frames*/
+#define ETH_P_PPP_MP    0x0008          /* Dummy type for PPP MP frames */
+#define ETH_P_LOCALTALK 0x0009		/* Localtalk pseudo type 	*/
+#define ETH_P_PPPTALK	0x0010		/* Dummy type for Atalk over PPP*/
+#define ETH_P_TR_802_2	0x0011		/* 802.2 frames 		*/
+#define ETH_P_MOBITEX	0x0015		/* Mobitex (kaz@cafe.net)	*/
+#define ETH_P_CONTROL	0x0016		/* Card specific control frames */
+#define ETH_P_IRDA	0x0017		/* Linux-IrDA			*/
+#define ETH_P_ECONET	0x0018		/* Acorn Econet			*/
+
+/*
+ *	This is an Ethernet frame header.
+ */
+//CONFIG_MEMORY_ACCESS_ALIGNED for 4byte aligned,ethdhr size is 16,leading error in wlanhdr_to_ethdr
+RTW_PACK_STRUCT_BEGIN
+struct ethhdr 
+{
+	unsigned char	h_dest[ETH_ALEN];	/* destination eth addr	*/
+	unsigned char	h_source[ETH_ALEN];	/* source ether addr	*/
+	unsigned short	h_proto;		/* packet type ID field	*/
+} RTW_PACK_STRUCT_STRUCT;
+RTW_PACK_STRUCT_END
+
+struct _vlan {
+   unsigned short       h_vlan_TCI;                // Encapsulates priority and VLAN ID
+   unsigned short       h_vlan_encapsulated_proto;
+};
+
+
+
+#define get_vlan_id(pvlan) ((_htons((unsigned short )pvlan->h_vlan_TCI)) & 0xfff)
+#define get_vlan_priority(pvlan) ((_htons((unsigned short )pvlan->h_vlan_TCI))>>13)
+#define get_vlan_encap_proto(pvlan) (_htons((unsigned short )pvlan->h_vlan_encapsulated_proto))
+
+
+#endif	/* _LINUX_IF_ETHER_H */
+

USDK/component/common/drivers/wlan/realtek/include/ip.h

@@ -0,0 +1,142 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef _LINUX_IP_H
+#define _LINUX_IP_H
+#include <rtw_byteorder.h>
+
+/* SOL_IP socket options */
+#ifndef IPTOS_TOS_MASK
+#define IPTOS_TOS_MASK		0x1E
+#define IPTOS_TOS(tos)		((tos)&IPTOS_TOS_MASK)
+#define	IPTOS_LOWDELAY		0x10
+#define	IPTOS_THROUGHPUT	0x08
+#define	IPTOS_RELIABILITY	0x04
+#define	IPTOS_MINCOST		0x02
+
+#define IPTOS_PREC_MASK		0xE0
+#define IPTOS_PREC(tos)		((tos)&IPTOS_PREC_MASK)
+#define IPTOS_PREC_NETCONTROL           0xe0
+#define IPTOS_PREC_INTERNETCONTROL      0xc0
+#define IPTOS_PREC_CRITIC_ECP           0xa0
+#define IPTOS_PREC_FLASHOVERRIDE        0x80
+#define IPTOS_PREC_FLASH                0x60
+#define IPTOS_PREC_IMMEDIATE            0x40
+#define IPTOS_PREC_PRIORITY             0x20
+#define IPTOS_PREC_ROUTINE              0x00
+#endif
+
+/* IP options */
+#define IPOPT_COPY		0x80
+#define IPOPT_CLASS_MASK	0x60
+#define IPOPT_NUMBER_MASK	0x1f
+
+#define	IPOPT_COPIED(o)		((o)&IPOPT_COPY)
+#define	IPOPT_CLASS(o)		((o)&IPOPT_CLASS_MASK)
+#define	IPOPT_NUMBER(o)		((o)&IPOPT_NUMBER_MASK)
+
+#define	IPOPT_CONTROL		0x00
+#define	IPOPT_RESERVED1		0x20
+#define	IPOPT_MEASUREMENT	0x40
+#define	IPOPT_RESERVED2		0x60
+
+#define IPOPT_END	(0 |IPOPT_CONTROL)
+#define IPOPT_NOOP	(1 |IPOPT_CONTROL)
+#define IPOPT_SEC	(2 |IPOPT_CONTROL|IPOPT_COPY)
+#define IPOPT_LSRR	(3 |IPOPT_CONTROL|IPOPT_COPY)
+#define IPOPT_TIMESTAMP	(4 |IPOPT_MEASUREMENT)
+#define IPOPT_RR	(7 |IPOPT_CONTROL)
+#define IPOPT_SID	(8 |IPOPT_CONTROL|IPOPT_COPY)
+#define IPOPT_SSRR	(9 |IPOPT_CONTROL|IPOPT_COPY)
+#define IPOPT_RA	(20|IPOPT_CONTROL|IPOPT_COPY)
+
+#define IPVERSION	4
+#define MAXTTL		255
+#define IPDEFTTL	64
+
+/* struct timestamp, struct route and MAX_ROUTES are removed.
+
+   REASONS: it is clear that nobody used them because:
+   - MAX_ROUTES value was wrong.
+   - "struct route" was wrong.
+   - "struct timestamp" had fatally misaligned bitfields and was completely unusable.
+ */
+
+#define IPOPT_OPTVAL 0
+#define IPOPT_OLEN   1
+#define IPOPT_OFFSET 2
+#define IPOPT_MINOFF 4
+#define MAX_IPOPTLEN 40
+#define IPOPT_NOP IPOPT_NOOP
+#define IPOPT_EOL IPOPT_END
+#define IPOPT_TS  IPOPT_TIMESTAMP
+
+#define	IPOPT_TS_TSONLY		0		/* timestamps only */
+#define	IPOPT_TS_TSANDADDR	1		/* timestamps and addresses */
+#define	IPOPT_TS_PRESPEC	3		/* specified modules only */
+
+#ifdef PLATFORM_LINUX
+
+struct ip_options {
+  __u32		faddr;				/* Saved first hop address */
+  unsigned char	optlen;
+  unsigned char srr;
+  unsigned char rr;
+  unsigned char ts;
+  unsigned char is_setbyuser:1,			/* Set by setsockopt?			*/
+                is_data:1,			/* Options in __data, rather than skb	*/
+                is_strictroute:1,		/* Strict source route			*/
+                srr_is_hit:1,			/* Packet destination addr was our one	*/
+                is_changed:1,			/* IP checksum more not valid		*/	
+                rr_needaddr:1,			/* Need to record addr of outgoing dev	*/
+                ts_needtime:1,			/* Need to record timestamp		*/
+                ts_needaddr:1;			/* Need to record addr of outgoing dev  */
+  unsigned char router_alert;
+  unsigned char __pad1;
+  unsigned char __pad2;
+  unsigned char __data[0];
+};
+
+#define optlength(opt) (sizeof(struct ip_options) + opt->optlen)
+#endif
+
+struct iphdr {
+#if defined(__LITTLE_ENDIAN_BITFIELD)
+	__u8	ihl:4,
+		version:4;
+#elif defined (__BIG_ENDIAN_BITFIELD)
+	__u8	version:4,
+  		ihl:4;
+#else
+#error	"Please fix <asm/byteorder.h>"
+#endif
+	__u8	tos;
+	__u16	tot_len;
+	__u16	id;
+	__u16	frag_off;
+	__u8	ttl;
+	__u8	protocol;
+	__u16	check;
+	__u32	saddr;
+	__u32	daddr;
+	/*The options start here. */
+};
+
+#endif	/* _LINUX_IP_H */
+

USDK/component/common/drivers/wlan/realtek/include/lxbus_hal.h

@@ -0,0 +1,24 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef __LXBUS_HAL_H__
+#define __LXBUS_HAL_H__
+
+#endif //__LXBUS_HAL_H__
+

USDK/component/common/drivers/wlan/realtek/include/lxbus_ops.h

@@ -0,0 +1,80 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef __LXBUS_OPS_H__
+#define __LXBUS_OPS_H__
+
+
+#if defined(CONFIG_RTL8195A) 
+//extern u32 TxbdRxbdInitRtl8195a(PADAPTER Adapter);
+//extern u32 TxbdRxbdResetRtl8195a(PADAPTER Adapter);
+
+extern VOID InitLxDmaRtl8195a(_adapter * Adapter);
+extern u32 rtl8195a_init_desc_ring(_adapter * padapter);
+extern u32 rtl8195a_free_desc_ring(_adapter * padapter);
+extern void rtl8195a_reset_desc_ring(_adapter * padapter);
+extern void EnableDMA8195a(PADAPTER padapter);
+extern void EnableInterrupt8195a(PADAPTER padapter);
+extern void DisableDMA8195a(PADAPTER padapter);
+extern void DisableInterrupt8195a(PADAPTER padapter);
+extern s32	InterruptHandle8195a(PADAPTER Adapter);
+extern void lxbus_set_intf_ops(struct _io_ops *pops);
+extern void	rtl8195a_xmit_tasklet(void *priv);
+extern void	rtl8195a_recv_tasklet(void *priv);
+extern void	rtl8195a_prepare_bcn_tasklet(void *priv);
+extern void rtl8195a_tx_int_handler(_adapter *padapter);
+extern void InitInterrupt8195a(PADAPTER padapter);
+extern VOID UpdateInterruptMask8195a(PADAPTER Adapter, u32 *pAddMSRB, u32 *pRemoveMSR);
+
+#ifdef CONFIG_WOWLAN
+extern void ClearInterrupt8195a(PADAPTER padapter);
+#endif
+
+extern void ClearWlPmcInterrupt8195a(PADAPTER padapter);
+extern BOOLEAN	InterruptRecognized8195a(PADAPTER Adapter);
+#elif  defined(CONFIG_RTL8711B)
+
+extern u32 rtl8711b_init_desc_ring(_adapter * padapter);
+extern u32 rtl8711b_free_desc_ring(_adapter * padapter);
+extern void rtl8711b_reset_desc_ring(_adapter * padapter);
+extern void EnableDMA8711b(PADAPTER padapter);
+extern void EnableInterrupt8711b(PADAPTER padapter);
+extern void DisableDMA8711b(PADAPTER padapter);
+extern void DisableInterrupt8711b(PADAPTER padapter);
+extern s32	InterruptHandle8711b(PADAPTER Adapter);
+extern void lxbus_set_intf_ops(struct _io_ops *pops);
+extern void	rtl8711b_xmit_tasklet(void *priv);
+extern void	rtl8711b_recv_tasklet(void *priv);
+extern void	rtl8711b_prepare_bcn_tasklet(void *priv);
+extern void rtl8711b_tx_int_handler(_adapter *padapter);
+extern void InitInterrupt8711b(PADAPTER padapter);
+extern VOID UpdateInterruptMask8711b(PADAPTER Adapter, u32 *pAddMSRB, u32 *pRemoveMSR);
+
+#ifdef CONFIG_WOWLAN
+extern void ClearInterrupt8711b(PADAPTER padapter);
+extern void DisableInterruptButCpwm28711b(PADAPTER padapter);
+#endif
+
+extern void ClearWlPmcInterrupt8711b(PADAPTER padapter);
+extern BOOLEAN	InterruptRecognized8711b(PADAPTER Adapter);
+#endif
+
+
+#endif // !__LXBUS_OPS_H__
+

USDK/component/common/drivers/wlan/realtek/include/lxbus_osintf.h

@@ -0,0 +1,29 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef __LXBUS_OSINTF_H
+#define __LXBUS_OSINTF_H
+
+
+//void	rtw_pci_disable_aspm(_adapter *padapter);
+//void	rtw_pci_enable_aspm(_adapter *padapter);
+//void	PlatformClearPciPMEStatus(PADAPTER Adapter);
+
+#endif //__LXBUS_OSINTF_H
+

USDK/component/common/drivers/wlan/realtek/include/pack_begin.h

@@ -0,0 +1,33 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************
+ *                                        
+ * Define the start point of packed structure
+ *
+ ******************************************************************************/
+
+#if defined(__IAR_SYSTEMS_ICC__)
+#pragma pack(1)
+#endif
+
+#if defined(PLATFORM_WINDOWS)
+#pragma pack(push)
+#pragma pack(1)
+#endif
+

USDK/component/common/drivers/wlan/realtek/include/pack_end.h

@@ -0,0 +1,33 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************
+ *                                        
+ * Define the end point of packed structure
+ *
+ ******************************************************************************/
+
+#if defined(__IAR_SYSTEMS_ICC__)
+#pragma pack()
+#endif
+
+#if defined(PLATFORM_WINDOWS)
+#pragma pack(pop)
+#endif
+
+

USDK/component/common/drivers/wlan/realtek/include/rom_aes.h

@@ -0,0 +1,53 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************
+ *                                        
+ * This is ROM code section. 
+ *
+ ******************************************************************************/
+#ifndef ROM_AES_H
+#define ROM_AES_H
+
+typedef struct
+{
+    u32 erk[64];     				/* encryption round keys */
+    u32 drk[64];     				/* decryption round keys */
+    int nr;             					/* number of rounds */
+}aes_context;
+
+
+#define AES_BLOCKSIZE8	8
+#define AES_BLK_SIZE    	16     	// # octets in an AES block
+typedef union _aes_block  		// AES cipher block
+{
+    unsigned long  x[AES_BLK_SIZE/4];    	// access as 8-bit octets or 32-bit words
+    unsigned char  b[AES_BLK_SIZE];
+}aes_block;
+
+
+void AES_WRAP(unsigned char * plain, int plain_len,
+			  		unsigned char * iv,	int iv_len,
+					unsigned char * kek,	int kek_len,
+			  		unsigned char *cipher, unsigned short *cipher_len);
+
+void AES_UnWRAP(unsigned char * cipher, int cipher_len,
+			   		 unsigned char * kek,	int kek_len,
+			    		unsigned char * plain);
+
+#endif

USDK/component/common/drivers/wlan/realtek/include/rom_arc4.h

@@ -0,0 +1,39 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************
+ *                                        
+ * This is ROM code section. 
+ *
+ ******************************************************************************/
+#ifndef ROM_ARC4_H
+#define ROM_ARC4_H
+
+struct arc4context
+{
+	u32 x;
+	u32 y;
+	u8 state[256];
+};
+
+u32 crc32_get(u8 *buf, sint len);
+void rt_arc4_init(struct arc4context 	*parc4ctx, u8 * key,u32	key_len);
+void rt_arc4_crypt(	struct arc4context	*parc4ctx, u8 * dest, u8 * src, u32 len);
+
+
+#endif //ROM_ARC4_H

USDK/component/common/drivers/wlan/realtek/include/rom_ieee80211.h

@@ -0,0 +1,127 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef __ROM_IEEE80211_H
+#define __ROM_IEEE80211_H
+
+extern const u8 RTW_WPA_OUI_TYPE[] ;
+extern const u8 WPA_CIPHER_SUITE_NONE[];
+extern const u8 WPA_CIPHER_SUITE_WEP40[];
+extern const u8 WPA_CIPHER_SUITE_TKIP[];
+extern const u8 WPA_CIPHER_SUITE_CCMP[];
+extern const u8 WPA_CIPHER_SUITE_WEP104[];
+extern const u16 RSN_VERSION_BSD;
+extern const u8 RSN_AUTH_KEY_MGMT_UNSPEC_802_1X[];
+extern const u8 RSN_AUTH_KEY_MGMT_PSK_OVER_802_1X[];
+extern const u8 RSN_CIPHER_SUITE_NONE[];
+extern const u8 RSN_CIPHER_SUITE_WEP40[];
+extern const u8 RSN_CIPHER_SUITE_TKIP[];
+extern const u8 RSN_CIPHER_SUITE_CCMP[];
+extern const u8 RSN_CIPHER_SUITE_WEP104[];
+
+/* Parsed Information Elements */
+struct rtw_ieee802_11_elems {
+	u8 *ssid;
+	u8 ssid_len;
+	u8 *supp_rates;
+	u8 supp_rates_len;
+	u8 *fh_params;
+	u8 fh_params_len;
+	u8 *ds_params;
+	u8 ds_params_len;
+	u8 *cf_params;
+	u8 cf_params_len;
+	u8 *tim;
+	u8 tim_len;
+	u8 *ibss_params;
+	u8 ibss_params_len;
+	u8 *challenge;
+	u8 challenge_len;
+	u8 *erp_info;
+	u8 erp_info_len;
+	u8 *ext_supp_rates;
+	u8 ext_supp_rates_len;
+	u8 *wpa_ie;
+	u8 wpa_ie_len;
+	u8 *rsn_ie;
+	u8 rsn_ie_len;
+	u8 *wme;
+	u8 wme_len;
+	u8 *wme_tspec;
+	u8 wme_tspec_len;
+	u8 *wps_ie;
+	u8 wps_ie_len;
+	u8 *power_cap;
+	u8 power_cap_len;
+	u8 *supp_channels;
+	u8 supp_channels_len;
+	u8 *mdie;
+	u8 mdie_len;
+	u8 *ftie;
+	u8 ftie_len;
+	u8 *timeout_int;
+	u8 timeout_int_len;
+	u8 *ht_capabilities;
+	u8 ht_capabilities_len;
+	u8 *ht_operation;
+	u8 ht_operation_len;
+	u8 *vendor_ht_cap;
+	u8 vendor_ht_cap_len;
+};
+
+typedef enum { ParseOK = 0, ParseUnknown = 1, ParseFailed = -1 } ParseRes;
+
+ParseRes rtw_ieee802_11_parse_elems(u8 *start, uint len,
+                struct rtw_ieee802_11_elems *elems,
+                int show_errors);
+
+u8 *rtw_set_fixed_ie(unsigned char *pbuf, unsigned int len, unsigned char *source, unsigned int *frlen);
+u8 *rtw_set_ie(u8 *pbuf, sint index, uint len, u8 *source, uint *frlen);
+u8 *rtw_get_ie(u8*pbuf, sint index, u32 *len, sint limit);
+
+void rtw_set_supported_rate(u8* SupportedRates, uint mode) ;
+
+unsigned char *rtw_get_wpa_ie(unsigned char *pie, u32 *wpa_ie_len, int limit);
+unsigned char *rtw_get_wpa2_ie(unsigned char *pie, u32 *rsn_ie_len, int limit);
+int rtw_get_wpa_cipher_suite(u8 *s);
+int rtw_get_wpa2_cipher_suite(u8 *s);
+
+int rtw_parse_wpa_ie(u8* wpa_ie, int wpa_ie_len, int *group_cipher, int *pairwise_cipher, int *is_8021x);
+int rtw_parse_wpa2_ie(u8* wpa_ie, int wpa_ie_len, int *group_cipher, int *pairwise_cipher, int *is_8021x);
+
+int rtw_get_sec_ie(u8 *in_ie,uint in_len,u8 *rsn_ie,u16 *rsn_len,u8 *wpa_ie,u16 *wpa_len);
+
+u8 *rtw_get_wps_ie(u8 *in_ie, uint in_len, u8 *wps_ie, uint *wps_ielen);
+u8 *rtw_get_wps_attr(u8 *wps_ie, uint wps_ielen, u16 target_attr_id ,u8 *buf_attr, u32 *len_attr);
+u8 *rtw_get_wps_attr_content(u8 *wps_ie, uint wps_ielen, u16 target_attr_id ,u8 *buf_content, uint *len_content);
+
+uint rtw_get_rateset_len(u8	*rateset);
+
+int rtw_get_bit_value_from_ieee_value(u8 val);
+
+uint rtw_is_cckrates_included(u8 *rate);
+
+uint rtw_is_cckratesonly_included(u8 *rate);
+
+int rtw_check_network_type(unsigned char *rate, int ratelen, int channel);
+
+u8 key_2char2num(u8 hch, u8 lch);
+
+#endif /* __ROM_IEEE80211_H */
+

USDK/component/common/drivers/wlan/realtek/include/rom_md5.h

@@ -0,0 +1,45 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************
+ *                                        
+ * This is ROM code section. 
+ *
+ ******************************************************************************/
+
+#ifndef ROM_MD5_H
+#define ROM_MD5_H
+
+#if PSK_SUPPORT_TKIP
+
+/* MD5 context. */
+typedef struct {
+  u32 state[4];                                   /* state (ABCD) */
+  u32 count[2];        /* number of bits, modulo 2^64 (lsb first) */
+  u8 buffer[64];                         /* input buffer */
+} md5_ctx;
+
+void rt_md5_init(md5_ctx *context);
+void rt_md5_append(md5_ctx *context, u8 *input, u32 inputLen);
+void rt_md5_final(u8 digest[16], md5_ctx *context);
+void rt_md5_hmac(unsigned char *text, int text_len, unsigned char *key,
+		 int key_len, void * digest);
+
+
+#endif	//#if PSK_SUPPORT_TKIP
+#endif

USDK/component/common/drivers/wlan/realtek/include/rom_rc4.h

@@ -0,0 +1,89 @@
+/* crypto/rc4/rc4.h */
+/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
+ * All rights reserved.
+ *
+ * This package is an SSL implementation written
+ * by Eric Young (eay@cryptsoft.com).
+ * The implementation was written so as to conform with Netscapes SSL.
+ *
+ * This library is free for commercial and non-commercial use as long as
+ * the following conditions are aheared to.  The following conditions
+ * apply to all code found in this distribution, be it the RC4, RSA,
+ * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
+ * included with this distribution is covered by the same copyright terms
+ * except that the holder is Tim Hudson (tjh@cryptsoft.com).
+ *
+ * Copyright remains Eric Young's, and as such any Copyright notices in
+ * the code are not to be removed.
+ * If this package is used in a product, Eric Young should be given attribution
+ * as the author of the parts of the library used.
+ * This can be in the form of a textual message at program startup or
+ * in documentation (online or textual) provided with the package.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *    "This product includes cryptographic software written by
+ *     Eric Young (eay@cryptsoft.com)"
+ *    The word 'cryptographic' can be left out if the rouines from the library
+ *    being used are not cryptographic related :-).
+ * 4. If you include any Windows specific code (or a derivative thereof) from
+ *    the apps directory (application code) you must include an acknowledgement:
+ *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * The licence and distribution terms for any publically available version or
+ * derivative of this code cannot be changed.  i.e. this code cannot simply be
+ * copied and put under another distribution licence
+ * [including the GNU Public Licence.]
+ */
+
+#ifndef HEADER_RC4_H
+#define HEADER_RC4_H
+
+#ifdef OPENSSL_NO_RC4
+#error RC4 is disabled.
+#endif
+
+//#include <openssl/opensslconf.h> /* RC4_INT */
+#define RC4_INT unsigned int
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+typedef struct rc4_key_st
+	{
+	RC4_INT x,y;
+	RC4_INT data[256];
+	} RC4_KEY;
+
+
+//const char *RC4_options(void);
+void RC4_set_key(RC4_KEY *key, int len, const unsigned char *data);
+void RC4(RC4_KEY *key, unsigned long len, const unsigned char *indata,
+		unsigned char *outdata);
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif

USDK/component/common/drivers/wlan/realtek/include/rom_rtw_message.h

@@ -0,0 +1,48 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef _ROM_RTW_MESSAGE_
+#define _ROM_RTW_MESSAGE_
+
+#include <platform_stdlib.h>
+
+typedef enum {
+#define ROM_E_RTW_MSGPOOL(name,str)  ROM_E_RTW_MSGP_##name,
+#include "rom_rtw_message_e.h"
+  ROM_E_RTW_MSGP_MAX
+} rom_e_rtw_msgp_t;
+
+#if ROM_E_RTW_MSG
+extern const char *rom_e_rtw_msgp_str_[];
+#define rom_e_rtw_msg_printf(name, fmt, args...) printf((char*)rom_e_rtw_msgp_str_[ROM_E_RTW_MSGP_##name], ## args)
+#define rom_e_rtw_msg_871X_LEVEL(name, level, fmt, args...) \
+	do {\
+		printf("\n\r");\
+		printf((char*)rom_e_rtw_msgp_str_[ROM_E_RTW_MSGP_##name], ## args);\
+	}while(0)
+#else
+#define rom_e_rtw_msg_printf(name, fmt, args...) printf(fmt, ## args)
+#define rom_e_rtw_msg_871X_LEVEL(name, level, fmt, args...) \
+	do {\
+		printf("\n\r");\
+		printf(DRIVER_PREFIX ##fmt, ## args);\
+	}while(0)
+#endif //ROM_E_RTW_MSG
+
+#endif //_ROM_RTW_MESSAGE_

USDK/component/common/drivers/wlan/realtek/include/rom_rtw_message_e.h

@@ -0,0 +1,174 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+// Debug message
+// DBG_PWR_INDEX
+ROM_E_RTW_MSGPOOL(PWR_INDEX_1,	"BandWidth = %d, Rate = %d, Channel = %d\n\r")
+ROM_E_RTW_MSGPOOL(PWR_INDEX_2,	"Base = %d, DiffByRate = %d, limit = %d, DiffByTrack = %d, Tx Power = %d\n\n\r")
+// DBG_RX_INFO
+ROM_E_RTW_MSGPOOL(RX_INFO_1,	"============ Rx Info dump ===================\n")
+ROM_E_RTW_MSGPOOL(RX_INFO_2,	"bLinked = %d, RSSI_Min = %d(%%), CurrentIGI = 0x%x\n")
+ROM_E_RTW_MSGPOOL(RX_INFO_3,	"Cnt_Cck_fail = %d, Cnt_Ofdm_fail = %d, Total False Alarm = %d\n")
+ROM_E_RTW_MSGPOOL(RX_INFO_4,	"RxRate = 0x%x, RSSI_A = %d(%%), RSSI_B = %d(%%)\n")
+// DBG_TX_RATE
+ROM_E_RTW_MSGPOOL(TX_RATE_1,	"Rate: 0x%x\n\r")
+ROM_E_RTW_MSGPOOL(TX_RATE_2,	"%s(): mac_id=%d raid=0x%x bw=%d mask=0x%x init_rate=0x%x\n")
+// DBG_DM_RA
+ROM_E_RTW_MSGPOOL(DM_RA_1,	"==> ReadRateMask = 0x%x RAMASK[%d] = 0x%x\n")
+ROM_E_RTW_MSGPOOL(DM_RA_2,	"==> TMP_rate = %x highest_rate = 0x%02X, lowest_rate = 0x%02X\n")
+ROM_E_RTW_MSGPOOL(DM_RA_3,	"==> MacID = %d rateid = 0x%x sgi = %d bw_idx = %d\n\r")
+ROM_E_RTW_MSGPOOL(DM_RA_4,	"%s(): mac_id=%d raid=0x%x bw=%d mask=0x%x\r\n")
+// DBG_DM_DIG
+ROM_E_RTW_MSGPOOL(DM_DIG_1,	"CurrentIGI(0x%02x)\n\n")
+// DBG_PWR_TRACKING
+ROM_E_RTW_MSGPOOL(PWR_TRACKING_1,	"Thermal = 0x%02X\r\n")
+ROM_E_RTW_MSGPOOL(PWR_TRACKING_2,	"delta = %d, AVG Thermal = 0x%02X, EFUSE = 0x%02X, PackageType = 0x%02X\r\n")
+ROM_E_RTW_MSGPOOL(PWR_TRACKING_3,	"Channel = %d, CCK PwrBase = 0x%02X, HT40M PwrBase = 0x%02X, OFDMdiff = %d, 20Mdiff = %d \n\r")
+ROM_E_RTW_MSGPOOL(PWR_TRACKING_4,	"Remnant_CCKSwingIdx  = %d\n\r")
+ROM_E_RTW_MSGPOOL(PWR_TRACKING_5,	"Remnant_OFDMSwingIdx = %d\n\r")
+ROM_E_RTW_MSGPOOL(PWR_TRACKING_6,	"CCK2~11: 0x86c = 0x%08X\r\n")
+ROM_E_RTW_MSGPOOL(PWR_TRACKING_7,	"MCS7~4 : 0xe14 = 0x%08X\r\n")
+// DBG_RF_IQK
+ROM_E_RTW_MSGPOOL(RF_IQK_1,	"Path A Tx IQK Success!\n")
+ROM_E_RTW_MSGPOOL(RF_IQK_2,	"Path A Rx IQK Success!\n")
+ROM_E_RTW_MSGPOOL(RF_IQK_3,	"Path A IQK failed!\n")
+ROM_E_RTW_MSGPOOL(RF_IQK_4,	"IQK finished\n")
+ROM_E_RTW_MSGPOOL(RF_IQK_5,	"LCK finished\n")
+// DBG_DM_ADAPTIVITY
+ROM_E_RTW_MSGPOOL(DM_ADAPTIVITY_1, "IGI_Base=0x%x, TH_L2H_ini = %d, TH_EDCCA_HL_diff = %d\n")
+ROM_E_RTW_MSGPOOL(DM_ADAPTIVITY_2, "DynamicLinkAdaptivity = %d, Adaptivity_enable = %d\n")
+ROM_E_RTW_MSGPOOL(DM_ADAPTIVITY_3, "IGI=0x%x, TH_L2H_dmc = 0x%x, TH_H2L_dmc = 0x%x\n\n")
+
+// freertos_ioctl.c
+// mac_reg_dump, bb_reg_dump, rf_reg_dump
+ROM_E_RTW_MSGPOOL(MAC_REG_DUMP_1,	"\n======= MAC REG =======\n")
+ROM_E_RTW_MSGPOOL(BB_REG_DUMP_1,	"\n======= BB REG =======\n")
+ROM_E_RTW_MSGPOOL(RF_REG_DUMP_1,	"\n======= RF REG =======\n")
+ROM_E_RTW_MSGPOOL(RF_REG_DUMP_2,	"\nRF_Path(%x)\n")
+ROM_E_RTW_MSGPOOL(REG_DUMP_1,	"0x%02x ")
+ROM_E_RTW_MSGPOOL(REG_DUMP_2,	" 0x%08x ")
+ROM_E_RTW_MSGPOOL(REG_DUMP_3,	"\n")
+// 0x70 read reg
+ROM_E_RTW_MSGPOOL(READ_REG_1,	"rtw_read8(0x%x)=0x%02x\n")
+ROM_E_RTW_MSGPOOL(READ_REG_2,	"rtw_read16(0x%x)=0x%04x\n")
+ROM_E_RTW_MSGPOOL(READ_REG_3,	"rtw_read32(0x%x)=0x%08x\n")
+// 0x71 write reg
+ROM_E_RTW_MSGPOOL(WRITE_REG_1,	"rtw_write8(0x%x)=0x%02x\n")
+ROM_E_RTW_MSGPOOL(WRITE_REG_2,	"rtw_write16(0x%x)=0x%04x\n")
+ROM_E_RTW_MSGPOOL(WRITE_REG_3,	"rtw_write32(0x%x)=0x%08x\n")
+// 0x72 read bb
+ROM_E_RTW_MSGPOOL(READ_BB_1,	"read_bbreg(0x%x)=0x%x\n")
+// 0x73 write bb
+ROM_E_RTW_MSGPOOL(WRITE_BB_1,	"write_bbreg(0x%x)=0x%x\n")
+// 0x74 read rf
+ROM_E_RTW_MSGPOOL(READ_RF_1,	"read RF_reg path(0x%02x),offset(0x%x),value(0x%08x)\n")
+// 0x75 write rf
+ROM_E_RTW_MSGPOOL(WRITE_RF_1,	"write RF_reg path(0x%02x),offset(0x%x),value(0x%08x)\n")
+// 0x17 fix channel
+ROM_E_RTW_MSGPOOL(FIX_CHANNEL_1,	"=>Fixed channel to %d\n")
+ROM_E_RTW_MSGPOOL(FIX_CHANNEL_2,	"Invalid channel number(%d)\n")
+// 0x22 enable / disable power saving mode
+ROM_E_RTW_MSGPOOL(PWR_SAVE_MODE_1,	"wlan power saving mode = %s\n")
+// 0xaa fix rate
+ROM_E_RTW_MSGPOOL(FIX_RATE_1,	"chang data rate to :0x%02x\n")
+// 0xc0 get odm dbg flag
+ROM_E_RTW_MSGPOOL(GET_ODM_DBG_FLAG_1,	"get odm dbg flag : 0x%08x\n")
+// 0xc1 set odm dbg flag
+ROM_E_RTW_MSGPOOL(SET_ODM_DBG_FLAG_1,	"set odm dbg flag : 0x%08x\n")
+// 0xcc open power index debug message (power by rate, power limit, power tracking)
+ROM_E_RTW_MSGPOOL(DUMP_PWR_IDX_1,	"Fixed rate = %d\n")
+// 0xdd dump info
+ROM_E_RTW_MSGPOOL(DUMP_INFO_1,	"Tx power:\n")
+ROM_E_RTW_MSGPOOL(DUMP_INFO_2,	"CCK 1(0xe08)= 0x%x\n")
+ROM_E_RTW_MSGPOOL(DUMP_INFO_3,	"CCK 11~2(0x86c)= 0x%x\n")
+ROM_E_RTW_MSGPOOL(DUMP_INFO_4,	"OFDM 18~6(0xe00)= 0x%x\n")
+ROM_E_RTW_MSGPOOL(DUMP_INFO_5,	"OFDM 54~24(0xe04)= 0x%x\n")
+ROM_E_RTW_MSGPOOL(DUMP_INFO_6,	"MCS 3~0(0xe10)= 0x%x\n")
+ROM_E_RTW_MSGPOOL(DUMP_INFO_7,	"MCS 7~4(0xe14)= 0x%x\n")
+ROM_E_RTW_MSGPOOL(DUMP_INFO_8,	"Country code: 0x%x\n")
+// 0xee turn on/off dynamic funcs
+ROM_E_RTW_MSGPOOL(DM_FUNC_FLAG_1,	" === DMFlag(0x%08x) === \n")
+ROM_E_RTW_MSGPOOL(DM_FUNC_FLAG_2,	"extra_arg = 0 - disable all dynamic func\n")
+ROM_E_RTW_MSGPOOL(DM_FUNC_FLAG_3,	"extra_arg = 1 - enable all dynamic func\n")
+ROM_E_RTW_MSGPOOL(DM_FUNC_FLAG_4,	"extra_arg = 2 - disable DIG\n")
+ROM_E_RTW_MSGPOOL(DM_FUNC_FLAG_5,	"extra_arg = 3 - enable DIG\n")
+ROM_E_RTW_MSGPOOL(DM_FUNC_FLAG_6,	"extra_arg = 4 - disable tx power tracking\n")
+ROM_E_RTW_MSGPOOL(DM_FUNC_FLAG_7,	"extra_arg = 5 - enable tx power tracking\n")
+ROM_E_RTW_MSGPOOL(DM_FUNC_FLAG_8,	"extra_arg = 6 - disable adaptivity\n")
+ROM_E_RTW_MSGPOOL(DM_FUNC_FLAG_9,	"extra_arg = 7 - enable adaptivity\n")
+
+// lxbus_ops.c
+ROM_E_RTW_MSGPOOL(RX_MPDU_1,	"Drop packet! crc_err = %d, icv_err = %d, rx_pkt_len = %d, skb_pkt_len = %d\n")
+
+// wlan driver DBG_871X_LEVEL
+#define ROM_E_RTW_MSGPOOL_871X(name,str) ROM_E_RTW_MSGPOOL(name,DRIVER_PREFIX str)
+// rtw_ap.c
+ROM_E_RTW_MSGPOOL_871X(AP_TIMEOUT_CHK_1,	"Asoc expire "MAC_FMT"\n")
+// rtw_intfs.c
+ROM_E_RTW_MSGPOOL_871X(INIT_DRV_SW_1,	"The driver is for MP\n")
+// rtw_ioctl_set.c
+ROM_E_RTW_MSGPOOL_871X(SET_BSSID_1,	"set BSSID: %02x:%02x:%02x:%02x:%02x:%02x\n")
+ROM_E_RTW_MSGPOOL_871X(SET_SSID_1,	"set ssid [%s] \n")
+// rtw_mlme_ext.c
+ROM_E_RTW_MSGPOOL_871X(ON_BEACON_1,	"ap has changed, disconnect now\n ")
+ROM_E_RTW_MSGPOOL_871X(ON_AUTH_1,	"+OnAuth: "MAC_FMT"\n")
+ROM_E_RTW_MSGPOOL_871X(ON_AUTH_2,	" Exceed the upper limit(%d) of supported clients...\n")
+ROM_E_RTW_MSGPOOL_871X(ON_AUTH_CLIENT_1,	"auth success, start assoc\n")
+ROM_E_RTW_MSGPOOL_871X(ON_ASSOC_REQ_1,	"+OnAssocReq\n")
+ROM_E_RTW_MSGPOOL_871X(ON_ASSOC_RSP_1,	"association success(res=%d)\n")
+ROM_E_RTW_MSGPOOL_871X(ON_DE_AUTH_1,	"ap recv deauth reason code(%d) sta:"MAC_FMT"\n")
+ROM_E_RTW_MSGPOOL_871X(ON_DE_AUTH_2,	"sta recv deauth reason code(%d) sta:"MAC_FMT"\n")
+ROM_E_RTW_MSGPOOL_871X(ON_DISASSOC_1,	"ap recv disassoc reason code(%d) sta:"MAC_FMT"\n")
+ROM_E_RTW_MSGPOOL_871X(ON_DISASSOC_2,	"sta recv disassoc reason code(%d) sta:"MAC_FMT"\n")
+ROM_E_RTW_MSGPOOL_871X(ISSUE_BEACON_1,	"beacon frame too large\n")
+ROM_E_RTW_MSGPOOL_871X(ISSUE_PROBERSP_1,	"probersp frame too large\n")
+ROM_E_RTW_MSGPOOL_871X(ISSUE_PROBEREQ_1,	"probereq frame too large\n")
+ROM_E_RTW_MSGPOOL_871X(ISSUE_AUTH_1,	"auth frame too large\n")
+ROM_E_RTW_MSGPOOL_871X(ISSUE_ASSOCRSP_1,	"assocrsp frame too large\n")
+ROM_E_RTW_MSGPOOL_871X(ISSUE_ASSOCREQ_1,	"assocreq frame too large\n")
+ROM_E_RTW_MSGPOOL_871X(ISSUE_NULLDATA_1,	"nulldata frame too large\n")
+ROM_E_RTW_MSGPOOL_871X(ISSUE_QOS_NULLDATA_1,	"qos nulldata frame too large\n")
+ROM_E_RTW_MSGPOOL_871X(ISSUE_DEAUTH_1,	"deauth frame too large\n")
+ROM_E_RTW_MSGPOOL_871X(ISSUE_ACTION_BA_1,	"action BA frame too large\n")
+ROM_E_RTW_MSGPOOL_871X(ISSUE_BSS_COEXIST_1,	"action BSSCoexist frame too large\n")
+ROM_E_RTW_MSGPOOL_871X(START_CLNT_AUTH_1,	"start auth to %02x:%02x:%02x:%02x:%02x:%02x\n")
+ROM_E_RTW_MSGPOOL_871X(LINKED_STATUS_CHK_1,	"no beacon for a long time, disconnect or roaming\n")
+ROM_E_RTW_MSGPOOL_871X(SETKEY_HDL_1,	"set group key to hw: alg:%d(WEP40-1 WEP104-5 TKIP-2 AES-4) keyid:%d\n")
+ROM_E_RTW_MSGPOOL_871X(SET_STAKEY_HDL_1,	"set pairwise key to hw: alg:%d(WEP40-1 WEP104-5 TKIP-2 AES-4)\n")
+ROM_E_RTW_MSGPOOL_871X(SET_STAKEY_HDL_2,	"set pairwise key to hw: alg:%d(WEP40-1 WEP104-5 TKIP-2 AES-4) for %x:%x:%x:%x:%x:%x\n")
+// rtw_p2p.c
+ROM_E_RTW_MSGPOOL_871X(P2P_BUILD_MGNT_FRAME_1,	"p2p mgnt frame too large\n")
+// rtw_psk.c
+ROM_E_RTW_MSGPOOL_871X(SEND_EAPOL_1,	"ap mode 4-1\n")
+ROM_E_RTW_MSGPOOL_871X(SEND_EAPOL_2,	"ap mode 4-3\n")
+ROM_E_RTW_MSGPOOL_871X(SEND_EAPOL_3,	"ap mode 2-1 to WPA_STA(%d)\n")
+ROM_E_RTW_MSGPOOL_871X(EAPOL_KEY_RECVD_1,	"ap mode 4-2\n")
+ROM_E_RTW_MSGPOOL_871X(EAPOL_KEY_RECVD_2,	"ap mode 4-4\n")
+ROM_E_RTW_MSGPOOL_871X(EAPOL_KEY_RECVD_3,	"ap mode 2-2 from WPA_STA(%d)\n")
+// rtw_recv.c
+ROM_E_RTW_MSGPOOL_871X(FREE_RECVFRAME_1,	"%s free_recvframe_cnt:%d > %d refree happen !!!!\n")
+// hal_com.c
+ROM_E_RTW_MSGPOOL_871X(VAR_PORT_SWITCH_1,	"port switch - port0("ADPT_FMT"), port1("ADPT_FMT")\n")
+ROM_E_RTW_MSGPOOL_871X(VAR_PORT_SWITCH_2,	"port switch - port0("ADPT_FMT"), port1("ADPT_FMT")\n")
+// osdep_service.c
+ROM_E_RTW_MSGPOOL_871X(DOWN_SEMA_1,	"%s(%p) failed, retry\n")
+
+
+#undef ROM_E_RTW_MSGPOOL
+#undef ROM_E_RTW_MSGPOOL_871X

USDK/component/common/drivers/wlan/realtek/include/rom_rtw_psk.h

@@ -0,0 +1,44 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************
+ *                                        
+ * This is ROM code section. 
+ *
+ ******************************************************************************/
+#ifndef __ROM_RTW_PSK_H_
+#define __ROM_RTW_PSK_H_
+
+int rom_psk_PasswordHash (
+				unsigned char *password,
+				int passwordlength,
+				unsigned char *ssid,
+				int ssidlength,
+				unsigned char *output);
+
+void rom_psk_CalcPTK(	unsigned char *addr1, unsigned char *addr2,
+			unsigned char *nonce1, unsigned char *nonce2,
+			unsigned char *keyin, int keyinlen,
+			unsigned char *keyout, int keyoutlen);
+
+void rom_psk_CalcGTK(unsigned char *addr, unsigned char *nonce,
+				unsigned char *keyin, int keyinlen,
+				unsigned char *keyout, int keyoutlen);
+
+#endif	//__ROM_RTW_PSK_H_
+

USDK/component/common/drivers/wlan/realtek/include/rom_rtw_security.h

@@ -0,0 +1,104 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************
+ *                                        
+ * This is ROM code section. 
+ *
+ ******************************************************************************/
+#ifndef __ROM_RTW_SECURITY_H_
+#define __ROM_RTW_SECURITY_H_
+
+struct mic_data
+{
+	u32  K0, K1;         // Key
+	u32  L, R;           // Current state
+	u32  M;              // Message accumulator (single word)
+	u32     nBytesInM;      // # bytes in M
+};
+
+union  u_crc 
+{    
+	unsigned char	ch[4];    
+	int i;  
+};
+
+//===============================
+// WEP related
+//===============================
+void wep_80211_encrypt(
+	u8 *pframe, u32 wlan_hdr_len, \
+	u32 iv_len, u32 payload_len,\
+	u8* key, u32 key_len);
+
+u8 wep_80211_decrypt(
+	u8 *pframe, u32 wlan_hdr_len, 
+	u32 iv_len, u32 payload_len,
+	u8* key, u32 key_len,
+	union u_crc *pcrc\
+	);
+
+//===============================
+// TKIP related
+//===============================
+void tkip_80211_encrypt(
+	u8 *pframe, u32 wlan_hdr_len, \
+	u32 iv_len, u32 payload_len,\
+	u8* key, u32 key_len,\
+	u8* ta);
+
+u8 tkip_80211_decrypt(
+	u8 *pframe, u32 wlan_hdr_len, \
+	u32 iv_len, u32 payload_len,\
+	u8* key, u32 key_len,\
+	u8* ta, union u_crc *pcrc);
+
+void tkip_micappendbyte(struct mic_data *pmicdata, u8 b );
+void rtw_secmicsetkey(struct mic_data *pmicdata, u8 * key);
+void rtw_secmicappend(struct mic_data *pmicdata, u8 * src, u32 nbytes );
+void rtw_secgetmic(struct mic_data *pmicdata, u8 * dst );
+void rtw_seccalctkipmic(u8 * key,u8 *header,u8 *data,u32 data_len,u8 *mic_code, u8 pri);
+void tkip_phase1(u16 *p1k,const u8 *tk,const u8 *ta,u32 iv32);
+void tkip_phase2(u8 *rc4key,const u8 *tk,const u16 *p1k,u16 iv16);
+
+
+//===============================
+// AES related
+//===============================
+void aes1_encrypt(u8 *key, u8 *data, u8 *ciphertext);
+void aesccmp_construct_mic_iv(
+	u8 *mic_iv, sint qc_exists, sint a4_exists, 
+	u8 *mpdu, uint payload_length,u8 *pn_vector);
+void aesccmp_construct_mic_header1(u8 *mic_header1, sint header_length, u8 *mpdu);
+void aesccmp_construct_mic_header2(
+	u8 *mic_header2, u8 *mpdu, sint a4_exists, sint qc_exists);
+void aesccmp_construct_ctr_preload(
+	u8 *ctr_preload, sint a4_exists, sint qc_exists,
+	u8 *mpdu, u8 *pn_vector, sint c);
+
+u32 aes_80211_encrypt(
+	u8 *pframe, u32 wlan_hdr_len, \
+	u32 payload_len, u8 *key, \
+	u32 frame_type, u8 *mic);
+
+u32 aes_80211_decrypt(
+	u8 *pframe, u32 wlan_hdr_len, \
+	u32 payload_len, u8 *key, \
+	u32 frame_type, u8 *mic);
+#endif	//__ROM_RTW_SECURITY_H_
+

USDK/component/common/drivers/wlan/realtek/include/rom_sha1.h

@@ -0,0 +1,71 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef _ROM_SHA1_
+#define _ROM_SHA1_
+
+
+#ifndef _SHA_enum_
+#define _SHA_enum_
+enum
+{
+    shaSuccess = 0,
+    shaNull,            /* Null pointer parameter */
+    shaInputTooLong,    /* input data too long */
+    shaStateError       /* called Input after Result */
+};
+#endif
+
+
+#define SHA1HashSize 20
+
+/*
+ *  This structure will hold context information for the SHA-1
+ *  hashing operation
+ */
+typedef struct SHA1Context
+{
+    u32 Intermediate_Hash[SHA1HashSize/4]; /* Message Digest  */
+
+    u32 Length_Low;            /* Message length in bits      */
+    u32 Length_High;           /* Message length in bits      */
+
+                               /* Index into message block array   */
+    u16 Message_Block_Index;
+    u8 Message_Block[64];      /* 512-bit message blocks      */
+
+    int Computed;               /* Is the digest computed?         */
+    int Corrupted;             /* Is the message digest corrupted? */
+} SHA1Context;
+
+
+/*
+ *  Function Prototypes
+ */
+
+
+int rt_sha1_init(  SHA1Context *);
+int rt_sha1_update(  SHA1Context *, const u8 *, unsigned int);
+int rt_sha1_finish( SHA1Context *, u8 Message_Digest[SHA1HashSize]);
+
+void rt_hmac_sha1(unsigned char *text, int text_len, unsigned char *key,
+		 int key_len, unsigned char *digest);
+
+
+#endif //_ROM_SHA1_

USDK/component/common/drivers/wlan/realtek/include/rtl8195a_hal.h

@@ -0,0 +1,618 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+
+#ifndef __RTL8195A_HAL_H__
+#define __RTL8195A_HAL_H__
+
+#include "drv_types.h"
+#include "rtl8195a/rtl8195a_pmu_task.h"
+#include "hal_data.h"
+
+#include "rtl8195a/rtl8195a_spec.h"
+#include "rtl8195a/rtl8195a_rf.h"
+#include "rtl8195a/rtl8195a_dm.h"
+#include "rtl8195a/rtl8195a_recv.h"
+#include "rtl8195a/rtl8195a_xmit.h"
+#include "rtl8195a/rtl8195a_cmd.h"
+#include "rtl8195a/rtl8195a_pmu_cmd.h"
+#include "rtl8195a/rtl8195a_led.h"
+#include "rtl8195a/Hal8195APwrSeq.h"
+#include "rtl8195a/Hal8195APhyReg.h"
+#include "rtl8195a/Hal8195APhyCfg.h"
+#include "rtl8195a/rom_Hal8195APhyCfg.h"
+
+#ifdef DBG_CONFIG_ERROR_DETECT
+#include "rtl8195a/rtl8195a_sreset.h"
+#endif
+
+#include "../src/hal/OUTSRC/phydm_precomp.h"
+
+#if (RTL8195A_SUPPORT==1)
+	//2TODO: We should define 8192S firmware related macro settings here!!
+	#define RTL819X_DEFAULT_RF_TYPE			RF_1T2R
+	#define RTL819X_TOTAL_RF_PATH				2
+
+//---------------------------------------------------------------------
+//		RTL8723BS From file
+//---------------------------------------------------------------------
+	#define RTL8723B_FW_IMG					"rtl8723B\\rtl8723bfw.bin"
+	#define RTL8195A_PHY_REG					"rtl8195A\\PHY_REG_1T.txt"
+	#define RTL8195A_PHY_RADIO_A			"rtl8195A\\radio_a_1T.txt"
+	#define RTL8195A_PHY_RADIO_B			"rtl8195A\\radio_b_1T.txt"
+	#define RTL8195A_TXPWR_TRACK			"rtl8195A\\TxPowerTrack.txt" 
+	#define RTL8195A_AGC_TAB					"rtl8195A\\AGC_TAB_1T.txt"
+	#define RTL8195A_PHY_MACREG				"rtl87195A\\MAC_REG.txt"
+	#define RTL8195A_PHY_REG_PG				"rtl8195A\\PHY_REG_PG.txt"
+	#define RTL8195A_PHY_REG_MP				"rtl8195A\\PHY_REG_MP.txt"
+	#define RTL8195A_TXPWR_LMT 				"rtl8195A\\TXPWR_LMT.txt"
+
+//---------------------------------------------------------------------
+//		RTL8723BS From header
+//---------------------------------------------------------------------
+
+	//#define Rtl8723B_FwImageArray				Array_MP_8723B_FW_NIC
+	//#define Rtl8723B_FwImgArrayLength			ArrayLength_MP_8723B_FW_NIC
+	//#define Rtl8723B_FwWoWImageArray			Array_MP_8723B_FW_WoWLAN
+	//#define Rtl8723B_FwWoWImgArrayLength		ArrayLength_MP_8723B_FW_WoWLAN
+
+	#define Rtl8723B_PHY_REG_Array_PG 			Rtl8723SPHY_REG_Array_PG
+	#define Rtl8723B_PHY_REG_Array_PGLength	Rtl8723SPHY_REG_Array_PGLength
+
+#if MP_DRIVER == 1
+	#define Rtl8723B_FwBTImgArray				Rtl8723BFwBTImgArray
+	#define Rtl8723B_FwBTImgArrayLength		Rtl8723BFwBTImgArrayLength
+
+	#define Rtl8723B_FwMPImageArray			Rtl8723BFwMPImgArray
+	#define Rtl8723B_FwMPImgArrayLength		Rtl8723BMPImgArrayLength
+
+	#define Rtl8723B_PHY_REG_Array_MP			Rtl8723B_PHYREG_Array_MP
+	#define Rtl8723B_PHY_REG_Array_MPLength	Rtl8723B_PHYREG_Array_MPLength
+#endif
+
+#endif // RTL8195A_SUPPORT
+
+#define FW_8723B_SIZE			0x8000
+#define FW_8723B_START_ADDRESS	0x1000
+#define FW_8723B_END_ADDRESS		0x1FFF //0x5FFF
+
+#define IS_FW_HEADER_EXIST_8723B(_pFwHdr)	((le16_to_cpu(_pFwHdr->Signature)&0xFFF0) == 0x5300)
+
+typedef struct _RT_FIRMWARE {
+	FIRMWARE_SOURCE	eFWSource;
+#ifdef CONFIG_EMBEDDED_FWIMG
+	u8*			szFwBuffer;
+#else
+	u8			szFwBuffer[FW_8723B_SIZE];
+#endif
+	u32			ulFwLength;
+
+#ifdef CONFIG_EMBEDDED_FWIMG
+	u8*			szBTFwBuffer;
+#else
+	u8			szBTFwBuffer[FW_8723B_SIZE];
+#endif
+	u32			ulBTFwLength;
+
+#ifdef CONFIG_WOWLAN
+	u8*			szWoWLANFwBuffer;
+	u32			ulWoWLANFwLength;
+#endif //CONFIG_WOWLAN
+} RT_FIRMWARE_8723B, *PRT_FIRMWARE_8723B;
+
+//
+// This structure must be cared byte-ordering
+//
+// Added by tynli. 2009.12.04.
+typedef struct _RT_8723B_FIRMWARE_HDR
+{
+	// 8-byte alinment required
+
+	//--- LONG WORD 0 ----
+	u16		Signature;	// 92C0: test chip; 92C, 88C0: test chip; 88C1: MP A-cut; 92C1: MP A-cut
+	u8		Category;	// AP/NIC and USB/PCI
+	u8		Function;	// Reserved for different FW function indcation, for further use when driver needs to download different FW in different conditions
+	u16		Version;		// FW Version
+	u8		Subversion;	// FW Subversion, default 0x00
+	u16		Rsvd1;
+
+
+	//--- LONG WORD 1 ----
+	u8		Month;	// Release time Month field
+	u8		Date;	// Release time Date field
+	u8		Hour;	// Release time Hour field
+	u8		Minute;	// Release time Minute field
+	u16		RamCodeSize;	// The size of RAM code
+	u16		Rsvd2;
+
+	//--- LONG WORD 2 ----
+	u32		SvnIdx;	// The SVN entry index
+	u32		Rsvd3;
+
+	//--- LONG WORD 3 ----
+	u32		Rsvd4;
+	u32		Rsvd5;
+}RT_8723B_FIRMWARE_HDR, *PRT_8723B_FIRMWARE_HDR;
+
+#define DRIVER_EARLY_INT_TIME_8195A         0x05 // 5ms
+#define BCN_DMA_ATIME_INT_TIME_8195A        0x02 // 2ms
+
+// for 8195A
+// TX 32K, RX 16K, Page size 128B for TX, 8B for RX
+#define PAGE_SIZE_TX_8195A                  128
+#define PAGE_SIZE_RX_8195A                  8
+
+#define RX_DMA_SIZE_8195A                   0x4000	// 16K
+#define RX_DMA_RESERVED_SIZE_8195A          0x80	// 128B, reserved for tx report
+#define RX_DMA_BOUNDARY_8195A               (RX_DMA_SIZE_8195A - RX_DMA_RESERVED_SIZE_8195A - 1)
+
+
+// Note: We will divide number of page equally for each queue other than public queue!
+
+//For General Reserved Page Number(Beacon Queue is reserved page)
+//Beacon:2, PS-Poll:1, Null Data:1,Qos Null Data:1,BT Qos Null Data:1
+#ifdef CONFIG_WLAN_HAL_TEST
+#define BCNQ_PAGE_NUM_8195A             0x00
+#else
+#define BCNQ_PAGE_NUM_8195A             0x08
+#endif
+
+#ifdef CONFIG_CONCURRENT_MODE
+#define BCNQ1_PAGE_NUM_8195A            0x04
+#else
+#define BCNQ1_PAGE_NUM_8195A            0x00
+#endif
+
+//For WoWLan , more reserved page
+//ARP Rsp:1, RWC:1, GTK Info:1,GTK RSP:2,GTK EXT MEM:2
+#ifdef CONFIG_WOWLAN
+#define WOWLAN_PAGE_NUM_8195A           0x07
+#else
+#define WOWLAN_PAGE_NUM_8195A           0x00
+#endif
+
+#ifdef CONFIG_WLAN_HAL_TEST
+#define TX_TOTAL_PAGE_NUMBER_8195A      0x40
+#define TX_PAGE_BOUNDARY_8195A          (TX_TOTAL_PAGE_NUMBER_8195A + 1)
+#else
+#define TX_TOTAL_PAGE_NUMBER_8195A      (0xFF - BCNQ_PAGE_NUM_8195A - BCNQ1_PAGE_NUM_8195A - WOWLAN_PAGE_NUM_8195A)
+#define TX_PAGE_BOUNDARY_8195A          (TX_TOTAL_PAGE_NUMBER_8195A + 1)
+#endif
+
+#define WMM_NORMAL_TX_TOTAL_PAGE_NUMBER TX_TOTAL_PAGE_NUMBER_8195A
+#define WMM_NORMAL_TX_PAGE_BOUNDARY		(WMM_NORMAL_TX_TOTAL_PAGE_NUMBER + 1)
+
+// For Normal Chip Setting
+// (HPQ + LPQ + NPQ + PUBQ) shall be TX_TOTAL_PAGE_NUMBER_8195A
+#ifdef CONFIG_WLAN_HAL_TEST
+#define NORMAL_PAGE_NUM_HPQ_8195A		0x10
+#define NORMAL_PAGE_NUM_LPQ_8195A		0x10
+#define NORMAL_PAGE_NUM_NPQ_8195A		0x10
+#else
+#define NORMAL_PAGE_NUM_HPQ_8195A		0x0C
+#define NORMAL_PAGE_NUM_LPQ_8195A		0x02
+#define NORMAL_PAGE_NUM_NPQ_8195A		0x02
+#endif
+
+// Note: For Normal Chip Setting, modify later
+#define WMM_NORMAL_PAGE_NUM_HPQ_8195A   0x30
+#define WMM_NORMAL_PAGE_NUM_LPQ_8195A   0x20
+#define WMM_NORMAL_PAGE_NUM_NPQ_8195A   0x20
+
+#include "HalVerDef.h"
+#include "hal_com.h"
+
+#define EFUSE_OOB_PROTECT_BYTES 		(52+28+16+32) // Security + RF + MAC + OTP = 128
+
+#define HWSET_MAX_SIZE_8195A            512
+#define EFUSE_REAL_CONTENT_LEN_8195A    256
+#define EFUSE_MAP_LEN_8195A             512
+#define EFUSE_MAX_SECTION_8195A			64
+
+#define EFUSE_IC_ID_OFFSET			506	//For some inferiority IC purpose. added by Roger, 2009.09.02.
+#define AVAILABLE_EFUSE_ADDR(addr) 	(addr < EFUSE_REAL_CONTENT_LEN_8195A)
+
+#define EFUSE_ACCESS_ON			0x69	// For RTL8723 only.
+#define EFUSE_ACCESS_OFF			0x00	// For RTL8723 only.
+
+#ifdef CONFIG_LITTLE_WIFI_MCU_FUNCTION_THREAD
+#define LITTLE_WIFI_STACKSIZE           512
+#ifdef PLATFORM_CMSIS_RTOS
+#define LITTLE_WIFI_TASK_PRIORITY       3 // osPriorityRealtime
+#ifdef CONFIG_POWER_SAVING
+#define CHECK_IN_REQ_STATE_STACKSIZE        256
+#define CHECK_IN_REQ_STATE_TASK_PRIORITY    0//osPriorityNormal
+
+#ifdef TDMA_POWER_SAVING
+#define TDMA_CHANGE_STATE_STACKSIZE         256
+#define TDMA_CHANGE_STATE_TASK_PRIORITY     2//osPriorityRealtime
+#endif //#ifdef TDMA_POWER_SAVING
+
+#endif
+#else
+#define LITTLE_WIFI_TASK_PRIORITY       6//TASK_PRORITY_LOW
+
+#ifdef CONFIG_POWER_SAVING
+#define CHECK_IN_REQ_STATE_STACKSIZE        256
+#define CHECK_IN_REQ_STATE_TASK_PRIORITY    1
+
+#ifdef TDMA_POWER_SAVING
+#define TDMA_CHANGE_STATE_STACKSIZE         256
+#define TDMA_CHANGE_STATE_TASK_PRIORITY     3
+#endif //#ifdef TDMA_POWER_SAVING
+
+#endif
+#endif
+#endif
+
+#define LX_DMA_IMR_DISABLED 0
+#define FW_IMR_DISABLED     0
+#define WL_PMC_IMR_DISABLED 0
+
+
+//========================================================
+//			EFUSE for BT definition
+//========================================================
+#define EFUSE_BT_REAL_BANK_CONTENT_LEN	512
+#define EFUSE_BT_REAL_CONTENT_LEN		1536	// 512*3
+#define EFUSE_BT_MAP_LEN				1024	// 1k bytes
+#define EFUSE_BT_MAX_SECTION			128		// 1024/8
+
+#define EFUSE_PROTECT_BYTES_BANK		16
+
+#define GET_RF_TYPE(priv)			(GET_HAL_DATA(priv)->rf_type)
+
+// Description: Determine the types of C2H events that are the same in driver and Fw.
+// Fisrt constructed by tynli. 2009.10.09.
+typedef enum _C2H_EVT
+{
+	C2H_DBG = 0,
+	C2H_TSF = 1,
+	C2H_AP_RPT_RSP = 2,
+	C2H_CCX_TX_RPT = 3,	// The FW notify the report of the specific tx packet.
+	C2H_BT_RSSI = 4,
+	C2H_BT_OP_MODE = 5,
+	C2H_EXT_RA_RPT = 6,
+	C2H_8723B_BT_INFO = 9,
+	C2H_HW_INFO_EXCH = 10,
+	C2H_8723B_BT_MP_INFO = 11,
+	MAX_C2HEVENT
+} C2H_EVT;
+
+typedef _PACKED struct _C2H_EVT_HDR
+{
+	u8	CmdID;
+	u8	CmdLen;
+	u8	CmdSeq;
+} C2H_EVT_HDR, *PC2H_EVT_HDR;
+
+typedef enum tag_Package_Definition
+{
+	PACKAGE_DEFAULT,
+	PACKAGE_QFN56,
+	PACKAGE_QFN48,
+	PACKAGE_BGA96,
+	PACKAGE_QFN88,
+	PACKAGE_QFN216
+}PACKAGE_TYPE_E;
+
+typedef enum tag_ChipID_Definition
+{
+	CHIPID_8711AM = 0xFF,
+	CHIPID_8195AM = 0xFE,
+	CHIPID_8711AF = 0xFD,
+	CHIPID_8710AF = 0xFC,
+	CHIPID_8711AN = 0xFB,
+	CHIPID_8710AM = 0xFA
+}CHIP_TD_E;
+
+
+#define INCLUDE_MULTI_FUNC_BT(_Adapter)		(GET_HAL_DATA(_Adapter)->MultiFunc & RT_MULTI_FUNC_BT)
+#define INCLUDE_MULTI_FUNC_GPS(_Adapter)	(GET_HAL_DATA(_Adapter)->MultiFunc & RT_MULTI_FUNC_GPS)
+
+//========================================================
+//			TXBD and RXBD definition
+//========================================================
+#ifdef CONFIG_MP_INCLUDED	// For MP Tx no idle
+#define TX_VIQ_DESC_NUM         4
+#define TX_VOQ_DESC_NUM         4
+#define TX_BKQ_DESC_NUM         4
+#define TX_BEQ_DESC_NUM         32
+#else
+#define TX_VIQ_DESC_NUM         4
+#define TX_VOQ_DESC_NUM         4
+#define TX_BKQ_DESC_NUM         4
+#define TX_BEQ_DESC_NUM         4
+#endif
+#define TX_BCNQ_DESC_NUM        2
+#define TX_MGQ_DESC_NUM         4
+#define TX_H0Q_DESC_NUM         2
+#define TX_H1Q_DESC_NUM         2
+#define TX_H2Q_DESC_NUM         2
+#define TX_H3Q_DESC_NUM         2
+#define TX_H4Q_DESC_NUM         2
+#define TX_H5Q_DESC_NUM         2
+#define TX_H6Q_DESC_NUM         2
+#define TX_H7Q_DESC_NUM         2
+#define RX_Q_DESC_NUM           4  //16 Reduce rx desc number due to memory limitation
+
+#define SET_VIQ_DES_NUM     (TX_VIQ_DESC_NUM<<16)
+#define SET_VOQ_DES_NUM     (TX_VOQ_DESC_NUM)
+#define SET_RXQ_DES_NUM     (RX_Q_DESC_NUM<<16)
+#define SET_MGQ_DES_NUM     (TX_MGQ_DESC_NUM)
+#define SET_BKQ_DES_NUM     (TX_BKQ_DESC_NUM<<16)
+#define SET_BEQ_DES_NUM     (TX_BEQ_DESC_NUM)
+#define SET_H1Q_DES_NUM     (TX_H1Q_DESC_NUM<<16)
+#define SET_H0Q_DES_NUM     (TX_H0Q_DESC_NUM)
+#define SET_H3Q_DES_NUM     (TX_H3Q_DESC_NUM<<16)
+#define SET_H2Q_DES_NUM     (TX_H2Q_DESC_NUM)
+#define SET_H5Q_DES_NUM     (TX_H5Q_DESC_NUM<<16)
+#define SET_H4Q_DES_NUM     (TX_H4Q_DESC_NUM)
+#define SET_H7Q_DES_NUM     (TX_H7Q_DESC_NUM<<16)
+#define SET_H6Q_DES_NUM     (TX_H6Q_DESC_NUM)
+
+#define TX_DESC_MODE        1
+
+//0: 2 segment 
+//1: 4 segment 
+//2: 8 segment 
+//#define TX_DESC_MODE            2
+
+#define MAX_TXBD_SEQMENT_NUM    ((TX_DESC_MODE)? (4*TX_DESC_MODE): 2)
+#define TXBD_SEGMENT_SIZE		8
+
+
+
+typedef struct _RXBD_ELEMENT_ {
+    u32         Dword0;
+    u32         PhyAddr;
+}RXBD_ELEMENT,*PRXBD_ELEMENT;
+
+
+typedef struct _TXBD_ELEMENT_ {
+    u32         Dword0;
+    u32         AddrLow;
+}TXBD_ELEMENT,*PTXBD_ELEMENT;
+
+typedef struct _LX_DMA_ELEMENT_ {
+    u32         QueueTRxBdBase;
+    u32         HwIndex;
+    u32         HostIndex;
+    u32         AvaliableCnt;
+}LX_DMA_ELEMENT, *PLX_DMA_ELEMENT;
+#if 1
+
+typedef enum _LX_DMA_QUEUE_TYPE_{
+    VO_QUEUE = 0,
+    VI_QUEUE = 1,
+    BE_QUEUE = 2,
+    BK_QUEUE = 3,
+    MG_QUEUE = 4,
+    RX_QUEUE = 5,
+    H0_QUEUE = 6,
+    H1_QUEUE = 7,
+    H2_QUEUE = 8,
+    H3_QUEUE = 9,
+    H4_QUEUE = 10,
+    H5_QUEUE = 11,
+    H6_QUEUE = 12,
+    H7_QUEUE = 13,
+    BCN_QUEUE = 14,
+    MAX_TX_QUEUE = 15,
+    ERROR_QUEUE = 16,
+}LX_DMA_QUEUE_TYPE, *PLX_DMA_QUEUE_TYPE;
+
+typedef struct _TX_FREE_QUEUE_ {
+    _queue               FreeQueue;
+    u32                  Qlen;
+}TX_FREE_QUEUE, *PTX_FREE_QUEUE;
+
+typedef struct _LX_DMA_MANAGER_ {
+    LX_DMA_ELEMENT       QueueTRxBd[MAX_TX_QUEUE];
+    u32                  QueueMaxValue[MAX_TX_QUEUE];
+    u32                  RxBdSkb[RX_Q_DESC_NUM];
+    u32                  RxLen;
+    u32                  RemainLen;
+    u16                  RxAggregateNum;
+    u16                  RxExpectTag;
+    u16                  RxSegFlow;
+    u16                  Flagls;
+    TX_FREE_QUEUE        TxFreeQueue[MAX_TX_QUEUE];
+    
+}LX_DMA_MANAGER, *PLX_DMA_MANAGER;
+
+#else
+
+typedef struct _LX_DMA_MANAGER_ {
+    u32                 *pVoqTXBD;
+    u32                 *pViqTXBD;
+    u32                 *pBeqTXBD;
+    u32                 *pBkqTXBD;
+    u32                 *pBcnqTXBD;
+    u32                 *pMgqTXBD;
+    u32                 *pH0qTXBD;
+    u32                 *pH1qTXBD;
+    u32                 *pH2qTXBD;
+    u32                 *pH3qTXBD;
+    u32                 *pH4qTXBD;
+    u32                 *pH5qTXBD;
+    u32                 *pH6qTXBD;
+    u32                 *pH7qTXBD;
+    u32                 *pExViqTXBD;
+    u32                 *pExVoqTXBD;
+    u32                 *pExBeqTXBD;
+    u32                 *pExBkqTXBD;
+    u32                 *pExMgqTXBD;
+    u32                 *pRXBD;
+//    u4Byte                  RxAggBufEntry[RX_Q_DESC_NUM];
+//    u4Byte                  RxAggLenEntry[RX_Q_DESC_NUM];
+    u32                  RxLen;
+    u32                  RemainLen;
+    u16                  ViqTxWritePoint;
+    u16                  ViqTxReadPoint;
+    u16                  VoqTxWritePoint;
+    u16                  VoqTxReadPoint;
+    u16                  BeqTxWritePoint;
+    u16                  BeqTxReadPoint;
+    u16                  BkqTxWritePoint;
+    u16                  BkqTxReadPoint;
+    u16                  RxWritePoint;
+    u16                  RxReadPoint;
+    u16                  RxAggregateNum;
+    u16                  RxExpectTag;
+    u16                  RxSegFlow;
+    u16                  Flagls;
+}LX_DMA_MANAGER, *PLX_DMA_MANAGER;
+#endif
+
+// rtl8723a_hal_init.c
+s32 rtl8195a_FirmwareDownload(PADAPTER padapter, BOOLEAN  bUsedWoWLANFw);
+void rtl8195a_FirmwareSelfReset(PADAPTER padapter);
+void rtl8195a_InitializeFirmwareVars(PADAPTER padapter);
+
+void rtl8195a_InitAntenna_Selection(PADAPTER padapter);
+void rtl8195a_DeinitAntenna_Selection(PADAPTER padapter);
+void rtl8195a_CheckAntenna_Selection(PADAPTER padapter);
+void rtl8195a_init_default_value(PADAPTER padapter);
+
+s32 rtl8195a_InitLLTTable(PADAPTER padapter);
+
+s32 CardDisableHWSM(PADAPTER padapter, u8 resetMCU);
+s32 CardDisableWithoutHWSM(PADAPTER padapter);
+
+// EFuse
+//u8 GetEEPROMSize8195a(PADAPTER padapter);
+void Hal_InitPGData(PADAPTER padapter, u8 *PROMContent);
+void Hal_EfuseParseIDCode(PADAPTER padapter, u8 *hwinfo);
+void Hal_EfuseParseTxPowerInfo_8195A(PADAPTER padapter, u8 *PROMContent, BOOLEAN AutoLoadFail);
+void Hal_EfuseParseBTCoexistInfo_8195A(PADAPTER padapter, u8 *hwinfo, BOOLEAN AutoLoadFail);
+void Hal_EfuseParseEEPROMVer_8195A(PADAPTER padapter, u8 *hwinfo, BOOLEAN AutoLoadFail);
+void Hal_EfuseParseChnlPlan_8195A(PADAPTER padapter, u8 *hwinfo, BOOLEAN AutoLoadFail);
+void Hal_EfuseParseCustomerID_8195A(PADAPTER padapter, u8 *hwinfo, BOOLEAN AutoLoadFail);
+void Hal_EfuseParseAntennaDiversity_8195A(PADAPTER padapter, u8 *hwinfo, BOOLEAN AutoLoadFail);
+void Hal_EfuseParseXtal_8195A(PADAPTER pAdapter, u8 *hwinfo, u8 AutoLoadFail);
+void Hal_EfuseParseThermalMeter_8195A(PADAPTER padapter, u8 *hwinfo, u8 AutoLoadFail);
+
+u8 rtw_flash_read(PADAPTER padapter, u16 addr, u16 cnts, u8 *data);
+u8 rtw_flash_write(PADAPTER padapter, u16 addr, u16 cnts, u8 *data);
+u8 rtw_config_map_read(PADAPTER padapter, u16 addr, u16 cnts, u8 *data, u8 efuse);
+u8 rtw_config_map_write(PADAPTER padapter, u16 addr, u16 cnts, u8 *data, u8 efuse);
+
+void rtl8195a_set_hal_ops(struct hal_ops *pHalFunc);
+void lxbus_set_intf_ops(struct _io_ops	*pops);
+void SetHwReg8195A(PADAPTER padapter, u8 variable, u8 *val);
+void GetHwReg8195A(PADAPTER padapter, u8 variable, u8 *val);
+u8 SetHalDefVar8195A(PADAPTER padapter, HAL_DEF_VARIABLE variable, void *pval);
+u8 GetHalDefVar8195A(PADAPTER padapter, HAL_DEF_VARIABLE variable, void *pval);
+void SetHalODMVar8195A( PADAPTER Adapter, HAL_ODM_VARIABLE eVariable, PVOID pValue1, BOOLEAN bSet);
+void GetHalODMVar8195A(PADAPTER Adapter, HAL_ODM_VARIABLE eVariable, PVOID pValue1, BOOLEAN	bSet);
+
+// register
+void rtl8195a_InitBeaconParameters(PADAPTER padapter);
+void rtl8195a_InitBeaconMaxError(PADAPTER padapter, u8 InfraMode);
+void	_InitBurstPktLen_8195AB(PADAPTER Adapter);
+#ifdef CONFIG_WOWLAN
+void _8051Reset8195a(PADAPTER padapter);
+void Hal_DetectWoWMode(PADAPTER pAdapter);
+#endif //CONFIG_WOWLAN
+
+void rtl8195a_start_thread(_adapter *padapter);
+void rtl8195a_stop_thread(_adapter *padapter);
+
+#if defined(CONFIG_CHECK_BT_HANG) && defined(CONFIG_BT_COEXIST)
+void rtl8195ab_init_checkbthang_workqueue(_adapter * adapter);
+void rtl8195ab_free_checkbthang_workqueue(_adapter * adapter);
+void rtl8195ab_cancle_checkbthang_workqueue(_adapter * adapter);
+void rtl8195ab_hal_check_bt_hang(_adapter * adapter);
+#endif
+
+#ifdef CONFIG_WOWLAN
+void rtw_get_current_ip_address(PADAPTER padapter, u8 *pcurrentip);
+void rtw_get_sec_iv(PADAPTER padapter, u8*pcur_dot11txpn, u8 *StaAddr);
+#endif
+
+#ifdef CONFIG_GPIO_WAKEUP
+void HalSetOutPutGPIO(PADAPTER padapter, u8 index, u8 OutPutValue);
+#endif
+
+#ifdef CONFIG_RF_GAIN_OFFSET
+void Hal_ReadRFGainOffset(PADAPTER pAdapter,u8* hwinfo,BOOLEAN AutoLoadFail);
+#endif //CONFIG_RF_GAIN_OFFSET
+
+
+//1TODO: Chris
+#if 1
+
+//=============
+// [1] Rx Buffer Descriptor (for PCIE) buffer descriptor architecture
+//DWORD 0
+#define SET_RX_BUFFER_DESC_DATA_LENGTH_92E(__pRxStatusDesc, __Value)		SET_BITS_TO_LE_4BYTE( __pRxStatusDesc, 0, 14, __Value)
+#define SET_RX_BUFFER_DESC_LS_92E(__pRxStatusDesc,__Value)	SET_BITS_TO_LE_4BYTE( __pRxStatusDesc, 14, 1, __Value)
+#define SET_RX_BUFFER_DESC_FS_92E(__pRxStatusDesc, __Value)		SET_BITS_TO_LE_4BYTE( __pRxStatusDesc, 15, 1, __Value)
+#define SET_RX_BUFFER_DESC_RX_TAG_92E(__pRxStatusDesc, __Value)		SET_BITS_TO_LE_4BYTE( __pRxStatusDesc, 16, 13, __Value)
+
+#define GET_RX_BUFFER_DESC_OWN_92E(__pRxStatusDesc)		LE_BITS_TO_4BYTE( __pRxStatusDesc, 31, 1)
+#define GET_RX_BUFFER_DESC_LS_92E(__pRxStatusDesc)		LE_BITS_TO_4BYTE( __pRxStatusDesc, 14, 1)
+#define GET_RX_BUFFER_DESC_FS_92E(__pRxStatusDesc)		LE_BITS_TO_4BYTE( __pRxStatusDesc, 15, 1)
+#define GET_RX_BUFFER_DESC_RX_TAG_92E(__pRxStatusDesc)		LE_BITS_TO_4BYTE( __pRxStatusDesc, 16, 13)
+#define GET_RX_BUFFER_DESC_TOTAL_LENGTH_92E(__pRxStatusDesc)LE_BITS_TO_4BYTE( __pRxStatusDesc, 0, 14) 
+
+
+//DWORD 1
+#define SET_RX_BUFFER_PHYSICAL_LOW_92E(__pRxStatusDesc, __Value)		SET_BITS_TO_LE_4BYTE( __pRxStatusDesc+4, 0, 32, __Value)
+#define GET_RX_BUFFER_PHYSICAL_LOW_92E(__pRxStatusDesc)		LE_BITS_TO_4BYTE( __pRxStatusDesc+4, 0, 32)
+
+//DWORD 2
+#define SET_RX_BUFFER_PHYSICAL_HIGH_92E(__pRxStatusDesc, __Value)		SET_BITS_TO_LE_4BYTE( __pRxStatusDesc+8, 0, 32, __Value)
+
+
+//=====Tx Desc Buffer content
+
+// config element for each tx buffer 
+/*
+#define SET_TXBUFFER_DESC_LEN_WITH_OFFSET(__pTxDesc, __Offset, __Valeu) SET_BITS_TO_LE_4BYTE(__pTxDesc+(__Offset*16), 0, 16, __Valeu)
+#define SET_TXBUFFER_DESC_AMSDU_WITH_OFFSET(__pTxDesc, __Offset, __Valeu) SET_BITS_TO_LE_4BYTE(__pTxDesc+(__Offset*16), 31, 1, __Valeu)
+#define SET_TXBUFFER_DESC_ADD_LOW_WITH_OFFSET(__pTxDesc, __Offset, __Valeu) SET_BITS_TO_LE_4BYTE(__pTxDesc+(__Offset*16)+4, 0, 32, __Valeu)
+#define SET_TXBUFFER_DESC_ADD_HIGT_WITH_OFFSET(__pTxDesc, __Offset, __Valeu) SET_BITS_TO_LE_4BYTE(__pTxDesc+(__Offset*16)+8, 0, 32, __Valeu)
+*/
+#define SET_TXBUFFER_DESC_LEN_WITH_OFFSET(__pTxDesc, __Offset, __Valeu) SET_BITS_TO_LE_4BYTE(__pTxDesc+(__Offset*8), 0, 16, __Valeu)
+#define SET_TXBUFFER_DESC_AMSDU_WITH_OFFSET(__pTxDesc, __Offset, __Valeu) SET_BITS_TO_LE_4BYTE(__pTxDesc+(__Offset*8), 31, 1, __Valeu)
+#define SET_TXBUFFER_DESC_ADD_LOW_WITH_OFFSET(__pTxDesc, __Offset, __Valeu) SET_BITS_TO_LE_4BYTE(__pTxDesc+(__Offset*8)+4, 0, 32, __Valeu)
+#define SET_TXBUFFER_DESC_ADD_HIGT_WITH_OFFSET(__pTxDesc, __Offset, __Valeu) SET_BITS_TO_LE_4BYTE(__pTxDesc+(__Offset*16)+8, 0, 32, __Valeu)
+
+// Dword 0
+#define SET_TX_BUFF_DESC_LEN_0_92E(__pTxDesc, __Valeu) SET_BITS_TO_LE_4BYTE(__pTxDesc, 0, 16, __Valeu)
+#define SET_TX_BUFF_DESC_PSB_92E(__pTxDesc, __Value) SET_BITS_TO_LE_4BYTE(__pTxDesc, 16, 8, __Value)
+#define SET_TX_BUFF_DESC_OWN_92E(__pTxDesc, __Value) SET_BITS_TO_LE_4BYTE(__pTxDesc, 31, 1, __Value)
+// Dword 1
+#define SET_TX_BUFF_DESC_ADDR_LOW_0_92E(__pTxDesc, __Value) SET_BITS_TO_LE_4BYTE(__pTxDesc+4, 0, 32, __Value)
+#define GET_TX_DESC_TX_BUFFER_ADDRESS_92E(__pTxDesc) LE_BITS_TO_4BYTE(__pTxDesc+4, 0,32)
+
+
+// Dword 2
+#define SET_TX_BUFF_DESC_ADDR_HIGH_0_92E(__pTxDesc, __Value) SET_BITS_TO_LE_4BYTE(__pTxDesc+8, 0, 32, __Value)
+// Dword 3, RESERVED 
+
+
+#define SET_TX_DESC_OWN_92E(__pTxDesc, __Value) SET_BITS_TO_LE_4BYTE(__pTxDesc, 31, 1, __Value)
+
+#endif
+
+#endif
+

USDK/component/common/drivers/wlan/realtek/include/rtl8711b_hal.h

@@ -0,0 +1,595 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+
+#ifndef __RTL8711B_HAL_H__
+#define __RTL8711B_HAL_H__
+
+#include "drv_types.h"
+//#include "rtl8711b/rtl8711b_pmu_task.h"
+#include "hal_data.h"
+
+#include "rtl8711b/rtl8711b_spec.h"
+#include "rtl8711b/rtl8711b_rf.h"
+#include "rtl8711b/rtl8711b_dm.h"
+#include "rtl8711b/rtl8711b_recv.h"
+#include "rtl8711b/rtl8711b_xmit.h"
+#include "rtl8711b/rtl8711b_cmd.h"
+//#include "rtl8711b/rtl8711b_pmu_cmd.h"
+#include "rtl8711b/rtl8711b_led.h"
+#include "rtl8711b/Hal8711BPwrSeq.h"
+#include "rtl8711b/Hal8711BPhyReg.h"
+#include "rtl8711b/Hal8711BPhyCfg.h"
+#include "rtl8711b/rom_Hal8711BPhyCfg.h"
+
+#ifdef DBG_CONFIG_ERROR_DETECT
+#include "rtl8711b/rtl8711b_sreset.h"
+#endif
+
+#include "../src/hal/OUTSRC/phydm_precomp.h"
+
+#if (RTL8711B_SUPPORT==1)
+	//2TODO: We should define 8192S firmware related macro settings here!!
+	#define RTL819X_DEFAULT_RF_TYPE			RF_1T2R
+	#define RTL819X_TOTAL_RF_PATH				2
+
+//---------------------------------------------------------------------
+//		RTL8723BS From file
+//---------------------------------------------------------------------
+	#define RTL8723B_FW_IMG					"rtl8723B\\rtl8723bfw.bin"
+	#define RTL8711B_PHY_REG					"rtl8711B\\PHY_REG_1T.txt"
+	#define RTL8711B_PHY_RADIO_A			"rtl8711B\\radio_a_1T.txt"
+	#define RTL8711B_PHY_RADIO_B			"rtl8711B\\radio_b_1T.txt"
+	#define RTL8711B_TXPWR_TRACK			"rtl8711B\\TxPowerTrack.txt" 
+	#define RTL8711B_AGC_TAB					"rtl8711B\\AGC_TAB_1T.txt"
+	#define RTL8711B_PHY_MACREG				"rtl87195A\\MAC_REG.txt"
+	#define RTL8711B_PHY_REG_PG				"rtl8711B\\PHY_REG_PG.txt"
+	#define RTL8711B_PHY_REG_MP				"rtl8711B\\PHY_REG_MP.txt"
+	#define RTL8711B_TXPWR_LMT 				"rtl8711B\\TXPWR_LMT.txt"
+
+//---------------------------------------------------------------------
+//		RTL8723BS From header
+//---------------------------------------------------------------------
+
+	//#define Rtl8723B_FwImageArray				Array_MP_8723B_FW_NIC
+	//#define Rtl8723B_FwImgArrayLength			ArrayLength_MP_8723B_FW_NIC
+	//#define Rtl8723B_FwWoWImageArray			Array_MP_8723B_FW_WoWLAN
+	//#define Rtl8723B_FwWoWImgArrayLength		ArrayLength_MP_8723B_FW_WoWLAN
+
+	#define Rtl8711B_PHY_REG_Array_PG 			Rtl8723SPHY_REG_Array_PG
+	#define Rtl8711B_PHY_REG_Array_PGLength	Rtl8723SPHY_REG_Array_PGLength
+
+#if MP_DRIVER == 1
+	#define Rtl8711B_FwBTImgArray				Rtl8723BFwBTImgArray
+	#define Rtl8711B_FwBTImgArrayLength		Rtl8723BFwBTImgArrayLength
+
+	#define Rtl8711B_FwMPImageArray			Rtl8723BFwMPImgArray
+	#define Rtl8711B_FwMPImgArrayLength		Rtl8723BMPImgArrayLength
+
+	#define Rtl8711B_PHY_REG_Array_MP			Rtl8723B_PHYREG_Array_MP
+	#define Rtl8711B_PHY_REG_Array_MPLength	Rtl8723B_PHYREG_Array_MPLength
+#endif
+
+#endif // RTL8711B_SUPPORT
+
+#define FW_8711B_SIZE			0x8000
+#define FW_8711B_START_ADDRESS	0x1000
+#define FW_8711B_END_ADDRESS		0x1FFF //0x5FFF
+
+#define IS_FW_HEADER_EXIST_8711B(_pFwHdr)	((GET_FIRMWARE_HDR_SIGNATURE(_pFwHdr)&0xFFF0) == 0x10B0)
+
+typedef struct _RT_FIRMWARE {
+	FIRMWARE_SOURCE	eFWSource;
+#ifdef CONFIG_EMBEDDED_FWIMG
+	u8*			szFwBuffer;
+#else
+	u8			szFwBuffer[FW_8711B_SIZE];
+#endif
+	u32			ulFwLength;
+
+#ifdef CONFIG_EMBEDDED_FWIMG
+	u8*			szBTFwBuffer;
+#else
+	u8			szBTFwBuffer[FW_8711B_SIZE];
+#endif
+	u32			ulBTFwLength;
+
+#ifdef CONFIG_WOWLAN
+	u8*			szWoWLANFwBuffer;
+	u32			ulWoWLANFwLength;
+#endif //CONFIG_WOWLAN
+} RT_FIRMWARE_8711B, *PRT_FIRMWARE_8711B;
+
+//
+// This structure must be cared byte-ordering
+//
+// Added by tynli. 2009.12.04.
+typedef struct _RT_8723B_FIRMWARE_HDR
+{
+	// 8-byte alinment required
+
+	//--- LONG WORD 0 ----
+	u16		Signature;	// 92C0: test chip; 92C, 88C0: test chip; 88C1: MP A-cut; 92C1: MP A-cut
+	u8		Category;	// AP/NIC and USB/PCI
+	u8		Function;	// Reserved for different FW function indcation, for further use when driver needs to download different FW in different conditions
+	u16		Version;		// FW Version
+	u8		Subversion;	// FW Subversion, default 0x00
+	u16		Rsvd1;
+
+
+	//--- LONG WORD 1 ----
+	u8		Month;	// Release time Month field
+	u8		Date;	// Release time Date field
+	u8		Hour;	// Release time Hour field
+	u8		Minute;	// Release time Minute field
+	u16		RamCodeSize;	// The size of RAM code
+	u16		Rsvd2;
+
+	//--- LONG WORD 2 ----
+	u32		SvnIdx;	// The SVN entry index
+	u32		Rsvd3;
+
+	//--- LONG WORD 3 ----
+	u32		Rsvd4;
+	u32		Rsvd5;
+}RT_8723B_FIRMWARE_HDR, *PRT_8723B_FIRMWARE_HDR;
+
+#define DRIVER_EARLY_INT_TIME_8711B         0x05 // 5ms
+#define BCN_DMA_ATIME_INT_TIME_8711B        0x02 // 2ms
+
+// for 8711B
+// TX 32K, RX 16K, Page size 128B for TX, 8B for RX
+#define PAGE_SIZE_TX_8711B                  128
+#define PAGE_SIZE_RX_8711B                  8
+
+#define RX_DMA_SIZE_8711B                   0x4000	// 16K
+#define RX_DMA_RESERVED_SIZE_8711B          0x80	// 128B, reserved for tx report
+#define RX_DMA_BOUNDARY_8711B               (RX_DMA_SIZE_8711B - RX_DMA_RESERVED_SIZE_8711B - 1)
+
+// Note: We will divide number of page equally for each queue other than public queue!
+
+//For General Reserved Page Number(Beacon Queue is reserved page)
+//Beacon:2, PS-Poll:1, Null Data:1,Qos Null Data:1,BT Qos Null Data:1
+#ifdef CONFIG_WLAN_HAL_TEST
+#define BCNQ_PAGE_NUM_8711B             0x00
+#else
+#define BCNQ_PAGE_NUM_8711B             0x08
+#endif
+
+#ifdef CONFIG_CONCURRENT_MODE
+#define BCNQ1_PAGE_NUM_8711B            0x04
+#else
+#define BCNQ1_PAGE_NUM_8711B            0x00
+#endif
+
+//For WoWLan , more reserved page
+//ARP Rsp:1, RWC:1, GTK Info:1,GTK RSP:2,GTK EXT MEM:2
+#ifdef CONFIG_WOWLAN
+#define WOWLAN_PAGE_NUM_8711B           0x07
+#else
+#define WOWLAN_PAGE_NUM_8711B           0x00
+#endif
+
+#ifdef CONFIG_WLAN_HAL_TEST
+#define TX_TOTAL_PAGE_NUMBER_8711B      (0xF8 - BCNQ_PAGE_NUM_8711B - BCNQ1_PAGE_NUM_8711B - WOWLAN_PAGE_NUM_8711B)
+//#define TX_TOTAL_PAGE_NUMBER_8711B      0x40
+#define TX_PAGE_BOUNDARY_8711B          (TX_TOTAL_PAGE_NUMBER_8711B + 1)
+#else
+#define TX_TOTAL_PAGE_NUMBER_8711B      (0xFF - BCNQ_PAGE_NUM_8711B - BCNQ1_PAGE_NUM_8711B - WOWLAN_PAGE_NUM_8711B)
+#define TX_PAGE_BOUNDARY_8711B          (TX_TOTAL_PAGE_NUMBER_8711B + 1)
+#endif
+
+#define WMM_NORMAL_TX_TOTAL_PAGE_NUMBER TX_TOTAL_PAGE_NUMBER_8711B
+#define WMM_NORMAL_TX_PAGE_BOUNDARY		(WMM_NORMAL_TX_TOTAL_PAGE_NUMBER + 1)
+
+// For Normal Chip Setting
+// (HPQ + LPQ + NPQ + PUBQ) shall be TX_TOTAL_PAGE_NUMBER_8711B
+#ifdef CONFIG_WLAN_HAL_TEST
+#define NORMAL_PAGE_NUM_HPQ_8711B		0x10
+#define NORMAL_PAGE_NUM_LPQ_8711B		0x10
+#define NORMAL_PAGE_NUM_NPQ_8711B		0x10
+#else
+#define NORMAL_PAGE_NUM_HPQ_8711B		0x0C
+#define NORMAL_PAGE_NUM_LPQ_8711B		0x02
+#define NORMAL_PAGE_NUM_NPQ_8711B		0x02
+#endif
+
+#ifdef CONFIG_WLAN_HAL_TEST
+#define WMM_NORMAL_PAGE_NUM_HPQ_8711B   0x10
+#define WMM_NORMAL_PAGE_NUM_LPQ_8711B   0x10
+#define WMM_NORMAL_PAGE_NUM_NPQ_8711B   0x10
+#else
+// Note: For Normal Chip Setting, modify later
+#define WMM_NORMAL_PAGE_NUM_HPQ_8711B   0x30
+#define WMM_NORMAL_PAGE_NUM_LPQ_8711B   0x20
+#define WMM_NORMAL_PAGE_NUM_NPQ_8711B   0x20
+#endif
+
+#include "HalVerDef.h"
+#include "hal_com.h"
+
+#define LX_DMA_IMR_DISABLED 0
+#define FW_IMR_DISABLED     0
+#define WL_PMC_IMR_DISABLED 0
+
+
+//========================================================
+//			EFUSE for BT definition
+//========================================================
+#define EFUSE_BT_REAL_BANK_CONTENT_LEN	512
+#define EFUSE_BT_REAL_CONTENT_LEN		1536	// 512*3
+#define EFUSE_BT_MAP_LEN				1024	// 1k bytes
+#define EFUSE_BT_MAX_SECTION			128		// 1024/8
+
+#define EFUSE_PROTECT_BYTES_BANK		16
+
+#define GET_RF_TYPE(priv)			(GET_HAL_DATA(priv)->rf_type)
+
+// Description: Determine the types of C2H events that are the same in driver and Fw.
+// Fisrt constructed by tynli. 2009.10.09.
+typedef enum _C2H_EVT
+{
+	C2H_DBG = 0,
+	C2H_TSF = 1,
+	C2H_AP_RPT_RSP = 2,
+	C2H_CCX_TX_RPT = 3,	// The FW notify the report of the specific tx packet.
+	C2H_BT_RSSI = 4,
+	C2H_BT_OP_MODE = 5,
+	C2H_EXT_RA_RPT = 6,
+	C2H_8723B_BT_INFO = 9,
+	C2H_HW_INFO_EXCH = 10,
+	C2H_8723B_BT_MP_INFO = 11,
+	MAX_C2HEVENT
+} C2H_EVT;
+
+typedef _PACKED struct _C2H_EVT_HDR
+{
+	u8	CmdID;
+	u8	CmdLen;
+	u8	CmdSeq;
+} C2H_EVT_HDR, *PC2H_EVT_HDR;
+
+typedef enum tag_Package_Definition
+{
+	PACKAGE_QFN32,
+	PACKAGE_QFN48_MCM,
+	PACKAGE_QFN48,
+	PACKAGE_QFN68,
+}PACKAGE_TYPE_E;
+
+typedef enum tag_ChipID_Definition
+{
+	CHIPID_8710BN = 0xFF, /* PACKAGE_QFN32 */
+	CHIPID_8710BU = 0xFE, /* PACKAGE_QFN48_MCM */
+	CHIPID_8711BN = 0xFD, /* PACKAGE_QFN48 */
+	CHIPID_8711BG = 0xFC, /* PACKAGE_QFN68 */
+}CHIP_TD_E;
+
+
+#define INCLUDE_MULTI_FUNC_BT(_Adapter)		(GET_HAL_DATA(_Adapter)->MultiFunc & RT_MULTI_FUNC_BT)
+#define INCLUDE_MULTI_FUNC_GPS(_Adapter)	(GET_HAL_DATA(_Adapter)->MultiFunc & RT_MULTI_FUNC_GPS)
+
+//========================================================
+//			TXBD and RXBD definition
+//========================================================
+#ifdef CONFIG_MP_INCLUDED	// For MP Tx no idle
+#define TX_VIQ_DESC_NUM         4
+#define TX_VOQ_DESC_NUM         4
+#define TX_BKQ_DESC_NUM         4
+#define TX_BEQ_DESC_NUM         32
+#else
+#define TX_VIQ_DESC_NUM         4
+#define TX_VOQ_DESC_NUM         4
+#define TX_BKQ_DESC_NUM         4
+#define TX_BEQ_DESC_NUM         4
+#endif
+#ifdef CONFIG_CONCURRENT_MODE
+#define TX_BCNQ_DESC_NUM        4
+#else
+#define TX_BCNQ_DESC_NUM        2
+#endif
+#define TX_MGQ_DESC_NUM         4
+#define TX_H0Q_DESC_NUM         2
+#define TX_H1Q_DESC_NUM         2
+#define TX_H2Q_DESC_NUM         2
+#define TX_H3Q_DESC_NUM         2
+#define TX_H4Q_DESC_NUM         2
+#define TX_H5Q_DESC_NUM         2
+#define TX_H6Q_DESC_NUM         2
+#define TX_H7Q_DESC_NUM         2
+#define RX_Q_DESC_NUM           4  //16 Reduce rx desc number due to memory limitation
+
+#define SET_VIQ_DES_NUM     (TX_VIQ_DESC_NUM<<16)
+#define SET_VOQ_DES_NUM     (TX_VOQ_DESC_NUM)
+#define SET_RXQ_DES_NUM     (RX_Q_DESC_NUM<<16)
+#define SET_MGQ_DES_NUM     (TX_MGQ_DESC_NUM)
+#define SET_BKQ_DES_NUM     (TX_BKQ_DESC_NUM<<16)
+#define SET_BEQ_DES_NUM     (TX_BEQ_DESC_NUM)
+#define SET_H1Q_DES_NUM     (TX_H1Q_DESC_NUM<<16)
+#define SET_H0Q_DES_NUM     (TX_H0Q_DESC_NUM)
+#define SET_H3Q_DES_NUM     (TX_H3Q_DESC_NUM<<16)
+#define SET_H2Q_DES_NUM     (TX_H2Q_DESC_NUM)
+#define SET_H5Q_DES_NUM     (TX_H5Q_DESC_NUM<<16)
+#define SET_H4Q_DES_NUM     (TX_H4Q_DESC_NUM)
+#define SET_H7Q_DES_NUM     (TX_H7Q_DESC_NUM<<16)
+#define SET_H6Q_DES_NUM     (TX_H6Q_DESC_NUM)
+
+#define TX_DESC_MODE        1
+
+//0: 2 segment 
+//1: 4 segment 
+//2: 8 segment 
+//#define TX_DESC_MODE            2
+
+#define MAX_TXBD_SEQMENT_NUM    ((TX_DESC_MODE)? (4*TX_DESC_MODE): 2)
+#define TXBD_SEGMENT_SIZE		8
+
+
+
+typedef struct _RXBD_ELEMENT_ {
+    u32         Dword0;
+    u32         PhyAddr;
+}RXBD_ELEMENT,*PRXBD_ELEMENT;
+
+
+typedef struct _TXBD_ELEMENT_ {
+    u32         Dword0;
+    u32         AddrLow;
+}TXBD_ELEMENT,*PTXBD_ELEMENT;
+
+typedef struct _LX_DMA_ELEMENT_ {
+    u32         QueueTRxBdBase;
+    u32         HwIndex;
+    u32         HostIndex;
+    u32         AvaliableCnt;
+}LX_DMA_ELEMENT, *PLX_DMA_ELEMENT;
+#if 1
+
+typedef enum _LX_DMA_QUEUE_TYPE_{
+    VO_QUEUE = 0,
+    VI_QUEUE = 1,
+    BE_QUEUE = 2,
+    BK_QUEUE = 3,
+    MG_QUEUE = 4,
+    RX_QUEUE = 5,
+    H0_QUEUE = 6,
+    H1_QUEUE = 7,
+    H2_QUEUE = 8,
+    H3_QUEUE = 9,
+    H4_QUEUE = 10,
+    H5_QUEUE = 11,
+    H6_QUEUE = 12,
+    H7_QUEUE = 13,
+    BCN_QUEUE = 14,
+    MAX_TX_QUEUE = 15,
+    ERROR_QUEUE = 16,
+}LX_DMA_QUEUE_TYPE, *PLX_DMA_QUEUE_TYPE;
+
+typedef struct _TX_FREE_QUEUE_ {
+    _queue               FreeQueue;
+    u32                  Qlen;
+}TX_FREE_QUEUE, *PTX_FREE_QUEUE;
+
+typedef struct _LX_DMA_MANAGER_ {
+    LX_DMA_ELEMENT       QueueTRxBd[MAX_TX_QUEUE];
+    u32                  QueueMaxValue[MAX_TX_QUEUE];
+    u32                  RxBdSkb[RX_Q_DESC_NUM];
+    u32                  RxLen;
+    u32                  RemainLen;
+    u16                  RxAggregateNum;
+    u16                  RxExpectTag;
+    u16                  RxSegFlow;
+    u16                  Flagls;
+    TX_FREE_QUEUE        TxFreeQueue[MAX_TX_QUEUE];
+    
+}LX_DMA_MANAGER, *PLX_DMA_MANAGER;
+
+#else
+
+typedef struct _LX_DMA_MANAGER_ {
+    u32                 *pVoqTXBD;
+    u32                 *pViqTXBD;
+    u32                 *pBeqTXBD;
+    u32                 *pBkqTXBD;
+    u32                 *pBcnqTXBD;
+    u32                 *pMgqTXBD;
+    u32                 *pH0qTXBD;
+    u32                 *pH1qTXBD;
+    u32                 *pH2qTXBD;
+    u32                 *pH3qTXBD;
+    u32                 *pH4qTXBD;
+    u32                 *pH5qTXBD;
+    u32                 *pH6qTXBD;
+    u32                 *pH7qTXBD;
+    u32                 *pExViqTXBD;
+    u32                 *pExVoqTXBD;
+    u32                 *pExBeqTXBD;
+    u32                 *pExBkqTXBD;
+    u32                 *pExMgqTXBD;
+    u32                 *pRXBD;
+//    u4Byte                  RxAggBufEntry[RX_Q_DESC_NUM];
+//    u4Byte                  RxAggLenEntry[RX_Q_DESC_NUM];
+    u32                  RxLen;
+    u32                  RemainLen;
+    u16                  ViqTxWritePoint;
+    u16                  ViqTxReadPoint;
+    u16                  VoqTxWritePoint;
+    u16                  VoqTxReadPoint;
+    u16                  BeqTxWritePoint;
+    u16                  BeqTxReadPoint;
+    u16                  BkqTxWritePoint;
+    u16                  BkqTxReadPoint;
+    u16                  RxWritePoint;
+    u16                  RxReadPoint;
+    u16                  RxAggregateNum;
+    u16                  RxExpectTag;
+    u16                  RxSegFlow;
+    u16                  Flagls;
+}LX_DMA_MANAGER, *PLX_DMA_MANAGER;
+#endif
+
+// rtl8723a_hal_init.c
+s32 rtl8711b_FirmwareDownload(PADAPTER padapter, BOOLEAN  bUsedWoWLANFw);
+void rtl8711b_FirmwareSelfReset(PADAPTER padapter);
+void rtl8711b_InitializeFirmwareVars(PADAPTER padapter);
+
+void rtl8711b_InitAntenna_Selection(PADAPTER padapter);
+void rtl8711b_DeinitAntenna_Selection(PADAPTER padapter);
+void rtl8711b_CheckAntenna_Selection(PADAPTER padapter);
+void rtl8711b_init_default_value(PADAPTER padapter);
+
+s32 rtl8711b_InitLLTTable(PADAPTER padapter);
+
+s32 CardDisableHWSM(PADAPTER padapter, u8 resetMCU);
+s32 CardDisableWithoutHWSM(PADAPTER padapter);
+
+// EFuse
+//u8 GetEEPROMSize8711b(PADAPTER padapter);
+void Hal_InitPGData(PADAPTER padapter, u8 *PROMContent);
+void Hal_EfuseParseIDCode(PADAPTER padapter, u8 *hwinfo);
+void Hal_EfuseParseTxPowerInfo_8711B(PADAPTER padapter, u8 *PROMContent, BOOLEAN AutoLoadFail);
+void Hal_EfuseParseBTCoexistInfo_8711B(PADAPTER padapter, u8 *hwinfo, BOOLEAN AutoLoadFail);
+void Hal_EfuseParseEEPROMVer_8711B(PADAPTER padapter, u8 *hwinfo, BOOLEAN AutoLoadFail);
+void Hal_EfuseParseChnlPlan_8711B(PADAPTER padapter, u8 *hwinfo, BOOLEAN AutoLoadFail);
+void Hal_EfuseParseCustomerID_8711B(PADAPTER padapter, u8 *hwinfo, BOOLEAN AutoLoadFail);
+void Hal_EfuseParseAntennaDiversity_8711B(PADAPTER padapter, u8 *hwinfo, BOOLEAN AutoLoadFail);
+void Hal_EfuseParseXtal_8711B(PADAPTER pAdapter, u8 *hwinfo, u8 AutoLoadFail);
+void Hal_EfuseParseThermalMeter_8711B(PADAPTER padapter, u8 *hwinfo, u8 AutoLoadFail);
+
+#ifdef CONFIG_C2H_PACKET_EN
+void C2HPacketHandler_8711B(PADAPTER padapter, u8 *pbuffer, u16 length);
+#endif
+
+u8 rtw_flash_read(PADAPTER padapter, u16 addr, u16 cnts, u8 *data);
+u8 rtw_flash_write(PADAPTER padapter, u16 addr, u16 cnts, u8 *data);
+u8 rtw_config_map_read(PADAPTER padapter, u16 addr, u16 cnts, u8 *data, u8 efuse);
+u8 rtw_config_map_write(PADAPTER padapter, u16 addr, u16 cnts, u8 *data, u8 efuse);
+
+void rtl8711b_set_hal_ops(struct hal_ops *pHalFunc);
+void lxbus_set_intf_ops(struct _io_ops	*pops);
+void SetHwReg8711B(PADAPTER padapter, u8 variable, u8 *val);
+void GetHwReg8711B(PADAPTER padapter, u8 variable, u8 *val);
+u8 SetHalDefVar8711B(PADAPTER padapter, HAL_DEF_VARIABLE variable, void *pval);
+u8 GetHalDefVar8711B(PADAPTER padapter, HAL_DEF_VARIABLE variable, void *pval);
+void SetHalODMVar8711B( PADAPTER Adapter, HAL_ODM_VARIABLE eVariable, PVOID pValue1, BOOLEAN bSet);
+void GetHalODMVar8711B(PADAPTER Adapter, HAL_ODM_VARIABLE eVariable, PVOID pValue1, BOOLEAN	bSet);
+
+// register
+void rtl8711b_InitBeaconParameters(PADAPTER padapter);
+void rtl8711b_InitBeaconMaxError(PADAPTER padapter, u8 InfraMode);
+void	_InitBurstPktLen_8711BB(PADAPTER Adapter);
+#ifdef CONFIG_WOWLAN
+void _8051Reset8711b(PADAPTER padapter);
+void Hal_DetectWoWMode(PADAPTER pAdapter);
+#endif //CONFIG_WOWLAN
+
+void rtl8711b_start_thread(_adapter *padapter);
+void rtl8711b_stop_thread(_adapter *padapter);
+
+#if defined(CONFIG_CHECK_BT_HANG) && defined(CONFIG_BT_COEXIST)
+void rtl8711bb_init_checkbthang_workqueue(_adapter * adapter);
+void rtl8711bb_free_checkbthang_workqueue(_adapter * adapter);
+void rtl8711bb_cancle_checkbthang_workqueue(_adapter * adapter);
+void rtl8711bb_hal_check_bt_hang(_adapter * adapter);
+#endif
+
+#ifdef CONFIG_WOWLAN
+void rtw_get_current_ip_address(PADAPTER padapter, u8 *pcurrentip);
+void rtw_get_sec_iv(PADAPTER padapter, u8*pcur_dot11txpn, u8 *StaAddr);
+#endif
+
+u32 rtl8710b_wlan_suspend(u32 expected_idle_time, void *param);
+u32 rtl8710b_wlan_late_resume(u32 expected_idle_time, void *param);
+u32 rtl8710b_wlan_resume(u32 expected_idle_time, void *param);
+
+#ifdef CONFIG_GPIO_WAKEUP
+void HalSetOutPutGPIO(PADAPTER padapter, u8 index, u8 OutPutValue);
+#endif
+
+void CCX_FwC2HTxRpt_8711B(PADAPTER padapter, u8 *pdata, u8 len);
+s32 c2h_id_filter_ccx_8711B(u8 *buf);
+s32 c2h_handler_8711B(PADAPTER padapter, u8 *pC2hEvent);
+u8 MRateToHwRate8723B(u8  rate);
+u8 HwRateToMRate8723B(u8	 rate);
+
+#ifdef CONFIG_RF_GAIN_OFFSET
+void Hal_ReadRFGainOffset(PADAPTER pAdapter,u8* hwinfo,BOOLEAN AutoLoadFail);
+#endif //CONFIG_RF_GAIN_OFFSET
+
+
+//1TODO: Chris
+#if 1
+
+//=============
+// [1] Rx Buffer Descriptor (for PCIE) buffer descriptor architecture
+//DWORD 0
+#define SET_RX_BUFFER_DESC_DATA_LENGTH_92E(__pRxStatusDesc, __Value)		SET_BITS_TO_LE_4BYTE( __pRxStatusDesc, 0, 14, __Value)
+#define SET_RX_BUFFER_DESC_LS_92E(__pRxStatusDesc,__Value)	SET_BITS_TO_LE_4BYTE( __pRxStatusDesc, 14, 1, __Value)
+#define SET_RX_BUFFER_DESC_FS_92E(__pRxStatusDesc, __Value)		SET_BITS_TO_LE_4BYTE( __pRxStatusDesc, 15, 1, __Value)
+#define SET_RX_BUFFER_DESC_RX_TAG_92E(__pRxStatusDesc, __Value)		SET_BITS_TO_LE_4BYTE( __pRxStatusDesc, 16, 13, __Value)
+
+#define GET_RX_BUFFER_DESC_OWN_92E(__pRxStatusDesc)		LE_BITS_TO_4BYTE( __pRxStatusDesc, 31, 1)
+#define GET_RX_BUFFER_DESC_LS_92E(__pRxStatusDesc)		LE_BITS_TO_4BYTE( __pRxStatusDesc, 14, 1)
+#define GET_RX_BUFFER_DESC_FS_92E(__pRxStatusDesc)		LE_BITS_TO_4BYTE( __pRxStatusDesc, 15, 1)
+#define GET_RX_BUFFER_DESC_RX_TAG_92E(__pRxStatusDesc)		LE_BITS_TO_4BYTE( __pRxStatusDesc, 16, 13)
+#define GET_RX_BUFFER_DESC_TOTAL_LENGTH_92E(__pRxStatusDesc)LE_BITS_TO_4BYTE( __pRxStatusDesc, 0, 14) 
+
+
+//DWORD 1
+#define SET_RX_BUFFER_PHYSICAL_LOW_92E(__pRxStatusDesc, __Value)		SET_BITS_TO_LE_4BYTE( __pRxStatusDesc+4, 0, 32, __Value)
+#define GET_RX_BUFFER_PHYSICAL_LOW_92E(__pRxStatusDesc)		LE_BITS_TO_4BYTE( __pRxStatusDesc+4, 0, 32)
+
+//DWORD 2
+#define SET_RX_BUFFER_PHYSICAL_HIGH_92E(__pRxStatusDesc, __Value)		SET_BITS_TO_LE_4BYTE( __pRxStatusDesc+8, 0, 32, __Value)
+
+
+//=====Tx Desc Buffer content
+
+// config element for each tx buffer 
+/*
+#define SET_TXBUFFER_DESC_LEN_WITH_OFFSET(__pTxDesc, __Offset, __Valeu) SET_BITS_TO_LE_4BYTE(__pTxDesc+(__Offset*16), 0, 16, __Valeu)
+#define SET_TXBUFFER_DESC_AMSDU_WITH_OFFSET(__pTxDesc, __Offset, __Valeu) SET_BITS_TO_LE_4BYTE(__pTxDesc+(__Offset*16), 31, 1, __Valeu)
+#define SET_TXBUFFER_DESC_ADD_LOW_WITH_OFFSET(__pTxDesc, __Offset, __Valeu) SET_BITS_TO_LE_4BYTE(__pTxDesc+(__Offset*16)+4, 0, 32, __Valeu)
+#define SET_TXBUFFER_DESC_ADD_HIGT_WITH_OFFSET(__pTxDesc, __Offset, __Valeu) SET_BITS_TO_LE_4BYTE(__pTxDesc+(__Offset*16)+8, 0, 32, __Valeu)
+*/
+#define SET_TXBUFFER_DESC_LEN_WITH_OFFSET(__pTxDesc, __Offset, __Valeu) SET_BITS_TO_LE_4BYTE(__pTxDesc+(__Offset*8), 0, 16, __Valeu)
+#define SET_TXBUFFER_DESC_AMSDU_WITH_OFFSET(__pTxDesc, __Offset, __Valeu) SET_BITS_TO_LE_4BYTE(__pTxDesc+(__Offset*8), 31, 1, __Valeu)
+#define SET_TXBUFFER_DESC_ADD_LOW_WITH_OFFSET(__pTxDesc, __Offset, __Valeu) SET_BITS_TO_LE_4BYTE(__pTxDesc+(__Offset*8)+4, 0, 32, __Valeu)
+#define SET_TXBUFFER_DESC_ADD_HIGT_WITH_OFFSET(__pTxDesc, __Offset, __Valeu) SET_BITS_TO_LE_4BYTE(__pTxDesc+(__Offset*16)+8, 0, 32, __Valeu)
+
+// Dword 0
+#define SET_TX_BUFF_DESC_LEN_0_92E(__pTxDesc, __Valeu) SET_BITS_TO_LE_4BYTE(__pTxDesc, 0, 16, __Valeu)
+#define SET_TX_BUFF_DESC_PSB_92E(__pTxDesc, __Value) SET_BITS_TO_LE_4BYTE(__pTxDesc, 16, 8, __Value)
+#define SET_TX_BUFF_DESC_OWN_92E(__pTxDesc, __Value) SET_BITS_TO_LE_4BYTE(__pTxDesc, 31, 1, __Value)
+// Dword 1
+#define SET_TX_BUFF_DESC_ADDR_LOW_0_92E(__pTxDesc, __Value) SET_BITS_TO_LE_4BYTE(__pTxDesc+4, 0, 32, __Value)
+#define GET_TX_DESC_TX_BUFFER_ADDRESS_92E(__pTxDesc) LE_BITS_TO_4BYTE(__pTxDesc+4, 0,32)
+
+
+// Dword 2
+#define SET_TX_BUFF_DESC_ADDR_HIGH_0_92E(__pTxDesc, __Value) SET_BITS_TO_LE_4BYTE(__pTxDesc+8, 0, 32, __Value)
+// Dword 3, RESERVED 
+
+
+#define SET_TX_DESC_OWN_92E(__pTxDesc, __Value) SET_BITS_TO_LE_4BYTE(__pTxDesc, 31, 1, __Value)
+
+#endif
+
+#endif
+

USDK/component/common/drivers/wlan/realtek/include/rtw_ap.h

@@ -0,0 +1,65 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef __RTW_AP_H_
+#define __RTW_AP_H_
+
+//#include <drv_types.h>
+
+
+#ifdef CONFIG_AP_MODE
+
+//external function
+extern void rtw_indicate_sta_assoc_event(_adapter *padapter, struct sta_info *psta);
+extern void rtw_indicate_sta_disassoc_event(_adapter *padapter, struct sta_info *psta);
+
+
+void init_mlme_ap_info(_adapter *padapter);
+void free_mlme_ap_info(_adapter *padapter);
+//void update_BCNTIM(_adapter *padapter);
+void rtw_add_bcn_ie(_adapter *padapter, WLAN_BSSID_EX *pnetwork, u8 index, u8 *data, u8 len);
+void rtw_remove_bcn_ie(_adapter *padapter, WLAN_BSSID_EX *pnetwork, u8 index);
+void update_beacon(_adapter *padapter, u8 ie_id, u8 *oui, u8 tx);
+void add_RATid(_adapter *padapter, struct sta_info *psta, u8 rssi_level);
+void expire_timeout_chk(_adapter *padapter);
+void update_sta_info_apmode(_adapter *padapter, struct sta_info *psta);
+int rtw_check_beacon_data(_adapter *padapter, u8 *pbuf,  int len);
+void rtw_set_macaddr_acl(_adapter *padapter, int mode);
+int rtw_acl_add_sta(_adapter *padapter, u8 *addr);
+int rtw_acl_remove_sta(_adapter *padapter, u8 *addr);
+int rtw_generate_bcn_ie(_adapter *adapter, u8 *ssid, u16 ssid_len, u8 *ie);
+#if USE_DEDICATED_BCN_TX
+struct xmit_frame *alloc_bcn_xmitframe(_adapter *padapter);
+#endif
+
+#ifdef CONFIG_NATIVEAP_MLME
+void associated_clients_update(_adapter *padapter, u8 updated);
+void bss_cap_update_on_sta_join(_adapter *padapter, struct sta_info *psta);
+u8 bss_cap_update_on_sta_leave(_adapter *padapter, struct sta_info *psta);
+void sta_info_update(_adapter *padapter, struct sta_info *psta);
+void ap_sta_info_defer_update(_adapter *padapter, struct sta_info *psta);
+u8 ap_free_sta(_adapter *padapter, struct sta_info *psta, u16 reason);
+int rtw_sta_flush(_adapter *padapter);
+void start_ap_mode(_adapter *padapter);
+void stop_ap_mode(_adapter *padapter);
+#endif
+#endif //end of CONFIG_AP_MODE
+
+#endif
+

USDK/component/common/drivers/wlan/realtek/include/rtw_byteorder.h

@@ -0,0 +1,53 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef _RTL871X_BYTEORDER_H_
+#define _RTL871X_BYTEORDER_H_
+
+#include <drv_conf.h>
+
+#if defined (CONFIG_LITTLE_ENDIAN) && defined (CONFIG_BIG_ENDIAN)
+#error "Shall be CONFIG_LITTLE_ENDIAN or CONFIG_BIG_ENDIAN, but not both!\n"
+#endif
+
+#if defined (CONFIG_LITTLE_ENDIAN)
+#ifndef CONFIG_PLATFORM_MSTAR389
+#  include <byteorder/little_endian.h>
+#endif
+#elif defined (CONFIG_BIG_ENDIAN)
+#  include <byteorder/big_endian.h>
+#else
+#  error "Must be LITTLE/BIG Endian Host"
+#endif
+
+#ifdef CONFIG_BIG_ENDIAN
+#define _htons(x) (x)
+#define _ntohs(x) (x)
+#define _htonl(x) (x)
+#define _ntohl(x) (x)
+#else /* !CONFIG_BIG_ENDIAN */
+u16 _htons(u16 x);
+u16 _ntohs(u16 x);
+u32 _htonl(u32 x);
+u32 _ntohl(u32 x);
+#endif /* CONFIG_BIG_ENDIAN */
+
+
+#endif /* _RTL871X_BYTEORDER_H_ */
+

USDK/component/common/drivers/wlan/realtek/include/rtw_debug.h

@@ -0,0 +1,456 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef __RTW_DEBUG_H__
+#define __RTW_DEBUG_H__
+
+
+#define _drv_always_		1
+#define _drv_emerg_			2
+#define _drv_alert_			3
+#define _drv_crit_			4
+#define _drv_err_			5
+#define	_drv_warning_		6
+#define _drv_notice_		7
+#define _drv_info_			8
+#define _drv_dump_			9
+#define	_drv_debug_			10
+
+
+#define _module_rtl871x_xmit_c_		BIT(0)
+#define _module_xmit_osdep_c_		BIT(1)
+#define _module_rtl871x_recv_c_		BIT(2)
+#define _module_recv_osdep_c_		BIT(3)
+#define _module_rtl871x_mlme_c_		BIT(4)
+#define _module_mlme_osdep_c_		BIT(5)
+#define _module_rtl871x_sta_mgt_c_		BIT(6)
+#define _module_rtl871x_cmd_c_			BIT(7)
+#define _module_cmd_osdep_c_		BIT(8)
+#define _module_rtl871x_io_c_				BIT(9)
+#define _module_io_osdep_c_		BIT(10)
+#define _module_os_intfs_c_			BIT(11)
+#define _module_rtl871x_security_c_		BIT(12)
+#define _module_rtl871x_eeprom_c_			BIT(13)
+#define _module_hal_init_c_		BIT(14)
+#define _module_hci_hal_init_c_		BIT(15)
+#define _module_rtl871x_ioctl_c_		BIT(16)
+#define _module_rtl871x_ioctl_set_c_		BIT(17)
+#define _module_rtl871x_ioctl_query_c_	BIT(18)
+#define _module_rtl871x_pwrctrl_c_			BIT(19)
+#define _module_hci_intfs_c_			BIT(20)
+#define _module_hci_ops_c_			BIT(21)
+#define _module_osdep_service_c_			BIT(22)
+#define _module_mp_			BIT(23)
+#define _module_hci_ops_os_c_			BIT(24)
+#define _module_rtl871x_ioctl_os_c		BIT(25)
+#define _module_rtl8712_cmd_c_		BIT(26)
+#define _module_fwcmd_c_			BIT(27)
+#define _module_rtl8192c_xmit_c_ BIT(28)
+#define _module_hal_xmit_c_	BIT(28)
+#define _module_efuse_			BIT(29)
+#define _module_rtl8712_recv_c_		BIT(30)
+#define _module_rtl8712_led_c_		BIT(31)
+
+#undef _MODULE_DEFINE_
+
+#if defined _RTW_XMIT_C_
+	#define _MODULE_DEFINE_	_module_rtl871x_xmit_c_
+#elif defined _XMIT_OSDEP_C_
+	#define _MODULE_DEFINE_	_module_xmit_osdep_c_
+#elif defined _RTW_RECV_C_
+	#define _MODULE_DEFINE_	_module_rtl871x_recv_c_
+#elif defined _RECV_OSDEP_C_
+	#define _MODULE_DEFINE_	_module_recv_osdep_c_
+#elif defined _RTW_MLME_C_
+	#define _MODULE_DEFINE_	_module_rtl871x_mlme_c_
+#elif defined _MLME_OSDEP_C_
+	#define _MODULE_DEFINE_	_module_mlme_osdep_c_
+#elif defined _RTW_MLME_EXT_C_
+	#define _MODULE_DEFINE_ 1
+#elif defined _RTW_STA_MGT_C_
+	#define _MODULE_DEFINE_	_module_rtl871x_sta_mgt_c_
+#elif defined _RTW_CMD_C_
+	#define _MODULE_DEFINE_	_module_rtl871x_cmd_c_
+#elif defined _CMD_OSDEP_C_
+	#define _MODULE_DEFINE_	_module_cmd_osdep_c_
+#elif defined _RTW_IO_C_
+	#define _MODULE_DEFINE_	_module_rtl871x_io_c_
+#elif defined _IO_OSDEP_C_
+	#define _MODULE_DEFINE_	_module_io_osdep_c_
+#elif defined _OS_INTFS_C_
+	#define	_MODULE_DEFINE_	_module_os_intfs_c_
+#elif defined _RTW_SECURITY_C_
+	#define	_MODULE_DEFINE_	_module_rtl871x_security_c_
+#elif defined _RTW_EEPROM_C_
+	#define	_MODULE_DEFINE_	_module_rtl871x_eeprom_c_
+#elif defined _HAL_INTF_C_
+	#define	_MODULE_DEFINE_	_module_hal_init_c_
+#elif (defined _HCI_HAL_INIT_C_) || (defined _SDIO_HALINIT_C_)
+	#define	_MODULE_DEFINE_	_module_hci_hal_init_c_
+#elif defined _RTL871X_IOCTL_C_
+	#define	_MODULE_DEFINE_	_module_rtl871x_ioctl_c_
+#elif defined _RTL871X_IOCTL_SET_C_
+	#define	_MODULE_DEFINE_	_module_rtl871x_ioctl_set_c_
+#elif defined _RTL871X_IOCTL_QUERY_C_
+	#define	_MODULE_DEFINE_	_module_rtl871x_ioctl_query_c_
+#elif defined _RTL871X_PWRCTRL_C_
+	#define	_MODULE_DEFINE_	_module_rtl871x_pwrctrl_c_
+#elif defined _RTW_PWRCTRL_C_
+	#define	_MODULE_DEFINE_	1
+#elif defined _HCI_INTF_C_
+	#define	_MODULE_DEFINE_	_module_hci_intfs_c_
+#elif defined _HCI_OPS_C_
+	#define	_MODULE_DEFINE_	_module_hci_ops_c_
+#elif defined _SDIO_OPS_C_
+	#define	_MODULE_DEFINE_ 1
+#elif defined _OSDEP_HCI_INTF_C_
+	#define	_MODULE_DEFINE_	_module_hci_intfs_c_
+#elif defined _OSDEP_SERVICE_C_
+	#define	_MODULE_DEFINE_	_module_osdep_service_c_
+#elif defined _HCI_OPS_OS_C_
+	#define	_MODULE_DEFINE_	_module_hci_ops_os_c_
+#elif defined _RTL871X_IOCTL_LINUX_C_
+	#define	_MODULE_DEFINE_	_module_rtl871x_ioctl_os_c
+#elif defined _RTL8712_CMD_C_
+	#define	_MODULE_DEFINE_	_module_rtl8712_cmd_c_
+#elif defined _RTL8192C_XMIT_C_
+	#define	_MODULE_DEFINE_	1
+#elif defined _RTL8723AS_XMIT_C_
+	#define	_MODULE_DEFINE_	1
+#elif defined _RTL8712_RECV_C_
+	#define	_MODULE_DEFINE_	_module_rtl8712_recv_c_
+#elif defined _RTL8192CU_RECV_C_
+	#define	_MODULE_DEFINE_	_module_rtl8712_recv_c_
+#elif defined _RTL871X_MLME_EXT_C_
+	#define _MODULE_DEFINE_	_module_mlme_osdep_c_
+#elif defined _RTW_MP_C_
+	#define	_MODULE_DEFINE_	_module_mp_
+#elif defined _RTW_MP_IOCTL_C_
+	#define	_MODULE_DEFINE_	_module_mp_
+#elif defined _RTW_EFUSE_C_
+	#define	_MODULE_DEFINE_	_module_efuse_
+#endif
+
+#ifdef PLATFORM_OS_CE
+extern void rtl871x_cedbg(const char *fmt, ...);
+#endif
+
+#define RT_TRACE(_Comp, _Level, Fmt) do{}while(0)
+#define _func_enter_ do{}while(0)
+#define _func_exit_ do{}while(0)
+#define RT_PRINT_DATA(_Comp, _Level, _TitleString, _HexData, _HexDataLen) do{}while(0)
+
+#ifdef PLATFORM_WINDOWS
+	#define DBG_871X do {} while(0)
+	#define MSG_8192C do {} while(0)
+	#define DBG_8192C do {} while(0)
+	#define DBG_871X_LEVEL do {} while(0)
+#else
+	#define DBG_871X(x, ...) do {} while(0)
+	#define MSG_8192C(x, ...) do {} while(0)
+	#define DBG_8192C(x,...) do {} while(0)
+	#define DBG_871X_LEVEL(x,...) do {} while(0)
+#endif
+
+#undef	_dbgdump
+#ifdef PLATFORM_WINDOWS
+
+	#ifdef PLATFORM_OS_XP
+		#define _dbgdump	DbgPrint
+	#elif defined PLATFORM_OS_CE
+		#define _dbgdump	rtl871x_cedbg
+	#endif
+
+#elif defined PLATFORM_LINUX
+	#define _dbgdump	printk
+#elif defined PLATFORM_ECOS
+	#define _dbgdump	diag_printf
+#elif defined(PLATFORM_FREERTOS) || defined (PLATFORM_CMSIS_RTOS)
+	#define _dbgdump	printf("\n\r"); printf
+#elif defined PLATFORM_FREEBSD
+	#define _dbgdump	printf
+#endif
+
+#if !defined(CONFIG_PLATFORM_8195A) && !defined(CONFIG_PLATFORM_8711B)
+#define DRIVER_PREFIX	"RTL871X: "
+#endif
+
+#define DEBUG_LEVEL	(_drv_err_)
+#if 	defined (_dbgdump)
+	#undef DBG_871X_LEVEL
+#if defined (__ICCARM__) || defined (__CC_ARM) ||defined(__GNUC__)|| defined(CONFIG_PLATFORM_8195A) || defined(CONFIG_PLATFORM_8711B)
+	#define DBG_871X_LEVEL(level, ...)     \
+	do {\
+		_dbgdump(DRIVER_PREFIX __VA_ARGS__);\
+	}while(0)
+#else
+	#define DBG_871X_LEVEL(level, fmt, arg...)     \
+	do {\
+		if (level <= DEBUG_LEVEL) {\
+			if (level <= _drv_err_ && level > _drv_always_) {\
+				_dbgdump(DRIVER_PREFIX"ERROR " fmt, ##arg);\
+			} \
+			else {\
+				_dbgdump(DRIVER_PREFIX fmt, ##arg);\
+			} \
+		}\
+	}while(0)
+#endif	//#ifdef __CC_ARM
+#endif
+
+#ifdef CONFIG_DEBUG
+#if	defined (_dbgdump)
+	#undef DBG_871X
+	#define DBG_871X(...)     do {\
+		_dbgdump(DRIVER_PREFIX __VA_ARGS__);\
+	}while(0)
+
+	#undef MSG_8192C
+	#define MSG_8192C(...)     do {\
+		_dbgdump(DRIVER_PREFIX __VA_ARGS__);\
+	}while(0)
+
+	#undef DBG_8192C
+	#define DBG_8192C(...)     do {\
+		_dbgdump(DRIVER_PREFIX __VA_ARGS__);\
+	}while(0)
+#endif
+#endif /* CONFIG_DEBUG */
+
+#ifdef CONFIG_DEBUG_RTL871X
+#ifndef _RTL871X_DEBUG_C_
+	extern u32 GlobalDebugLevel;
+	extern u64 GlobalDebugComponents;
+#endif
+
+#if	defined (_dbgdump) && defined (_MODULE_DEFINE_)
+
+		#undef RT_TRACE
+		#define RT_TRACE(_Comp, _Level, Fmt)\
+		do {\
+			if((_Comp & GlobalDebugComponents) && (_Level <= GlobalDebugLevel)) {\
+				_dbgdump("%s [0x%08x,%d]", DRIVER_PREFIX, (unsigned int)_Comp, _Level);\
+				_dbgdump Fmt;\
+			}\
+		}while(0)
+
+#endif
+
+
+#if	defined (_dbgdump)
+
+		#undef  _func_enter_
+		#define _func_enter_ \
+		do {	\
+			if (GlobalDebugLevel >= _drv_debug_) \
+			{																	\
+				_dbgdump("\n %s : %s enters at %d\n", DRIVER_PREFIX, __FUNCTION__, __LINE__);\
+			}		\
+		} while(0)
+
+		#undef  _func_exit_
+		#define _func_exit_ \
+		do {	\
+			if (GlobalDebugLevel >= _drv_debug_) \
+			{																	\
+				_dbgdump("\n %s : %s exits at %d\n", DRIVER_PREFIX, __FUNCTION__, __LINE__); \
+			}	\
+		} while(0)
+
+		#undef RT_PRINT_DATA
+		#define RT_PRINT_DATA(_Comp, _Level, _TitleString, _HexData, _HexDataLen)			\
+			if(((_Comp) & GlobalDebugComponents) && (_Level <= GlobalDebugLevel))	\
+			{									\
+				int __i;								\
+				u8	*ptr = (u8 *)_HexData;				\
+				printf("\r\n%s", DRIVER_PREFIX);						\
+				printf(_TitleString "--------Len=%d\n\r", _HexDataLen);						\
+				for( __i=0; __i<(int)_HexDataLen; __i++ )				\
+				{								\
+					printf("%02X%s", ptr[__i], (((__i + 1) % 4) == 0)?"  ":" ");	\
+					if (((__i + 1) % 16) == 0)	printf("\n\r");			\
+				}								\
+				printf("\n\r");							\
+			}
+#endif
+#endif /* CONFIG_DEBUG_RTL871X */
+
+
+#ifdef CONFIG_PROC_DEBUG
+
+	int proc_get_drv_version(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+	int proc_get_write_reg(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+ 	int proc_set_write_reg(struct file *file, const char *buffer,
+		unsigned long count, void *data);
+
+	int proc_get_read_reg(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+	int proc_set_read_reg(struct file *file, const char *buffer,
+		unsigned long count, void *data);
+
+
+	int proc_get_fwstate(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+	int proc_get_sec_info(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+	int proc_get_mlmext_state(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+	int proc_get_qos_option(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+	int proc_get_ht_option(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+	int proc_get_rf_info(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+	int proc_get_ap_info(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+	int proc_get_adapter_state(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+	int proc_get_trx_info(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+	int proc_get_mac_reg_dump1(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+	int proc_get_mac_reg_dump2(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+	int proc_get_mac_reg_dump3(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+	int proc_get_bb_reg_dump1(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+	int proc_get_bb_reg_dump2(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+	int proc_get_bb_reg_dump3(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+	int proc_get_rf_reg_dump1(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+	int proc_get_rf_reg_dump2(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+	int proc_get_rf_reg_dump3(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+	int proc_get_rf_reg_dump4(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+#ifdef CONFIG_AP_MODE
+
+	int proc_get_all_sta_info(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+#endif
+
+#ifdef DBG_MEMORY_LEAK
+	int proc_get_malloc_cnt(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+#endif
+
+#ifdef CONFIG_FIND_BEST_CHANNEL
+	int proc_get_best_channel(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+#endif
+
+	int proc_get_rx_signal(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+	int proc_set_rx_signal(struct file *file, const char *buffer,
+		unsigned long count, void *data);
+#ifdef CONFIG_80211N_HT
+	int proc_get_cbw40_enable(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+	int proc_set_cbw40_enable(struct file *file, const char *buffer,
+		unsigned long count, void *data);
+	
+	int proc_get_ampdu_enable(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+			  
+	int proc_set_ampdu_enable(struct file *file, const char *buffer,
+		unsigned long count, void *data);
+	
+	int proc_get_rx_stbc(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+		
+	int proc_set_rx_stbc(struct file *file, const char *buffer,
+		unsigned long count, void *data);
+#endif //CONFIG_80211N_HT
+
+	int proc_get_two_path_rssi(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+	int proc_get_rssi_disp(char *page, char **start,
+			  off_t offset, int count,
+			  int *eof, void *data);
+
+	int proc_set_rssi_disp(struct file *file, const char *buffer,
+		unsigned long count, void *data);
+
+
+#endif //CONFIG_PROC_DEBUG
+
+#endif	//__RTW_DEBUG_H__
+

USDK/component/common/drivers/wlan/realtek/include/rtw_eeprom.h

@@ -0,0 +1,158 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef __RTW_EEPROM_H__
+#define __RTW_EEPROM_H__
+
+#define	RTL8712_EEPROM_ID			0x8712
+//#define	EEPROM_MAX_SIZE			256
+
+#define	HWSET_MAX_SIZE_512		512
+#define	EEPROM_MAX_SIZE			HWSET_MAX_SIZE_512
+
+#define	CLOCK_RATE					50			//100us		
+
+//- EEPROM opcodes
+#define EEPROM_READ_OPCODE		06
+#define EEPROM_WRITE_OPCODE		05
+#define EEPROM_ERASE_OPCODE		07
+#define EEPROM_EWEN_OPCODE		19      // Erase/write enable
+#define EEPROM_EWDS_OPCODE		16      // Erase/write disable
+
+//Country codes
+#define USA							0x555320
+#define EUROPE						0x1 //temp, should be provided later	
+#define JAPAN						0x2 //temp, should be provided later
+
+#define	EEPROM_CID_DEFAULT			0x0
+#define	EEPROM_CID_ALPHA				0x1
+#define	EEPROM_CID_Senao				0x3
+#define	EEPROM_CID_NetCore				0x5
+#define	EEPROM_CID_CAMEO				0X8
+#define	EEPROM_CID_SITECOM				0x9
+#define	EEPROM_CID_COREGA				0xB
+#define	EEPROM_CID_EDIMAX_BELKIN		0xC
+#define	EEPROM_CID_SERCOMM_BELKIN		0xE
+#define	EEPROM_CID_CAMEO1				0xF
+#define	EEPROM_CID_WNC_COREGA		0x12
+#define	EEPROM_CID_CLEVO				0x13
+#define	EEPROM_CID_WHQL				0xFE // added by chiyoko for dtm, 20090108
+
+//
+// Customer ID, note that: 
+// This variable is initiailzed through EEPROM or registry, 
+// however, its definition may be different with that in EEPROM for 
+// EEPROM size consideration. So, we have to perform proper translation between them.
+// Besides, CustomerID of registry has precedence of that of EEPROM.
+// defined below. 060703, by rcnjko.
+//
+typedef enum _RT_CUSTOMER_ID
+{
+	RT_CID_DEFAULT = 0,
+	RT_CID_8187_ALPHA0 = 1,
+	RT_CID_8187_SERCOMM_PS = 2,
+	RT_CID_8187_HW_LED = 3,
+	RT_CID_8187_NETGEAR = 4,
+	RT_CID_WHQL = 5,
+	RT_CID_819x_CAMEO  = 6, 
+	RT_CID_819x_RUNTOP = 7,
+	RT_CID_819x_Senao = 8,
+	RT_CID_TOSHIBA = 9,	// Merge by Jacken, 2008/01/31.
+	RT_CID_819x_Netcore = 10,
+	RT_CID_Nettronix = 11,
+	RT_CID_DLINK = 12,
+	RT_CID_PRONET = 13,
+	RT_CID_COREGA = 14,
+	RT_CID_CHINA_MOBILE = 15,
+	RT_CID_819x_ALPHA = 16,
+	RT_CID_819x_Sitecom = 17,
+	RT_CID_CCX = 18, // It's set under CCX logo test and isn't demanded for CCX functions, but for test behavior like retry limit and tx report. By Bruce, 2009-02-17.
+	RT_CID_819x_Lenovo = 19,	
+	RT_CID_819x_QMI = 20,
+	RT_CID_819x_Edimax_Belkin = 21,		
+	RT_CID_819x_Sercomm_Belkin = 22,			
+	RT_CID_819x_CAMEO1 = 23,
+	RT_CID_819x_MSI = 24,
+	RT_CID_819x_Acer = 25,
+	RT_CID_819x_AzWave_ASUS = 26,
+	RT_CID_819x_AzWave = 27, // For AzWave in PCIe, The ID is AzWave use and not only Asus
+	RT_CID_819x_HP = 28,
+	RT_CID_819x_WNC_COREGA = 29,
+	RT_CID_819x_Arcadyan_Belkin = 30,
+	RT_CID_819x_SAMSUNG = 31,
+	RT_CID_819x_CLEVO = 32,
+	RT_CID_819x_DELL = 33,
+	RT_CID_819x_PRONETS = 34,
+	RT_CID_819x_Edimax_ASUS = 35,
+	RT_CID_819x_CAMEO_NETGEAR = 36,
+	RT_CID_PLANEX = 37,
+	RT_CID_CC_C = 38,
+	RT_CID_819x_Xavi = 39,
+	RT_CID_819x_FUNAI_TV = 40,
+	RT_CID_819x_ALPHA_WD=41,
+}RT_CUSTOMER_ID, *PRT_CUSTOMER_ID;
+
+struct eeprom_priv 
+{    
+	u8		bautoload_fail_flag;
+	//u8		bempty;
+	//u8		sys_config;
+	u8		mac_addr[6];	//PermanentAddress
+	//u8		config0;
+//	u16		channel_plan;
+	u16		CustomerID;
+	//u8		country_string[3];	
+	//u8		tx_power_b[15];
+	//u8		tx_power_g[15];
+	//u8		tx_power_a[201];
+
+	u8		EepromOrEfuse;
+#ifdef CONFIG_MEMORY_ACCESS_ALIGNED
+	u8		rsvd;	//For byte aligned. By Fangyuan, 141201
+#endif
+	u8		efuse_eeprom_data[HWSET_MAX_SIZE_512]; //92C:256bytes, 88E:512bytes, we use union set (512bytes)
+
+#ifdef CONFIG_RF_GAIN_OFFSET
+	u8		EEPROMRFGainOffset;
+	u8		EEPROMRFGainVal;
+#endif //CONFIG_RF_GAIN_OFFSET
+};
+
+//TODO
+#if 0
+
+extern void eeprom_write16(_adapter *padapter, u16 reg, u16 data);
+extern u16 eeprom_read16(_adapter *padapter, u16 reg);
+extern void read_eeprom_content(_adapter *padapter);
+extern void eeprom_read_sz(_adapter * padapter, u16 reg,u8* data, u32 sz); 
+
+extern void read_eeprom_content_by_attrib(_adapter *	padapter	);
+
+#ifdef PLATFORM_LINUX
+#ifdef CONFIG_ADAPTOR_INFO_CACHING_FILE
+extern int isAdaptorInfoFileValid(void);
+extern int storeAdaptorInfoFile(char *path, struct eeprom_priv * eeprom_priv);
+extern int retriveAdaptorInfoFile(char *path, struct eeprom_priv * eeprom_priv);
+#endif //CONFIG_ADAPTOR_INFO_CACHING_FILE
+#endif //PLATFORM_LINUX
+
+#endif	//#if 0
+
+#endif  //__RTL871X_EEPROM_H__
+

USDK/component/common/drivers/wlan/realtek/include/rtw_efuse.h

@@ -0,0 +1,163 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef __RTW_EFUSE_H__
+#define __RTW_EFUSE_H__
+
+#if (RTL8195A_SUPPORT == 1)
+#include "rtl8195a.h"
+#endif
+#if (RTL8711B_SUPPORT == 1)
+#include "ameba_soc.h"
+#endif
+/*--------------------------Define efuse Parameters-------------------------*/
+#define	EFUSE_ERROE_HANDLE		1
+
+#define	PG_STATE_HEADER 		0x01
+#define	PG_STATE_WORD_0			0x02
+#define	PG_STATE_WORD_1			0x04
+#define	PG_STATE_WORD_2			0x08
+#define	PG_STATE_WORD_3			0x10
+#define	PG_STATE_DATA			0x20
+
+#define	PG_SWBYTE_H				0x01
+#define	PG_SWBYTE_L				0x02
+
+#define	PGPKT_DATA_SIZE			8
+
+#define	EFUSE_WIFI				0
+#define	EFUSE_BT				1
+
+enum _EFUSE_DEF_TYPE {
+	TYPE_EFUSE_MAX_SECTION				= 0,
+	TYPE_EFUSE_REAL_CONTENT_LEN			= 1,
+	TYPE_AVAILABLE_EFUSE_BYTES_BANK		= 2,
+	TYPE_AVAILABLE_EFUSE_BYTES_TOTAL	= 3,
+	TYPE_EFUSE_MAP_LEN					= 4,
+	TYPE_EFUSE_PROTECT_BYTES_BANK		= 5,
+	TYPE_EFUSE_CONTENT_LEN_BANK			= 6,
+};
+
+#define EFUSE_MAP_SIZE			512
+#define EFUSE_MAX_SIZE			256
+
+#define	EFUSE_MAX_MAP_LEN		512
+#define	EFUSE_MAX_HW_SIZE		256
+#define	EFUSE_MAX_SECTION_BASE	16
+
+#define EXT_HEADER(header) ((header & 0x1F ) == 0x0F)
+#define ALL_WORDS_DISABLED(wde)	((wde & 0x0F) == 0x0F)
+#define GET_HDR_OFFSET_2_0(header) ( (header & 0xE0) >> 5)
+
+#define		EFUSE_REPEAT_THRESHOLD_		3
+#define		EFUSE_MAX_WORD_UNIT			4
+
+//=============================================
+//	The following is for BT Efuse definition
+//=============================================
+#define		EFUSE_BT_MAX_MAP_LEN	1024
+#define		EFUSE_MAX_BANK			4
+#define		EFUSE_MAX_BT_BANK		(EFUSE_MAX_BANK-1)
+//=============================================
+
+/*--------------------------Define flash Parameters-------------------------*/
+#if CONFIG_ADAPTOR_INFO_CACHING_FLASH
+#if defined CONFIG_RTL8195A || defined(CONFIG_RTL8711B)
+	#define FLASH_MAX_SIZE			FLASH_CAL_DATA_SIZE
+	#define FLASH_MAGIC_NUMBER		0x8195 // magic number
+	#define FLASH_HEADER_SIZE		4 // 2: address, 2: length
+#endif
+#endif // CONFIG_ADAPTOR_INFO_CACHING_FLASH
+/*------------------------------Define structure----------------------------*/ 
+typedef struct PG_PKT_STRUCT_A{
+	u8 offset;
+	u8 word_en;
+	u8 data[8];	
+	u8 word_cnts;
+}PGPKT_STRUCT,*PPGPKT_STRUCT;
+
+#ifdef HAL_EFUSE_MEMORY
+typedef struct _EFUSE_HAL{
+	u8	fakeEfuseBank;
+	u32	fakeEfuseUsedBytes;
+	u8	fakeEfuseContent[EFUSE_MAX_HW_SIZE];
+	u8	fakeEfuseInitMap[EFUSE_MAX_MAP_LEN];
+	u8	fakeEfuseModifiedMap[EFUSE_MAX_MAP_LEN];
+	
+	u16	BTEfuseUsedBytes;
+	u8	BTEfuseUsedPercentage;
+	u8	BTEfuseContent[EFUSE_MAX_BT_BANK][EFUSE_MAX_HW_SIZE];
+	u8	BTEfuseInitMap[EFUSE_BT_MAX_MAP_LEN];
+	u8	BTEfuseModifiedMap[EFUSE_BT_MAX_MAP_LEN];
+
+	u16	fakeBTEfuseUsedBytes;
+	u8	fakeBTEfuseContent[EFUSE_MAX_BT_BANK][EFUSE_MAX_HW_SIZE];
+	u8	fakeBTEfuseInitMap[EFUSE_BT_MAX_MAP_LEN];
+	u8	fakeBTEfuseModifiedMap[EFUSE_BT_MAX_MAP_LEN];
+}EFUSE_HAL, *PEFUSE_HAL;
+#endif // HAL_EFUSE_MEMORY
+
+/*------------------------Export global variable----------------------------*/
+#if CONFIG_FAKE_EFUSE
+extern u8 fakeEfuseBank;
+extern u32 fakeEfuseUsedBytes;
+extern u8 fakeEfuseContent[];
+extern u8 fakeEfuseInitMap[];
+extern u8 fakeEfuseModifiedMap[];
+#endif
+
+#ifdef CONFIG_BT_COEXIST
+extern u32 BTEfuseUsedBytes;
+extern u8 BTEfuseContent[EFUSE_MAX_BT_BANK][EFUSE_MAX_HW_SIZE];
+extern u8 BTEfuseInitMap[];
+extern u8 BTEfuseModifiedMap[];
+#if CONFIG_FAKE_EFUSE
+extern u32 fakeBTEfuseUsedBytes;
+extern u8 fakeBTEfuseContent[EFUSE_MAX_BT_BANK][EFUSE_MAX_HW_SIZE];
+extern u8 fakeBTEfuseInitMap[];
+extern u8 fakeBTEfuseModifiedMap[];
+#endif
+#endif
+
+/*------------------------Export global variable----------------------------*/
+
+u8	efuse_GetCurrentSize(_adapter * padapter, u16 *size);
+u8	rtw_efuse_access(_adapter * padapter, u8 bRead, u16 start_addr, u16 cnts, u8 *data);
+u8	rtw_efuse_map_read(_adapter * padapter, u16 addr, u16 cnts, u8 *data);
+u8	rtw_efuse_map_write(_adapter * padapter, u16 addr, u16 cnts, u8 *data);
+u8	rtw_BT_efuse_map_read(_adapter * padapter, u16 addr, u16 cnts, u8 *data);
+u8 	rtw_BT_efuse_map_write(_adapter * padapter, u16 addr, u16 cnts, u8 *data);
+
+u16	Efuse_GetCurrentSize(_adapter * pAdapter, u8 efuseType, BOOLEAN bPseudoTest);
+u8	Efuse_CalculateWordCnts(u8 word_en);
+void	EFUSE_GetEfuseDefinition(_adapter * pAdapter, u8 efuseType, u8 type, void *pOut, BOOLEAN bPseudoTest);
+u8	efuse_OneByteRead(_adapter * pAdapter, u16 addr, u8 *data, BOOLEAN	 bPseudoTest);
+u8	efuse_OneByteWrite(_adapter * pAdapter, u16 addr, u8 data, BOOLEAN	 bPseudoTest);
+
+void	Efuse_PowerSwitch(_adapter * pAdapter,u8	bWrite,u8	 PwrState);
+//int 	Efuse_PgPacketRead(_adapter * pAdapter, u8 offset, u8 *data, BOOLEAN bPseudoTest);
+int 	Efuse_PgPacketWrite(_adapter * pAdapter, u8 offset, u8 word_en, u8 *data, BOOLEAN bPseudoTest);
+void	efuse_WordEnableDataRead(u8 word_en, u8 *sourdata, u8 *targetdata);
+u8	Efuse_WordEnableDataWrite(_adapter * pAdapter, u16 efuse_addr, u8 word_en, u8 *data, BOOLEAN bPseudoTest);
+
+void	EFUSE_ShadowMapUpdate(_adapter * pAdapter, u8 efuseType, BOOLEAN bPseudoTest);
+void	EFUSE_ShadowRead(_adapter * pAdapter, u8 Type, u16 Offset, u32 *Value);
+
+#endif
+

USDK/component/common/drivers/wlan/realtek/include/rtw_event.h

@@ -0,0 +1,151 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef _RTW_EVENT_H_
+#define _RTW_EVENT_H_
+
+#ifndef CONFIG_RTL8711FW
+#ifdef PLATFORM_LINUX
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26))
+#include <asm/semaphore.h>
+#else
+#include <linux/semaphore.h>
+#endif
+#include <linux/sem.h>
+#endif
+#endif//CONFIG_RTL8711FW
+
+
+
+#ifdef CONFIG_H2CLBK
+#include <h2clbk.h>
+#endif
+
+/*
+Used to report a bss has been scanned
+
+*/
+struct survey_event	{
+	WLAN_BSSID_EX bss;
+};
+
+/*
+Used to report that the requested site survey has been done.
+
+bss_cnt indicates the number of bss that has been reported.
+
+
+*/
+struct surveydone_event {
+	unsigned int	bss_cnt;	
+	
+};
+
+/*
+Used to report the link result of joinning the given bss
+
+
+join_res:
+-1: authentication fail
+-2: association fail
+> 0: TID
+
+*/
+struct joinbss_event {
+	//struct	wlan_network	network;
+	int join_res;
+};
+
+/*
+Used to report a given STA has joinned the created BSS.
+It is used in AP/Ad-HoC(M) mode.
+
+
+*/
+struct stassoc_event {
+	unsigned char macaddr[6];
+	unsigned char rsvd[2];
+	int    cam_id;
+	
+};
+
+struct stadel_event {
+ unsigned char macaddr[6];
+ unsigned char rsvd[2]; //for reason
+ int mac_id;
+};
+
+struct addba_event
+{
+ 	unsigned int tid;
+};
+
+
+#ifdef CONFIG_H2CLBK
+struct c2hlbk_event{
+	unsigned char mac[6];
+	unsigned short	s0;
+	unsigned short	s1;
+	unsigned int	w0;
+	unsigned char	b0;
+	unsigned short  s2;
+	unsigned char	b1;
+	unsigned int	w1;	
+};
+#endif//CONFIG_H2CLBK
+
+#define GEN_EVT_CODE(event)	event ## _EVT_
+
+struct fwevent {
+	u32	parmsize;
+	void (*event_callback)(_adapter *dev, u8 *pbuf);
+};
+
+//TODO
+#if 0
+
+#define C2HEVENT_SZ			32	
+
+struct event_node{
+	unsigned char *node;
+	unsigned char evt_code;
+	unsigned short evt_sz;
+	volatile int	*caller_ff_tail;
+	int	caller_ff_sz;
+};
+
+struct c2hevent_queue {
+	volatile int	head;
+	volatile int	tail;
+	struct	event_node	nodes[C2HEVENT_SZ];
+	unsigned char	seq;
+};
+
+#define NETWORK_QUEUE_SZ	4
+
+struct network_queue {
+	volatile int	head;
+	volatile int	tail;
+	WLAN_BSSID_EX networks[NETWORK_QUEUE_SZ];	
+};
+
+#endif	//#if 0
+
+#endif // _WLANEVENT_H_
+

USDK/component/common/drivers/wlan/realtek/include/rtw_ht.h

@@ -0,0 +1,66 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef _RTW_HT_H_
+#define _RTW_HT_H_
+
+#include "wifi.h"
+
+struct ht_priv
+{
+	u32	ht_option;	
+	u32	ampdu_enable;//for enable Tx A-MPDU
+	//u8	baddbareq_issued[16];
+	//u32	tx_amsdu_enable;//for enable Tx A-MSDU
+	//u32	tx_amdsu_maxlen; // 1: 8k, 0:4k ; default:8k, for tx
+	//u32	rx_ampdu_maxlen; //for rx reordering ctrl win_sz, updated when join_callback.
+	
+	u8	bwmode;//
+	u8	ch_offset;//PRIME_CHNL_OFFSET
+	u8	sgi;//short GI
+
+	//for processing Tx A-MPDU
+	u8	agg_enable_bitmap;
+	//u8	ADDBA_retry_count;
+	u8	candidate_tid_bitmap;
+
+	u8	stbc_cap;
+	
+	struct rtw_ieee80211_ht_cap ht_cap;
+	
+};
+
+#define	STBC_HT_ENABLE_RX			BIT0
+#define	STBC_HT_ENABLE_TX			BIT1
+#define	STBC_HT_TEST_TX_ENABLE		BIT2
+#define	STBC_HT_CAP_TX				BIT3
+
+typedef enum AGGRE_SIZE{
+	HT_AGG_SIZE_8K = 0,
+	HT_AGG_SIZE_16K = 1,
+	HT_AGG_SIZE_32K = 2,
+	HT_AGG_SIZE_64K = 3,
+	VHT_AGG_SIZE_128K = 4,
+	VHT_AGG_SIZE_256K = 5,
+	VHT_AGG_SIZE_512K = 6,
+	VHT_AGG_SIZE_1024K = 7,
+}AGGRE_SIZE_E, *PAGGRE_SIZE_E;
+
+#endif	//_RTL871X_HT_H_
+

USDK/component/common/drivers/wlan/realtek/include/rtw_intfs.h

@@ -0,0 +1,39 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef _RTW_INTFS_H_
+#define _RTW_INTFS_H_
+
+extern u8 rtw_init_default_value(_adapter *padapter);
+#ifdef CONFIG_WOWLAN
+void rtw_cancel_dynamic_chk_timer(_adapter *padapter);
+#endif
+extern void rtw_cancel_all_timer(_adapter *padapter);
+
+extern u8 rtw_init_drv_sw(_adapter *padapter);
+extern u8 rtw_free_drv_sw(_adapter *padapter);
+extern u8 rtw_reset_drv_sw(_adapter *padapter);
+
+extern int rtw_drv_init(ADAPTER *padapter);
+extern void rtw_drv_deinit(ADAPTER *Adapter);
+
+extern u32 rtw_start_drv_threads(_adapter *padapter);
+extern void rtw_stop_drv_threads (_adapter *padapter);
+
+#endif //_RTW_INTFS_H_

USDK/component/common/drivers/wlan/realtek/include/rtw_io.h

@@ -0,0 +1,140 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+
+#ifndef _RTW_IO_H_
+#define _RTW_IO_H_
+
+//IO Bus domain address mapping
+#define DEFUALT_OFFSET					0x0   
+#define WLAN_LOCAL_OFFSET    			0x10250000
+#define WLAN_IOREG_OFFSET   			0x10260000
+#define FW_FIFO_OFFSET 	    			0x10270000
+#define TX_HIQ_OFFSET	    				0x10310000
+#define TX_MIQ_OFFSET					0x1032000
+#define TX_LOQ_OFFSET					0x10330000
+#define RX_RXOFF_OFFSET	    			0x10340000
+
+struct fifo_more_data {
+	u32 more_data;
+	u32 len;
+};
+
+struct dvobj_priv;
+
+typedef struct _io_ops {
+		int (*init_io_priv)(struct dvobj_priv *pdvobj);
+		int (*write8_endian)(struct dvobj_priv *pdvobj, u32 addr, u32 buf, u32 big);
+
+		u8 (*_read8)(struct dvobj_priv *pdvobj, u32 addr, s32 *err);		
+		u16 (*_read16)(struct dvobj_priv *pdvobj, u32 addr, s32 *err);		
+		u32 (*_read32)(struct dvobj_priv *pdvobj, u32 addr, s32 *err);
+
+		s32  (*_write8)(struct dvobj_priv *pdvobj, u32 addr, u8 buf, s32 *err);		
+		s32  (*_write16)(struct dvobj_priv *pdvobj, u32 addr,u16 buf, s32 *err);		
+		s32  (*_write32)(struct dvobj_priv *pdvobj, u32 addr, u32 buf, s32 *err);
+
+		int (*read_rx_fifo)(struct dvobj_priv *pdvobj, u32 addr, u8 *buf, u32 len, struct fifo_more_data *more_data);
+		int (*write_tx_fifo)(struct dvobj_priv *pdvobj, u32 addr, u8 *buf, u32 len);		
+} IO_OPS_T;
+
+struct bus_transfer {
+	void	*tx_buf;
+	void	*rx_buf;
+	unsigned	int len;
+};
+
+typedef struct _bus_drv_ops {
+		int (*bus_drv_init)(ADAPTER *Adapter);
+		int (*bus_send_msg)(PADAPTER Adapter, struct bus_transfer xfers[], u32 RegAction);
+} BUS_DRV_OPS_T;
+
+/*
+struct	intf_hdl {
+
+	u32	intf_option;
+	u32	bus_status;
+	u32	do_flush;
+	u8	*adapter;
+	u8	*intf_dev;	
+	struct intf_priv	*pintfpriv;
+	u8	cnt;
+	void (*intf_hdl_init)(u8 *priv);
+	void (*intf_hdl_unload)(u8 *priv);
+	void (*intf_hdl_open)(u8 *priv);
+	void (*intf_hdl_close)(u8 *priv);
+	struct	_io_ops	io_ops;
+	//u8 intf_status;//moved to struct intf_priv
+	u16 len;
+	u16 done_len;	
+
+	_adapter *padapter;
+	struct dvobj_priv *pintf_dev;//	pointer to &(padapter->dvobjpriv);
+	
+	struct _io_ops	io_ops;
+
+};
+*/
+
+struct io_priv{
+	struct _io_ops	io_ops;
+};
+
+
+extern u8 rtw_read8(ADAPTER *adapter, u32 addr);
+extern u16 rtw_read16(ADAPTER *adapter, u32 addr);
+extern u32 rtw_read32(ADAPTER *adapter, u32 addr);
+extern s32 rtw_write8(ADAPTER *adapter, u32 addr, u8 val);
+extern s32 rtw_write16(ADAPTER *adapter, u32 addr, u16 val);
+extern s32 rtw_write32(ADAPTER *adapter, u32 addr, u32 val);
+
+#define PlatformEFIOWrite1Byte(_a,_b,_c)		\
+	rtw_write8(_a,_b,_c)
+#define PlatformEFIOWrite2Byte(_a,_b,_c)		\
+	rtw_write16(_a,_b,_c)
+#define PlatformEFIOWrite4Byte(_a,_b,_c)		\
+	rtw_write32(_a,_b,_c)
+
+#define PlatformEFIORead1Byte(_a,_b)		\
+		rtw_read8(_a,_b)
+#define PlatformEFIORead2Byte(_a,_b)		\
+		rtw_read16(_a,_b)
+#define PlatformEFIORead4Byte(_a,_b)		\
+		rtw_read32(_a,_b)
+
+extern IO_OPS_T io_ops;
+
+extern u32 rtw_write_port(
+	ADAPTER *adapter,
+	u32 addr,
+	u32 cnt,
+	u8 *mem);
+extern u32 rtw_read_port(
+	ADAPTER *adapter,
+	u32 addr,
+	u32 cnt,
+	u8 *mem,
+	struct fifo_more_data *more_data);
+extern void rtw_set_chip_endian(PADAPTER padapter);
+extern int rtw_get_chip_endian(PADAPTER padapter);
+
+int rtw_init_io_priv(_adapter *padapter, void (*set_intf_ops)(struct _io_ops *pops));
+
+#endif	//_RTW_IO_H_
+

USDK/component/common/drivers/wlan/realtek/include/rtw_ioctl_set.h

@@ -0,0 +1,75 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef __RTW_IOCTL_SET_H_
+#define __RTW_IOCTL_SET_H_
+
+
+#ifdef PLATFORM_OS_XP
+typedef struct _NDIS_802_11_PMKID {
+	u32	Length;
+	u32	BSSIDInfoCount;
+	BSSIDInfo BSSIDInfo[1];
+} NDIS_802_11_PMKID, *PNDIS_802_11_PMKID;
+#endif
+
+
+#ifdef PLATFORM_WINDOWS
+typedef u8 NDIS_802_11_PMKID_VALUE[16];
+
+typedef struct _BSSIDInfo {
+	NDIS_802_11_MAC_ADDRESS  BSSID;
+	NDIS_802_11_PMKID_VALUE  PMKID;
+} BSSIDInfo, *PBSSIDInfo;
+
+u8 rtw_set_802_11_reload_defaults(_adapter * padapter, NDIS_802_11_RELOAD_DEFAULTS reloadDefaults);
+u8 rtw_set_802_11_test(_adapter * padapter, NDIS_802_11_TEST * test);
+u8 rtw_set_802_11_pmkid(_adapter *pdapter, NDIS_802_11_PMKID *pmkid);
+
+u8 rtw_pnp_set_power_sleep(_adapter* padapter);
+u8 rtw_pnp_set_power_wakeup(_adapter* padapter);
+
+void rtw_pnp_resume_wk(void *context);
+void rtw_pnp_sleep_wk(void * context);
+
+#endif
+
+u8 rtw_set_802_11_add_key(_adapter * padapter, NDIS_802_11_KEY * key);
+u8 rtw_set_802_11_authentication_mode(_adapter *pdapter, NDIS_802_11_AUTHENTICATION_MODE authmode);
+u8 rtw_set_802_11_bssid(_adapter* padapter, u8 *bssid);
+u8 rtw_set_802_11_add_wep(_adapter * padapter, NDIS_802_11_WEP * wep);
+u8 rtw_set_802_11_disassociate(_adapter * padapter);
+u8 rtw_set_802_11_bssid_list_scan(_adapter* padapter, NDIS_802_11_SSID *pssid, int ssid_max_num);
+u8 rtw_set_802_11_infrastructure_mode(_adapter * padapter, NDIS_802_11_NETWORK_INFRASTRUCTURE networktype);
+u8 rtw_set_802_11_remove_wep(_adapter * padapter, u32 keyindex);
+u8 rtw_set_802_11_ssid(_adapter * padapter, NDIS_802_11_SSID * ssid);
+u8 rtw_set_802_11_connect(_adapter* padapter, u8 *bssid, NDIS_802_11_SSID *ssid);
+u8 rtw_set_802_11_remove_key(_adapter * padapter, NDIS_802_11_REMOVE_KEY * key);
+
+u8 rtw_validate_bssid(u8 *bssid);
+u8 rtw_validate_ssid(NDIS_802_11_SSID *ssid);
+
+u16 rtw_get_cur_max_rate(_adapter *adapter);
+//int rtw_set_scan_mode(_adapter *adapter, RT_SCAN_TYPE scan_mode);
+int rtw_set_channel_plan(_adapter *adapter, u8 channel_plan);
+int rtw_set_country(_adapter *adapter, const char *country_code);
+//int rtw_set_band(_adapter *adapter, enum _BAND band);
+
+#endif
+

USDK/component/common/drivers/wlan/realtek/include/rtw_led.h

@@ -0,0 +1,250 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef __RTW_LED_H_
+#define __RTW_LED_H_
+
+//TODO
+#if 0
+
+//#include <drv_types.h>
+
+#define MSECS(t)        (HZ * ((t) / 1000) + (HZ * ((t) % 1000)) / 1000)
+
+#define LED_BLINK_NORMAL_INTERVAL	100
+#define LED_BLINK_SLOWLY_INTERVAL	200
+#define LED_BLINK_LONG_INTERVAL	400
+
+#define LED_BLINK_NO_LINK_INTERVAL_ALPHA		1000
+#define LED_BLINK_LINK_INTERVAL_ALPHA			500		//500
+#define LED_BLINK_SCAN_INTERVAL_ALPHA		180 	//150
+#define LED_BLINK_FASTER_INTERVAL_ALPHA		50
+#define LED_BLINK_WPS_SUCESS_INTERVAL_ALPHA	5000
+
+#define LED_BLINK_NORMAL_INTERVAL_NETTRONIX  100
+#define LED_BLINK_SLOWLY_INTERVAL_NETTRONIX  2000
+
+#define LED_BLINK_SLOWLY_INTERVAL_PORNET 1000
+#define LED_BLINK_NORMAL_INTERVAL_PORNET 100
+
+#define LED_BLINK_FAST_INTERVAL_BITLAND 30
+
+// 060403, rcnjko: Customized for AzWave.
+#define LED_CM2_BLINK_ON_INTERVAL			250
+#define LED_CM2_BLINK_OFF_INTERVAL		4750
+
+#define LED_CM8_BLINK_INTERVAL			500		//for QMI
+#define LED_CM8_BLINK_OFF_INTERVAL	3750	//for QMI
+
+// 080124, lanhsin: Customized for RunTop
+#define LED_RunTop_BLINK_INTERVAL			300
+
+// 060421, rcnjko: Customized for Sercomm Printer Server case.
+#define LED_CM3_BLINK_INTERVAL				1500
+
+#endif	//#if 0
+
+typedef enum _LED_CTL_MODE{
+	LED_CTL_POWER_ON = 1,
+	LED_CTL_LINK = 2,
+	LED_CTL_NO_LINK = 3,
+	LED_CTL_TX = 4,
+	LED_CTL_RX = 5,
+	LED_CTL_SITE_SURVEY = 6,
+	LED_CTL_POWER_OFF = 7,
+	LED_CTL_START_TO_LINK = 8,
+	LED_CTL_START_WPS = 9,
+	LED_CTL_STOP_WPS = 10,
+	LED_CTL_START_WPS_BOTTON = 11, //added for runtop
+	LED_CTL_STOP_WPS_FAIL = 12, //added for ALPHA	
+	LED_CTL_STOP_WPS_FAIL_OVERLAP = 13, //added for BELKIN
+	LED_CTL_CONNECTION_NO_TRANSFER = 14,
+}LED_CTL_MODE;
+
+//TODO
+#if 0
+
+typedef enum _LED_STATE_871x{
+	LED_UNKNOWN = 0,
+	RTW_LED_ON = 1,
+	RTW_LED_OFF = 2,
+	LED_BLINK_NORMAL = 3,
+	LED_BLINK_SLOWLY = 4,
+	LED_BLINK_POWER_ON = 5,
+	LED_BLINK_SCAN = 6, // LED is blinking during scanning period, the # of times to blink is depend on time for scanning.
+	LED_BLINK_NO_LINK = 7, // LED is blinking during no link state.
+	LED_BLINK_StartToBlink = 8,// Customzied for Sercomm Printer Server case
+	LED_BLINK_TXRX = 9,
+	LED_BLINK_WPS = 10,	// LED is blinkg during WPS communication	
+	LED_BLINK_WPS_STOP = 11,	//for ALPHA	
+	LED_BLINK_WPS_STOP_OVERLAP = 12,	//for BELKIN
+	LED_BLINK_RUNTOP = 13, // Customized for RunTop
+	LED_BLINK_CAMEO = 14,
+	LED_BLINK_XAVI = 15,
+	LED_BLINK_ALWAYS_ON = 16,	
+}LED_STATE_871x;
+
+typedef enum _LED_PIN_871x{
+	LED_PIN_NULL = 0,
+	LED_PIN_LED0 = 1,
+	LED_PIN_LED1 = 2,
+	LED_PIN_LED2 = 3,
+	LED_PIN_GPIO0 = 4,
+}LED_PIN_871x;
+
+typedef struct _LED_871x{
+	_adapter				*padapter;
+	
+	LED_PIN_871x		LedPin;	// Identify how to implement this SW led.
+	LED_STATE_871x		CurrLedState; // Current LED state.
+	LED_STATE_871x		BlinkingLedState; // Next state for blinking, either RTW_LED_ON or RTW_LED_OFF are.
+	
+	u8					bLedOn; // true if LED is ON, false if LED is OFF.
+
+	u8					bLedBlinkInProgress; // true if it is blinking, false o.w..
+
+	u8					bLedWPSBlinkInProgress;
+
+	u32					BlinkTimes; // Number of times to toggle led state for blinking.
+
+	_timer				BlinkTimer; // Timer object for led blinking.
+
+#if defined(CONFIG_USB_HCI) || defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
+	u8					bSWLedCtrl;
+
+	// ALPHA, added by chiyoko, 20090106
+	u8					bLedNoLinkBlinkInProgress;
+	u8					bLedLinkBlinkInProgress;
+	u8					bLedStartToLinkBlinkInProgress;
+	u8					bLedScanBlinkInProgress;
+	
+	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)|| defined PLATFORM_FREEBSD
+	_workitem			BlinkWorkItem; // Workitem used by BlinkTimer to manipulate H/W to blink LED.
+	#endif
+#endif //defined(CONFIG_USB_HCI) || defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
+	
+#if defined(CONFIG_PCI_HCI) || defined(CONFIG_LX_HCI)
+	u8					bLedSlowBlinkInProgress;//added by vivi, for led new mode
+#endif
+
+} LED_871x, *PLED_871x;
+
+#if defined(CONFIG_USB_HCI) || defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
+
+#define IS_LED_WPS_BLINKING(_LED_871x)	(((PLED_871x)_LED_871x)->CurrLedState==LED_BLINK_WPS \
+					|| ((PLED_871x)_LED_871x)->CurrLedState==LED_BLINK_WPS_STOP \
+					|| ((PLED_871x)_LED_871x)->bLedWPSBlinkInProgress)
+
+#define IS_LED_BLINKING(_LED_871x) 	(((PLED_871x)_LED_871x)->bLedWPSBlinkInProgress \
+					||((PLED_871x)_LED_871x)->bLedScanBlinkInProgress)
+
+//================================================================================
+// LED customization.
+//================================================================================
+
+typedef	enum _LED_STRATEGY_871x{
+	SW_LED_MODE0 = 0, // SW control 1 LED via GPIO0. It is default option.
+	SW_LED_MODE1= 1, // 2 LEDs, through LED0 and LED1. For ALPHA.
+	SW_LED_MODE2 = 2, // SW control 1 LED via GPIO0, customized for AzWave 8187 minicard.
+	SW_LED_MODE3 = 3, // SW control 1 LED via GPIO0, customized for Sercomm Printer Server case.
+	SW_LED_MODE4 = 4, //for Edimax / Belkin
+	SW_LED_MODE5 = 5, //for Sercomm / Belkin
+	SW_LED_MODE6 = 6, //for 88CU minicard, porting from ce SW_LED_MODE7
+	HW_LED = 50, // HW control 2 LEDs, LED0 and LED1 (there are 4 different control modes, see MAC.CONFIG1 for details.)
+	LED_ST_NONE = 99,
+}LED_STRATEGY_871x, *PLED_STRATEGY_871x;
+
+void
+LedControl871x(
+	_adapter				*padapter,
+	LED_CTL_MODE		LedAction
+	);
+#endif //defined(CONFIG_USB_HCI) || defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
+
+#if defined(CONFIG_PCI_HCI) || defined(CONFIG_LX_HCI)
+//================================================================================
+// LED customization.
+//================================================================================
+
+typedef	enum _LED_STRATEGY_871x{
+	SW_LED_MODE0 = 0, // SW control 1 LED via GPIO0. It is default option.
+	SW_LED_MODE1 = 1, // SW control for PCI Express
+	SW_LED_MODE2 = 2, // SW control for Cameo.
+	SW_LED_MODE3 = 3, // SW contorl for RunTop.
+	SW_LED_MODE4 = 4, // SW control for Netcore
+	SW_LED_MODE5 = 5, //added by vivi, for led new mode, DLINK
+	SW_LED_MODE6 = 6, //added by vivi, for led new mode, PRONET
+	SW_LED_MODE7 = 7, //added by chiyokolin, for Lenovo, PCI Express Minicard Spec Rev.1.2 spec
+	SW_LED_MODE8 = 8, //added by chiyokolin, for QMI
+	SW_LED_MODE9 = 9, //added by chiyokolin, for BITLAND, PCI Express Minicard Spec Rev.1.1 
+	SW_LED_MODE10 = 10, //added by chiyokolin, for Edimax-ASUS
+	HW_LED = 50, // HW control 2 LEDs, LED0 and LED1 (there are 4 different control modes)
+	LED_ST_NONE = 99,
+}LED_STRATEGY_871x, *PLED_STRATEGY_871x;
+#endif //defined(CONFIG_PCI_HCI)
+
+struct led_priv{
+	/* add for led controll */
+	LED_871x			SwLed0;
+	LED_871x			SwLed1;
+	LED_STRATEGY_871x	LedStrategy;
+	u8					bRegUseLed;
+	void (*LedControlHandler)(_adapter *padapter, LED_CTL_MODE LedAction);
+	/* add for led controll */
+};
+
+#endif	//#if 0
+
+#ifdef CONFIG_SW_LED
+#define rtw_led_control(adapter, LedAction) \
+	do { \
+		if((adapter)->ledpriv.LedControlHandler) \
+			(adapter)->ledpriv.LedControlHandler((adapter), (LedAction)); \
+	} while(0)
+#else //CONFIG_SW_LED
+#define rtw_led_control(adapter, LedAction)
+#endif //CONFIG_SW_LED
+
+//TODO
+#if 0
+
+void BlinkTimerCallback(void *data);
+void BlinkWorkItemCallback(struct work_struct *work);
+
+void ResetLedStatus(PLED_871x pLed);
+
+void
+InitLed871x(
+	_adapter			*padapter,
+	PLED_871x		pLed,
+	LED_PIN_871x	LedPin
+	);
+
+void
+DeInitLed871x(
+	PLED_871x			pLed
+	);
+
+//hal...
+extern void BlinkHandler(PLED_871x	 pLed);
+
+#endif	//#if 0
+
+#endif //__RTW_LED_H_
+

USDK/component/common/drivers/wlan/realtek/include/rtw_mlme.h

@@ -0,0 +1,795 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef __RTW_MLME_H_
+#define __RTW_MLME_H_
+
+#ifdef CONFIG_INTEL_WIDI
+#include <rtw_intel_widi.h>
+#endif
+
+#if defined(PLATFORM_ECOS)
+#define	MAX_BSS_CNT	10	//alloc less wlan_network due to memory limitation - Alex Fang
+#elif defined(PLATFORM_FREERTOS) || defined (PLATFORM_CMSIS_RTOS)
+#define	MAX_BSS_CNT	1	//alloc less wlan_network due to memory limitation - Alex Fang
+#else
+#define	MAX_BSS_CNT	128
+#endif
+//#define   MAX_JOIN_TIMEOUT	2000
+//#define   MAX_JOIN_TIMEOUT	2500
+#define   MAX_JOIN_TIMEOUT	6500
+
+#ifdef CONFIG_MULTICAST
+#define MULTICAST_LIST_SIZE		4
+#endif
+
+//	Commented by Albert 20101105
+//	Increase the scanning timeout because of increasing the SURVEY_TO value.
+
+#define 	SCANNING_TIMEOUT 	8000
+
+#define	SCAN_INTERVAL	(30) // unit:2sec, 30*2=60sec
+
+#ifdef PALTFORM_OS_WINCE
+#define	SCANQUEUE_LIFETIME 12000000 // unit:us
+#else
+#define	SCANQUEUE_LIFETIME 20 // unit:sec
+#endif
+
+#define 	WIFI_NULL_STATE		0x00000000
+#define	WIFI_ASOC_STATE		0x00000001		// Under Linked state...
+#define 	WIFI_REASOC_STATE	       0x00000002
+#define	WIFI_SLEEP_STATE	       0x00000004
+#define	WIFI_STATION_STATE	0x00000008
+#define	WIFI_AP_STATE				0x00000010
+#define	WIFI_ADHOC_STATE			0x00000020
+#define   WIFI_ADHOC_MASTER_STATE 0x00000040
+#define   WIFI_UNDER_LINKING		0x00000080
+//#define WIFI_UNDER_CMD			0x00000200
+// ========== P2P Section Start ===============
+#define	WIFI_P2P_LISTEN_STATE		0x00010000
+#define	WIFI_P2P_GROUP_FORMATION_STATE		0x00020000
+// ========== P2P Section End ===============
+#define WIFI_UNDER_WPS			0x00000100
+#define WIFI_SITE_MONITOR		0x00000800		//to indicate the station is under site surveying
+
+#ifdef WDS
+#define	WIFI_WDS				0x00001000
+#define	WIFI_WDS_RX_BEACON	0x00002000		// already rx WDS AP beacon
+#endif
+#ifdef AUTO_CONFIG
+#define	WIFI_AUTOCONF			0x00004000
+#define	WIFI_AUTOCONF_IND	0x00008000
+#endif
+
+//#ifdef UNDER_MPTEST
+#define	WIFI_MP_STATE						0x00010000
+#define	WIFI_MP_CTX_BACKGROUND			0x00020000	// in continous tx background
+#define	WIFI_MP_CTX_ST					0x00040000	// in continous tx with single-tone
+#define	WIFI_MP_CTX_BACKGROUND_PENDING	0x00080000	// pending in continous tx background due to out of skb
+#define	WIFI_MP_CTX_CCK_HW				0x00100000	// in continous tx
+#define	WIFI_MP_CTX_CCK_CS				0x00200000	// in continous tx with carrier suppression
+#define   WIFI_MP_LPBK_STATE				0x00400000
+//#endif
+
+//#define _FW_UNDER_CMD		WIFI_UNDER_CMD
+#define _FW_UNDER_LINKING	WIFI_UNDER_LINKING
+#define _FW_LINKED			WIFI_ASOC_STATE
+#define _FW_UNDER_SURVEY	WIFI_SITE_MONITOR
+
+enum dot11AuthAlgrthmNum {
+ dot11AuthAlgrthm_Open = 0,
+ dot11AuthAlgrthm_Shared,
+ dot11AuthAlgrthm_8021X,
+ dot11AuthAlgrthm_Auto,
+ dot11AuthAlgrthm_WAPI,
+ dot11AuthAlgrthm_MaxNum
+};
+
+// Scan type including active and passive scan.
+typedef enum _RT_SCAN_TYPE
+{
+	SCAN_PASSIVE,
+	SCAN_ACTIVE,
+	SCAN_MIX,
+} RT_SCAN_TYPE, *PRT_SCAN_TYPE;
+
+/*
+
+there are several "locks" in mlme_priv,
+since mlme_priv is a shared resource between many threads,
+like ISR/Call-Back functions, the OID handlers, and even timer functions.
+
+
+Each _queue has its own locks, already.
+Other items are protected by mlme_priv.lock.
+
+To avoid possible dead lock, any thread trying to modifiying mlme_priv
+SHALL not lock up more than one locks at a time!
+
+*/
+
+
+#define traffic_threshold	10
+#define	traffic_scan_period	500
+
+struct sitesurvey_ctrl {
+	u64	last_tx_pkts;
+	uint	last_rx_pkts;
+	sint	traffic_busy;
+	_timer	sitesurvey_ctrl_timer;
+};
+
+typedef struct _RT_LINK_DETECT_T{
+	u32			NumTxOkInPeriod;
+	u32			NumRxOkInPeriod;
+	u32			NumRxUnicastOkInPeriod;
+	BOOLEAN			bBusyTraffic;
+	BOOLEAN			bTxBusyTraffic;
+	BOOLEAN			bRxBusyTraffic;
+	BOOLEAN			bHigherBusyTraffic;	// For interrupt migration purpose.
+	BOOLEAN			bHigherBusyRxTraffic;	// We may disable Tx interrupt according as Rx traffic.
+	BOOLEAN			bHigherBusyTxTraffic;	// We may disable Tx interrupt according as Tx traffic.
+} RT_LINK_DETECT_T, *PRT_LINK_DETECT_T;
+
+//TODO
+#if 0
+
+struct profile_info {
+	u8	ssidlen;
+	u8	ssid[ WLAN_SSID_MAXLEN ];
+	u8	peermac[ ETH_ALEN ];
+};
+
+struct tx_invite_req_info{
+	u8					token;
+	u8					benable;
+	u8					go_ssid[ WLAN_SSID_MAXLEN ];
+	u8					ssidlen;
+	u8					go_bssid[ ETH_ALEN ];
+	u8					peer_macaddr[ ETH_ALEN ];
+	u8					operating_ch;	//	This information will be set by using the p2p_set op_ch=x
+	u8					peer_ch;		//	The listen channel for peer P2P device
+
+};
+
+struct tx_invite_resp_info{
+	u8					token;	//	Used to record the dialog token of p2p invitation request frame.
+};
+
+#ifdef CONFIG_WFD
+
+struct wifi_display_info{
+	u16					wfd_enable;			//	Eanble/Disable the WFD function.
+	u16					rtsp_ctrlport;		//	TCP port number at which the this WFD device listens for RTSP messages
+	u16					peer_rtsp_ctrlport;	//	TCP port number at which the peer WFD device listens for RTSP messages
+											//	This filed should be filled when receiving the gropu negotiation request
+
+	u8					peer_session_avail;	//	WFD session is available or not for the peer wfd device.
+											//	This variable will be set when sending the provisioning discovery request to peer WFD device.
+											//	And this variable will be reset when it is read by using the iwpriv p2p_get wfd_sa command.
+	u8					ip_address[4];
+	u8					peer_ip_address[4];
+	u8					wfd_pc;				//	WFD preferred connection
+											//	0 -> Prefer to use the P2P for WFD connection on peer side.
+											//	1 -> Prefer to use the TDLS for WFD connection on peer side.
+											
+	u8					wfd_device_type;	//	WFD Device Type
+											//	0 -> WFD Source Device
+											//	1 -> WFD Primary Sink Device
+
+};
+#endif //CONFIG_WFD
+
+struct tx_provdisc_req_info{
+	u16					wps_config_method_request;	//	Used when sending the provisioning request frame
+	u16					peer_channel_num[2];		//	The channel number which the receiver stands.
+	NDIS_802_11_SSID	ssid;
+	u8					peerDevAddr[ ETH_ALEN ];		//	Peer device address
+	u8					peerIFAddr[ ETH_ALEN ];		//	Peer interface address
+	u8					benable;					//	This provision discovery request frame is trigger to send or not
+};
+
+struct rx_provdisc_req_info{	//When peer device issue prov_disc_req first, we should store the following informations
+	u8					peerDevAddr[ ETH_ALEN ];		//	Peer device address
+	u8					strconfig_method_desc_of_prov_disc_req[4];	//	description for the config method located in the provisioning discovery request frame.	
+																	//	The UI must know this information to know which config method the remote p2p device is requiring.
+};
+
+struct tx_nego_req_info{
+	u16					peer_channel_num[2];		//	The channel number which the receiver stands.
+	u8					peerDevAddr[ ETH_ALEN ];		//	Peer device address
+	u8					benable;					//	This negoitation request frame is trigger to send or not
+};
+
+struct group_id_info{
+	u8					go_device_addr[ ETH_ALEN ];	//	The GO's device address of this P2P group
+	u8					ssid[ WLAN_SSID_MAXLEN ];	//	The SSID of this P2P group
+};
+
+#ifdef CONFIG_IOCTL_CFG80211
+struct cfg80211_wifidirect_info{
+	_timer					remain_on_ch_timer;
+	u8						restore_channel;
+	struct ieee80211_channel	remain_on_ch_channel;
+	enum nl80211_channel_type	remain_on_ch_type;
+	u64						remain_on_ch_cookie;
+	struct net_device 			*remain_on_ch_dev;
+	bool is_ro_ch;
+};
+#endif //CONFIG_IOCTL_CFG80211
+
+#endif
+
+struct wifidirect_info{
+	enum P2P_ROLE			role;
+	enum P2P_STATE			p2p_state;
+	u8						baction_tx_pending;
+	u8						pending_peer[ETH_ALEN];
+	struct xmit_frame			*pending_action;
+	_timer					pre_tx_scan_timer;
+	
+#if 0
+	_adapter*				padapter;
+	_timer					find_phase_timer;
+	_timer					restore_p2p_state_timer;
+	
+	//	Used to do the scanning. After confirming the peer is availalble, the driver transmits the P2P frame to peer.
+	_timer					pre_tx_scan_timer;
+#ifdef CONFIG_CONCURRENT_MODE
+	//	Used to switch the channel between legacy AP and listen state.
+	_timer					ap_p2p_switch_timer;
+#endif
+	struct tx_provdisc_req_info	tx_prov_disc_info;
+	struct rx_provdisc_req_info rx_prov_disc_info;
+	struct tx_invite_req_info	invitereq_info;
+	struct profile_info			profileinfo[ P2P_MAX_PERSISTENT_GROUP_NUM ];	//	Store the profile information of persistent group
+	struct tx_invite_resp_info	inviteresp_info;
+	struct tx_nego_req_info	nego_req_info;
+	struct group_id_info		groupid_info;	//	Store the group id information when doing the group negotiation handshake.
+#ifdef CONFIG_WFD
+	struct wifi_display_info		*wfd_info;
+#endif	
+	enum P2P_ROLE			role;
+	enum P2P_STATE			pre_p2p_state;
+	enum P2P_STATE			p2p_state;
+	u8 						device_addr[ETH_ALEN];	//	The device address should be the mac address of this device.
+	u8						interface_addr[ETH_ALEN];
+	u8						social_chan[4];
+	u8						listen_channel;
+	u8						operating_channel;
+	u8						listen_dwell;		//	This value should be between 1 and 3
+	u8						support_rate[8];
+	u8						p2p_wildcard_ssid[P2P_WILDCARD_SSID_LEN];
+	u8						intent;		//	should only include the intent value.
+	u8						p2p_peer_interface_addr[ ETH_ALEN ];
+	u8						p2p_peer_device_addr[ ETH_ALEN ];
+	u8						peer_intent;	//	Included the intent value and tie breaker value.
+	u8						device_name[ WPS_MAX_DEVICE_NAME_LEN ];	//	Device name for displaying on searching device screen
+	u8						device_name_len;
+	u8						profileindex;	//	Used to point to the index of profileinfo array
+	u8						peer_operating_ch;
+	u8						find_phase_state_exchange_cnt;
+	u16						device_password_id_for_nego;	//	The device password ID for group negotation
+	u8						negotiation_dialog_token;
+	u8						nego_ssid[ WLAN_SSID_MAXLEN ];	//	SSID information for group negotitation
+	u8						nego_ssidlen;
+	u8 						p2p_group_ssid[WLAN_SSID_MAXLEN];
+	u8 						p2p_group_ssid_len;
+	u8						persistent_supported;		//	Flag to know the persistent function should be supported or not.
+														//	In the Sigma test, the Sigma will provide this enable from the sta_set_p2p CAPI.
+														//	0: disable
+														//	1: enable
+	u8						session_available;			//	Flag to set the WFD session available to enable or disable "by Sigma"
+														//	In the Sigma test, the Sigma will disable the session available by using the sta_preset CAPI.
+														//	0: disable
+														//	1: enable
+
+	u8						wfd_tdls_enable;			//	Flag to enable or disable the TDLS by WFD Sigma
+														//	0: disable
+														//	1: enable
+	u8						wfd_tdls_weaksec;			//	Flag to enable or disable the weak security function for TDLS by WFD Sigma
+														//	0: disable
+														//	In this case, the driver can't issue the tdsl setup request frame.
+														//	1: enable
+														//	In this case, the driver can issue the tdls setup request frame
+														//	even the current security is weak security.
+
+	enum	P2P_WPSINFO		ui_got_wps_info;			//	This field will store the WPS value (PIN value or PBC) that UI had got from the user.
+	u16						supported_wps_cm;			//	This field describes the WPS config method which this driver supported.
+														//	The value should be the combination of config method defined in page104 of WPS v2.0 spec.	
+	uint						channel_list_attr_len;		//	This field will contain the length of body of P2P Channel List attribute of group negotitation response frame.
+	u8						channel_list_attr[100];		//	This field will contain the body of P2P Channel List attribute of group negotitation response frame.
+														//	We will use the channel_cnt and channel_list fields when constructing the group negotitation confirm frame.
+#ifdef CONFIG_CONCURRENT_MODE
+	u16						ext_listen_interval;	//	The interval to be available with legacy AP (ms)
+	u16						ext_listen_period;	//	The time period to be available for P2P listen state (ms)
+#endif
+	u8						p2p_ps_enable;
+	enum P2P_PS				p2p_ps; // indicate p2p ps state
+	u8						noa_index; // Identifies and instance of Notice of Absence timing.
+	u8						ctwindow; // Client traffic window. A period of time in TU after TBTT.
+	u8						opp_ps; // opportunistic power save.
+	u8						noa_num; // number of NoA descriptor in P2P IE.
+	u8						noa_count[P2P_MAX_NOA_NUM]; // Count for owner, Type of client.
+	u32						noa_duration[P2P_MAX_NOA_NUM]; // Max duration for owner, preferred or min acceptable duration for client.
+	u32						noa_interval[P2P_MAX_NOA_NUM]; // Length of interval for owner, preferred or max acceptable interval of client.
+	u32						noa_start_time[P2P_MAX_NOA_NUM]; // schedule expressed in terms of the lower 4 bytes of the TSF timer.
+#endif
+};
+#if 0
+struct tdls_ss_record{	//signal strength record
+	u8		macaddr[ETH_ALEN];
+	u8		RxPWDBAll;
+	u8		is_tdls_sta;	// _TRUE: direct link sta, _FALSE: else
+};
+
+struct tdls_info{
+	u8					ap_prohibited;
+	uint					setup_state;
+	u8					sta_cnt;
+	u8					sta_maximum;	// 1:tdls sta is equal (NUM_STA-1), reach max direct link number; 0: else;
+	struct tdls_ss_record	ss_record;
+	u8					macid_index;	//macid entry that is ready to write
+	u8					clear_cam;	//cam entry that is trying to clear, using it in direct link teardown
+	u8					ch_sensing;
+	u8					cur_channel;
+	u8					candidate_ch;
+	u8					collect_pkt_num[MAX_CHANNEL_NUM];
+	_lock				cmd_lock;
+	_lock				hdl_lock;
+	u8					watchdog_count;
+	u8					dev_discovered;		//WFD_TDLS: for sigma test
+	u8					enable;
+#ifdef CONFIG_WFD
+	struct wifi_display_info		*wfd_info;
+#endif		
+};
+
+#endif	//#if 0
+
+struct mlme_priv {
+
+	_lock	lock;
+	sint	fw_state;	//shall we protect this variable? maybe not necessarily...
+	u8 bScanInProcess;
+	u8	to_join; //flag
+	#ifdef CONFIG_LAYER2_ROAMING
+	u8 to_roaming; // roaming trying times
+	#endif
+
+	u8		*nic_hdl;		//can be removed
+
+	//u8		not_indic_disco;
+	_list		*pscanned;
+	_queue	free_bss_pool;
+	_queue	scanned_queue;
+	u8		*free_bss_buf;
+	u16		num_of_scanned;
+	
+#if SUPPORT_SCAN_BUF	// Cloud 2013/12/20
+	u8		*scan_buf;
+	u32		scan_buf_len;
+	u16		scan_cnt;
+	u16		scan_type;
+#endif
+
+	NDIS_802_11_SSID	assoc_ssid;
+	u8	assoc_bssid[6];
+
+	struct wlan_network	cur_network;
+
+	//uint wireless_mode; no used, remove it
+
+	u32	scan_interval;
+
+	_timer assoc_timer;
+
+	u8 assoc_by_bssid;
+	u8 assoc_by_rssi;
+
+	_timer scan_to_timer; // driver itself handles scan_timeout status.
+	u32 scan_start_time; // used to evaluate the time spent in scanning
+
+	#ifdef CONFIG_SET_SCAN_DENY_TIMER
+	_timer set_scan_deny_timer;
+	ATOMIC_T set_scan_deny; //0: allowed, 1: deny
+	#endif
+
+	struct qos_priv qospriv;
+
+#ifdef CONFIG_80211N_HT
+
+	/* Number of non-HT AP/stations */
+	u16 num_sta_no_ht; //int num_sta_no_ht;
+
+	/* Number of HT AP/stations 20 MHz */
+	//int num_sta_ht_20mhz; 
+
+
+	u16 num_FortyMHzIntolerant; //int num_FortyMHzIntolerant;
+
+	struct ht_priv	htpriv;
+
+#endif
+
+	RT_LINK_DETECT_T	LinkDetectInfo;
+	_timer	dynamic_chk_timer; //dynamic/periodic check timer
+
+ 	u8 	key_mask; //use for ips to set wep key after ips_leave
+	u8	acm_mask; // for wmm acm mask
+	u8	ChannelPlan;
+	RT_SCAN_TYPE 	scan_mode; // active: 1, passive: 0
+
+#ifdef CONFIG_WPS	
+	u8 *wps_probe_req_ie;
+	u32 wps_probe_req_ie_len;
+	u8 *wps_assoc_req_ie;
+	u32 wps_assoc_req_ie_len;
+#endif	
+
+#if defined (CONFIG_AP_MODE) && defined (CONFIG_NATIVEAP_MLME)
+	/* Number of associated Non-ERP stations (i.e., stations using 802.11b
+	 * in 802.11g BSS) */
+	u16 num_sta_non_erp;
+
+	/* Number of associated stations that do not support Short Slot Time */
+	u16 num_sta_no_short_slot_time;
+
+	/* Number of associated stations that do not support Short Preamble */
+	u16 num_sta_no_short_preamble;
+
+	//int olbc; /* Overlapping Legacy BSS Condition */
+
+	/* Number of HT associated stations that do not support greenfield */
+	u16 num_sta_ht_no_gf;
+
+	/* Number of associated non-HT stations */
+	//int num_sta_no_ht;
+
+	/* Number of HT associated stations 20 MHz */
+	u16 num_sta_ht_20mhz;
+
+	/* Overlapping BSS information */
+	u8 olbc_ht;
+	
+#ifdef CONFIG_80211N_HT
+	u16 ht_op_mode;
+#endif /* CONFIG_80211N_HT */	
+
+#ifdef CONFIG_WPS	
+	u8 *wps_beacon_ie;	
+	u8 *wps_probe_resp_ie;
+	u8 *wps_assoc_resp_ie; // for CONFIG_IOCTL_CFG80211, this IE could include p2p ie
+
+	u32 wps_beacon_ie_len;
+	u32 wps_probe_resp_ie_len;
+	u32 wps_assoc_resp_ie_len;
+	
+
+#ifdef CONFIG_P2P_NEW
+	u8 *p2p_beacon_ie;
+	u8 *p2p_probe_req_ie;
+	u8 *p2p_probe_resp_ie;	
+//	u8 *p2p_go_probe_resp_ie; //for GO	
+	u8 *p2p_assoc_req_ie;
+	u8 *p2p_assoc_rsp_ie;
+
+	u32 p2p_beacon_ie_len;
+	u32 p2p_probe_req_ie_len;
+	u32 p2p_probe_resp_ie_len;
+//	u32 p2p_go_probe_resp_ie_len; //for GO
+	u32 p2p_assoc_req_ie_len;
+	u32 p2p_assoc_rsp_ie_len;
+#endif //CONFIG_P2P
+#endif //CONFIG_WPS
+	
+	_lock	bcn_update_lock;
+	u8		update_bcn;
+#if USE_DEDICATED_BCN_TX
+	//Dedicated xmit frame and buffer for beacon update - Alex Fang
+	struct xmit_frame bcn_xmit_frame;
+	struct xmit_buf bcn_xmit_buf;
+	//u8 bcn_buf[256];
+	u8 bcn_buf[320];  //p2p go beacon size is about 272+32 bytes
+#endif
+#endif //#if defined (CONFIG_AP_MODE) && defined (CONFIG_NATIVEAP_MLME)
+
+#ifdef RTK_DMP_PLATFORM
+	// DMP kobject_hotplug function  signal need in passive level
+	_workitem	Linkup_workitem;
+	_workitem	Linkdown_workitem;
+#endif
+
+#ifdef CONFIG_INTEL_WIDI
+	int	widi_state;
+	int	listen_state;
+	_timer	listen_timer;
+	ATOMIC_T	rx_probe_rsp; // 1:receive probe respone from RDS source.
+	u8	*l2sdTaBuffer;
+	u8	channel_idx;
+	u8	group_cnt;	//In WiDi 3.5, they specified another scan algo. for WFD/RDS co-existed
+	u8	sa_ext[L2SDTA_SERVICE_VE_LEN];
+#endif // CONFIG_INTEL_WIDI
+
+#ifdef CONFIG_CONCURRENT_MODE
+	u8	scanning_via_buddy_intf;
+#endif
+
+#ifdef CONFIG_FTP_PROTECT
+	u8	ftp_lock_flag;
+#endif //CONFIG_FTP_PROTECT
+
+#ifdef CONFIG_MULTICAST
+	u32 multicast_list[MULTICAST_LIST_SIZE];
+#endif
+	//For fast reconnection to keep frame info temporarily
+	union recv_frame *p_copy_recv_frame;
+};
+
+#ifdef CONFIG_AP_MODE
+
+struct hostapd_priv
+{
+	_adapter *padapter;
+
+#ifdef CONFIG_HOSTAPD_MLME
+	struct net_device *pmgnt_netdev;
+	struct usb_anchor anchored;
+#endif	
+	
+};
+
+extern int hostapd_mode_init(_adapter *padapter);
+extern void hostapd_mode_unload(_adapter *padapter);
+#endif
+
+
+extern void rtw_joinbss_event_prehandle(_adapter *adapter, u8 *pbuf);
+extern void rtw_survey_event_callback(_adapter *adapter, u8 *pbuf);
+extern void rtw_surveydone_event_callback(_adapter *adapter, u8 *pbuf);
+extern void rtw_joinbss_event_callback(_adapter *adapter, u8 *pbuf);
+extern void rtw_stassoc_event_callback(_adapter *adapter, u8 *pbuf);
+extern void rtw_stadel_event_callback(_adapter *adapter, u8 *pbuf);
+extern void rtw_atimdone_event_callback(_adapter *adapter, u8 *pbuf);
+extern void rtw_cpwm_event_callback(_adapter *adapter, u8 *pbuf);
+
+#ifdef PLATFORM_WINDOWS
+extern thread_return event_thread(void *context);
+
+extern void rtw_join_timeout_handler (
+	IN	PVOID					SystemSpecific1,
+	IN	PVOID					FunctionContext,
+	IN	PVOID					SystemSpecific2,
+	IN	PVOID					SystemSpecific3
+	);
+
+extern void _rtw_scan_timeout_handler (
+	IN	PVOID					SystemSpecific1,
+	IN	PVOID					FunctionContext,
+	IN	PVOID					SystemSpecific2,
+	IN	PVOID					SystemSpecific3
+	);
+
+#endif
+
+#if defined (PLATFORM_LINUX)|| defined (PLATFORM_FREEBSD)
+extern int event_thread(void *context);
+extern void rtw_join_timeout_handler(void* FunctionContext);
+extern void _rtw_scan_timeout_handler(void* FunctionContext);
+#endif
+
+extern void rtw_free_network_queue(_adapter *adapter,u8 isfreeall);
+extern int rtw_init_mlme_priv(_adapter *adapter);// (struct mlme_priv *pmlmepriv);
+
+extern void rtw_free_mlme_priv (struct mlme_priv *pmlmepriv);
+
+
+extern sint rtw_select_and_join_from_scanned_queue(struct mlme_priv *pmlmepriv);
+extern sint rtw_set_key(_adapter *adapter,struct security_priv *psecuritypriv,sint keyid, u8 set_tx);
+extern sint rtw_set_auth(_adapter *adapter,struct security_priv *psecuritypriv);
+extern sint rtw_linked_check(_adapter *padapter);
+
+__inline static u8 *get_bssid(struct mlme_priv *pmlmepriv)
+{	//if sta_mode:pmlmepriv->cur_network.network.MacAddress=> bssid
+	// if adhoc_mode:pmlmepriv->cur_network.network.MacAddress=> ibss mac address
+	return pmlmepriv->cur_network.network.MacAddress;
+}
+
+__inline static sint check_fwstate(struct mlme_priv *pmlmepriv, sint state)
+{
+	if (pmlmepriv->fw_state & state)
+		return _TRUE;
+
+	return _FALSE;
+}
+
+__inline static sint get_fwstate(struct mlme_priv *pmlmepriv)
+{
+	return pmlmepriv->fw_state;
+}
+
+/*
+ * No Limit on the calling context,
+ * therefore set it to be the critical section...
+ *
+ * ### NOTE:#### (!!!!)
+ * MUST TAKE CARE THAT BEFORE CALLING THIS FUNC, YOU SHOULD HAVE LOCKED pmlmepriv->lock
+ */
+__inline static void set_fwstate(struct mlme_priv *pmlmepriv, sint state)
+{
+	pmlmepriv->fw_state |= state;
+	//FOR HW integration
+	if(_FW_UNDER_SURVEY==state){
+		pmlmepriv->bScanInProcess = _TRUE;
+	}
+}
+
+__inline static void _clr_fwstate_(struct mlme_priv *pmlmepriv, sint state)
+{
+	pmlmepriv->fw_state &= ~state;
+	//FOR HW integration
+	if(_FW_UNDER_SURVEY==state){
+		pmlmepriv->bScanInProcess = _FALSE;
+	}
+}
+
+/*
+ * No Limit on the calling context,
+ * therefore set it to be the critical section...
+ */
+__inline static void clr_fwstate(struct mlme_priv *pmlmepriv, sint state)
+{
+	_irqL irqL;
+
+	rtw_enter_critical_bh(&pmlmepriv->lock, &irqL);
+	if (check_fwstate(pmlmepriv, state) == _TRUE)
+		pmlmepriv->fw_state ^= state;
+	rtw_exit_critical_bh(&pmlmepriv->lock, &irqL);
+}
+
+__inline static void clr_fwstate_ex(struct mlme_priv *pmlmepriv, sint state)
+{
+	_irqL irqL;
+
+	rtw_enter_critical_bh(&pmlmepriv->lock, &irqL);
+	_clr_fwstate_(pmlmepriv, state);
+	rtw_exit_critical_bh(&pmlmepriv->lock, &irqL);
+}
+
+__inline static void up_scanned_network(struct mlme_priv *pmlmepriv)
+{
+	_irqL irqL;
+
+	rtw_enter_critical_bh(&pmlmepriv->lock, &irqL);
+	pmlmepriv->num_of_scanned++;
+	rtw_exit_critical_bh(&pmlmepriv->lock, &irqL);
+}
+
+#ifdef CONFIG_CONCURRENT_MODE
+sint rtw_buddy_adapter_up(_adapter *padapter);
+sint check_buddy_fwstate(_adapter *padapter, sint state);
+#endif //CONFIG_CONCURRENT_MODE
+
+__inline static void down_scanned_network(struct mlme_priv *pmlmepriv)
+{
+	_irqL irqL;
+
+	rtw_enter_critical_bh(&pmlmepriv->lock, &irqL);
+	pmlmepriv->num_of_scanned--;
+	rtw_exit_critical_bh(&pmlmepriv->lock, &irqL);
+}
+
+__inline static void set_scanned_network_val(struct mlme_priv *pmlmepriv, sint val)
+{
+	_irqL irqL;
+
+	rtw_enter_critical_bh(&pmlmepriv->lock, &irqL);
+	pmlmepriv->num_of_scanned = val;
+	rtw_exit_critical_bh(&pmlmepriv->lock, &irqL);
+}
+
+extern u16 rtw_get_capability(WLAN_BSSID_EX *bss);
+extern void rtw_update_scanned_network(_adapter *adapter, WLAN_BSSID_EX *target);
+extern void rtw_disconnect_hdl_under_linked(_adapter* adapter, struct sta_info *psta, u8 free_assoc);
+extern void rtw_generate_random_ibss(u8 *pibss);
+extern struct wlan_network* rtw_find_network(_queue *scanned_queue, u8 *addr);
+extern struct wlan_network* rtw_get_oldest_wlan_network(_queue *scanned_queue);
+
+extern void rtw_free_assoc_resources(_adapter* adapter, int lock_scanned_queue);
+extern void rtw_indicate_disconnect(_adapter* adapter);
+extern void rtw_indicate_connect(_adapter* adapter);
+void rtw_indicate_scan_done( _adapter *padapter, bool aborted);
+void rtw_scan_abort(_adapter *adapter);
+
+extern int rtw_restruct_sec_ie(_adapter *adapter,u8 *in_ie,u8 *out_ie,uint in_len);
+extern int rtw_restruct_wmm_ie(_adapter *adapter, u8 *in_ie, u8 *out_ie, uint in_len, uint initial_out_len);
+//extern void rtw_init_registrypriv_dev_network(_adapter *adapter);
+
+//extern void rtw_update_registrypriv_dev_network(_adapter *adapter);
+
+extern void rtw_get_encrypt_decrypt_from_registrypriv(_adapter *adapter);
+
+extern void _rtw_join_timeout_handler(_adapter *adapter);
+extern void rtw_scan_timeout_handler(_adapter *adapter);
+
+extern void rtw_dynamic_check_timer_handlder(_adapter *adapter);
+#ifdef CONFIG_SET_SCAN_DENY_TIMER
+extern void rtw_set_scan_deny_timer_hdl(_adapter *adapter);
+void rtw_set_scan_deny(struct mlme_priv *mlmepriv, u32 ms);
+#endif
+
+
+extern int _rtw_init_mlme_priv(_adapter *padapter);
+
+void rtw_free_mlme_priv_ie_data(struct mlme_priv *pmlmepriv);
+
+extern void _rtw_free_mlme_priv(struct mlme_priv *pmlmepriv);
+
+extern int _rtw_enqueue_network(_queue *queue, struct wlan_network *pnetwork);
+
+extern struct wlan_network* _rtw_dequeue_network(_queue *queue);
+
+extern struct wlan_network* _rtw_alloc_network(struct mlme_priv *pmlmepriv);
+
+
+extern void _rtw_free_network(struct mlme_priv *pmlmepriv, struct wlan_network *pnetwork, u8 isfreeall);
+extern void _rtw_free_network_nolock(struct mlme_priv *pmlmepriv, struct wlan_network *pnetwork);
+
+
+extern struct wlan_network* _rtw_find_network(_queue *scanned_queue, u8 *addr);
+
+extern void _rtw_free_network_queue(_adapter* padapter, u8 isfreeall);
+
+extern sint rtw_if_up(_adapter *padapter);
+
+
+u8 *rtw_get_capability_from_ie(u8 *ie);
+u8 *rtw_get_timestampe_from_ie(u8 *ie);
+u8 *rtw_get_beacon_interval_from_ie(u8 *ie);
+
+
+void rtw_joinbss_reset(_adapter *padapter);
+
+#ifdef CONFIG_80211N_HT
+unsigned int rtw_restructure_ht_ie(_adapter *padapter, u8 *in_ie, u8 *out_ie, uint in_len, uint *pout_len);
+void rtw_update_ht_cap(_adapter *padapter, u8 *pie, uint ie_len);
+void rtw_issue_addbareq_cmd(_adapter *padapter, struct xmit_frame *pxmitframe);
+#endif
+
+int rtw_is_same_ibss(_adapter *adapter, struct wlan_network *pnetwork);
+int is_same_network(WLAN_BSSID_EX *src, WLAN_BSSID_EX *dst);
+
+#ifdef CONFIG_LAYER2_ROAMING
+void rtw_roaming(_adapter *padapter, struct wlan_network *tgt_network);
+void _rtw_roaming(_adapter *padapter, struct wlan_network *tgt_network);
+#endif
+
+
+#ifdef CONFIG_INTEL_PROXIM
+void rtw_proxim_enable(_adapter *padapter);
+void rtw_proxim_disable(_adapter *padapter);
+void rtw_proxim_send_packet(_adapter *padapter,u8 *pbuf,u16 len,u8 hw_rate);
+#endif //CONFIG_INTEL_PROXIM
+
+extern void rtw_os_indicate_disconnect( _adapter *adapter );
+extern void rtw_os_indicate_scan_done( _adapter *padapter, bool aborted);
+extern void rtw_reset_securitypriv( _adapter *adapter );
+#endif //__RTL871X_MLME_H_
+

USDK/component/common/drivers/wlan/realtek/include/rtw_mp.h

@@ -0,0 +1,722 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef _RTW_MP_H_
+#define _RTW_MP_H_
+
+#ifndef PLATFORM_WINDOWS
+//	00 - Success
+//	11 - Error
+#define STATUS_SUCCESS				(0x00000000L)
+#define STATUS_PENDING				(0x00000103L)
+
+#define STATUS_UNSUCCESSFUL			(0xC0000001L)
+#define STATUS_INSUFFICIENT_RESOURCES		(0xC000009AL)
+#define STATUS_NOT_SUPPORTED			(0xC00000BBL)
+
+#define NDIS_STATUS_SUCCESS			((NDIS_STATUS)STATUS_SUCCESS)
+#define NDIS_STATUS_PENDING			((NDIS_STATUS)STATUS_PENDING)
+#define NDIS_STATUS_NOT_RECOGNIZED		((NDIS_STATUS)0x00010001L)
+#define NDIS_STATUS_NOT_COPIED			((NDIS_STATUS)0x00010002L)
+#define NDIS_STATUS_NOT_ACCEPTED		((NDIS_STATUS)0x00010003L)
+#define NDIS_STATUS_CALL_ACTIVE			((NDIS_STATUS)0x00010007L)
+
+#define NDIS_STATUS_FAILURE			((NDIS_STATUS)STATUS_UNSUCCESSFUL)
+#define NDIS_STATUS_RESOURCES			((NDIS_STATUS)STATUS_INSUFFICIENT_RESOURCES)
+#define NDIS_STATUS_CLOSING			((NDIS_STATUS)0xC0010002L)
+#define NDIS_STATUS_BAD_VERSION			((NDIS_STATUS)0xC0010004L)
+#define NDIS_STATUS_BAD_CHARACTERISTICS		((NDIS_STATUS)0xC0010005L)
+#define NDIS_STATUS_ADAPTER_NOT_FOUND		((NDIS_STATUS)0xC0010006L)
+#define NDIS_STATUS_OPEN_FAILED			((NDIS_STATUS)0xC0010007L)
+#define NDIS_STATUS_DEVICE_FAILED		((NDIS_STATUS)0xC0010008L)
+#define NDIS_STATUS_MULTICAST_FULL		((NDIS_STATUS)0xC0010009L)
+#define NDIS_STATUS_MULTICAST_EXISTS		((NDIS_STATUS)0xC001000AL)
+#define NDIS_STATUS_MULTICAST_NOT_FOUND		((NDIS_STATUS)0xC001000BL)
+#define NDIS_STATUS_REQUEST_ABORTED		((NDIS_STATUS)0xC001000CL)
+#define NDIS_STATUS_RESET_IN_PROGRESS		((NDIS_STATUS)0xC001000DL)
+#define NDIS_STATUS_CLOSING_INDICATING		((NDIS_STATUS)0xC001000EL)
+#define NDIS_STATUS_NOT_SUPPORTED		((NDIS_STATUS)STATUS_NOT_SUPPORTED)
+#define NDIS_STATUS_INVALID_PACKET		((NDIS_STATUS)0xC001000FL)
+#define NDIS_STATUS_OPEN_LIST_FULL		((NDIS_STATUS)0xC0010010L)
+#define NDIS_STATUS_ADAPTER_NOT_READY		((NDIS_STATUS)0xC0010011L)
+#define NDIS_STATUS_ADAPTER_NOT_OPEN		((NDIS_STATUS)0xC0010012L)
+#define NDIS_STATUS_NOT_INDICATING		((NDIS_STATUS)0xC0010013L)
+#define NDIS_STATUS_INVALID_LENGTH		((NDIS_STATUS)0xC0010014L)
+#define NDIS_STATUS_INVALID_DATA		((NDIS_STATUS)0xC0010015L)
+#define NDIS_STATUS_BUFFER_TOO_SHORT		((NDIS_STATUS)0xC0010016L)
+#define NDIS_STATUS_INVALID_OID			((NDIS_STATUS)0xC0010017L)
+#define NDIS_STATUS_ADAPTER_REMOVED		((NDIS_STATUS)0xC0010018L)
+#define NDIS_STATUS_UNSUPPORTED_MEDIA		((NDIS_STATUS)0xC0010019L)
+#define NDIS_STATUS_GROUP_ADDRESS_IN_USE	((NDIS_STATUS)0xC001001AL)
+#define NDIS_STATUS_FILE_NOT_FOUND		((NDIS_STATUS)0xC001001BL)
+#define NDIS_STATUS_ERROR_READING_FILE		((NDIS_STATUS)0xC001001CL)
+#define NDIS_STATUS_ALREADY_MAPPED		((NDIS_STATUS)0xC001001DL)
+#define NDIS_STATUS_RESOURCE_CONFLICT		((NDIS_STATUS)0xC001001EL)
+#define NDIS_STATUS_NO_CABLE			((NDIS_STATUS)0xC001001FL)
+
+#define NDIS_STATUS_INVALID_SAP			((NDIS_STATUS)0xC0010020L)
+#define NDIS_STATUS_SAP_IN_USE			((NDIS_STATUS)0xC0010021L)
+#define NDIS_STATUS_INVALID_ADDRESS		((NDIS_STATUS)0xC0010022L)
+#define NDIS_STATUS_VC_NOT_ACTIVATED		((NDIS_STATUS)0xC0010023L)
+#define NDIS_STATUS_DEST_OUT_OF_ORDER		((NDIS_STATUS)0xC0010024L)  // cause 27
+#define NDIS_STATUS_VC_NOT_AVAILABLE		((NDIS_STATUS)0xC0010025L)  // cause 35,45
+#define NDIS_STATUS_CELLRATE_NOT_AVAILABLE	((NDIS_STATUS)0xC0010026L)  // cause 37
+#define NDIS_STATUS_INCOMPATABLE_QOS		((NDIS_STATUS)0xC0010027L)  // cause 49
+#define NDIS_STATUS_AAL_PARAMS_UNSUPPORTED	((NDIS_STATUS)0xC0010028L)  // cause 93
+#define NDIS_STATUS_NO_ROUTE_TO_DESTINATION	((NDIS_STATUS)0xC0010029L)  // cause 3
+#endif /* #ifndef PLATFORM_WINDOWS */
+
+#if 0
+#define MPT_NOOP			0
+#define MPT_READ_MAC_1BYTE		1
+#define MPT_READ_MAC_2BYTE		2
+#define MPT_READ_MAC_4BYTE		3
+#define MPT_WRITE_MAC_1BYTE		4
+#define MPT_WRITE_MAC_2BYTE		5
+#define MPT_WRITE_MAC_4BYTE		6
+#define MPT_READ_BB_CCK			7
+#define MPT_WRITE_BB_CCK		8
+#define MPT_READ_BB_OFDM		9
+#define MPT_WRITE_BB_OFDM		10
+#define MPT_READ_RF			11
+#define MPT_WRITE_RF			12
+#define MPT_READ_EEPROM_1BYTE		13
+#define MPT_WRITE_EEPROM_1BYTE		14
+#define MPT_READ_EEPROM_2BYTE		15
+#define MPT_WRITE_EEPROM_2BYTE		16
+#define MPT_SET_CSTHRESHOLD		21
+#define MPT_SET_INITGAIN		22
+#define MPT_SWITCH_BAND			23
+#define MPT_SWITCH_CHANNEL		24
+#define MPT_SET_DATARATE		25
+#define MPT_SWITCH_ANTENNA		26
+#define MPT_SET_TX_POWER		27
+#define MPT_SET_CONT_TX			28
+#define MPT_SET_SINGLE_CARRIER		29
+#define MPT_SET_CARRIER_SUPPRESSION	30
+#define MPT_GET_RATE_TABLE		31
+#define MPT_READ_TSSI			32
+#define MPT_GET_THERMAL_METER		33
+#endif
+
+typedef enum _ANTENNA_PATH{
+		ANTENNA_NONE	= 0x00,
+		ANTENNA_D		,
+		ANTENNA_C		,
+		ANTENNA_CD		,
+		ANTENNA_B		,
+		ANTENNA_BD		,
+		ANTENNA_BC		,
+		ANTENNA_BCD 	,
+		ANTENNA_A		,
+		ANTENNA_AD		,
+		ANTENNA_AC		,
+		ANTENNA_ACD 	,
+		ANTENNA_AB		,
+		ANTENNA_ABD 	,
+		ANTENNA_ABC 	,
+		ANTENNA_ABCD
+} ANTENNA_PATH;
+
+
+#define MAX_MP_XMITBUF_SZ 	2048
+#define NR_MP_XMITFRAME		8
+
+struct mp_xmit_frame
+{
+	_list	list;
+
+	struct pkt_attrib attrib;
+
+	_pkt *pkt;
+
+	int frame_tag;
+
+	_adapter *padapter;
+
+#ifdef CONFIG_USB_HCI
+
+	//insert urb, irp, and irpcnt info below...
+	//max frag_cnt = 8
+
+	u8 *mem_addr;
+	u32 sz[8];
+
+#if defined(PLATFORM_OS_XP) || defined(PLATFORM_LINUX)
+	PURB pxmit_urb[8];
+#endif
+
+#ifdef PLATFORM_OS_XP
+	PIRP pxmit_irp[8];
+#endif
+
+	u8 bpending[8];
+	s32 ac_tag[8];
+	s32 last[8];
+	uint irpcnt;
+	uint fragcnt;
+#endif /* CONFIG_USB_HCI */
+
+	uint mem[(MAX_MP_XMITBUF_SZ >> 2)];
+};
+
+struct mp_wiparam
+{
+	u32 bcompleted;
+	u32 act_type;
+	u32 io_offset;
+	u32 io_value;
+};
+
+typedef void(*wi_act_func)(void* padapter);
+
+#ifdef PLATFORM_WINDOWS
+struct mp_wi_cntx
+{
+	u8 bmpdrv_unload;
+
+	// Work Item
+	NDIS_WORK_ITEM mp_wi;
+	NDIS_EVENT mp_wi_evt;
+	_lock mp_wi_lock;
+	u8 bmp_wi_progress;
+	wi_act_func curractfunc;
+	// Variable needed in each implementation of CurrActFunc.
+	struct mp_wiparam param;
+};
+#endif
+
+struct mp_tx
+{
+	u8 stop;
+	u32 count, sended;
+	u8 payload;
+	struct pkt_attrib attrib;
+	struct tx_desc desc;
+	u8 *pallocated_buf;
+	u8 *buf;
+	u32 buf_size, write_size;
+	//_thread_hdl_	PktTxThread;
+	struct task_struct	MpXmitThread;
+};
+
+#define MP_MAX_LINES		1000
+#define MP_MAX_LINES_BYTES	256
+
+
+typedef void (*MPT_WORK_ITEM_HANDLER)(IN void *Adapter);
+typedef struct _MPT_CONTEXT
+{
+	// Indicate if we have started Mass Production Test.
+	BOOLEAN			bMassProdTest;
+
+	// Indicate if the driver is unloading or unloaded.
+	BOOLEAN			bMptDrvUnload;
+
+	_sema			MPh2c_Sema;
+	_timer			MPh2c_timeout_timer;
+// Event used to sync H2c for BT control
+
+	BOOLEAN		MptH2cRspEvent;
+	BOOLEAN		MptBtC2hEvent;
+	BOOLEAN		bMPh2c_timeout;
+
+	/* 8190 PCI does not support NDIS_WORK_ITEM. */
+	// Work Item for Mass Production Test.
+	//NDIS_WORK_ITEM	MptWorkItem;
+//	RT_WORK_ITEM		MptWorkItem;
+	// Event used to sync the case unloading driver and MptWorkItem is still in progress.
+//	NDIS_EVENT		MptWorkItemEvent;
+	// To protect the following variables.
+//	NDIS_SPIN_LOCK		MptWorkItemSpinLock;
+	// Indicate a MptWorkItem is scheduled and not yet finished.
+	BOOLEAN			bMptWorkItemInProgress;
+	// An instance which implements function and context of MptWorkItem.
+	MPT_WORK_ITEM_HANDLER	CurrMptAct;
+
+	// 1=Start, 0=Stop from UI.
+	u32			MptTestStart;
+	// _TEST_MODE, defined in MPT_Req2.h
+	u32			MptTestItem;
+	// Variable needed in each implementation of CurrMptAct.
+	u32			MptActType; 	// Type of action performed in CurrMptAct.
+	// The Offset of IO operation is depend of MptActType.
+	u32			MptIoOffset;
+	// The Value of IO operation is depend of MptActType.
+	u32			MptIoValue;
+	// The RfPath of IO operation is depend of MptActType.
+	u32			MptRfPath;
+
+	WIRELESS_MODE		MptWirelessModeToSw;	// Wireless mode to switch.
+	u8			MptChannelToSw; 	// Channel to switch.
+	u8			MptInitGainToSet; 	// Initial gain to set.
+	//u32			bMptAntennaA; 		// TRUE if we want to use antenna A.
+	u32			MptBandWidth;		// bandwidth to switch.
+	u32			MptRateIndex;		// rate index.
+	// Register value kept for Single Carrier Tx test.
+	u8			btMpCckTxPower;
+	// Register value kept for Single Carrier Tx test.
+	u8			btMpOfdmTxPower;
+	// For MP Tx Power index
+	u8			TxPwrLevel[2];	// rf-A, rf-B
+
+	// Content of RCR Regsiter for Mass Production Test.
+	u32			MptRCR;
+	// TRUE if we only receive packets with specific pattern.
+	BOOLEAN			bMptFilterPattern;
+ 	// Rx OK count, statistics used in Mass Production Test.
+ 	u32			MptRxOkCnt;
+ 	// Rx CRC32 error count, statistics used in Mass Production Test.
+ 	u32			MptRxCrcErrCnt;
+
+	BOOLEAN			bCckContTx;	// TRUE if we are in CCK Continuous Tx test.
+ 	BOOLEAN			bOfdmContTx;	// TRUE if we are in OFDM Continuous Tx test.
+	BOOLEAN			bStartContTx; 	// TRUE if we have start Continuous Tx test.
+	// TRUE if we are in Single Carrier Tx test.
+	BOOLEAN			bSingleCarrier;
+	// TRUE if we are in Carrier Suppression Tx Test.
+	BOOLEAN			bCarrierSuppression;
+	//TRUE if we are in Single Tone Tx test.
+	BOOLEAN			bSingleTone;
+
+	// ACK counter asked by K.Y..
+	BOOLEAN			bMptEnableAckCounter;
+	u32			MptAckCounter;
+
+	// SD3 Willis For 8192S to save 1T/2T RF table for ACUT	Only fro ACUT delete later ~~~!
+	//s8		BufOfLines[2][MAX_LINES_HWCONFIG_TXT][MAX_BYTES_LINE_HWCONFIG_TXT];
+	//s8			BufOfLines[2][MP_MAX_LINES][MP_MAX_LINES_BYTES];
+	//s32			RfReadLine[2];
+
+	u8		APK_bound[2];	//for APK	path A/path B
+	BOOLEAN		bMptIndexEven;
+
+	u8		backup0xc50;
+	u8		backup0xc58;
+	u8		backup0xc30;
+	u8 		backup0x52_RF_A;
+	u8 		backup0x52_RF_B;
+
+	u8			h2cReqNum;
+	u8			c2hBuf[20];
+
+	u8          btInBuf[100];
+	u32			mptOutLen;
+	u8          mptOutBuf[100];
+
+}MPT_CONTEXT, *PMPT_CONTEXT;
+//#endif
+
+//#define RTPRIV_IOCTL_MP 					( SIOCIWFIRSTPRIV + 0x17)
+enum {
+	WRITE_REG = 1,
+	READ_REG,
+	WRITE_RF,
+	READ_RF,
+	MP_START,
+	MP_STOP,
+	MP_RATE,
+	MP_CHANNEL,
+	MP_BANDWIDTH,
+	MP_TXPOWER,
+	MP_ANT_TX,
+	MP_ANT_RX,
+	MP_CTX,
+	MP_QUERY,
+	MP_ARX,
+	MP_PSD,
+	MP_PWRTRK,
+	MP_THER,
+	MP_IOCTL,
+	EFUSE_GET,
+	EFUSE_SET,
+	CONFIG_GET,
+	CONFIG_SET,
+	MP_RESET_STATS,
+	MP_DUMP,
+	MP_PHYPARA,
+	MP_SetRFPathSwh,
+	MP_QueryDrvStats,
+	MP_SetBT,
+	TEST_CFG,
+	MP_NULL,
+	MP_GET_TXPOWER_INX,
+	MP_SET_PREAMBLE,
+	MP_DISABLE_BT_COEXIST,
+	MP_PwrCtlDM,
+	MP_IQK,
+	MP_LCK,
+	MP_DRV_ABILITY
+};
+
+struct mp_priv
+{
+	_adapter *papdater;
+
+	//Testing Flag
+	u32 mode;//0 for normal type packet, 1 for loopback packet (16bytes TXCMD)
+
+	u32 prev_fw_state;
+
+	//OID cmd handler
+	struct mp_wiparam workparam;
+//	u8 act_in_progress;
+
+	//Tx Section
+	u8 TID;
+	u32 tx_pktcount;
+	struct mp_tx tx;
+
+	//Rx Section
+	u8 rx_pkt_by_mac;
+	u32 rx_pktcount;
+	u32 rx_crcerrpktcount;
+	u32 rx_macpktcount;
+	u32 rx_pktloss;
+	
+	struct recv_stat rxstat;
+
+	//RF/BB relative
+	u8 channel;
+	u8 bandwidth;
+	u8 prime_channel_offset;
+	u8 txpoweridx;
+	u8 txpoweridx_b;
+	u8 rateidx;
+	u32 preamble;
+//	u8 modem;
+	u32 CrystalCap;
+//	u32 curr_crystalcap;
+
+	u16 antenna_tx;
+	u16 antenna_rx;
+//	u8 curr_rfpath;
+
+	u8 check_mp_pkt;
+
+	u8 bSetTxPower;
+	u8 bCCKTxPowerAdjust;
+	u8 bFAStatistics;
+//	uint ForcedDataRate;
+	u8 mp_dm;
+	struct wlan_network mp_network;
+	NDIS_802_11_MAC_ADDRESS network_macaddr;
+
+#ifdef PLATFORM_WINDOWS
+	u32 rx_testcnt;
+	u32 rx_testcnt1;
+	u32 rx_testcnt2;
+	u32 tx_testcnt;
+	u32 tx_testcnt1;
+
+	struct mp_wi_cntx wi_cntx;
+
+	u8 h2c_result;
+	u8 h2c_seqnum;
+	u16 h2c_cmdcode;
+	u8 h2c_resp_parambuf[512];
+	_lock h2c_lock;
+	_lock wkitm_lock;
+	u32 h2c_cmdcnt;
+	NDIS_EVENT h2c_cmd_evt;
+	NDIS_EVENT c2h_set;
+	NDIS_EVENT h2c_clr;
+	NDIS_EVENT cpwm_int;
+
+	NDIS_EVENT scsir_full_evt;
+	NDIS_EVENT scsiw_empty_evt;
+#endif
+
+	u8 *pallocated_mp_xmitframe_buf;
+	u8 *pmp_xmtframe_buf;
+	_queue free_mp_xmitqueue;
+	u32 free_mp_xmitframe_cnt;
+
+	MPT_CONTEXT MptCtx;
+};
+
+typedef struct _IOCMD_STRUCT_ {
+	u8	cmdclass;
+	u16	value;
+	u8	index;
+}IOCMD_STRUCT;
+
+struct rf_reg_param {
+	u32 path;
+	u32 offset;
+	u32 value;
+};
+
+struct bb_reg_param {
+	u32 offset;
+	u32 value;
+};
+//=======================================================================
+
+#define LOWER 	_TRUE
+#define RAISE	_FALSE
+
+/* Hardware Registers */
+#if 0
+#if 0
+#define IOCMD_CTRL_REG			0x102502C0
+#define IOCMD_DATA_REG			0x102502C4
+#else
+#define IOCMD_CTRL_REG			0x10250370
+#define IOCMD_DATA_REG			0x10250374
+#endif
+
+#define IOCMD_GET_THERMAL_METER		0xFD000028
+
+#define IOCMD_CLASS_BB_RF		0xF0
+#define IOCMD_BB_READ_IDX		0x00
+#define IOCMD_BB_WRITE_IDX		0x01
+#define IOCMD_RF_READ_IDX		0x02
+#define IOCMD_RF_WRIT_IDX		0x03
+#endif
+#define BB_REG_BASE_ADDR		0x800
+
+/* MP variables */
+#if 0
+#define _2MAC_MODE_	0
+#define _LOOPBOOK_MODE_	1
+#endif
+typedef enum _MP_MODE_ {
+	MP_OFF,
+	MP_ON,
+	MP_ERR,
+	MP_CONTINUOUS_TX,
+	MP_SINGLE_CARRIER_TX,
+	MP_CARRIER_SUPPRISSION_TX,
+	MP_SINGLE_TONE_TX,
+	MP_PACKET_TX,
+	MP_PACKET_RX
+} MP_MODE;
+
+
+#define MAX_RF_PATH_NUMS	MAX_RF_PATH
+
+
+extern u8 mpdatarate[NumRates];
+
+/* MP set force data rate base on the definition. */
+typedef enum _MPT_RATE_INDEX
+{
+	/* CCK rate. */
+	MPT_RATE_1M,	/* 0 */
+	MPT_RATE_2M,
+	MPT_RATE_55M,
+	MPT_RATE_11M,	/* 3 */
+
+	/* OFDM rate. */
+	MPT_RATE_6M,	/* 4 */
+	MPT_RATE_9M,
+	MPT_RATE_12M,
+	MPT_RATE_18M,
+	MPT_RATE_24M,
+	MPT_RATE_36M,
+	MPT_RATE_48M,
+	MPT_RATE_54M,	/* 11 */
+
+	/* HT rate. */
+	MPT_RATE_MCS0,	/* 12 */
+	MPT_RATE_MCS1,
+	MPT_RATE_MCS2,
+	MPT_RATE_MCS3,
+	MPT_RATE_MCS4,
+	MPT_RATE_MCS5,
+	MPT_RATE_MCS6,
+	MPT_RATE_MCS7,	/* 19 */
+	MPT_RATE_MCS8,
+	MPT_RATE_MCS9,
+	MPT_RATE_MCS10,
+	MPT_RATE_MCS11,
+	MPT_RATE_MCS12,
+	MPT_RATE_MCS13,
+	MPT_RATE_MCS14,
+	MPT_RATE_MCS15,	/* 27 */
+	MPT_RATE_LAST
+}MPT_RATE_E, *PMPT_RATE_E;
+
+#define MAX_TX_PWR_INDEX_N_MODE 64	// 0x3F
+
+typedef enum _POWER_MODE_ {
+	POWER_LOW = 0,
+	POWER_NORMAL
+}POWER_MODE;
+
+
+#define RX_PKT_BROADCAST	1
+#define RX_PKT_DEST_ADDR	2
+#define RX_PKT_PHY_MATCH	3
+
+#if 0
+#define RPTMaxCount 0x000FFFFF;
+
+// parameter 1 : BitMask
+// 	bit 0  : OFDM PPDU
+//	bit 1  : OFDM False Alarm
+//	bit 2  : OFDM MPDU OK
+//	bit 3  : OFDM MPDU Fail
+//	bit 4  : CCK PPDU
+//	bit 5  : CCK False Alarm
+//	bit 6  : CCK MPDU ok
+//	bit 7  : CCK MPDU fail
+//	bit 8  : HT PPDU counter
+//	bit 9  : HT false alarm
+//	bit 10 : HT MPDU total
+//	bit 11 : HT MPDU OK
+//	bit 12 : HT MPDU fail
+//	bit 15 : RX full drop
+typedef enum _RXPHY_BITMASK_
+{
+	OFDM_PPDU_BIT = 0,
+	OFDM_FALSE_BIT,
+	OFDM_MPDU_OK_BIT,
+	OFDM_MPDU_FAIL_BIT,
+	CCK_PPDU_BIT,
+	CCK_FALSE_BIT,
+	CCK_MPDU_OK_BIT,
+	CCK_MPDU_FAIL_BIT,
+	HT_PPDU_BIT,
+	HT_FALSE_BIT,
+	HT_MPDU_BIT,
+	HT_MPDU_OK_BIT,
+	HT_MPDU_FAIL_BIT,
+} RXPHY_BITMASK;
+#endif
+
+typedef enum _ENCRY_CTRL_STATE_ {
+	HW_CONTROL,		//hw encryption& decryption
+	SW_CONTROL,		//sw encryption& decryption
+	HW_ENCRY_SW_DECRY,	//hw encryption & sw decryption
+	SW_ENCRY_HW_DECRY	//sw encryption & hw decryption
+}ENCRY_CTRL_STATE;
+
+typedef enum _PREAMBLE {
+		Long_Preamble	= 0x01,
+		Short_Preamble		  ,
+		Long_GI 			  ,
+		Short_GI
+} PREAMBLE;
+
+
+
+//=======================================================================
+//extern struct mp_xmit_frame *alloc_mp_xmitframe(struct mp_priv *pmp_priv);
+//extern int free_mp_xmitframe(struct xmit_priv *pxmitpriv, struct mp_xmit_frame *pmp_xmitframe);
+
+extern s32 init_mp_priv(_adapter * padapter);
+extern void free_mp_priv(struct mp_priv *pmp_priv);
+extern s32 MPT_InitializeAdapter(_adapter * padapter, u8 Channel);
+extern void MPT_DeInitAdapter(_adapter * padapter);
+extern s32 mp_start_test(_adapter * padapter);
+extern void mp_stop_test(_adapter * padapter);
+
+//=======================================================================
+//extern void	IQCalibrateBcut(_adapter * pAdapter);
+
+//extern u32	bb_reg_read(_adapter * Adapter, u16 offset);
+//extern u8	bb_reg_write(_adapter * Adapter, u16 offset, u32 value);
+//extern u32	rf_reg_read(_adapter * Adapter, u8 path, u8 offset);
+//extern u8	rf_reg_write(_adapter * Adapter, u8 path, u8 offset, u32 value);
+
+//extern u32	get_bb_reg(_adapter * Adapter, u16 offset, u32 bitmask);
+//extern u8	set_bb_reg(_adapter * Adapter, u16 offset, u32 bitmask, u32 value);
+//extern u32	get_rf_reg(_adapter * Adapter, u8 path, u8 offset, u32 bitmask);
+//extern u8	set_rf_reg(_adapter * Adapter, u8 path, u8 offset, u32 bitmask, u32 value);
+
+extern u32 _read_rfreg(_adapter * padapter, u8 rfpath, u32 addr, u32 bitmask);
+extern void _write_rfreg(_adapter * padapter, u8 rfpath, u32 addr, u32 bitmask, u32 val);
+
+extern u32 read_macreg(_adapter *padapter, u32 addr, u32 sz);
+extern void write_macreg(_adapter *padapter, u32 addr, u32 val, u32 sz);
+extern u32 read_bbreg(_adapter *padapter, u32 addr, u32 bitmask);
+extern void write_bbreg(_adapter *padapter, u32 addr, u32 bitmask, u32 val);
+extern u32 read_rfreg(_adapter * padapter, u8 rfpath, u32 addr);
+extern void write_rfreg(_adapter * padapter, u8 rfpath, u32 addr, u32 val);
+
+extern void	SetChannel(_adapter * pAdapter);
+extern void	SetBandwidth(_adapter * pAdapter);
+extern void	SetTxPower(_adapter * pAdapter);
+extern void	SetAntennaPathPower(_adapter * pAdapter);
+//extern void	SetTxAGCOffset(_adapter * pAdapter, u32 ulTxAGCOffset);
+extern void	SetDataRate(_adapter * pAdapter);
+
+extern void	SetAntenna(_adapter * pAdapter);
+
+//extern void	SetCrystalCap(_adapter * pAdapter);
+
+extern s32	SetThermalMeter(_adapter * pAdapter, u8 target_ther);
+extern void	GetThermalMeter(_adapter * pAdapter, u8 *value);
+
+extern void	SetContinuousTx(_adapter * pAdapter, u8 bStart);
+extern void	SetSingleCarrierTx(_adapter * pAdapter, u8 bStart);
+extern void	SetSingleToneTx(_adapter * pAdapter, u8 bStart);
+extern void	SetCarrierSuppressionTx(_adapter * pAdapter, u8 bStart);
+extern void PhySetTxPowerLevel(_adapter * pAdapter);
+
+extern void	fill_txdesc_for_mp(_adapter * padapter, struct tx_desc *ptxdesc);
+extern void	SetPacketTx(_adapter * padapter);
+extern void	SetPacketRx(_adapter * pAdapter, u8 bStartRx);
+
+extern void	ResetPhyRxPktCount(_adapter * pAdapter);
+extern u32	GetPhyRxPktReceived(_adapter * pAdapter);
+extern u32	GetPhyRxPktCRC32Error(_adapter * pAdapter);
+
+extern s32	SetPowerTracking(_adapter * padapter, u8 enable);
+extern void	GetPowerTracking(_adapter * padapter, u8 *enable);
+
+extern u32	mp_query_psd(_adapter * pAdapter, u8 *data);
+
+
+extern void Hal_SetAntenna(_adapter * pAdapter);
+extern void Hal_SetBandwidth(_adapter * pAdapter);
+
+extern void Hal_SetTxPower(_adapter * pAdapter);
+extern void Hal_SetCarrierSuppressionTx(_adapter * pAdapter, u8 bStart);
+extern void Hal_SetSingleToneTx ( _adapter * pAdapter , u8 bStart );
+extern void Hal_SetSingleCarrierTx (_adapter * pAdapter, u8 bStart);
+extern void Hal_SetContinuousTx (_adapter * pAdapter, u8 bStart);
+extern void Hal_SetBandwidth(_adapter * pAdapter);
+
+extern void Hal_SetDataRate(_adapter * pAdapter);
+extern void Hal_SetChannel(_adapter * pAdapter);
+extern void Hal_SetAntennaPathPower(_adapter * pAdapter);
+extern s32 Hal_SetThermalMeter(_adapter * pAdapter, u8 target_ther);
+extern s32 Hal_SetPowerTracking(_adapter * padapter, u8 enable);
+extern void Hal_GetPowerTracking(_adapter * padapter, u8 * enable);
+extern void Hal_GetThermalMeter(_adapter * pAdapter, u8 *value);
+extern void Hal_mpt_SwitchRfSetting(_adapter * pAdapter);
+extern void Hal_MPT_CCKTxPowerAdjust(_adapter * Adapter);
+extern void Hal_MPT_CCKTxPowerAdjustbyIndex(_adapter * pAdapter, BOOLEAN beven);
+extern void Hal_SetCCKTxPower(_adapter * pAdapter, u8 * TxPower);
+extern void Hal_SetOFDMTxPower(_adapter * pAdapter, u8 * TxPower);
+extern void Hal_TriggerRFThermalMeter(_adapter * pAdapter);
+extern u8 Hal_ReadRFThermalMeter(_adapter * pAdapter);
+extern void Hal_SetCCKContinuousTx(_adapter * pAdapter, u8 bStart);
+extern void Hal_SetOFDMContinuousTx(_adapter * pAdapter, u8 bStart);
+extern void Hal_ProSetCrystalCap (_adapter * pAdapter , u32 CrystalCapVal);
+extern void _rtw_mp_xmit_priv(struct xmit_priv *pxmitpriv);
+extern void MP_PHY_SetRFPathSwitch(_adapter * pAdapter ,BOOLEAN bMain);
+extern u32 mpt_ProQueryCalTxPower(_adapter * pAdapter, u8 RfPath);
+extern void MPT_PwrCtlDM(PADAPTER padapter, u32 bstart);
+
+#endif //_RTW_MP_H_
+

USDK/component/common/drivers/wlan/realtek/include/rtw_p2p.h

@@ -0,0 +1,58 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef _RTW_P2P_H_
+#define _RTW_P2P_H_
+
+#define P2P_WILDCARD_SSID "DIRECT-"
+#define P2P_WILDCARD_SSID_LEN 7
+
+#define P2P_SEND_ACTION_AFTER_PROBE_RSP 1
+
+#define RTW_P2P_SEND_ACTION_SUCCESS	0
+#define RTW_P2P_SEND_ACTION_FAILED		2
+
+static inline bool rtw_p2p_chk_state(struct wifidirect_info *wdinfo, enum P2P_STATE state)
+{
+	return wdinfo->p2p_state == state;
+}
+static inline bool rtw_p2p_chk_role(struct wifidirect_info *wdinfo, enum P2P_ROLE role)
+{
+	return wdinfo->role == role;
+}
+
+extern void rtw_p2p_remain_on_channel(_adapter *padapter, u8 channel, u8 wait_time);
+extern void rtw_p2p_cancel_remain_on_channel(_adapter *padapter);
+extern void rtw_p2p_special_scan_param(_adapter *padapter, u8 channel, u8 *mac);
+extern void rtw_p2p_set_p2p_role(_adapter *padapter, u32 role);
+extern void rtw_p2p_set_p2p_state(_adapter *padapter, u32 state);
+extern int rtw_p2p_send_mgnt(_adapter *padapter, u8 *data, u16 len, u16 flags);
+extern void rtw_p2p_indicate_mgnt(_adapter *padapter, u8 *data, u16 len, u8 channel);
+extern void rtw_indicate_sta_assoc(_adapter *padapter, u8 *addr, u8 *buf, u16 len);
+extern void rtw_p2p_indicate_sta_disassoc(_adapter *padapter, u8 *addr);
+extern void rtw_p2p_indicate_send_action_done(_adapter *padapter, u16 status);
+
+extern int rtw_p2p_init_mlme_ext(_adapter *padapter);
+extern void rtw_p2p_deinit_mlme_ext(_adapter *padapter);
+extern int rtw_init_p2p_wdinfo(_adapter *padapter);
+extern void rtw_deinit_p2p_wdinfo(_adapter *padapter);
+extern void rtw_p2p_pre_tx_scan_cmd_callback(_adapter *padapter);
+
+#endif //_RTW_P2P_H_
+

USDK/component/common/drivers/wlan/realtek/include/rtw_promisc.h

@@ -0,0 +1,38 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+
+#ifndef _RTW_PROMISC_H_
+#define _RTW_PROMISC_H_
+#include <drv_types.h>
+#ifdef CONFIG_PROMISC
+void promisc_deinit(_adapter *padapter);
+//void promisc_set_enable(_adapter *padapter, u8 enabled, u8 len_used);
+int promisc_recv_func(_adapter *padapter, union recv_frame *rframe);
+#endif
+int promisc_set(rtw_rcr_level_t enabled, void (*callback)(unsigned char*, unsigned int, void*), unsigned char len_used);
+unsigned char is_promisc_enabled(void);
+int promisc_get_fixed_channel(void * fixed_bssid, u8 * ssid, int *ssid_length);
+void promisc_issue_probereq(void);
+void promisc_issue_probersp(unsigned char *da);
+void promisc_stop_tx_beacn(void);
+void promisc_resume_tx_beacn(void);
+void promisc_get_ap_info(rtw_result_t (*func)(char *ssid, u8 ssid_len, s16 rssi, char channel, char security));
+#endif	//_RTW_PROMISC_H_
+

USDK/component/common/drivers/wlan/realtek/include/rtw_psk.h

@@ -0,0 +1,341 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+
+#ifndef _RTW_PSK_H_
+#define _RTW_PSK_H_
+
+#define GMK_LEN					32
+#define GTK_LEN					32
+#define PMK_LEN					32
+#define KEY_NONCE_LEN			32
+#define NumGroupKey				4
+#define KEY_RC_LEN				8
+#define KEY_IV_LEN				16
+#define KEY_RSC_LEN				8
+#define KEY_ID_LEN				8
+#define KEY_MIC_LEN				16
+#define KEY_MATERIAL_LEN		2
+#define PTK_LEN_EAPOLMIC        16
+#define PTK_LEN_EAPOLENC        16
+#define PTK_LEN_TKIP           	64
+#define PTK_LEN_CCMP            48
+#define LIB1X_ETHER_EAPOL_TYPE	0x888E
+
+#define DescTypePos				0
+#define KeyInfoPos				1
+#define KeyLenPos				3
+#define ReplayCounterPos		5
+#define KeyNoncePos				13
+#define KeyIVPos				45
+#define KeyRSCPos				61
+#define KeyIDPos				69
+#define KeyMICPos				77
+#define KeyDataLenPos			93
+#define KeyDataPos				95
+#define LIB1X_EAPOL_VER				1	//0000 0001B
+#define LIB1X_EAPOL_EAPPKT			0       //0000 0000B
+#define LIB1X_EAPOL_START			1	//0000 0001B
+#define LIB1X_EAPOL_LOGOFF			2       //0000 0010B
+#define LIB1X_EAPOL_KEY				3	//0000 0011B
+#define LIB1X_EAPOL_ENCASFALERT			4	//0000 0100B
+
+
+#define A_SHA_DIGEST_LEN		20
+#define ETHER_HDRLEN			14
+#define LIB1X_EAPOL_HDRLEN		4
+#define INFO_ELEMENT_SIZE       128
+#define MAX_EAPOLMSG_LEN        512
+#define MAX_EAPOLKEYMSG_LEN		(MAX_EAPOLMSG_LEN-(ETHER_HDRLEN+LIB1X_EAPOL_HDRLEN))
+#define EAPOLMSG_HDRLEN			95      //EAPOL-key payload length without KeyData
+#define WPA_ELEMENT_ID			0xDD
+#define WPA2_ELEMENT_ID			0x30
+
+#ifndef TRUE
+#define TRUE					1
+#endif
+#ifndef FALSE
+#define FALSE					0
+#endif
+
+#define ETHER_ADDRLEN					6
+#define PMK_EXPANSION_CONST				"Pairwise key expansion"
+#define PMK_EXPANSION_CONST_SIZE		22
+#define GMK_EXPANSION_CONST				"Group key expansion"
+#define GMK_EXPANSION_CONST_SIZE		19
+#define RANDOM_EXPANSION_CONST			"Init Counter"
+#define RANDOM_EXPANSION_CONST_SIZE		12
+
+#define	WLAN_REASON_MIC_FAILURE				14
+#define WLAN_REASON_4WAY_HANDSHAKE_TIMEOUT	15
+
+/*
+	2008-12-16, For Corega CG-WLCB54GL 54Mbps NIC interoperability issue.
+	The behavior of this NIC when it connect to the other AP with WPA/TKIP is:
+		AP	<----------------------> 	STA
+			....................
+			------------> Assoc Rsp (ok)
+			------------> EAPOL-key (4-way msg 1)
+			<------------ unknown TKIP encryption data
+			------------> EAPOL-key (4-way msg 1)
+			<------------ unknown TKIP encryption data
+			.....................
+			<------------ disassoc (code=8, STA is leaving) when the 5 seconds timer timeout counting from Assoc_Rsp is got.
+			....................
+			------------> Assoc Rsp (ok)
+			<-----------> EAPOL-key (4-way handshake success)
+
+	If MAX_RESEND_NUM=3, our AP will send disassoc (code=15, 4-way timeout) to STA before STA sending disassoc to AP.
+	And this NIC will always can not connect to our AP.
+	set MAX_RESEND_NUM=5 can fix this issue.
+ */
+//#define MAX_RESEND_NUM	3
+#define MAX_RESEND_NUM		5
+#define RESEND_TIME			1000
+
+#define GK_REKEY_TIME		3600000		//Set rekey period to 1 hour
+
+typedef enum {
+	desc_type_RSN	= 2,
+	desc_type_WPA	= 254
+} DescTypeRSN;
+
+typedef enum {
+	type_Group	= 0,
+	type_Pairwise	= 1
+} KeyType;
+
+typedef enum {
+	key_desc_ver1 	= 1,
+	key_desc_ver2 	= 2
+} KeyDescVer;
+
+enum {
+	PSK_WPA		= 1,
+	PSK_WPA2	= 2
+};
+
+enum {
+	PSK_STATE_IDLE,
+	PSK_STATE_PTKSTART,
+	PSK_STATE_PTKINITNEGOTIATING,
+	PSK_STATE_PTKINITDONE,
+};
+
+enum {
+	PSK_GSTATE_REKEYNEGOTIATING,
+	PSK_GSTATE_REKEYESTABLISHED,
+	PSK_GSTATE_KEYERROR,
+};
+
+typedef	struct _OCTET_STRING {
+	unsigned char	*Octet;
+	int		Length;
+} OCTET_STRING;
+
+typedef union _LARGE_INTEGER {
+	unsigned char 	charData[8];
+	struct {
+		unsigned long 	HighPart;
+		unsigned long 	LowPart;
+	} field;
+} LARGE_INTEGER, *PLARGE_INTEGER;
+
+typedef union _OCTET16_INTEGER {
+	unsigned char 	charData[16];
+	struct {
+		LARGE_INTEGER	HighPart;
+		LARGE_INTEGER	LowPart;
+	} field;
+} OCTET16_INTEGER;
+
+typedef union  _OCTET32_INTEGER {
+	unsigned char	charData[32];
+	struct {
+		OCTET16_INTEGER	HighPart;
+		OCTET16_INTEGER	LowPart;
+	} field;
+} OCTET32_INTEGER;
+
+// group key info
+typedef struct _wpa_global_info {
+	OCTET32_INTEGER		Counter;
+//Save PSK to global array
+//	unsigned char		PSK[A_SHA_DIGEST_LEN * 2];
+	int					GTKAuthenticator;
+	int					GKeyDoneStations;
+	int					GInitAKeys;
+	int					GUpdateStationKeys;
+	int					GkeyReady;
+	OCTET_STRING		AuthInfoElement;
+	unsigned char		AuthInfoBuf[INFO_ELEMENT_SIZE];
+	unsigned char		MulticastCipher;
+	OCTET_STRING		GNonce;
+	unsigned char		GNonceBuf[KEY_NONCE_LEN];
+	unsigned char		GTK[NumGroupKey][GTK_LEN];
+	unsigned char		GMK[GMK_LEN];
+	int					GN;
+	int					GM;
+	int					GTKRekey;
+#ifdef CONFIG_GK_REKEY
+	struct timer_list	GKRekeyTimer;
+#endif
+} WPA_GLOBAL_INFO;
+
+// wpa sta info
+typedef struct _wpa_sta_info {
+	int					state;
+	int					gstate;
+	int					RSNEnabled;		// bit0-WPA, bit1-WPA2
+	int					PInitAKeys;
+	unsigned char		UnicastCipher;
+	LARGE_INTEGER		CurrentReplayCounter;
+	LARGE_INTEGER		ReplayCounterStarted; // david+1-12-2007
+	OCTET_STRING		ANonce;
+	OCTET_STRING		SNonce;
+	unsigned char		AnonceBuf[KEY_NONCE_LEN];
+	unsigned char		SnonceBuf[KEY_NONCE_LEN];
+	unsigned char		PMK[PMK_LEN];
+ 	unsigned char		PTK[PTK_LEN_TKIP];
+	OCTET_STRING		EAPOLMsgRecvd;
+	OCTET_STRING		EAPOLMsgSend;
+	OCTET_STRING		EapolKeyMsgRecvd;
+	OCTET_STRING		EapolKeyMsgSend;
+	
+	unsigned char		eapSendBuf[MAX_EAPOLMSG_LEN];
+//	unsigned char		eapRecvdBuf[MAX_EAPOLMSG_LEN];
+	struct timer_list	resendTimer;
+	int					resendCnt;
+	int					clientHndshkProcessing;
+	int					clientHndshkDone;
+	int 				clientGkeyUpdate;
+	LARGE_INTEGER		clientMICReportReplayCounter;
+} WPA_STA_INFO;
+
+typedef struct _LIB1X_EAPOL_KEY
+{
+ 	unsigned char		key_desc_ver;
+ 	unsigned char		key_info[2];
+ 	unsigned char		key_len[2];
+ 	unsigned char		key_replay_counter[KEY_RC_LEN];
+ 	unsigned char		key_nounce[KEY_NONCE_LEN];
+ 	unsigned char		key_iv[KEY_IV_LEN];
+ 	unsigned char		key_rsc[KEY_RSC_LEN];
+ 	unsigned char		key_id[KEY_ID_LEN];
+ 	unsigned char		key_mic[KEY_MIC_LEN];
+ 	unsigned char		key_data_len[KEY_MATERIAL_LEN];
+ 	unsigned char		*key_data;
+} lib1x_eapol_key;
+
+struct lib1x_eapol
+{
+ 	unsigned char		protocol_version;
+ 	unsigned char		packet_type;			// This makes it odd in number !
+ 	unsigned short		packet_body_length;
+};
+
+struct wlan_ethhdr_t
+{
+	unsigned char		daddr[WLAN_ETHADDR_LEN];
+	unsigned char		saddr[WLAN_ETHADDR_LEN];
+	unsigned short		type;
+};
+
+typedef enum{
+        DOT11_PortStatus_Unauthorized,
+        DOT11_PortStatus_Authorized,
+        DOT11_PortStatus_Guest
+}DOT11_PORT_STATUS;
+
+#ifdef CONFIG_MOVE_PSK_TO_ROM
+static __inline__ OCTET_STRING SubStr(OCTET_STRING f, unsigned short s, unsigned short l)
+{
+	OCTET_STRING res;
+
+	res.Length = l;
+	res.Octet = f.Octet + s;
+
+	return res;
+}
+#endif
+
+#define SetSubStr(f,a,l)					memcpy(f.Octet+l,a.Octet,a.Length)
+#define GetKeyInfo0(f, mask) 				((f.Octet[KeyInfoPos + 1] & mask) ? 1 : 0)
+#define SetKeyInfo0(f,mask,b)				(f.Octet[KeyInfoPos + 1] = (f.Octet[KeyInfoPos + 1] & ~mask) | ( b?mask:0x0) )
+#define GetKeyInfo1(f, mask)				((f.Octet[KeyInfoPos] & mask) ? 1 : 0)
+#define SetKeyInfo1(f,mask,b)				(f.Octet[KeyInfoPos] = (f.Octet[KeyInfoPos] & ~mask) | ( b?mask:0x0) )
+
+// EAPOLKey
+#define Message_DescType(f)				(f.Octet[DescTypePos])
+#define Message_setDescType(f, type)		(f.Octet[DescTypePos] = type)
+// Key Information Filed
+#define Message_KeyDescVer(f)			(f.Octet[KeyInfoPos+1] & 0x07)
+#define Message_setKeyDescVer(f, v)		(f.Octet[KeyInfoPos+1] &= 0xf8) , f.Octet[KeyInfoPos+1] |= (v & 0x07)
+#define Message_KeyType(f)				GetKeyInfo0(f, 0x08)
+#define Message_setKeyType(f, b)			SetKeyInfo0(f,0x08,b)
+#define Message_KeyIndex(f)				((f.Octet[KeyInfoPos+1] & 0x30) >> 4) & 0x03
+#define Message_setKeyIndex(f, v)			(f.Octet[KeyInfoPos+1] &= 0xcf), f.Octet[KeyInfoPos+1] |= ((v<<4) & 0x30)
+#define Message_setInstall(f, b)			SetKeyInfo0(f,0x40,b)
+#define Message_setKeyAck(f, b)			SetKeyInfo0(f,0x80,b)
+
+#define Message_KeyMIC(f)				GetKeyInfo1(f, 0x01)
+#define Message_setKeyMIC(f, b)			SetKeyInfo1(f,0x01,b)
+#define Message_Secure(f)				GetKeyInfo1(f,0x02)
+#define Message_setSecure(f, b)			SetKeyInfo1(f,0x02,b)
+#define Message_Error(f)					GetKeyInfo1(f,0x04)
+#define Message_setError(f, b)				SetKeyInfo1(f,0x04,b)
+#define Message_Request(f)				GetKeyInfo1(f,0x08)
+#define Message_setRequest(f, b)			SetKeyInfo1(f,0x08,b)
+#define Message_setReserved(f, v)			(f.Octet[KeyInfoPos] |= (v<<4&0xff))
+#define Message_KeyLength(f)				((unsigned short)(f.Octet[KeyLenPos] <<8) + (unsigned short)(f.Octet[KeyLenPos+1]))
+#define Message_setKeyLength(f, v)		(f.Octet[KeyLenPos] = (v&0xff00) >>8 ,  f.Octet[KeyLenPos+1] = (v&0x00ff))
+
+#define Message_KeyNonce(f)				SubStr(f, KeyNoncePos, KEY_NONCE_LEN)
+#define Message_setKeyNonce(f, v)			SetSubStr(f, v, KeyNoncePos)
+#define Message_EqualKeyNonce(f1, f2)		memcmp(f1.Octet + KeyNoncePos, f2.Octet, KEY_NONCE_LEN)? 0:1
+#define Message_setKeyIV(f, v)			SetSubStr(f, v, KeyIVPos)
+#define Message_setKeyRSC(f, v)			SetSubStr(f, v, KeyRSCPos)
+#define Message_setKeyID(f, v)			SetSubStr(f, v, KeyIDPos)
+#define Message_setMIC(f, v)				SetSubStr(f, v, KeyMICPos)
+#define Message_KeyDataLength(f)			((unsigned short)(f.Octet[KeyDataLenPos] <<8) + (unsigned short)(f.Octet[KeyDataLenPos+1]))
+#define Message_setKeyDataLength(f, v)	(f.Octet[KeyDataLenPos] = (v&0xff00) >>8 ,  f.Octet[KeyDataLenPos+1] = (v&0x00ff))
+#define Message_setKeyData(f, v)			SetSubStr(f, v, KeyDataPos);
+
+#define Message_CopyReplayCounter(f1, f2)	memcpy(f1.Octet + ReplayCounterPos, f2.Octet + ReplayCounterPos, KEY_RC_LEN)
+#define Message_DefaultReplayCounter(li)	(((li.field.HighPart == 0xffffffff) && (li.field.LowPart == 0xffffffff) ) ?1:0)
+
+#define GET_MY_HWADDR(padapter)		((padapter)->eeprompriv.mac_addr)
+#define LargeIntegerOverflow(x)			(x.field.HighPart == 0xffffffff) && (x.field.LowPart == 0xffffffff)
+#define LargeIntegerZero(x)				memset(&x.charData, 0, 8)
+#define Octet16IntegerOverflow(x)			LargeIntegerOverflow(x.field.HighPart) && LargeIntegerOverflow(x.field.LowPart)
+#define Octet16IntegerZero(x)				memset(&x.charData, 0, 16)
+#define SetNonce(ocDst, oc32Counter)		SetEAPOL_KEYIV(ocDst, oc32Counter)
+
+void ClientSendEAPOL(_adapter *padapter, struct sta_info *psta, int resend);
+void SendEAPOL(_adapter *padapter, struct sta_info *psta, int resend);
+void EAPOLKeyRecvd(_adapter *padapter, struct sta_info *psta);
+void ClientEAPOLKeyRecvd(_adapter *padapter, struct sta_info *psta);
+void init_wpa_sta_info(_adapter *padapter, struct sta_info *psta);
+void psk_init(_adapter *padapter, unsigned char *pie, unsigned short ielen);
+void psk_derive(_adapter *padapter, unsigned char *passphrase, unsigned char *ssid);
+u16 psk_strip_rsn_pairwise(u8 *ie, u16 ie_len);
+u16 psk_strip_wpa_pairwise(u8 *ie, u16 ie_len);
+
+#endif // _RTW_PSK_H_
+

USDK/component/common/drivers/wlan/realtek/include/rtw_pwrctrl.h

@@ -0,0 +1,386 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef __RTW_PWRCTRL_H_
+#define __RTW_PWRCTRL_H_
+
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+#include <linux/earlysuspend.h>
+#endif //CONFIG_HAS_EARLYSUSPEND
+
+#define FW_PWR0		0	
+#define FW_PWR1 	1
+#define FW_PWR2 	2
+#define FW_PWR3 	3
+
+
+#define HW_PWR0		7	
+#define HW_PWR1 	6
+#define HW_PWR2 	2
+#define HW_PWR3		0
+#define HW_PWR4		8
+
+#define FW_PWRMSK	0x7
+
+
+#define XMIT_ALIVE	BIT(0)
+#define RECV_ALIVE	BIT(1)
+#define CMD_ALIVE	BIT(2)
+#define EVT_ALIVE	BIT(3)
+
+
+enum Power_Mgnt
+{
+	PS_MODE_ACTIVE	= 0	,
+	PS_MODE_MIN		,
+	PS_MODE_MAX		,
+	PS_MODE_DTIM		,
+	PS_MODE_VOIP		,
+	PS_MODE_UAPSD_WMM	,
+	PS_MODE_UAPSD		,
+	PS_MODE_IBSS		,
+	PS_MODE_WWLAN		,
+	PM_Radio_Off		,
+	PM_Card_Disable		,
+	PS_MODE_NUM
+};
+
+
+/*
+	BIT[2:0] = HW state
+	BIT[3] = Protocol PS state,   0: register active state , 1: register sleep state
+	BIT[4] = sub-state
+*/
+
+#define PS_DPS				BIT(0)
+#define PS_LCLK				(PS_DPS)
+#define PS_RF_OFF			BIT(1)
+#define PS_ALL_ON			BIT(2)
+#define PS_ST_ACTIVE		BIT(3)
+
+#define PS_ISR_ENABLE		BIT(4)
+#define PS_IMR_ENABLE		BIT(5)
+#define PS_ACK				BIT(6)
+#define PS_TOGGLE			BIT(7)
+
+#define PS_STATE_MASK		(0x0F)
+#define PS_STATE_HW_MASK	(0x07)
+#define PS_SEQ_MASK			(0xc0)
+
+#define PS_STATE(x)		(PS_STATE_MASK & (x))
+#define PS_STATE_HW(x)	(PS_STATE_HW_MASK & (x))
+#define PS_SEQ(x)		(PS_SEQ_MASK & (x))
+
+#define PS_STATE_S0		(PS_DPS)
+#define PS_STATE_S1		(PS_LCLK)
+#define PS_STATE_S2		(PS_RF_OFF)
+#define PS_STATE_S3		(PS_ALL_ON)
+#define PS_STATE_S4		((PS_ST_ACTIVE) | (PS_ALL_ON))
+
+
+#define PS_IS_RF_ON(x)	((x) & (PS_ALL_ON))
+#define PS_IS_ACTIVE(x)	((x) & (PS_ST_ACTIVE))
+#define CLR_PS_STATE(x)	((x) = ((x) & (0xF0)))
+
+
+struct reportpwrstate_parm {
+	unsigned char mode;
+	unsigned char state; //the CPWM value
+	unsigned short rsvd;
+}; 
+
+
+typedef _sema _pwrlock;
+
+
+__inline static void _init_pwrlock(_pwrlock *plock)
+{
+	rtw_init_sema(plock, 1);
+}
+
+__inline static void _free_pwrlock(_pwrlock *plock)
+{
+	rtw_free_sema(plock);
+}
+
+
+__inline static void _enter_pwrlock(_pwrlock *plock)
+{
+	rtw_down_sema(plock);
+}
+
+
+__inline static void _exit_pwrlock(_pwrlock *plock)
+{
+	rtw_up_sema(plock);
+}
+
+#define LPS_DELAY_TIME	1 // 1 sec
+
+#define EXE_PWR_NONE	0x01
+#define EXE_PWR_IPS		0x02
+#define EXE_PWR_LPS		0x04
+
+// RF state.
+typedef enum _rt_rf_power_state
+{
+	rf_on,		// RF is on after RFSleep or RFOff
+	rf_sleep,	// 802.11 Power Save mode
+	rf_off,		// HW/SW Radio OFF or Inactive Power Save
+	//=====Add the new RF state above this line=====//
+	rf_max
+}rt_rf_power_state;
+
+// RF Off Level for IPS or HW/SW radio off
+#define	RT_RF_OFF_LEVL_ASPM			BIT(0)	// PCI ASPM
+#define	RT_RF_OFF_LEVL_CLK_REQ		BIT(1)	// PCI clock request
+#define	RT_RF_OFF_LEVL_PCI_D3			BIT(2)	// PCI D3 mode
+#define	RT_RF_OFF_LEVL_HALT_NIC		BIT(3)	// NIC halt, re-initialize hw parameters
+#define	RT_RF_OFF_LEVL_FREE_FW		BIT(4)	// FW free, re-download the FW
+#define	RT_RF_OFF_LEVL_FW_32K		BIT(5)	// FW in 32k
+#define	RT_RF_PS_LEVEL_ALWAYS_ASPM	BIT(6)	// Always enable ASPM and Clock Req in initialization.
+#define	RT_RF_LPS_DISALBE_2R			BIT(30)	// When LPS is on, disable 2R if no packet is received or transmittd.
+#define	RT_RF_LPS_LEVEL_ASPM			BIT(31)	// LPS with ASPM
+
+#define	RT_IN_PS_LEVEL(ppsc, _PS_FLAG)		((ppsc->cur_ps_level & _PS_FLAG) ? _TRUE : _FALSE)
+#define	RT_CLEAR_PS_LEVEL(ppsc, _PS_FLAG)	(ppsc->cur_ps_level &= (~(_PS_FLAG)))
+#define	RT_SET_PS_LEVEL(ppsc, _PS_FLAG)		(ppsc->cur_ps_level |= _PS_FLAG)
+
+
+enum _PS_BBRegBackup_ {
+	PSBBREG_RF0 = 0,
+	PSBBREG_RF1,
+	PSBBREG_RF2,
+	PSBBREG_AFE0,
+	PSBBREG_TOTALCNT
+};
+
+enum { // for ips_mode
+	IPS_NONE=0,
+	IPS_NORMAL,
+	IPS_LEVEL_2,
+	IPS_NUM
+};
+
+struct pwrctrl_priv
+{
+	_pwrlock	lock;
+	volatile u8 rpwm; // requested power state for fw
+	volatile u8 cpwm; // fw current power state. updated when 1. read from HCPWM 2. driver lowers power level
+	volatile u8 tog; // toggling
+	volatile u8 cpwm_tog; // toggling
+
+	u8	pwr_mode;
+	u8	smart_ps;
+	u8	bcn_ant_mode;
+
+	u32	alives;
+	u64  wowlan_fw_iv;
+//TODO
+//	_workitem cpwm_event;
+#ifdef CONFIG_LPS_RPWM_TIMER
+	u8 brpwmtimeout;
+	_workitem rpwmtimeoutwi;
+	_timer pwr_rpwm_timer;
+#endif // CONFIG_LPS_RPWM_TIMER
+	u8	bpower_saving;
+
+	u8	b_hw_radio_off;
+	u8	reg_rfoff;
+	u8	reg_pdnmode; //powerdown mode
+	u32	rfoff_reason;
+
+	//RF OFF Level
+	u32	cur_ps_level;
+	u32	reg_rfps_level;
+
+
+
+#if defined(CONFIG_PCI_HCI) || defined(CONFIG_LX_HCI)
+	//just for PCIE ASPM
+	u8	b_support_aspm; // If it supports ASPM, Offset[560h] = 0x40, otherwise Offset[560h] = 0x00. 
+	u8	b_support_backdoor;
+
+	//just for PCIE ASPM
+	u8	const_amdpci_aspm;
+#endif
+
+	uint 	ips_enter_cnts;
+	uint 	ips_leave_cnts;
+
+	u8	ps_enable;
+	u8	ips_mode; 
+	u8	ips_org_mode; 
+	u8	ips_mode_req; // used to accept the mode setting request, will update to ipsmode later
+	uint bips_processing;
+	u32 ips_deny_time; /* will deny IPS when system time is smaller than this */
+	u8 ps_processing; /* temporarily used to mark whether in rtw_ps_processor */
+
+	u8	bLeisurePs;
+	u8	LpsIdleCount;
+	u8	power_mgnt;
+	u8	org_power_mgnt;
+	u8	bFwCurrentInPSMode;
+	u32	DelayLPSLastTimeStamp;
+	u8 	btcoex_rfon;
+	s32		pnp_current_pwr_state;
+	u8		pnp_bstop_trx;
+
+
+	u8		bInternalAutoSuspend;
+	u8		bInSuspend;
+#ifdef	CONFIG_BT_COEXIST
+	u8		bAutoResume;
+	u8		autopm_cnt;
+#endif
+	u8		bSupportRemoteWakeup;	
+#ifdef CONFIG_WOWLAN
+	u8      wowlan_txpause_status;
+	u8		wowlan_mode;
+	u8		wowlan_pattern;
+	u8		wowlan_magic;
+	u8		wowlan_unicast;
+	u8		wowlan_pattern_idx;
+	u8		wowlan_wake_reason;
+	u32		wowlan_pattern_context[8][5];
+#endif // CONFIG_WOWLAN
+	_timer 	pwr_state_check_timer;
+	int		pwr_state_check_interval;
+	u8		pwr_state_check_cnts;
+
+	int 		ps_flag;
+	
+	rt_rf_power_state	rf_pwrstate;//cur power state
+	//rt_rf_power_state 	current_rfpwrstate;
+	rt_rf_power_state	change_rfpwrstate;
+
+	u8		wepkeymask;
+	u8		bHWPowerdown;//if support hw power down
+	u8		bHWPwrPindetect;
+	u8		bkeepfwalive;		
+	u8		brfoffbyhw;
+	unsigned long PS_BBRegBackup[PSBBREG_TOTALCNT];
+
+	#ifdef CONFIG_RESUME_IN_WORKQUEUE
+	struct workqueue_struct *rtw_workqueue;
+	_workitem resume_work;
+	#endif
+
+	#ifdef CONFIG_HAS_EARLYSUSPEND
+	struct early_suspend early_suspend;
+	u8 do_late_resume;
+	#endif //CONFIG_HAS_EARLYSUSPEND
+	
+	#ifdef CONFIG_ANDROID_POWER
+	android_early_suspend_t early_suspend;
+	u8 do_late_resume;
+	#endif
+
+	#ifdef CONFIG_INTEL_PROXIM
+	u8	stored_power_mgnt;
+	#endif
+
+	#ifdef TDMA_POWER_SAVING
+	u8	tdma_slot_period;
+    u8	tdma_rfon_period_len_1;
+    u8	tdma_rfon_period_len_2;
+    u8	tdma_rfon_period_len_3;
+	#endif
+
+	u8	lps_dtim;
+};
+
+#define rtw_get_ips_mode_req(pwrctrlpriv) \
+	(pwrctrlpriv)->ips_mode_req
+
+#define rtw_ips_mode_req(pwrctrlpriv, ips_mode) \
+	(pwrctrlpriv)->ips_mode_req = (ips_mode)
+
+#define RTW_PWR_STATE_CHK_INTERVAL 2000
+
+#define _rtw_set_pwr_state_check_timer(pwrctrlpriv, ms) \
+	do { \
+		/*DBG_871X("%s _rtw_set_pwr_state_check_timer(%p, %d)\n", __FUNCTION__, (pwrctrlpriv), (ms));*/ \
+		rtw_set_timer(&(pwrctrlpriv)->pwr_state_check_timer, (ms)); \
+	} while(0)
+	
+#define rtw_set_pwr_state_check_timer(pwrctrlpriv) \
+	_rtw_set_pwr_state_check_timer((pwrctrlpriv), (pwrctrlpriv)->pwr_state_check_interval)
+
+extern void rtw_init_pwrctrl_priv(_adapter *adapter);
+extern void rtw_free_pwrctrl_priv(_adapter * adapter);
+
+#ifdef CONFIG_LPS_LCLK
+extern s32 rtw_register_tx_alive(PADAPTER padapter);
+extern void rtw_unregister_tx_alive(PADAPTER padapter);
+extern s32 rtw_register_rx_alive(PADAPTER padapter);
+extern void rtw_unregister_rx_alive(PADAPTER padapter);
+extern s32 rtw_register_cmd_alive(PADAPTER padapter);
+extern void rtw_unregister_cmd_alive(PADAPTER padapter);
+extern s32 rtw_register_evt_alive(PADAPTER padapter);
+extern void rtw_unregister_evt_alive(PADAPTER padapter);
+extern void cpwm_int_hdl(PADAPTER padapter, struct reportpwrstate_parm *preportpwrstate);
+extern void LPS_Leave_check(PADAPTER padapter);
+#endif
+
+extern void rtw_set_ps_mode(PADAPTER padapter, u8 ps_mode, u8 smart_ps, u8 bcn_ant_mode);
+extern void rtw_set_rpwm(_adapter * padapter, u8 val8);
+extern void LeaveAllPowerSaveMode(PADAPTER Adapter);
+#ifdef CONFIG_IPS
+void ips_enter(_adapter * padapter);
+int ips_leave(_adapter * padapter);
+#endif
+
+void rtw_ps_processor(_adapter*padapter);
+
+#ifdef CONFIG_AUTOSUSPEND
+int autoresume_enter(_adapter* padapter);
+#endif
+#ifdef SUPPORT_HW_RFOFF_DETECTED
+rt_rf_power_state RfOnOffDetect(IN	PADAPTER pAdapter );
+#endif
+
+
+#ifdef CONFIG_LPS
+s32 LPS_RF_ON_check(PADAPTER padapter, u32 delay_ms);
+void LPS_Enter(PADAPTER padapter);
+void LPS_Leave(PADAPTER padapter);
+#endif
+
+#ifdef CONFIG_RESUME_IN_WORKQUEUE
+void rtw_resume_in_workqueue(struct pwrctrl_priv *pwrpriv);
+#endif //CONFIG_RESUME_IN_WORKQUEUE
+
+#if defined(CONFIG_HAS_EARLYSUSPEND ) || defined(CONFIG_ANDROID_POWER)
+#define rtw_is_earlysuspend_registered(pwrpriv) (pwrpriv)->early_suspend.suspend
+void rtw_register_early_suspend(struct pwrctrl_priv *pwrpriv);
+void rtw_unregister_early_suspend(struct pwrctrl_priv *pwrpriv);
+#endif //CONFIG_HAS_EARLYSUSPEND || CONFIG_ANDROID_POWER
+//TODO
+//u8 rtw_interface_ps_func(_adapter *padapter,HAL_INTF_PS_FUNC efunc_id,u8* val);
+int _rtw_pwr_wakeup(_adapter *padapter, u32 ips_deffer_ms, const char *caller);
+#define rtw_pwr_wakeup(adapter) _rtw_pwr_wakeup(adapter, RTW_PWR_STATE_CHK_INTERVAL, __FUNCTION__)
+int rtw_pm_set_ips(_adapter *padapter, u8 mode);
+int rtw_pm_set_lps(_adapter *padapter, u8 mode);
+int rtw_pm_set_tdma_param(_adapter *padapter, u8 tdma_slot_period, u8 tdma_rfon_period_len_1, u8 tdma_rfon_period_len_2, u8 tdma_rfon_period_len_3);
+int rtw_pm_set_lps_dtim(_adapter *padapter, u8 lps_dtim);
+u8 rtw_pm_get_lps_dtim(_adapter *padapter);
+#endif  //__RTL871X_PWRCTRL_H_
+

USDK/component/common/drivers/wlan/realtek/include/rtw_qos.h

@@ -0,0 +1,33 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+
+
+#ifndef _RTW_QOS_H_
+#define _RTW_QOS_H_
+
+struct	qos_priv	{
+	
+	u32	  qos_option;	//bit mask option: u-apsd, s-apsd, ts, block ack...		
+
+};
+
+
+#endif	//_RTL871X_QOS_H_
+

USDK/component/common/drivers/wlan/realtek/include/rtw_recv.h

@@ -0,0 +1,918 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
+ *                                        
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * 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, USA
+ *
+ *
+ ******************************************************************************/
+#ifndef _RTW_RECV_H_
+#define _RTW_RECV_H_
+#include <hal_pg.h>
+
+#if defined(PLATFORM_ECOS)
+#define NR_RECVFRAME 16	//Decrease recv frame due to memory limitation - Alex Fang
+#elif defined(PLATFORM_FREERTOS) || defined (PLATFORM_CMSIS_RTOS)
+#ifdef CONFIG_RECV_REORDERING_CTRL
+#define NR_RECVFRAME 16	//Increase recv frame due to rx reorder - Andy Sun
+#else
+#if WIFI_LOGO_CERTIFICATION
+    #define NR_RECVFRAME 8	//Decrease recv frame due to memory limitation - Alex Fang
+#else
+#ifndef CONFIG_HIGH_TP
+    #define NR_RECVFRAME 2	//Decrease recv frame due to memory limitation - YangJue
+#else
+    #define NR_RECVFRAME 256
+#endif
+#endif
+#endif
+#else
+#define NR_RECVFRAME 256
+#endif
+
+#ifdef PLATFORM_OS_XP
+	#define NR_RECVBUFF (16)
+#elif defined(PLATFORM_OS_CE)
+	#define NR_RECVBUFF (4)
+#elif defined(PLATFORM_FREERTOS) || defined (PLATFORM_CMSIS_RTOS)
+#ifndef CONFIG_HIGH_TP
+//	#define NR_RECVBUFF (8)	//Decrease recv buffer due to memory limitation - Alex Fang
+	#define NR_RECVBUFF (1)	//Decrease recv buffer due to memory limitation - YangJue
+#else
+	#define NR_RECVBUFF (32)
+#endif
+#else
+	#if (defined CONFIG_GSPI_HCI || defined CONFIG_SDIO_HCI)
+		#define NR_RECVBUFF (32)
+	#else
+		#define NR_RECVBUFF (4)
+	#endif
+
+	#define NR_PREALLOC_RECV_SKB (8)
+#endif
+
+#define RECV_BULK_IN_ADDR		0x80
+#define RECV_INT_IN_ADDR		0x81
+
+#define PHY_RSSI_SLID_WIN_MAX			100
+#define PHY_LINKQUALITY_SLID_WIN_MAX		20
+
+// Rx smooth factor
+#define Rx_Smooth_Factor (20)
+
+#define RXFRAME_ALIGN	8
+#define RXFRAME_ALIGN_SZ	(1<<RXFRAME_ALIGN)
+
+#define DRVINFO_SZ	4 // unit is 8bytes
+
+#define MAX_RXFRAME_CNT	512
+#define MAX_RX_NUMBLKS		(32)
+#define RECVFRAME_HDR_ALIGN 128
+
+#define SNAP_SIZE sizeof(struct ieee80211_snap_hdr)
+
+#define RX_MPDU_QUEUE				0
+#define RX_CMD_QUEUE				1
+#define RX_MAX_QUEUE				2
+
+#define MAX_SUBFRAME_COUNT	64
+
+//for Rx reordering buffer control
+struct recv_reorder_ctrl
+{
+	_adapter	*padapter;
+	u8 enable;
+	u16 indicate_seq;//=wstart_b, init_value=0xffff
+	u16 wend_b;
+	u8 wsize_b;
+	_queue pending_recvframe_queue;
+	_timer reordering_ctrl_timer;
+};
+
+struct	stainfo_rxcache	{
+	u16 	tid_rxseq[16];
+/*
+	unsigned short 	tid0_rxseq;
+	unsigned short 	tid1_rxseq;
+	unsigned short 	tid2_rxseq;
+	unsigned short 	tid3_rxseq;
+	unsigned short 	tid4_rxseq;
+	unsigned short 	tid5_rxseq;
+	unsigned short 	tid6_rxseq;
+	unsigned short 	tid7_rxseq;
+	unsigned short 	tid8_rxseq;
+	unsigned short 	tid9_rxseq;
+	unsigned short 	tid10_rxseq;
+	unsigned short 	tid11_rxseq;
+	unsigned short 	tid12_rxseq;
+	unsigned short 	tid13_rxseq;
+	unsigned short 	tid14_rxseq;
+	unsigned short 	tid15_rxseq;
+*/
+};
+
+struct smooth_rssi_data {
+	u32	elements[100];	//array to store values
+	u32	index;			//index to current array to store
+	u32	total_num;		//num of valid elements
+	u32	total_val;		//sum of valid elements
+};
+
+struct signal_stat {
+	u8	update_req;		//used to indicate 
+	u8	avg_val;		//avg of valid elements
+	u32	total_num;		//num of valid elements
+	u32	total_val;		//sum of valid elements	
+};
+
+
+#if (RTL8195A_SUPPORT==1)
+/* struct phy_info must be same with ODM ODM_PHY_INFO_T, see rtl8195a_query_rx_phy_status() */
+struct phy_info
+{
+	u8		RxPWDBAll;
+	u8		SignalQuality;	 						// in 0-100 index. 
+	u8		RxMIMOSignalStrength[MAX_RF_PATH];		// in 0~100 index
+	s8		RecvSignalPower;						// Real power in dBm for this packet, no beautification and aggregation. Keep this raw info to be used for the other procedures.
+	u8		SignalStrength; 						// in 0-100 index.
+	#if ((RTL8195A_SUPPORT == 0) && (RTL8711B_SUPPORT == 0))
+		s8		RxMIMOSignalQuality[MAX_RF_PATH];	// per-path's EVM
+		s8		RxPower;							// in dBm Translate from PWdB
+		u8		BTRxRSSIPercentage; 
+		s8		RxPwr[MAX_RF_PATH];				// per-path's pwdb
+		u8		RxSNR[MAX_RF_PATH];				// per-path's SNR	
+		u8		btCoexPwrAdjust;
+	#endif
+	#if (ODM_IC_11AC_SERIES_SUPPORT)
+		u8		RxMIMOEVMdbm[MAX_RF_PATH];		// per-path's EVM dbm
+		s16		Cfo_short[MAX_RF_PATH]; 		// per-path's Cfo_short
+		s16		Cfo_tail[MAX_RF_PATH];			// per-path's Cfo_tail
+		u8		BandWidth;
+	#endif
+};
+#elif(RTL8188F_SUPPORT == 1)
+struct phy_info
+{
+	u8		RxPWDBAll;
+
+	u8		SignalQuality;	 // in 0-100 index.
+	s8		RxMIMOSignalQuality[MAX_RF_PATH];	//per-path's EVM
+	u8		RxMIMOEVMdbm[MAX_RF_PATH]; 		//per-path's EVM dbm
+	u8		RxMIMOSignalStrength[MAX_RF_PATH];// in 0~100 index
+	u16		Cfo_short[MAX_RF_PATH]; 			// per-path's Cfo_short
+	u16		Cfo_tail[MAX_RF_PATH];			// per-path's Cfo_tail
+
+	s8		RxPower; // in dBm Translate from PWdB
+	s8		RecvSignalPower;// Real power in dBm for this packet, no beautification and aggregation. Keep this raw info to be used for the other procedures.
+	u8		BTRxRSSIPercentage;
+	u8		SignalStrength; // in 0-100 index.
+	s8		RxPwr[MAX_RF_PATH];				//per-path's pwdb
+	u8		RxSNR[MAX_RF_PATH];				//per-path's SNR
+	u8		BandWidth;
+	u8		btCoexPwrAdjust;
+};
+#elif(RTL8711B_SUPPORT == 1)
+struct phy_info
+{
+	u8		RxPWDBAll;
+	
+	u8		SignalQuality;				/* in 0-100 index. */
+	s8		RxMIMOSignalQuality[4];		/* per-path's EVM */
+	u8		RxMIMOEVMdbm[4];			/* per-path's EVM dbm */
+	u8		RxMIMOSignalStrength[4];	/* in 0~100 index */
+	s16		Cfo_short[4];				/* per-path's Cfo_short */
+	s16		Cfo_tail[4];					/* per-path's Cfo_tail */
+	s8		RxPower;					/* in dBm Translate from PWdB */
+	s8		RecvSignalPower;			/* Real power in dBm for this packet, no beautification and aggregation. Keep this raw info to be used for the other procedures. */
+	u8		BTRxRSSIPercentage;
+	u8		SignalStrength;				/* in 0-100 index. */
+	s8		RxPwr[4];					/* per-path's pwdb */
+	s8		RxSNR[4];					/* per-path's SNR	*/
+	u8		RxCount:2;					/* RX path counter---*/
+	u8		BandWidth:2;
+	u8		rxsc:4;						/* sub-channel---*/
+	u8		btCoexPwrAdjust;
+	u8		channel;						/* channel number---*/
+	u8		bMuPacket;					/* is MU packet or not---*/
+	u8		bBeamformed;				/* BF packet---*/
+};
+#else
+#define MAX_PATH_NUM_92CS		2
+struct phy_info //ODM_PHY_INFO_T
+{	
+	u8		RxPWDBAll;	
+	u8		SignalQuality;	 // in 0-100 index. 
+	u8		RxMIMOSignalQuality[MAX_PATH_NUM_92CS]; //EVM
+	u8		RxMIMOSignalStrength[MAX_PATH_NUM_92CS];// in 0~100 index
+	s8		RxPower; // in dBm Translate from PWdB
+	s8		RecvSignalPower;// Real power in dBm for this packet, no beautification and aggregation. Keep this raw info to be used for the other procedures.
+	u8		BTRxRSSIPercentage;	
+	u8		SignalStrength; // in 0-100 index.
+	u8		RxPwr[MAX_PATH_NUM_92CS];//per-path's pwdb
+	u8		RxSNR[MAX_PATH_NUM_92CS];//per-path's SNR
+};
+#endif
+
+struct rx_pkt_attrib	{
+	u16	pkt_len;
+	u8	physt;
+	u8	drvinfo_sz;
+	u8	shift_sz;
+	u8	hdrlen; //the WLAN Header Len
+	u8 	to_fr_ds;
+	u8 	amsdu;
+	u8	qos;
+	u8	priority;
+	u8	pw_save;
+	u8	mdata;
+	u16	seq_num;
+	u8	frag_num;
+	u8	mfrag;
+	u8	order;
+	u8	privacy; //in frame_ctrl field
+	u8	bdecrypted;
+	u8	encrypt; //when 0 indicate no encrypt. when non-zero, indicate the encrypt algorith
+	u8	iv_len;
+	u8	icv_len;
+	u8	crc_err;
+	u8	icv_err;
+
+	u16 eth_type;
+
+	u8 	dst[ETH_ALEN];
+	u8 	src[ETH_ALEN];
+	u8 	ta[ETH_ALEN];
+	u8 	ra[ETH_ALEN];
+	u8 	bssid[ETH_ALEN];
+	
+	u8 ack_policy;
+	
+//#ifdef CONFIG_TCP_CSUM_OFFLOAD_RX
+	u8	tcpchk_valid; // 0: invalid, 1: valid
+	u8	ip_chkrpt; //0: incorrect, 1: correct
+	u8	tcp_chkrpt; //0: incorrect, 1: correct
+//#endif
+	u8 	key_index;
+
+	u8	mcs_rate;
+	u8	rxht;
+	u8 	sgi;
+	u8 	pkt_rpt_type;
+	u32	MacIDValidEntry[2];	// 64 bits present 64 entry.
+
+
+	u8   data_rate;
+/*
+	u8	signal_qual;
+	s8	rx_mimo_signal_qual[2];
+	u8	signal_strength;
+	u32	RxPWDBAll;	
+	s32	RecvSignalPower;
+*/
+	struct phy_info phy_info;	
+};
+
+//These definition is used for Rx packet reordering.
+#define SN_LESS(a, b)		(((a-b)&0x800)!=0)
+#define SN_EQUAL(a, b)	(a == b)
+//#define REORDER_WIN_SIZE	128
+//#define REORDER_ENTRY_NUM	128
+#define REORDER_WAIT_TIME	(30) // (ms)
+
+#define RECVBUFF_ALIGN_SZ 8
+
+#define RXDESC_SIZE	24
+#define RXDESC_OFFSET RXDESC_SIZE
+
+struct recv_stat
+{
+	unsigned int rxdw0;
+
+	unsigned int rxdw1;
+
+	unsigned int rxdw2;
+
+	unsigned int rxdw3;
+
+	unsigned int rxdw4;
+
+	unsigned int rxdw5;
+
+#ifdef CONFIG_PCI_HCI
+	unsigned int rxdw6;
+
+	unsigned int rxdw7;
+#endif
+};
+
+
+struct recv_buf_stat {
+	unsigned int rxdw0;
+
+	unsigned int rxdw1;
+};
+
+#define EOR BIT(30)
+
+#if defined(CONFIG_LX_HCI)
+#define LX_MAX_RX_QUEUE		1// MSDU packet queue, Rx Command Queue
+#define LX_MAX_RX_COUNT		4//RX_Q_DESC_NUM// 128
+
+struct rtw_rx_ring {
+#if ((RTL8195A_SUPPORT ==1) ||(RTL8711B_SUPPORT == 1))
+	struct recv_buf_stat	*desc;
+#else
+	struct recv_stat	*desc;
+#endif
+
+	dma_addr_t		dma;
+	unsigned int		idx;
+	struct sk_buff	*rx_buf[LX_MAX_RX_COUNT];
+};
+#endif
+
+
+/*
+accesser of recv_priv: rtw_recv_entry(dispatch / passive level); recv_thread(passive) ; returnpkt(dispatch)
+; halt(passive) ;
+
+using enter_critical section to protect
+*/
+struct recv_priv
+{
+	_lock	lock;
+
+	//_queue	blk_strms[MAX_RX_NUMBLKS];    // keeping the block ack frame until return ack
+	_queue	free_recv_queue;
+	_queue	recv_pending_queue;
+	_queue	uc_swdec_pending_queue;
+
+
+	u8 *pallocated_frame_buf;
+	u8 *precv_frame_buf;
+
+	uint free_recvframe_cnt;
+
+	_adapter	*adapter;
+
+#ifdef PLATFORM_WINDOWS
+	_nic_hdl  RxPktPoolHdl;
+	_nic_hdl  RxBufPoolHdl;
+
+#ifdef PLATFORM_OS_XP
+	PMDL	pbytecnt_mdl;
+#endif
+	uint	counter; //record the number that up-layer will return to drv; only when counter==0 can we  release recv_priv
+	NDIS_EVENT 	recv_resource_evt ;
+#endif
+
+	u32	bIsAnyNonBEPkts;
+	u64	rx_bytes;
+	u64	rx_pkts;
+	u64	rx_drop;
+	u64 rx_overflow;
+	u64	last_rx_bytes;
+
+	uint  rx_icv_err;
+	uint  rx_largepacket_crcerr;
+	uint  rx_smallpacket_crcerr;
+	uint  rx_middlepacket_crcerr;
+
+#ifdef CONFIG_USB_HCI
+	//u8 *pallocated_urb_buf;
+	_sema allrxreturnevt;
+	uint	ff_hwaddr;
+	u8	rx_pending_cnt;
+
+#ifdef CONFIG_USB_INTERRUPT_IN_PIPE
+#ifdef PLATFORM_LINUX
+	PURB	int_in_urb;
+#endif
+
+	u8	*int_in_buf;
+#endif //CONFIG_USB_INTERRUPT_IN_PIPE
+
+#endif
+#if defined(PLATFORM_LINUX) || defined(PLATFORM_FREEBSD)
+#ifdef PLATFORM_FREEBSD
+	struct task irq_prepare_beacon_tasklet;
+	struct task recv_tasklet;
+#else //PLATFORM_FREEBSD
+	struct tasklet_struct irq_prepare_beacon_tasklet;
+	struct tasklet_struct recv_tasklet;
+#endif //PLATFORM_FREEBSD
+	struct sk_buff_head free_recv_skb_queue;
+	struct sk_buff_head rx_skb_queue;
+#ifdef CONFIG_RX_INDICATE_QUEUE
+	struct task rx_indicate_tasklet;
+	struct ifqueue rx_indicate_queue;
+#endif	// CONFIG_RX_INDICATE_QUEUE
+
+#ifdef CONFIG_USE_USB_BUFFER_ALLOC_RX
+	_queue	recv_buf_pending_queue;
+#endif	// CONFIG_USE_USB_BUFFER_ALLOC_RX
+#endif //defined(PLATFORM_LINUX) || defined(PLATFORM_FREEBSD)
+
+	u8 *pallocated_recv_buf;
+	u8 *precv_buf;    // 4 alignment
+	_queue	free_recv_buf_queue;
+	u32	free_recv_buf_queue_cnt;
+
+#if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
+	_queue	recv_buf_pending_queue;
+#endif
+
+#if defined(CONFIG_PCI_HCI) || defined(CONFIG_LX_HCI)
+	// Rx
+	struct rtw_rx_ring	rx_ring[LX_MAX_RX_QUEUE];
+	int 	rxringcount;
+	u16	rxbuffersize;
+#endif
+
+	//For display the phy informatiom
+	u8 is_signal_dbg;	// for debug
+	u8 signal_strength_dbg;	// for debug
+	s8 rssi;
+	s8 rxpwdb;
+	u8 signal_strength;
+	u8 signal_qual;
+	u8 noise;
+	int RxSNRdB[2];
+	s8 RxRssi[2];
+	int FalseAlmCnt_all;
+
+#ifdef CONFIG_NEW_SIGNAL_STAT_PROCESS
+	_timer signal_stat_timer;
+	u32 signal_stat_sampling_interval;
+	//u32 signal_stat_converging_constant;
+	struct signal_stat signal_qual_data;
+	struct signal_stat signal_strength_data;
+#else //CONFIG_NEW_SIGNAL_STAT_PROCESS
+	struct smooth_rssi_data signal_qual_data;
+	struct smooth_rssi_data signal_strength_data;
+#endif //CONFIG_NEW_SIGNAL_STAT_PROCESS
+
+#ifdef CONFIG_PROMISC
+	u8 promisc_enabled;
+	u8 promisc_len_used;
+	_list promisc_list;
+	_lock promisc_lock;
+	u32 promisc_bk_rcr;
+	u16 promisc_bk_rxfltmap2;
+	u8 promisc_mgntframe_enabled;
+#endif
+};
+
+#ifdef CONFIG_NEW_SIGNAL_STAT_PROCESS
+#define rtw_set_signal_stat_timer(recvpriv) rtw_set_timer(&(recvpriv)->signal_stat_timer, (recvpriv)->signal_stat_sampling_interval)
+#endif //CONFIG_NEW_SIGNAL_STAT_PROCESS
+
+struct sta_recv_priv {
+
+	_lock	lock;
+	sint	option;
+
+	//_queue	blk_strms[MAX_RX_NUMBLKS];
+	_queue defrag_q;	 //keeping the fragment frame until defrag
+
+	struct	stainfo_rxcache rxcache;
+
+	//uint	sta_rx_bytes;
+	//uint	sta_rx_pkts;
+	//uint	sta_rx_fail;
+
+};
+
+struct recv_buf
+{
+	_list list;
+
+//	_lock recvbuf_lock;
+
+//	u32	ref_cnt;
+
+	PADAPTER adapter;
+
+//	u8	*pbuf;
+//	u8	*pallocated_buf;
+
+	u32	len;
+	u8	*phead;
+	u8	*pdata;
+	u8	*ptail;
+	u8	*pend;
+
+#ifdef CONFIG_USB_HCI
+
+	#if defined(PLATFORM_OS_XP)||defined(PLATFORM_LINUX)||defined(PLATFORM_FREEBSD)
+	PURB	purb;
+	dma_addr_t dma_transfer_addr;	/* (in) dma addr for transfer_buffer */
+	u32 alloc_sz;
+	#endif
+
+	#ifdef PLATFORM_OS_XP
+	PIRP		pirp;
+	#endif
+
+	#ifdef PLATFORM_OS_CE
+	USB_TRANSFER	usb_transfer_read_port;
+	#endif
+
+	u8  irp_pending;
+	int  transfer_len;
+
+#endif
+
+#if defined(PLATFORM_LINUX) || defined(PLATFORM_ECOS) || defined(PLATFORM_FREERTOS) || defined (PLATFORM_CMSIS_RTOS)
+	_pkt	*pskb;
+//	u8	reuse;
+#endif
+#ifdef PLATFORM_FREEBSD //skb solution
+	struct sk_buff *pskb;
+	u8	reuse;
+#endif //PLATFORM_FREEBSD //skb solution
+};
+
+/*
+	head  ----->
+
+		data  ----->
+
+			payload
+
+		tail  ----->
+
+
+	end   ----->
+
+	len = (unsigned int )(tail - data);
+
+*/
+struct recv_frame_hdr
+{
+	_list	list;
+#ifndef CONFIG_BSD_RX_USE_MBUF
+	struct sk_buff	 *pkt;
+	struct sk_buff	 *pkt_newalloc;
+#else // CONFIG_BSD_RX_USE_MBUF
+	_pkt	*pkt;
+	_pkt *pkt_newalloc;
+#endif // CONFIG_BSD_RX_USE_MBUF
+
+	_adapter  *adapter;
+
+	u8 fragcnt;
+
+	int frame_tag;
+
+	struct rx_pkt_attrib attrib;
+
+	uint  len;
+	u8 *rx_head;
+	u8 *rx_data;
+	u8 *rx_tail;
+	u8 *rx_end;
+
+	void *precvbuf;
+
+
+	//
+	struct sta_info *psta;
+#ifdef CONFIG_RECV_REORDERING_CTRL
+	//for A-MPDU Rx reordering buffer control
+	struct recv_reorder_ctrl *preorder_ctrl;
+#endif
+#ifdef CONFIG_WAPI_SUPPORT
+	u8 UserPriority;
+	u8 WapiTempPN[16];
+	u8 WapiSrcAddr[6];
+	u8 bWapiCheckPNInDecrypt;
+	u8 bIsWaiPacket;
+#endif
+
+};
+
+union recv_frame{
+
+	union{
+		_list list;
+		struct recv_frame_hdr hdr;
+		uint mem[RECVFRAME_HDR_ALIGN>>2];
+	}u;
+
+	//uint mem[MAX_RXSZ>>2];
+
+};
+
+typedef enum _RX_PACKET_TYPE{
+	NORMAL_RX,//Normal rx packet
+	TX_REPORT1,//CCX
+	TX_REPORT2,//TX RPT
+	HIS_REPORT,// USB HISR RPT
+	C2H_PACKET
+}RX_PACKET_TYPE, *PRX_PACKET_TYPE;
+
+extern union recv_frame *_rtw_alloc_recvframe (_queue *pfree_recv_queue);  //get a free recv_frame from pfree_recv_queue
+extern void rtw_init_recvframe(union recv_frame *precvframe ,struct recv_priv *precvpriv);
+extern int	 rtw_free_recvframe(union recv_frame *precvframe, _queue *pfree_recv_queue);
+
+#define rtw_dequeue_recvframe(queue) rtw_alloc_recvframe(queue)
+extern int _rtw_enqueue_recvframe(union recv_frame *precvframe, _queue *queue);
+
+#ifdef CONFIG_TRACE_SKB
+int __rtw_enqueue_recvframe(union recv_frame *precvframe, _queue *queue);
+union recv_frame *__rtw_alloc_recvframe (_queue *pfree_recv_queue);  //get a free recv_frame from pfree_recv_queue
+
+#define rtw_enqueue_recvframe(precvframe, queue, Q) \
+	do{\
+		set_skb_list_flag(precvframe->u.hdr.pkt, SKBLIST_RECVFRAME_##Q);\
+		__rtw_enqueue_recvframe(precvframe, queue);\
+	}while (0)
+#define rtw_alloc_recvframe(queue, precvframe, Q) \
+	(\
+		precvframe = __rtw_alloc_recvframe(queue),\
+		precvframe ? clear_skb_list_flag(precvframe->u.hdr.pkt, SKBLIST_RECVFRAME_##Q):0,\
+		precvframe\
+	)
+#else
+extern int rtw_enqueue_recvframe(union recv_frame *precvframe, _queue *queue);
+extern union recv_frame *rtw_alloc_recvframe (_queue *pfree_recv_queue);  //get a free recv_frame from pfree_recv_queue
+#endif
+
+extern void rtw_free_recvframe_queue(_queue *pframequeue,  _queue *pfree_recv_queue);
+u32 rtw_free_uc_swdec_pending_queue(_adapter *adapter);
+
+#ifdef CONFIG_TRACE_SKB
+sint _rtw_enqueue_recvbuf_to_head(struct recv_buf *precvbuf, _queue *queue);
+sint _rtw_enqueue_recvbuf(struct recv_buf *precvbuf, _queue *queue);
+struct recv_buf *_rtw_dequeue_recvbuf (_queue *queue);
+
+#define rtw_enqueue_recvbuf_to_head(precvbuf, queue, Q) \
+	do{\
+		set_skb_list_flag(precvbuf->pskb, SKBLIST_RECVBUF_##Q);\
+		_rtw_enqueue_recvbuf_to_head(precvbuf, queue);\
+	}while (0)
+#define rtw_enqueue_recvbuf(precvbuf, queue, Q) \
+	do{\
+		set_skb_list_flag(precvbuf->pskb, SKBLIST_RECVBUF_##Q);\
+		_rtw_enqueue_recvbuf(precvbuf, queue);\
+	}while (0)
+#define rtw_dequeue_recvbuf(queue, precvbuf, Q) \
+	(\
+		precvbuf = _rtw_dequeue_recvbuf(queue),\
+		precvbuf ? clear_skb_list_flag(precvbuf->pskb, SKBLIST_RECVBUF_##Q):0,\
+		precvbuf\
+	)
+
+#else
+sint rtw_enqueue_recvbuf_to_head(struct recv_buf *precvbuf, _queue *queue);
+sint rtw_enqueue_recvbuf(struct recv_buf *precvbuf, _queue *queue);
+struct recv_buf *rtw_dequeue_recvbuf (_queue *queue);
+#endif
+
+void rtw_reordering_ctrl_timeout_handler(void *pcontext);
+
+
+__inline static u8 *get_rxmem(union recv_frame *precvframe)
+{
+	//always return rx_head...
+	if(precvframe==NULL)
+		return NULL;
+
+	return precvframe->u.hdr.rx_head;
+}
+
+__inline static u8 *get_rx_status(union recv_frame *precvframe)
+{
+
+	return get_rxmem(precvframe);
+
+}
+
+
+
+__inline static u8 *get_recvframe_data(union recv_frame *precvframe)
+{
+
+	//alwasy return rx_data
+	if(precvframe==NULL)
+		return NULL;
+
+	return precvframe->u.hdr.rx_data;
+
+}
+
+//TODO
+#if 0
+
+__inline static u8 *recvframe_push(union recv_frame *precvframe, sint sz)
+{
+	// append data before rx_data
+
+	/* add data to the start of recv_frame
+ *
+ *      This function extends the used data area of the recv_frame at the buffer
+ *      start. rx_data must be still larger than rx_head, after pushing.
+ */
+
+	if(precvframe==NULL)
+		return NULL;
+
+
+	precvframe->u.hdr.rx_data -= sz ;
+	if( precvframe->u.hdr.rx_data < precvframe->u.hdr.rx_head )
+	{
+		precvframe->u.hdr.rx_data += sz ;
+		return NULL;
+	}
+
+	precvframe->u.hdr.len +=sz;
+
+	return precvframe->u.hdr.rx_data;
+
+}
+
+#endif	//#if 0
+
+__inline static u8 *recvframe_pull(union recv_frame *precvframe, sint sz)
+{
+	// rx_data += sz; move rx_data sz bytes  hereafter
+
+	//used for extract sz bytes from rx_data, update rx_data and return the updated rx_data to the caller
+
+
+	if(precvframe==NULL)
+		return NULL;
+
+
+	precvframe->u.hdr.rx_data += sz;
+
+	if(precvframe->u.hdr.rx_data > precvframe->u.hdr.rx_tail)
+	{
+		precvframe->u.hdr.rx_data -= sz;
+		return NULL;
+	}
+
+	precvframe->u.hdr.len -=sz;
+
+	return precvframe->u.hdr.rx_data;
+
+}
+
+__inline static u8 *recvframe_put(union recv_frame *precvframe, sint sz)
+{
+	// rx_tai += sz; move rx_tail sz bytes  hereafter
+
+	//used for append sz bytes from ptr to rx_tail, update rx_tail and return the updated rx_tail to the caller
+	//after putting, rx_tail must be still larger than rx_end. 	
+
+	if(precvframe==NULL)
+		return NULL;
+
+	precvframe->u.hdr.rx_tail += sz;
+
+	if(precvframe->u.hdr.rx_tail > precvframe->u.hdr.rx_end)
+	{
+		precvframe->u.hdr.rx_tail -= sz;
+		return NULL;
+	}
+
+	precvframe->u.hdr.len +=sz;
+
+	return precvframe->u.hdr.rx_tail;
+
+}
+
+
+
+__inline static u8 *recvframe_pull_tail(union recv_frame *precvframe, sint sz)
+{
+	// rmv data from rx_tail (by yitsen)
+
+	//used for extract sz bytes from rx_end, update rx_end and return the updated rx_end to the caller
+	//after pulling, rx_end must be still larger than rx_data.
+
+	if(precvframe==NULL)
+		return NULL;
+
+	precvframe->u.hdr.rx_tail -= sz;
+
+	if(precvframe->u.hdr.rx_tail < precvframe->u.hdr.rx_data)
+	{
+		precvframe->u.hdr.rx_tail += sz;
+		return NULL;
+	}
+
+	precvframe->u.hdr.len -=sz;
+
+	return precvframe->u.hdr.rx_tail;
+
+}
+
+__inline static _buffer * get_rxbuf_desc(union recv_frame *precvframe)
+{
+	_buffer * buf_desc = NULL;
+
+	if(precvframe==NULL)
+		return NULL;
+#ifdef PLATFORM_WINDOWS
+	NdisQueryPacket(precvframe->u.hdr.pkt, NULL, NULL, &buf_desc, NULL);
+#endif
+
+	return buf_desc;
+}
+
+
+__inline static union recv_frame *rxmem_to_recvframe(u8 *rxmem)
+{
+	//due to the design of 2048 bytes alignment of recv_frame, we can reference the union recv_frame
+	//from any given member of recv_frame.
+	// rxmem indicates the any member/address in recv_frame
+
+	return (union recv_frame*)(((SIZE_PTR)rxmem >> RXFRAME_ALIGN) << RXFRAME_ALIGN);
+
+}
+
+__inline static union recv_frame *pkt_to_recvframe(_pkt *pkt)
+{
+
+	u8 * buf_star = NULL;
+	union recv_frame * precv_frame = NULL;
+#ifdef PLATFORM_WINDOWS
+	_buffer * buf_desc;
+	uint len;
+
+	NdisQueryPacket(pkt, NULL, NULL, &buf_desc, &len);
+	NdisQueryBufferSafe(buf_desc, &buf_star, &len, HighPagePriority);
+#endif
+	precv_frame = rxmem_to_recvframe((unsigned char*)buf_star);
+
+	return precv_frame;
+}
+
+__inline static u8 *pkt_to_recvmem(_pkt *pkt)
+{
+	// return the rx_head
+
+	union recv_frame * precv_frame = pkt_to_recvframe(pkt);
+
+	return 	precv_frame->u.hdr.rx_head;
+
+}
+
+__inline static u8 *pkt_to_recvdata(_pkt *pkt)
+{
+	// return the rx_data
+
+	union recv_frame * precv_frame =pkt_to_recvframe(pkt);
+
+	return 	precv_frame->u.hdr.rx_data;
+
+}
+
+
+__inline static sint get_recvframe_len(union recv_frame *precvframe)
+{
+	return precvframe->u.hdr.len;
+}
+
+
+__inline static s32 translate_percentage_to_dbm(u32 SignalStrengthIndex)
+{
+	s32	SignalPower; // in dBm.
+
+#ifndef CONFIG_SKIP_SIGNAL_SCALE_MAPPING
+	// Translate to dBm (x=0.9y-95).
+	SignalPower = (s32)((SignalStrengthIndex *18) /20); 
+	SignalPower -= 95; 
+#else
+	/* Translate to dBm (x=y-100) */
+	SignalPower = SignalStrengthIndex - 100;
+#endif
+
+	return SignalPower;
+}
+
+
+struct sta_info;
+
+extern void _rtw_init_sta_recv_priv(struct sta_recv_priv *psta_recvpriv);
+extern void  mgt_dispatcher(_adapter *padapter, union recv_frame *precv_frame);
+int process_recv_indicatepkts(_adapter *padapter, union recv_frame *prframe);
+
+void rtw_rxhandler(_adapter * padapter, struct recv_buf *precvbuf);
+u32 rtw_free_buf_pending_queue(_adapter *adapter);
+
+#endif
+