staging: r8822be: Add existing rtlwifi and rtl_pci parts for new driver (56bde846) · Commits · e / devices / android_kernel_fairphone_FP4

drivers/staging/rtlwifi/base.c

0 → 100644

+2826 −0

File added.

Preview size limit exceeded, changes collapsed.

drivers/staging/rtlwifi/base.h

0 → 100644

+186 −0

Original line number	Diff line number	Diff line
		/******************************************************************************
		*
		* Copyright(c) 2009-2012 Realtek Corporation.
		*
		* 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.
		*
		* The full GNU General Public License is included in this distribution in the
		* file called LICENSE.
		*
		* Contact Information:
		* wlanfae <wlanfae@realtek.com>
		* Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
		* Hsinchu 300, Taiwan.
		*
		* Larry Finger <Larry.Finger@lwfinger.net>
		*
		*****************************************************************************/

		#ifndef __RTL_BASE_H__
		#define __RTL_BASE_H__

		enum ap_peer {
		PEER_UNKNOWN = 0,
		PEER_RTL = 1,
		PEER_RTL_92SE = 2,
		PEER_BROAD = 3,
		PEER_RAL = 4,
		PEER_ATH = 5,
		PEER_CISCO = 6,
		PEER_MARV = 7,
		PEER_AIRGO = 9,
		PEER_MAX = 10,
		};

		#define RTL_DUMMY_OFFSET 0
		#define RTL_DUMMY_UNIT 8
		#define RTL_TX_DUMMY_SIZE (RTL_DUMMY_OFFSET * RTL_DUMMY_UNIT)
		#define RTL_TX_DESC_SIZE 32
		#define RTL_TX_HEADER_SIZE (RTL_TX_DESC_SIZE + RTL_TX_DUMMY_SIZE)

		#define MAX_BIT_RATE_40MHZ_MCS15 300 /* Mbps */
		#define MAX_BIT_RATE_40MHZ_MCS7 150 /* Mbps */

		#define MAX_BIT_RATE_SHORT_GI_2NSS_80MHZ_MCS9 867 /* Mbps */
		#define MAX_BIT_RATE_SHORT_GI_2NSS_80MHZ_MCS7 650 /* Mbps */
		#define MAX_BIT_RATE_LONG_GI_2NSS_80MHZ_MCS9 780 /* Mbps */
		#define MAX_BIT_RATE_LONG_GI_2NSS_80MHZ_MCS7 585 /* Mbps */

		#define MAX_BIT_RATE_SHORT_GI_1NSS_80MHZ_MCS9 434 /* Mbps */
		#define MAX_BIT_RATE_SHORT_GI_1NSS_80MHZ_MCS7 325 /* Mbps */
		#define MAX_BIT_RATE_LONG_GI_1NSS_80MHZ_MCS9 390 /* Mbps */
		#define MAX_BIT_RATE_LONG_GI_1NSS_80MHZ_MCS7 293 /* Mbps */

		#define FRAME_OFFSET_FRAME_CONTROL 0
		#define FRAME_OFFSET_DURATION 2
		#define FRAME_OFFSET_ADDRESS1 4
		#define FRAME_OFFSET_ADDRESS2 10
		#define FRAME_OFFSET_ADDRESS3 16
		#define FRAME_OFFSET_SEQUENCE 22
		#define FRAME_OFFSET_ADDRESS4 24
		#define MAX_LISTEN_INTERVAL 10
		#define MAX_RATE_TRIES 4

		#define SET_80211_HDR_FRAME_CONTROL(_hdr, _val) \
		WRITEEF2BYTE(_hdr, _val)
		#define SET_80211_HDR_TYPE_AND_SUBTYPE(_hdr, _val) \
		WRITEEF1BYTE(_hdr, _val)
		#define SET_80211_HDR_PWR_MGNT(_hdr, _val) \
		SET_BITS_TO_LE_2BYTE(_hdr, 12, 1, _val)
		#define SET_80211_HDR_TO_DS(_hdr, _val) \
		SET_BITS_TO_LE_2BYTE(_hdr, 8, 1, _val)

		#define SET_80211_PS_POLL_AID(_hdr, _val) \
		((u16 )((u8 *)(_hdr) + 2) = _val)
		#define SET_80211_PS_POLL_BSSID(_hdr, _val) \
		ether_addr_copy(((u8 )(_hdr)) + 4, (u8 )(_val))
		#define SET_80211_PS_POLL_TA(_hdr, _val) \
		ether_addr_copy(((u8 )(_hdr)) + 10, (u8 )(_val))

		#define SET_80211_HDR_DURATION(_hdr, _val) \
		((u16 )((u8 *)(_hdr) + FRAME_OFFSET_DURATION) = le16_to_cpu(_val))
		#define SET_80211_HDR_ADDRESS1(_hdr, _val) \
		CP_MACADDR((u8 )(_hdr) + FRAME_OFFSET_ADDRESS1, (u8 )(_val))
		#define SET_80211_HDR_ADDRESS2(_hdr, _val) \
		CP_MACADDR((u8 )(_hdr) + FRAME_OFFSET_ADDRESS2, (u8 )(_val))
		#define SET_80211_HDR_ADDRESS3(_hdr, _val) \
		CP_MACADDR((u8 )(_hdr) + FRAME_OFFSET_ADDRESS3, (u8 )(_val))
		#define SET_80211_HDR_FRAGMENT_SEQUENCE(_hdr, _val) \
		WRITEEF2BYTE((u8 *)(_hdr) + FRAME_OFFSET_SEQUENCE, _val)

		#define SET_BEACON_PROBE_RSP_TIME_STAMP_LOW(__phdr, __val) \
		WRITEEF4BYTE(((u8 *)(__phdr)) + 24, __val)
		#define SET_BEACON_PROBE_RSP_TIME_STAMP_HIGH(__phdr, __val) \
		WRITEEF4BYTE(((u8 *)(__phdr)) + 28, __val)
		#define SET_BEACON_PROBE_RSP_BEACON_INTERVAL(__phdr, __val) \
		WRITEEF2BYTE(((u8 *)(__phdr)) + 32, __val)
		#define GET_BEACON_PROBE_RSP_CAPABILITY_INFO(__phdr) \
		READEF2BYTE(((u8 *)(__phdr)) + 34)
		#define SET_BEACON_PROBE_RSP_CAPABILITY_INFO(__phdr, __val) \
		WRITEEF2BYTE(((u8 *)(__phdr)) + 34, __val)
		#define MASK_BEACON_PROBE_RSP_CAPABILITY_INFO(__phdr, __val) \
		SET_BEACON_PROBE_RSP_CAPABILITY_INFO(__phdr, \
		(GET_BEACON_PROBE_RSP_CAPABILITY_INFO(__phdr) & (~(__val))))

		#define SET_TX_DESC_SPE_RPT(__pdesc, __val) \
		SET_BITS_TO_LE_4BYTE((__pdesc) + 8, 19, 1, __val)
		#define SET_TX_DESC_SW_DEFINE(__pdesc, __val) \
		SET_BITS_TO_LE_4BYTE((__pdesc) + 24, 0, 12, __val)

		int rtl_init_core(struct ieee80211_hw *hw);
		void rtl_deinit_core(struct ieee80211_hw *hw);
		void rtl_init_rx_config(struct ieee80211_hw *hw);
		void rtl_init_rfkill(struct ieee80211_hw *hw);
		void rtl_deinit_rfkill(struct ieee80211_hw *hw);

		void rtl_watch_dog_timer_callback(unsigned long data);
		void rtl_deinit_deferred_work(struct ieee80211_hw *hw);

		bool rtl_action_proc(struct ieee80211_hw hw, struct sk_buff skb, u8 is_tx);
		int rtlwifi_rate_mapping(struct ieee80211_hw *hw, bool isht,
		bool isvht, u8 desc_rate);
		bool rtl_tx_mgmt_proc(struct ieee80211_hw hw, struct sk_buff skb);
		u8 rtl_is_special_data(struct ieee80211_hw hw, struct sk_buff skb, u8 is_tx,
		bool is_enc);

		bool rtl_is_tx_report_skb(struct ieee80211_hw hw, struct sk_buff skb);
		void rtl_get_tx_report(struct rtl_tcb_desc ptcb_desc, u8 pdesc,
		struct ieee80211_hw *hw);
		void rtl_tx_report_handler(struct ieee80211_hw hw, u8 tmp_buf,
		u8 c2h_cmd_len);
		bool rtl_check_tx_report_acked(struct ieee80211_hw *hw);
		void rtl_wait_tx_report_acked(struct ieee80211_hw *hw, u32 wait_ms);
		u32 rtl_get_hal_edca_param(struct ieee80211_hw *hw,
		struct ieee80211_vif *vif,
		enum wireless_mode wirelessmode,
		struct ieee80211_tx_queue_params *param);

		void rtl_beacon_statistic(struct ieee80211_hw hw, struct sk_buff skb);
		void rtl_collect_scan_list(struct ieee80211_hw hw, struct sk_buff skb);
		void rtl_scan_list_expire(struct ieee80211_hw *hw);
		int rtl_tx_agg_start(struct ieee80211_hw hw, struct ieee80211_vif vif,
		struct ieee80211_sta sta, u16 tid, u16 ssn);
		int rtl_tx_agg_stop(struct ieee80211_hw hw, struct ieee80211_vif vif,
		struct ieee80211_sta *sta, u16 tid);
		int rtl_tx_agg_oper(struct ieee80211_hw *hw,
		struct ieee80211_sta *sta, u16 tid);
		int rtl_rx_agg_start(struct ieee80211_hw *hw,
		struct ieee80211_sta *sta, u16 tid);
		int rtl_rx_agg_stop(struct ieee80211_hw *hw,
		struct ieee80211_sta *sta, u16 tid);
		void rtl_rx_ampdu_apply(struct rtl_priv *rtlpriv);
		void rtl_watchdog_wq_callback(void *data);
		void rtl_fwevt_wq_callback(void *data);
		void rtl_c2hcmd_wq_callback(void *data);
		void rtl_c2hcmd_launcher(struct ieee80211_hw *hw, int exec);
		void rtl_c2hcmd_enqueue(struct ieee80211_hw hw, u8 tag, u8 len, u8 val);

		u8 rtl_mrate_idx_to_arfr_id(
		struct ieee80211_hw *hw, u8 rate_index,
		enum wireless_mode wirelessmode);
		void rtl_get_tcb_desc(struct ieee80211_hw *hw,
		struct ieee80211_tx_info *info,
		struct ieee80211_sta *sta,
		struct sk_buff skb, struct rtl_tcb_desc tcb_desc);

		int rtl_send_smps_action(struct ieee80211_hw *hw,
		struct ieee80211_sta *sta,
		enum ieee80211_smps_mode smps);
		u8 rtl_find_ie(u8 data, unsigned int len, u8 ie);
		void rtl_recognize_peer(struct ieee80211_hw hw, u8 data, unsigned int len);
		u8 rtl_tid_to_ac(u8 tid);
		void rtl_easy_concurrent_retrytimer_callback(unsigned long data);
		extern struct rtl_global_var rtl_global_var;
		void rtl_phy_scan_operation_backup(struct ieee80211_hw *hw, u8 operation);
		bool rtl_check_beacon_key(struct ieee80211_hw hw, void data,
		unsigned int len);
		int rtl_core_module_init(void);
		void rtl_core_module_exit(void);
		#endif

drivers/staging/rtlwifi/cam.c

0 → 100644

+326 −0

Original line number	Diff line number	Diff line
		/******************************************************************************
		*
		* Copyright(c) 2009-2012 Realtek Corporation.
		*
		* 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.
		*
		* The full GNU General Public License is included in this distribution in the
		* file called LICENSE.
		*
		* Contact Information:
		* wlanfae <wlanfae@realtek.com>
		* Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
		* Hsinchu 300, Taiwan.
		*
		* Larry Finger <Larry.Finger@lwfinger.net>
		*
		*****************************************************************************/
		#include "wifi.h"
		#include "cam.h"
		#include <linux/export.h>

		void rtl_cam_reset_sec_info(struct ieee80211_hw *hw)
		{
		struct rtl_priv *rtlpriv = rtl_priv(hw);

		rtlpriv->sec.use_defaultkey = false;
		rtlpriv->sec.pairwise_enc_algorithm = NO_ENCRYPTION;
		rtlpriv->sec.group_enc_algorithm = NO_ENCRYPTION;
		memset(rtlpriv->sec.key_buf, 0, KEY_BUF_SIZE * MAX_KEY_LEN);
		memset(rtlpriv->sec.key_len, 0, KEY_BUF_SIZE);
		rtlpriv->sec.pairwise_key = NULL;
		}

		static void rtl_cam_program_entry(struct ieee80211_hw *hw, u32 entry_no,
		u8 mac_addr, u8 key_cont_128, u16 us_config)
		{
		struct rtl_priv *rtlpriv = rtl_priv(hw);

		u32 target_command;
		u32 target_content = 0;
		int entry_i;

		RT_PRINT_DATA(rtlpriv, COMP_SEC, DBG_DMESG, "Key content :",
		key_cont_128, 16);

		/* 0-1 config + mac, 2-5 fill 128key,6-7 are reserved */
		for (entry_i = CAM_CONTENT_COUNT - 1; entry_i >= 0; entry_i--) {
		target_command = entry_i + CAM_CONTENT_COUNT * entry_no;
		target_command = target_command \| BIT(31) \| BIT(16);

		if (entry_i == 0) {
		target_content = (u32)(*(mac_addr + 0)) << 16 \|
		(u32)(*(mac_addr + 1)) << 24 \|
		(u32)us_config;

		rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[WCAMI],
		target_content);
		rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[RWCAM],
		target_command);

		RT_TRACE(rtlpriv, COMP_SEC, DBG_LOUD,
		"WRITE %x: %x\n",
		rtlpriv->cfg->maps[WCAMI], target_content);
		RT_TRACE(rtlpriv, COMP_SEC, DBG_LOUD,
		"The Key ID is %d\n", entry_no);
		RT_TRACE(rtlpriv, COMP_SEC, DBG_LOUD,
		"WRITE %x: %x\n",
		rtlpriv->cfg->maps[RWCAM], target_command);

		} else if (entry_i == 1) {
		target_content = (u32)(*(mac_addr + 5)) << 24 \|
		(u32)(*(mac_addr + 4)) << 16 \|
		(u32)(*(mac_addr + 3)) << 8 \|
		(u32)(*(mac_addr + 2));

		rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[WCAMI],
		target_content);
		rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[RWCAM],
		target_command);

		RT_TRACE(rtlpriv, COMP_SEC, DBG_LOUD,
		"WRITE A4: %x\n", target_content);
		RT_TRACE(rtlpriv, COMP_SEC, DBG_LOUD,
		"WRITE A0: %x\n", target_command);
		} else {
		target_content =
		(u32)((key_cont_128 + (entry_i 4 - 8) + 3)) <<
		24 \| (u32)((key_cont_128 + (entry_i 4 - 8) + 2))
		<< 16 \|
		(u32)((key_cont_128 + (entry_i 4 - 8) + 1)) << 8
		\| (u32)((key_cont_128 + (entry_i 4 - 8) + 0));

		rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[WCAMI],
		target_content);
		rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[RWCAM],
		target_command);

		RT_TRACE(rtlpriv, COMP_SEC, DBG_LOUD,
		"WRITE A4: %x\n", target_content);
		RT_TRACE(rtlpriv, COMP_SEC, DBG_LOUD,
		"WRITE A0: %x\n", target_command);
		}
		}

		RT_TRACE(rtlpriv, COMP_SEC, DBG_LOUD,
		"after set key, usconfig:%x\n", us_config);
		}

		u8 rtl_cam_add_one_entry(struct ieee80211_hw hw, u8 mac_addr,
		u32 ul_key_id, u32 ul_entry_idx, u32 ul_enc_alg,
		u32 ul_default_key, u8 *key_content)
		{
		u32 us_config;
		struct rtl_priv *rtlpriv = rtl_priv(hw);

		RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
		"EntryNo:%x, ulKeyId=%x, ulEncAlg=%x, ulUseDK=%x MacAddr %pM\n",
		ul_entry_idx, ul_key_id, ul_enc_alg,
		ul_default_key, mac_addr);

		if (ul_key_id == TOTAL_CAM_ENTRY) {
		RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING,
		"ulKeyId exceed!\n");
		return 0;
		}

		if (ul_default_key == 1)
		us_config = CFG_VALID \| ((u16)(ul_enc_alg) << 2);
		else
		us_config = CFG_VALID \| ((ul_enc_alg) << 2) \| ul_key_id;

		rtl_cam_program_entry(hw, ul_entry_idx, mac_addr,
		(u8 *)key_content, us_config);

		RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG, "end\n");

		return 1;
		}

		int rtl_cam_delete_one_entry(struct ieee80211_hw *hw,
		u8 *mac_addr, u32 ul_key_id)
		{
		u32 ul_command;
		struct rtl_priv *rtlpriv = rtl_priv(hw);

		RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG, "key_idx:%d\n", ul_key_id);

		ul_command = ul_key_id * CAM_CONTENT_COUNT;
		ul_command = ul_command \| BIT(31) \| BIT(16);

		rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[WCAMI], 0);
		rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[RWCAM], ul_command);

		RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
		"%s(): WRITE A4: %x\n", __func__, 0);
		RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
		"%s(): WRITE A0: %x\n", __func__, ul_command);

		return 0;
		}

		void rtl_cam_reset_all_entry(struct ieee80211_hw *hw)
		{
		u32 ul_command;
		struct rtl_priv *rtlpriv = rtl_priv(hw);

		ul_command = BIT(31) \| BIT(30);
		rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[RWCAM], ul_command);
		}

		void rtl_cam_mark_invalid(struct ieee80211_hw *hw, u8 uc_index)
		{
		struct rtl_priv *rtlpriv = rtl_priv(hw);

		u32 ul_command;
		u32 ul_content;
		u32 ul_enc_algo = rtlpriv->cfg->maps[SEC_CAM_AES];

		switch (rtlpriv->sec.pairwise_enc_algorithm) {
		case WEP40_ENCRYPTION:
		ul_enc_algo = rtlpriv->cfg->maps[SEC_CAM_WEP40];
		break;
		case WEP104_ENCRYPTION:
		ul_enc_algo = rtlpriv->cfg->maps[SEC_CAM_WEP104];
		break;
		case TKIP_ENCRYPTION:
		ul_enc_algo = rtlpriv->cfg->maps[SEC_CAM_TKIP];
		break;
		case AESCCMP_ENCRYPTION:
		ul_enc_algo = rtlpriv->cfg->maps[SEC_CAM_AES];
		break;
		default:
		ul_enc_algo = rtlpriv->cfg->maps[SEC_CAM_AES];
		}

		ul_content = (uc_index & 3) \| ((u16)(ul_enc_algo) << 2);

		ul_content \|= BIT(15);
		ul_command = CAM_CONTENT_COUNT * uc_index;
		ul_command = ul_command \| BIT(31) \| BIT(16);

		rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[WCAMI], ul_content);
		rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[RWCAM], ul_command);

		RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
		"%s(): WRITE A4: %x\n", __func__, ul_content);
		RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
		"%s(): WRITE A0: %x\n", __func__, ul_command);
		}

		void rtl_cam_empty_entry(struct ieee80211_hw *hw, u8 uc_index)
		{
		struct rtl_priv *rtlpriv = rtl_priv(hw);

		u32 ul_command;
		u32 ul_content;
		u32 ul_encalgo = rtlpriv->cfg->maps[SEC_CAM_AES];
		u8 entry_i;

		switch (rtlpriv->sec.pairwise_enc_algorithm) {
		case WEP40_ENCRYPTION:
		ul_encalgo = rtlpriv->cfg->maps[SEC_CAM_WEP40];
		break;
		case WEP104_ENCRYPTION:
		ul_encalgo = rtlpriv->cfg->maps[SEC_CAM_WEP104];
		break;
		case TKIP_ENCRYPTION:
		ul_encalgo = rtlpriv->cfg->maps[SEC_CAM_TKIP];
		break;
		case AESCCMP_ENCRYPTION:
		ul_encalgo = rtlpriv->cfg->maps[SEC_CAM_AES];
		break;
		default:
		ul_encalgo = rtlpriv->cfg->maps[SEC_CAM_AES];
		}

		for (entry_i = 0; entry_i < CAM_CONTENT_COUNT; entry_i++) {
		if (entry_i == 0) {
		ul_content =
		(uc_index & 0x03) \| ((u16)(ul_encalgo) << 2);
		ul_content \|= BIT(15);
		} else {
		ul_content = 0;
		}

		ul_command = CAM_CONTENT_COUNT * uc_index + entry_i;
		ul_command = ul_command \| BIT(31) \| BIT(16);

		rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[WCAMI], ul_content);
		rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[RWCAM], ul_command);

		RT_TRACE(rtlpriv, COMP_SEC, DBG_LOUD,
		"%s(): WRITE A4: %x\n", __func__, ul_content);
		RT_TRACE(rtlpriv, COMP_SEC, DBG_LOUD,
		"%s(): WRITE A0: %x\n", __func__, ul_command);
		}
		}

		u8 rtl_cam_get_free_entry(struct ieee80211_hw hw, u8 sta_addr)
		{
		struct rtl_priv *rtlpriv = rtl_priv(hw);
		u32 bitmap = (rtlpriv->sec.hwsec_cam_bitmap) >> 4;
		u8 entry_idx = 0;
		u8 i, *addr;

		if (!sta_addr) {
		pr_err("sta_addr is NULL.\n");
		return TOTAL_CAM_ENTRY;
		}
		/* Does STA already exist? */
		for (i = 4; i < TOTAL_CAM_ENTRY; i++) {
		addr = rtlpriv->sec.hwsec_cam_sta_addr[i];
		if (ether_addr_equal_unaligned(addr, sta_addr))
		return i;
		}
		/* Get a free CAM entry. */
		for (entry_idx = 4; entry_idx < TOTAL_CAM_ENTRY; entry_idx++) {
		if ((bitmap & BIT(0)) == 0) {
		pr_err("-----hwsec_cam_bitmap: 0x%x entry_idx=%d\n",
		rtlpriv->sec.hwsec_cam_bitmap, entry_idx);
		rtlpriv->sec.hwsec_cam_bitmap \|= BIT(0) << entry_idx;
		memcpy(rtlpriv->sec.hwsec_cam_sta_addr[entry_idx],
		sta_addr, ETH_ALEN);
		return entry_idx;
		}
		bitmap = bitmap >> 1;
		}
		return TOTAL_CAM_ENTRY;
		}

		void rtl_cam_del_entry(struct ieee80211_hw hw, u8 sta_addr)
		{
		struct rtl_priv *rtlpriv = rtl_priv(hw);
		u32 bitmap;
		u8 i, *addr;

		if (!sta_addr) {
		pr_err("sta_addr is NULL.\n");
		return;
		}

		if (is_zero_ether_addr(sta_addr)) {
		pr_err("sta_addr is %pM\n", sta_addr);
		return;
		}
		/* Does STA already exist? */
		for (i = 4; i < TOTAL_CAM_ENTRY; i++) {
		addr = rtlpriv->sec.hwsec_cam_sta_addr[i];
		bitmap = (rtlpriv->sec.hwsec_cam_bitmap) >> i;
		if (((bitmap & BIT(0)) == BIT(0)) &&
		(ether_addr_equal_unaligned(addr, sta_addr))) {
		/* Remove from HW Security CAM */
		eth_zero_addr(rtlpriv->sec.hwsec_cam_sta_addr[i]);
		rtlpriv->sec.hwsec_cam_bitmap &= ~(BIT(0) << i);
		RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
		"&&&&&&&&&del entry %d\n", i);
		}
		}
		}

drivers/staging/rtlwifi/cam.h

0 → 100644

+50 −0

Original line number	Diff line number	Diff line
		/******************************************************************************
		*
		* Copyright(c) 2009-2012 Realtek Corporation.
		*
		* 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.
		*
		* The full GNU General Public License is included in this distribution in the
		* file called LICENSE.
		*
		* Contact Information:
		* wlanfae <wlanfae@realtek.com>
		* Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
		* Hsinchu 300, Taiwan.
		*
		* Larry Finger <Larry.Finger@lwfinger.net>
		*
		*****************************************************************************/

		#ifndef __RTL_CAM_H_
		#define __RTL_CAM_H_

		#define CAM_CONTENT_COUNT 8

		#define CFG_VALID BIT(15)

		#define PAIRWISE_KEYIDX 0
		#define CAM_PAIRWISE_KEY_POSITION 4

		#define CAM_CONFIG_NO_USEDK 0

		void rtl_cam_reset_all_entry(struct ieee80211_hw *hw);
		u8 rtl_cam_add_one_entry(struct ieee80211_hw hw, u8 mac_addr,
		u32 ul_key_id, u32 ul_entry_idx, u32 ul_enc_alg,
		u32 ul_default_key, u8 *key_content);
		int rtl_cam_delete_one_entry(struct ieee80211_hw hw, u8 mac_addr,
		u32 ul_key_id);
		void rtl_cam_mark_invalid(struct ieee80211_hw *hw, u8 uc_index);
		void rtl_cam_empty_entry(struct ieee80211_hw *hw, u8 uc_index);
		void rtl_cam_reset_sec_info(struct ieee80211_hw *hw);
		u8 rtl_cam_get_free_entry(struct ieee80211_hw hw, u8 sta_addr);
		void rtl_cam_del_entry(struct ieee80211_hw hw, u8 sta_addr);

		#endif

drivers/staging/rtlwifi/core.c

0 → 100644

+2046 −0

File added.

Preview size limit exceeded, changes collapsed.