Attachment #113191 for bug #60713





#include <linux/ip.h>
#include <linux/module.h>
#include <linux/udp.h>

/*
 *NOTICE!!!: This file will be very big, we should

	if (!ieee80211_is_data(fc))
		return false;

	ip = (const struct iphdr *)(skb->data + mac_hdr_len +
				    SNAP_SIZE + PROTOC_TYPE_SIZE);
	ether_type = be16_to_cpup((__be16 *)
				  (skb->data + mac_hdr_len + SNAP_SIZE));

	switch (ether_type) {
	case ETH_P_IP: {
		struct udphdr *udp;
		u16 src;
		u16 dst;

		if (ip->protocol != IPPROTO_UDP)
			return false;
		udp = (struct udphdr *)((u8 *)ip + (ip->ihl << 2));
		src = be16_to_cpu(udp->source);
		dst = be16_to_cpu(udp->dest);

		/* If this case involves port 68 (UDP BOOTP client) connecting
		 * with port 67 (UDP BOOTP server), then return true so that
		 * the lowest speed is used.
		 */
		if (!((src == 68 && dst == 67) || (src == 67 && dst == 68)))
			return false;

		RT_TRACE(rtlpriv, (COMP_SEND | COMP_RECV), DBG_DMESG,
			 "dhcp %s !!\n", is_tx ? "Tx" : "Rx");
		break;
	}
	case ETH_P_ARP:
		break;
	case ETH_P_PAE:
			struct udphdr *udp = (struct udphdr *)((u8 *) ip +
							       (ip->ihl << 2));
			if (((((u8 *) udp)[1] == 68) &&
			     (((u8 *) udp)[3] == 67)) ||
			    ((((u8 *) udp)[1] == 67) &&
			     (((u8 *) udp)[3] == 68))) {
				/*
				 * 68 : UDP BOOTP client
				 * 67 : UDP BOOTP server
				 */
				RT_TRACE(rtlpriv, (COMP_SEND | COMP_RECV),
					 DBG_DMESG, "dhcp %s !!\n",
					 is_tx ? "Tx" : "Rx");

				if (is_tx) {
					rtlpriv->enter_ps = false;
					schedule_work(&rtlpriv->
						      works.lps_change_work);
					ppsc->last_delaylps_stamp_jiffies =
					    jiffies;
				}

				return true;
			}
		}
	} else if (ETH_P_ARP == ether_type) {
		if (is_tx) {
			rtlpriv->enter_ps = false;
			schedule_work(&rtlpriv->works.lps_change_work);
			ppsc->last_delaylps_stamp_jiffies = jiffies;
		}

		return true;
	} else if (ETH_P_PAE == ether_type) {
		RT_TRACE(rtlpriv, (COMP_SEND | COMP_RECV), DBG_DMESG,
			 "802.1X %s EAPOL pkt!!\n", is_tx ? "Tx" : "Rx");
		break;
	case ETH_P_IPV6:
		/* TODO: Is this right? */
		return false;
	default:
		return false;

		return true;
	} else if (ETH_P_IPV6 == ether_type) {
		/* IPv6 */
		return true;
	}
	if (is_tx) {
		rtlpriv->enter_ps = false;
		schedule_work(&rtlpriv->works.lps_change_work);
		ppsc->last_delaylps_stamp_jiffies = jiffies;
	}
	return true;
}
EXPORT_SYMBOL_GPL(rtl_is_special_data);


			/* if we can't recv beacon for 6s, we should
			 * reconnect this AP
			 */
			if ((rtlpriv->link_info.roam_times >= 3) &&
			    !is_zero_ether_addr(rtlpriv->mac80211.bssid)) {
				RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
					 "AP off, try to reconnect now\n");
				rtlpriv->link_info.roam_times = 0;




#define RTL_SLOT_TIME_9				9
#define RTL_SLOT_TIME_20			20

/*related to tcp/ip. */
/*if_ehther.h*/
#define ETH_P_PAE		0x888E	/*Port Access Entity (IEEE 802.1X) */
#define ETH_P_IP		0x0800	/*Internet Protocol packet */
#define ETH_P_ARP		0x0806	/*Address Resolution packet */
#define SNAP_SIZE		6
#define PROTOC_TYPE_SIZE	2



struct rssi_sta {
	long undec_sm_pwdb;
	long undec_sm_cck;
};

struct rtl_tid_data {

struct rtl_dm {
	/*PHY status for Dynamic Management */
	long entry_min_undec_sm_pwdb;
	long undec_sm_cck;
	long undec_sm_pwdb;	/*out dm */
	long entry_max_undec_sm_pwdb;
	s32 ofdm_pkt_cnt;
	bool dm_initialgain_enable;
	bool dynamic_txpower_enable;
	bool current_turbo_edca;

	bool inform_fw_driverctrldm;
	bool current_mrc_switch;
	u8 txpowercount;
	u8 powerindex_backup[6];

	u8 thermalvalue_rxgain;
	u8 thermalvalue_iqk;

	bool done_txpower;
	u8 dynamic_txhighpower_lvl;	/*Tx high power level */
	u8 dm_flag;		/*Indicate each dynamic mechanism's status. */
	u8 dm_flag_tmp;
	u8 dm_type;
	u8 dm_rssi_sel;
	u8 txpower_track_control;
	bool interrupt_migration;
	bool disable_tx_int;

	bool write_readback;
	char *name;
	char *fw_name;
	char *alt_fw_name;
	struct rtl_hal_ops *ops;
	struct rtl_mod_params *mod_params;
	struct rtl_hal_usbint_cfg *usb_interface_cfg;

	u8 pre_ccastate;
	u8 cur_ccasate;
	u8 large_fa_hit;
	u8 dig_dynamic_min;
	u8 forbidden_igi;
	u8 dig_state;
	u8 dig_highpwrstate;

	struct dig_t dm_digtable;
	struct ps_t dm_pstable;

	u32 reg_874;
	u32 reg_c70;
	u32 reg_85c;
	u32 reg_a74;
	bool reg_init;	/* true if regs saved */
	bool bt_operation_on;
	__le32 *usb_data;
	int usb_data_index;
	bool initialized;
			u32 reg_874;
			u32 reg_c70;
			u32 reg_85c;
			u32 reg_a74;
			bool bt_operation_on;
		};
	};
	bool enter_ps;	/* true when entering PS */
	u8 rate_mask[5];





			 "Firmware callback routine entered!\n");
	complete(&rtlpriv->firmware_loading_complete);
	if (!firmware) {
		if (rtlpriv->cfg->alt_fw_name) {
			err = request_firmware(&firmware,
					       rtlpriv->cfg->alt_fw_name,
					       rtlpriv->io.dev);
			pr_info("Loading alternative firmware %s\n",
				rtlpriv->cfg->alt_fw_name);
			if (!err)
				goto found_alt;
		}
		pr_err("Firmware %s not available\n", rtlpriv->cfg->fw_name);
		rtlpriv->max_fw_size = 0;
		return;
	}
found_alt:
	if (firmware->size > rtlpriv->max_fw_size) {
		RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
			 "Firmware is too big!\n");

					rtlpriv->cfg->maps
					[RTL_IBSS_INT_MASKS]);
		}
		mac->link_state = MAC80211_LINKED;
		break;
	case NL80211_IFTYPE_ADHOC:
		RT_TRACE(rtlpriv, COMP_MAC80211, DBG_LOUD,

Lines 49-54 MODULE_AUTHOR("Larry Finger <Larry.Finge Link Here

(-)linux-2.6/drivers/net/wireless/rtlwifi/rtl8192cu/sw.c (-3 / +13 lines)
49	MODULE_LICENSE("GPL");	49	MODULE_LICENSE("GPL");
50	MODULE_DESCRIPTION("Realtek 8192C/8188C 802.11n USB wireless");	50	MODULE_DESCRIPTION("Realtek 8192C/8188C 802.11n USB wireless");
51	MODULE_FIRMWARE("rtlwifi/rtl8192cufw.bin");	51	MODULE_FIRMWARE("rtlwifi/rtl8192cufw.bin");
		52	MODULE_FIRMWARE("rtlwifi/rtl8192cufw_A.bin");
		53	MODULE_FIRMWARE("rtlwifi/rtl8192cufw_B.bin");
		54	MODULE_FIRMWARE("rtlwifi/rtl8192cufw_TMSC.bin");
52		55
53	static int rtl92cu_init_sw_vars(struct ieee80211_hw *hw)	56	static int rtl92cu_init_sw_vars(struct ieee80211_hw *hw)
54	{	57	{
Lines 68-81 static int rtl92cu_init_sw_vars(struct i Link Here
68	"Can't alloc buffer for fw\n");	71	"Can't alloc buffer for fw\n");
69	return 1;	72	return 1;
70	}	73	}
71		74	if (IS_VENDOR_UMC_A_CUT(rtlpriv->rtlhal.version) &&
		75	!IS_92C_SERIAL(rtlpriv->rtlhal.version)) {
		76	rtlpriv->cfg->fw_name = "rtlwifi/rtl8192cufw_A.bin";
		77	} else if (IS_81xxC_VENDOR_UMC_B_CUT(rtlpriv->rtlhal.version)) {
		78	rtlpriv->cfg->fw_name = "rtlwifi/rtl8192cufw_B.bin";
		79	} else {
		80	rtlpriv->cfg->fw_name = "rtlwifi/rtl8192cufw_TMSC.bin";
		81	}
		82	/* provide name of alternative file */
		83	rtlpriv->cfg->alt_fw_name = "rtlwifi/rtl8192cufw.bin";
72	pr_info("Loading firmware %s\n", rtlpriv->cfg->fw_name);	84	pr_info("Loading firmware %s\n", rtlpriv->cfg->fw_name);
73	rtlpriv->max_fw_size = 0x4000;	85	rtlpriv->max_fw_size = 0x4000;
74	err = request_firmware_nowait(THIS_MODULE, 1,	86	err = request_firmware_nowait(THIS_MODULE, 1,
75	rtlpriv->cfg->fw_name, rtlpriv->io.dev,	87	rtlpriv->cfg->fw_name, rtlpriv->io.dev,
76	GFP_KERNEL, hw, rtl_fw_cb);	88	GFP_KERNEL, hw, rtl_fw_cb);
77
78
79	return err;	89	return err;
80	}	90	}
81		91

Lines 91-96 Link Here

(-)linux-2.6/drivers/net/wireless/rtlwifi/rtl8192c/dm_common.h (+14 lines)
91	#define TX_POWER_NEAR_FIELD_THRESH_LVL2 74	91	#define TX_POWER_NEAR_FIELD_THRESH_LVL2 74
92	#define TX_POWER_NEAR_FIELD_THRESH_LVL1 67	92	#define TX_POWER_NEAR_FIELD_THRESH_LVL1 67
93		93
		94	#define DYNAMIC_FUNC_DISABLE 0x0
		95	#define DYNAMIC_FUNC_DIG BIT(0)
		96	#define DYNAMIC_FUNC_HP BIT(1)
		97	#define DYNAMIC_FUNC_SS BIT(2) /Tx Power Tracking/
		98	#define DYNAMIC_FUNC_BT BIT(3)
		99	#define DYNAMIC_FUNC_ANT_DIV BIT(4)
		100
		101	#define RSSI_CCK 0
		102	#define RSSI_OFDM 1
		103	#define RSSI_DEFAULT 2
		104
94	struct swat_t {	105	struct swat_t {
95	u8 failure_cnt;	106	u8 failure_cnt;
96	u8 try_flag;	107	u8 try_flag;
Lines 167-171 void rtl92c_phy_lc_calibrate(struct ieee Link Here
167	void rtl92c_phy_iq_calibrate(struct ieee80211_hw *hw, bool recovery);	178	void rtl92c_phy_iq_calibrate(struct ieee80211_hw *hw, bool recovery);
168	void rtl92c_dm_dynamic_txpower(struct ieee80211_hw *hw);	179	void rtl92c_dm_dynamic_txpower(struct ieee80211_hw *hw);
169	void rtl92c_dm_bt_coexist(struct ieee80211_hw *hw);	180	void rtl92c_dm_bt_coexist(struct ieee80211_hw *hw);
		181	void dm_savepowerindex(struct ieee80211_hw *hw);
		182	void dm_writepowerindex(struct ieee80211_hw *hw, u8 value);
		183	void dm_restorepowerindex(struct ieee80211_hw *hw);
170		184
171	#endif	185	#endif

Lines 484-489 static void _rtl_usb_rx_process_agg(stru Link Here

(-)linux-2.6/drivers/net/wireless/rtlwifi/usb.c (-1 / +3 lines)
484	if (unicast)	484	if (unicast)
485	rtlpriv->link_info.num_rx_inperiod++;	485	rtlpriv->link_info.num_rx_inperiod++;
486	}	486	}
		487	/* static bcn for roaming */
		488	rtl_beacon_statistic(hw, skb);
487	}	489	}
488	}	490	}
489		491
Lines 555-561 static void _rtl_rx_pre_process(struct i Link Here
555	}	557	}
556	}	558	}
557		559
558	#define __RX_SKB_MAX_QUEUED 32	560	#define __RX_SKB_MAX_QUEUED 64
559		561
560	static void _rtl_rx_work(unsigned long param)	562	static void _rtl_rx_work(unsigned long param)
561	{	563	{




	{0x09, 0x08, 0x07, 0x04, 0x00, 0x00, 0x00, 0x00}
};

static u32 power_index_reg[6] = {0xc90, 0xc91, 0xc92, 0xc98, 0xc99, 0xc9a};

void dm_restorepowerindex(struct ieee80211_hw *hw)
{
	struct rtl_priv *rtlpriv = rtl_priv(hw);
	u8	index;

	for (index = 0; index < 6; index++)
		rtl_write_byte(rtlpriv, power_index_reg[index],
			       rtlpriv->dm.powerindex_backup[index]);
}
EXPORT_SYMBOL_GPL(dm_restorepowerindex);

void dm_writepowerindex(struct ieee80211_hw *hw, u8 value)
{
	struct rtl_priv *rtlpriv = rtl_priv(hw);
	u8 index;

	for (index = 0; index < 6; index++)
		rtl_write_byte(rtlpriv, power_index_reg[index], value);
}
EXPORT_SYMBOL_GPL(dm_writepowerindex);

void dm_savepowerindex(struct ieee80211_hw *hw)
{
	struct rtl_priv *rtlpriv = rtl_priv(hw);
	u8 index;
	u8 tmp;

	for (index = 0; index < 6; index++) {
		tmp = rtl_read_byte(rtlpriv, power_index_reg[index]);
		rtlpriv->dm.powerindex_backup[index] = tmp;
	}
}
EXPORT_SYMBOL_GPL(dm_savepowerindex);

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

	dm_digtable->back_range_max = DM_DIG_BACKOFF_MAX;
	dm_digtable->back_range_min = DM_DIG_BACKOFF_MIN;
	dm_digtable->pre_cck_pd_state = CCK_PD_STAGE_MAX;
	dm_digtable->cur_cck_pd_state = CCK_PD_STAGE_LowRssi;

	dm_digtable->forbidden_igi = DM_DIG_MIN;
	dm_digtable->large_fa_hit = 0;
	dm_digtable->recover_cnt = 0;
	dm_digtable->dig_dynamic_min  = 0x25;
}

static u8 rtl92c_dm_initial_gain_min_pwdb(struct ieee80211_hw *hw)

		rssi_val_min = rtlpriv->dm.entry_min_undec_sm_pwdb;
	}

	if (rssi_val_min > 100)
		rssi_val_min = 100;
	return (u8)rssi_val_min;
}

static void rtl92c_dm_false_alarm_counter_statistics(struct ieee80211_hw *hw)


	ret_value = rtl_get_bbreg(hw, ROFDM_PHYCOUNTER3, MASKDWORD);
	falsealm_cnt->cnt_mcs_fail = (ret_value & 0xffff);

	 ret_value = rtl_get_bbreg(hw, ROFDM0_FRAMESYNC, MASKDWORD);
	falsealm_cnt->cnt_fast_fsync_fail = (ret_value & 0xffff);
	falsealm_cnt->cnt_sb_search_fail = ((ret_value & 0xffff0000) >> 16);

	falsealm_cnt->cnt_ofdm_fail = falsealm_cnt->cnt_parity_fail +
				      falsealm_cnt->cnt_rate_illegal +
				      falsealm_cnt->cnt_crc8_fail +
				      falsealm_cnt->cnt_mcs_fail +
				      falsealm_cnt->cnt_fast_fsync_fail +
				      falsealm_cnt->cnt_sb_search_fail;

	rtl_set_bbreg(hw, RCCK0_FALSEALARMREPORT, BIT(14), 1);
	ret_value = rtl_get_bbreg(hw, RCCK0_FACOUNTERLOWER, MASKBYTE0);

		value_igi++;
	else if (rtlpriv->falsealm_cnt.cnt_all >= DM_DIG_FA_TH2)
		value_igi += 2;

	if (value_igi > DM_DIG_FA_UPPER)
		value_igi = DM_DIG_FA_UPPER;
	else if (value_igi < DM_DIG_FA_LOWER)
		value_igi = DM_DIG_FA_LOWER;

	if (rtlpriv->falsealm_cnt.cnt_all > 10000)
		value_igi = DM_DIG_FA_UPPER;

	dm_digtable->cur_igvalue = value_igi;
	rtl92c_dm_write_dig(hw);

{
	struct rtl_priv *rtlpriv = rtl_priv(hw);
	struct dig_t *digtable = &rtlpriv->dm_digtable;
	u32 isbt;

	/* modify DIG lower bound, deal with abnorally large false alarm */
	if (rtlpriv->falsealm_cnt.cnt_all > 10000) {
		digtable->large_fa_hit++;
		if (digtable->forbidden_igi < digtable->cur_igvalue) {
			digtable->forbidden_igi = digtable->cur_igvalue;
			digtable->large_fa_hit = 1;
		}

		if (digtable->large_fa_hit >= 3) {
			if ((digtable->forbidden_igi + 1) >
			    digtable->rx_gain_max)
				digtable->rx_gain_min = digtable->rx_gain_max;
			else
				digtable->rx_gain_min = (digtable->forbidden_igi + 1);
			digtable->recover_cnt = 3600; /* 3600=2hr */
		}
	} else {
		/* Recovery mechanism for IGI lower bound */
		if (digtable->recover_cnt != 0) {
			digtable->recover_cnt--;
		} else {
			if (digtable->large_fa_hit == 0) {
				if ((digtable->forbidden_igi-1) < DM_DIG_MIN) {
					digtable->forbidden_igi = DM_DIG_MIN;
					digtable->rx_gain_min = DM_DIG_MIN;
				} else {
					digtable->forbidden_igi--;
					digtable->rx_gain_min = digtable->forbidden_igi + 1;
				}
			} else if (digtable->large_fa_hit == 3) {
				digtable->large_fa_hit = 0;
			}
		}
	}
	if (rtlpriv->falsealm_cnt.cnt_all < 250) {
		isbt = rtl_read_byte(rtlpriv, 0x4fd) & 0x01;

		if (!isbt) {
			if (rtlpriv->falsealm_cnt.cnt_all >
			    digtable->fa_lowthresh) {
				if ((digtable->back_val - 2) <
				   digtable->back_range_min)
					digtable->back_val = digtable->back_range_min;
				else
					digtable->back_val -= 2;
			} else if (rtlpriv->falsealm_cnt.cnt_all <
				   digtable->fa_lowthresh) {
				if ((digtable->back_val + 2) >
				    digtable->back_range_max)
					digtable->back_val = digtable->back_range_max;
				else
					digtable->back_val += 2;
			}
		} else {
			digtable->back_val = DM_DIG_BACKOFF_DEFAULT;
		}
	} else {
		/* Adjust initial gain by false alarm */
		if (rtlpriv->falsealm_cnt.cnt_all > 1000)
			digtable->cur_igvalue = digtable->pre_igvalue + 2;
		else if (rtlpriv->falsealm_cnt.cnt_all > 750)
			digtable->cur_igvalue = digtable->pre_igvalue + 1;
		else if (rtlpriv->falsealm_cnt.cnt_all < 500)
			digtable->cur_igvalue = digtable->pre_igvalue - 1;
	}

	/* Check initial gain by upper/lower bound */
	if (digtable->cur_igvalue > digtable->rx_gain_max)
		digtable->cur_igvalue = digtable->rx_gain_max;
	else if ((digtable->rssi_val_min + 10 -
		  digtable->back_val) < digtable->rx_gain_min)
		digtable->cur_igvalue = digtable->rx_gain_min;
	else
		digtable->cur_igvalue = digtable->rssi_val_min + 10 -
		    digtable->back_val;

	if (digtable->cur_igvalue < digtable->rx_gain_min)
		digtable->cur_igvalue = digtable->rx_gain_min;
		 digtable->rssi_val_min, digtable->back_val);

	rtl92c_dm_write_dig(hw);
}

		multi_sta = true;

	if (!multi_sta ||
	    dm_digtable->cursta_cstate == DIG_STA_DISCONNECT) {
		initialized = false;
		dm_digtable->dig_ext_port_stage = DIG_EXT_PORT_STAGE_MAX;
		return;

	RT_TRACE(rtlpriv, COMP_DIG, DBG_TRACE,
		 "presta_cstate = %x, cursta_cstate = %x\n",
		 dm_digtable->presta_cstate, dm_digtable->cursta_cstate);

	if (dm_digtable->presta_cstate == dm_digtable->cursta_cstate ||
	    dm_digtable->cursta_cstate == DIG_STA_BEFORE_CONNECT ||
	    dm_digtable->cursta_cstate == DIG_STA_CONNECT) {

		if (dm_digtable->cursta_cstate != DIG_STA_DISCONNECT) {
			dm_digtable->rssi_val_min =
			    rtl92c_dm_initial_gain_min_pwdb(hw);
			if (dm_digtable->rssi_val_min > 100)
				dm_digtable->rssi_val_min = 100;
			rtl92c_dm_ctrl_initgain_by_rssi(hw);
		}
	} else {

static void rtl92c_dm_cck_packet_detection_thresh(struct ieee80211_hw *hw)
{
	struct rtl_priv *rtlpriv = rtl_priv(hw);
	struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
	struct dig_t *dm_digtable = &rtlpriv->dm_digtable;

	if (dm_digtable->cursta_cstate == DIG_STA_CONNECT) {
		dm_digtable->rssi_val_min = rtl92c_dm_initial_gain_min_pwdb(hw);
		if (dm_digtable->rssi_val_min > 100)
			dm_digtable->rssi_val_min = 100;

		if (dm_digtable->pre_cck_pd_state == CCK_PD_STAGE_LowRssi) {
			if (dm_digtable->rssi_val_min <= 25)

	}

	if (dm_digtable->pre_cck_pd_state != dm_digtable->cur_cck_pd_state) {
		if ((dm_digtable->cur_cck_pd_state == CCK_PD_STAGE_LowRssi) ||
		    (dm_digtable->cur_cck_pd_state == CCK_PD_STAGE_MAX))
			rtl_set_bbreg(hw, RCCK0_CCA, MASKBYTE2, 0x83);
		else
			else
				dm_digtable->cur_cck_fa_state = CCK_FA_STAGE_Low;

			if (dm_digtable->pre_cck_fa_state !=
			    dm_digtable->cur_cck_fa_state) {
				if (dm_digtable->cur_cck_fa_state ==
				    CCK_FA_STAGE_Low)
					rtl_set_bbreg(hw, RCCK0_CCA, MASKBYTE2,
						      0x83);
				else
					rtl_set_bbreg(hw, RCCK0_CCA, MASKBYTE2,
						      0xcd);

				dm_digtable->pre_cck_fa_state =
				    dm_digtable->cur_cck_fa_state;
			}

			rtl_set_bbreg(hw, RCCK0_SYSTEM, MASKBYTE1, 0x40);

			if (IS_92C_SERIAL(rtlhal->version))
				rtl_set_bbreg(hw, RCCK0_FALSEALARMREPORT,
					      MASKBYTE2, 0xd7);
		} else {
			rtl_set_bbreg(hw, RCCK0_CCA, MASKBYTE2, 0xcd);
			rtl_set_bbreg(hw, RCCK0_SYSTEM, MASKBYTE1, 0x47);

			if (IS_92C_SERIAL(rtlhal->version))
				rtl_set_bbreg(hw, RCCK0_FALSEALARMREPORT,
					      MASKBYTE2, 0xd3);
		}
		dm_digtable->pre_cck_pd_state = dm_digtable->cur_cck_pd_state;
	}

	RT_TRACE(rtlpriv, COMP_DIG, DBG_TRACE, "CCKPDStage=%x\n",
		 dm_digtable->cur_cck_pd_state);

	RT_TRACE(rtlpriv, COMP_DIG, DBG_TRACE, "is92C=%x\n",
		 IS_92C_SERIAL(rtlhal->version));
}

static void rtl92c_dm_ctrl_initgain_by_twoport(struct ieee80211_hw *hw)

	else
		dm_digtable->cursta_cstate = DIG_STA_DISCONNECT;

	dm_digtable->curmultista_cstate = DIG_MULTISTA_DISCONNECT;

	rtl92c_dm_initial_gain_sta(hw);
	rtl92c_dm_initial_gain_multi_sta(hw);
	rtl92c_dm_cck_packet_detection_thresh(hw);

static void rtl92c_dm_dig(struct ieee80211_hw *hw)
{
	struct rtl_priv *rtlpriv = rtl_priv(hw);
	struct dig_t *dm_digtable = &rtlpriv->dm_digtable;

	if (rtlpriv->dm.dm_initialgain_enable == false)
		return;
	if (!rtlpriv->dm.dm_flag & DYNAMIC_FUNC_DIG)
		return;

	rtl92c_dm_ctrl_initgain_by_twoport(hw);

}

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

	if (rtlpriv->rtlhal.interface == INTF_USB &&
	    rtlpriv->rtlhal.board_type & 0x1) {
		dm_savepowerindex(hw);
		rtlpriv->dm.dynamic_txpower_enable = true;
	} else {
		rtlpriv->dm.dynamic_txpower_enable = false;
	}
	rtlpriv->dm.last_dtp_lvl = TXHIGHPWRLEVEL_NORMAL;
	rtlpriv->dm.dynamic_txhighpower_lvl = TXHIGHPWRLEVEL_NORMAL;
}

		 dm_digtable->cur_igvalue, dm_digtable->pre_igvalue,
		 dm_digtable->back_val);

	if (rtlpriv->rtlhal.interface == INTF_USB &&
	    !dm_digtable->dig_enable_flag) {
		dm_digtable->pre_igvalue = 0x17;
		return;
	}
	dm_digtable->cur_igvalue -= 1;
	if (dm_digtable->cur_igvalue < DM_DIG_MIN)
		dm_digtable->cur_igvalue = DM_DIG_MIN;

	if (dm_digtable->pre_igvalue != dm_digtable->cur_igvalue) {
		rtl_set_bbreg(hw, ROFDM0_XAAGCCORE1, 0x7f,


		dm_digtable->pre_igvalue = dm_digtable->cur_igvalue;
	}
	RT_TRACE(rtlpriv, COMP_DIG, DBG_WARNING,
		 "dig values 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
		 dm_digtable->cur_igvalue, dm_digtable->pre_igvalue,
		 dm_digtable->rssi_val_min, dm_digtable->back_val,
		 dm_digtable->rx_gain_max, dm_digtable->rx_gain_min,
		 dm_digtable->large_fa_hit, dm_digtable->forbidden_igi);
}
EXPORT_SYMBOL(rtl92c_dm_write_dig);

static void rtl92c_dm_pwdb_monitor(struct ieee80211_hw *hw)
{
	struct rtl_priv *rtlpriv = rtl_priv(hw);
	struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
	long tmpentry_max_pwdb = 0, tmpentry_min_pwdb = 0xff;

	if (mac->link_state != MAC80211_LINKED)
		return;

	if (mac->opmode == NL80211_IFTYPE_ADHOC ||
	    mac->opmode == NL80211_IFTYPE_AP) {
		/* TODO: Handle ADHOC and AP Mode */
	}

	if (tmpentry_max_pwdb != 0)
		rtlpriv->dm.entry_max_undec_sm_pwdb = tmpentry_max_pwdb;
	else
		rtlpriv->dm.entry_max_undec_sm_pwdb = 0;
	}

	if (tmpentry_min_pwdb != 0xff)
		rtlpriv->dm.entry_min_undec_sm_pwdb = tmpentry_min_pwdb;
	else
		rtlpriv->dm.entry_min_undec_sm_pwdb = 0;
	}

/* TODO:
 *	if (mac->opmode == NL80211_IFTYPE_STATION) {
 *		if (rtlpriv->rtlhal.fw_ready) {
 *			u32 param = (u32)(rtlpriv->dm.undec_sm_pwdb << 16);
 *			rtl8192c_set_rssi_cmd(hw, param);
 *		}
 *	}
 */
}

void rtl92c_dm_init_edca_turbo(struct ieee80211_hw *hw)

	s8 cck_index = 0;
	int i;
	bool is2t = IS_92C_SERIAL(rtlhal->version);
	s8 txpwr_level[3] = {0, 0, 0};
	u8 ofdm_min_index = 6, rf;

	rtlpriv->dm.txpower_trackinginit = true;

				rtlpriv->dm.ofdm_index[i] = ofdm_index_old[i];
			rtlpriv->dm.cck_index = cck_index_old;
		}
		/* Handle USB High PA boards */

		delta = (thermalvalue > rtlpriv->dm.thermalvalue) ?
		    (thermalvalue - rtlpriv->dm.thermalvalue) :

{
	struct rtl_priv *rtlpriv = rtl_priv(hw);
	struct ps_t *dm_pstable = &rtlpriv->dm_pstable;
	static u8 initialize;
	static u32 reg_874, reg_c70, reg_85c, reg_a74;

	if (!rtlpriv->reg_init) {
		rtlpriv->reg_874 = (rtl_get_bbreg(hw,
						  RFPGA0_XCD_RFINTERFACESW,
						  MASKDWORD) & 0x1CC000) >> 14;

		rtlpriv->reg_c70 = (rtl_get_bbreg(hw, ROFDM0_AGCPARAMETER1,
				    MASKDWORD) & BIT(3)) >> 3;

		rtlpriv->reg_85c = (rtl_get_bbreg(hw, RFPGA0_XCD_SWITCHCONTROL,
				    MASKDWORD) & 0xFF000000) >> 24;

		rtlpriv->reg_a74 = (rtl_get_bbreg(hw, 0xa74, MASKDWORD) &
				    0xF000) >> 12;

		rtlpriv->reg_init = true;
	}

	if (!bforce_in_normal) {

			rtl_set_bbreg(hw, 0x818, BIT(28), 0x1);
		} else {
			rtl_set_bbreg(hw, RFPGA0_XCD_RFINTERFACESW,
				      0x1CC000, rtlpriv->reg_874);
			rtl_set_bbreg(hw, ROFDM0_AGCPARAMETER1, BIT(3),
				      rtlpriv->reg_c70);
			rtl_set_bbreg(hw, RFPGA0_XCD_SWITCHCONTROL, 0xFF000000,
				      rtlpriv->reg_85c);
			rtl_set_bbreg(hw, 0xa74, 0xF000, rtlpriv->reg_a74);
			rtl_set_bbreg(hw, 0x818, BIT(28), 0x0);
		}


	struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
	struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));

	/* Determine the minimum RSSI */
	if (((mac->link_state == MAC80211_NOLINK)) &&
	    (rtlpriv->dm.entry_min_undec_sm_pwdb == 0)) {
		dm_pstable->rssi_val_min = 0;

			 dm_pstable->rssi_val_min);
	}

	/* Power Saving for 92C */
	if (IS_92C_SERIAL(rtlhal->version))
		;/* rtl92c_dm_1r_cca(hw); */
	else

	struct rtl_priv *rtlpriv = rtl_priv(hw);

	rtlpriv->dm.dm_type = DM_TYPE_BYDRIVER;
	rtlpriv->dm.dm_flag = DYNAMIC_FUNC_DISABLE | DYNAMIC_FUNC_DIG;
	rtlpriv->dm.undec_sm_pwdb = -1;
	rtlpriv->dm.undec_sm_cck = -1;
	rtlpriv->dm.dm_initialgain_enable = true;
	rtl92c_dm_diginit(hw);

	rtlpriv->dm.dm_flag |= HAL_DM_HIPWR_DISABLE;
	rtl92c_dm_init_dynamic_txpower(hw);

	rtl92c_dm_init_edca_turbo(hw);
	rtl92c_dm_init_rate_adaptive_mask(hw);
	rtlpriv->dm.dm_flag |= DYNAMIC_FUNC_SS;
	rtl92c_dm_initialize_txpower_tracking(hw);
	rtl92c_dm_init_dynamic_bb_powersaving(hw);

	rtlpriv->dm.ofdm_pkt_cnt = 0;
	rtlpriv->dm.dm_rssi_sel = RSSI_DEFAULT;
}
EXPORT_SYMBOL(rtl92c_dm_init);


	}

	if (undec_sm_pwdb >= TX_POWER_NEAR_FIELD_THRESH_LVL2) {
		rtlpriv->dm.dynamic_txhighpower_lvl = TXHIGHPWRLEVEL_LEVEL2;
		RT_TRACE(rtlpriv, COMP_POWER, DBG_LOUD,
			 "TXHIGHPWRLEVEL_LEVEL1 (TxPwr=0x0)\n");
	} else if ((undec_sm_pwdb < (TX_POWER_NEAR_FIELD_THRESH_LVL2 - 3)) &&

			 "PHY_SetTxPowerLevel8192S() Channel = %d\n",
			 rtlphy->current_channel);
		rtl92c_phy_set_txpower_level(hw, rtlphy->current_channel);
		if (rtlpriv->dm.dynamic_txhighpower_lvl ==
		    TXHIGHPWRLEVEL_NORMAL)
			dm_restorepowerindex(hw);
		else if (rtlpriv->dm.dynamic_txhighpower_lvl ==
			 TXHIGHPWRLEVEL_LEVEL1)
			dm_writepowerindex(hw, 0x14);
		else if (rtlpriv->dm.dynamic_txhighpower_lvl ==
			 TXHIGHPWRLEVEL_LEVEL2)
			dm_writepowerindex(hw, 0x10);
	}

	rtlpriv->dm.last_dtp_lvl = rtlpriv->dm.dynamic_txhighpower_lvl;
}


	else
		curr_bt_rssi_state &= (~BT_RSSI_STATE_SPECIAL_LOW);

	/* Set Tx Power according to BT status. */
	if (undec_sm_pwdb >= 30)
		curr_bt_rssi_state |=  BT_RSSI_STATE_TXPOWER_LOW;
	else if (undec_sm_pwdb < 25)
		curr_bt_rssi_state &= (~BT_RSSI_STATE_TXPOWER_LOW);

	/* Check BT state related to BT_Idle in B/G mode. */
	if (undec_sm_pwdb < 15)
		curr_bt_rssi_state |=  BT_RSSI_STATE_BG_EDCA_LOW;

Lines 101-106 void rtl92cu_dm_dynamic_txpower(struct i Link Here

(-)linux-2.6/drivers/net/wireless/rtlwifi/rtl8192cu/dm.c (+9 lines)
101	"PHY_SetTxPowerLevel8192S() Channel = %d\n",	101	"PHY_SetTxPowerLevel8192S() Channel = %d\n",
102	rtlphy->current_channel);	102	rtlphy->current_channel);
103	rtl92c_phy_set_txpower_level(hw, rtlphy->current_channel);	103	rtl92c_phy_set_txpower_level(hw, rtlphy->current_channel);
		104	if (rtlpriv->dm.dynamic_txhighpower_lvl ==
		105	TXHIGHPWRLEVEL_NORMAL)
		106	dm_restorepowerindex(hw);
		107	else if (rtlpriv->dm.dynamic_txhighpower_lvl ==
		108	TXHIGHPWRLEVEL_LEVEL1)
		109	dm_writepowerindex(hw, 0x14);
		110	else if (rtlpriv->dm.dynamic_txhighpower_lvl ==
		111	TXHIGHPWRLEVEL_LEVEL2)
		112	dm_writepowerindex(hw, 0x10);
104	}	113	}
105		114
106	rtlpriv->dm.last_dtp_lvl = rtlpriv->dm.dynamic_txhighpower_lvl;	115	rtlpriv->dm.last_dtp_lvl = rtlpriv->dm.dynamic_txhighpower_lvl;

Lines 30-32 Link Here

(-)linux-2.6/drivers/net/wireless/rtlwifi/rtl8192cu/dm.h (+3 lines)
30	#include "../rtl8192ce/dm.h"	30	#include "../rtl8192ce/dm.h"
31		31
32	void rtl92cu_dm_dynamic_txpower(struct ieee80211_hw *hw);	32	void rtl92cu_dm_dynamic_txpower(struct ieee80211_hw *hw);
		33	void dm_savepowerindex(struct ieee80211_hw *hw);
		34	void dm_writepowerindex(struct ieee80211_hw *hw, u8 value);
		35	void dm_restorepowerindex(struct ieee80211_hw *hw);




	if (mac->act_scanning) {
		tx_agc[RF90_PATH_A] = 0x3f3f3f3f;
		tx_agc[RF90_PATH_B] = 0x3f3f3f3f;
		for (idx1 = RF90_PATH_A; idx1 <= RF90_PATH_B; idx1++) {
			tx_agc[idx1] = ppowerlevel[idx1] |
			    (ppowerlevel[idx1] << 8) |
			    (ppowerlevel[idx1] << 16) |
			    (ppowerlevel[idx1] << 24);
			if (rtlhal->interface == INTF_USB) {
				if (tx_agc[idx1] > 0x20 &&
				    rtlefuse->external_pa)
					tx_agc[idx1] = 0x20;
						tx_agc[idx1] = 0x20;
				}
			}
		}
	} else {

			   TXHIGHPWRLEVEL_LEVEL2) {
			tx_agc[RF90_PATH_A] = 0x00000000;
			tx_agc[RF90_PATH_B] = 0x00000000;
		} else {
			for (idx1 = RF90_PATH_A; idx1 <= RF90_PATH_B; idx1++) {
				tx_agc[idx1] = ppowerlevel[idx1] |
				    (ppowerlevel[idx1] << 8) |

			    regoffset == RTXAGC_B_MCS07_MCS04)
				regoffset = 0xc98;
			for (i = 0; i < 3; i++) {
				if (i != 2)
					writeVal = (writeVal > 8) ?
						   (writeVal - 8) : 0;
				else
					writeVal = (writeVal > 6) ?
						   (writeVal - 6) : 0;
				rtl_write_byte(rtlpriv, (u32)(regoffset + i),
					      (u8)writeVal);
			}

Lines 176-181 static void rtl_process_pwdb(struct ieee Link Here

(-)linux-2.6/drivers/net/wireless/rtlwifi/stats.c (+14 lines)
176	struct rtl_sta_info *drv_priv = NULL;	176	struct rtl_sta_info *drv_priv = NULL;
177	struct ieee80211_sta *sta = NULL;	177	struct ieee80211_sta *sta = NULL;
178	long undec_sm_pwdb;	178	long undec_sm_pwdb;
		179	long undec_sm_cck;
179		180
180	rcu_read_lock();	181	rcu_read_lock();
181	if (rtlpriv->mac80211.opmode != NL80211_IFTYPE_STATION)	182	if (rtlpriv->mac80211.opmode != NL80211_IFTYPE_STATION)
Lines 185-196 static void rtl_process_pwdb(struct ieee Link Here
185	if (sta) {	186	if (sta) {
186	drv_priv = (struct rtl_sta_info *) sta->drv_priv;	187	drv_priv = (struct rtl_sta_info *) sta->drv_priv;
187	undec_sm_pwdb = drv_priv->rssi_stat.undec_sm_pwdb;	188	undec_sm_pwdb = drv_priv->rssi_stat.undec_sm_pwdb;
		189	undec_sm_cck = drv_priv->rssi_stat.undec_sm_cck;
188	} else {	190	} else {
189	undec_sm_pwdb = rtlpriv->dm.undec_sm_pwdb;	191	undec_sm_pwdb = rtlpriv->dm.undec_sm_pwdb;
		192	undec_sm_cck = rtlpriv->dm.undec_sm_cck;
190	}	193	}
191		194
192	if (undec_sm_pwdb < 0)	195	if (undec_sm_pwdb < 0)
193	undec_sm_pwdb = pstatus->rx_pwdb_all;	196	undec_sm_pwdb = pstatus->rx_pwdb_all;
		197	if (undec_sm_cck < 0)
		198	undec_sm_cck = pstatus->rx_pwdb_all;
194	if (pstatus->rx_pwdb_all > (u32) undec_sm_pwdb) {	199	if (pstatus->rx_pwdb_all > (u32) undec_sm_pwdb) {
195	undec_sm_pwdb = (((undec_sm_pwdb) *	200	undec_sm_pwdb = (((undec_sm_pwdb) *
196	(RX_SMOOTH_FACTOR - 1)) +	201	(RX_SMOOTH_FACTOR - 1)) +
Lines 200-205 static void rtl_process_pwdb(struct ieee Link Here
200	undec_sm_pwdb = (((undec_sm_pwdb) * (RX_SMOOTH_FACTOR - 1)) +	205	undec_sm_pwdb = (((undec_sm_pwdb) * (RX_SMOOTH_FACTOR - 1)) +
201	(pstatus->rx_pwdb_all)) / (RX_SMOOTH_FACTOR);	206	(pstatus->rx_pwdb_all)) / (RX_SMOOTH_FACTOR);
202	}	207	}
		208	if (pstatus->rx_pwdb_all > (u32) undec_sm_cck) {
		209	undec_sm_cck = (((undec_sm_pwdb) *
		210	(RX_SMOOTH_FACTOR - 1)) +
		211	(pstatus->rx_pwdb_all)) / (RX_SMOOTH_FACTOR);
		212	undec_sm_cck = undec_sm_cck + 1;
		213	} else {
		214	undec_sm_pwdb = (((undec_sm_cck) * (RX_SMOOTH_FACTOR - 1)) +
		215	(pstatus->rx_pwdb_all)) / (RX_SMOOTH_FACTOR);
		216	}
203		217
204	if (sta) {	218	if (sta) {
205	drv_priv->rssi_stat.undec_sm_pwdb = undec_sm_pwdb;	219	drv_priv->rssi_stat.undec_sm_pwdb = undec_sm_pwdb;

Return to bug 60713

Lines 37-42 Link Here

(-)linux-2.6/drivers/net/wireless/rtlwifi/base.c (-55 / +45 lines)
37		37
38	#include <linux/ip.h>	38	#include <linux/ip.h>
39	#include <linux/module.h>	39	#include <linux/module.h>
		40	#include <linux/udp.h>
40		41
41	/*	42	/*
42	*NOTICE!!!: This file will be very big, we should	43	*NOTICE!!!: This file will be very big, we should
Lines 1074-1137 u8 rtl_is_special_data(struct ieee80211_ Link Here
1074	if (!ieee80211_is_data(fc))	1075	if (!ieee80211_is_data(fc))
1075	return false;	1076	return false;
1076		1077
		1078	ip = (const struct iphdr *)(skb->data + mac_hdr_len +
		1079	SNAP_SIZE + PROTOC_TYPE_SIZE);
		1080	ether_type = be16_to_cpup((__be16 *)
		1081	(skb->data + mac_hdr_len + SNAP_SIZE));
		1082
		1083	switch (ether_type) {
		1084	case ETH_P_IP: {
		1085	struct udphdr *udp;
		1086	u16 src;
		1087	u16 dst;
		1088
		1089	if (ip->protocol != IPPROTO_UDP)
		1090	return false;
		1091	udp = (struct udphdr )((u8 )ip + (ip->ihl << 2));
		1092	src = be16_to_cpu(udp->source);
		1093	dst = be16_to_cpu(udp->dest);
		1094
		1095	/* If this case involves port 68 (UDP BOOTP client) connecting
		1096	* with port 67 (UDP BOOTP server), then return true so that
		1097	* the lowest speed is used.
		1098	*/
		1099	if (!((src == 68 && dst == 67) \|\| (src == 67 && dst == 68)))
		1100	return false;
1077		1101
1078	ip = (struct iphdr )((u8 ) skb->data + mac_hdr_len +	1102	RT_TRACE(rtlpriv, (COMP_SEND \| COMP_RECV), DBG_DMESG,
1079	SNAP_SIZE + PROTOC_TYPE_SIZE);	1103	"dhcp %s !!\n", is_tx ? "Tx" : "Rx");
1080	ether_type = (u16 ) ((u8 *) skb->data + mac_hdr_len + SNAP_SIZE);	1104	break;
1081	/* ether_type = ntohs(ether_type); */	1105	}
1082		1106	case ETH_P_ARP:
1083	if (ETH_P_IP == ether_type) {	1107	break;
1084	if (IPPROTO_UDP == ip->protocol) {	1108	case ETH_P_PAE:
1085	struct udphdr udp = (struct udphdr )((u8 *) ip +
1086	(ip->ihl << 2));
1087	if (((((u8 *) udp)[1] == 68) &&
1088	(((u8 *) udp)[3] == 67)) \|\|
1089	((((u8 *) udp)[1] == 67) &&
1090	(((u8 *) udp)[3] == 68))) {
1091	/*
1092	* 68 : UDP BOOTP client
1093	* 67 : UDP BOOTP server
1094	*/
1095	RT_TRACE(rtlpriv, (COMP_SEND \| COMP_RECV),
1096	DBG_DMESG, "dhcp %s !!\n",
1097	is_tx ? "Tx" : "Rx");
1098
1099	if (is_tx) {
1100	rtlpriv->enter_ps = false;
1101	schedule_work(&rtlpriv->
1102	works.lps_change_work);
1103	ppsc->last_delaylps_stamp_jiffies =
1104	jiffies;
1105	}
1106
1107	return true;
1108	}
1109	}
1110	} else if (ETH_P_ARP == ether_type) {
1111	if (is_tx) {
1112	rtlpriv->enter_ps = false;
1113	schedule_work(&rtlpriv->works.lps_change_work);
1114	ppsc->last_delaylps_stamp_jiffies = jiffies;
1115	}
1116
1117	return true;
1118	} else if (ETH_P_PAE == ether_type) {
1119	RT_TRACE(rtlpriv, (COMP_SEND \| COMP_RECV), DBG_DMESG,	1109	RT_TRACE(rtlpriv, (COMP_SEND \| COMP_RECV), DBG_DMESG,
1120	"802.1X %s EAPOL pkt!!\n", is_tx ? "Tx" : "Rx");	1110	"802.1X %s EAPOL pkt!!\n", is_tx ? "Tx" : "Rx");
1121		1111	break;
1122	if (is_tx) {	1112	case ETH_P_IPV6:
1123	rtlpriv->enter_ps = false;	1113	/* TODO: Is this right? */
1124	schedule_work(&rtlpriv->works.lps_change_work);	1114	return false;
1125	ppsc->last_delaylps_stamp_jiffies = jiffies;	1115	default:
1126	}	1116	return false;
1127
1128	return true;
1129	} else if (ETH_P_IPV6 == ether_type) {
1130	/* IPv6 */
1131	return true;
1132	}	1117	}
1133		1118	if (is_tx) {
1134	return false;	1119	rtlpriv->enter_ps = false;
		1120	schedule_work(&rtlpriv->works.lps_change_work);
		1121	ppsc->last_delaylps_stamp_jiffies = jiffies;
		1122	}
		1123	return true;
1135	}	1124	}
1136	EXPORT_SYMBOL_GPL(rtl_is_special_data);	1125	EXPORT_SYMBOL_GPL(rtl_is_special_data);
1137		1126
Lines 1448-1454 void rtl_watchdog_wq_callback(void *data Link Here
1448	/* if we can't recv beacon for 6s, we should	1437	/* if we can't recv beacon for 6s, we should
1449	* reconnect this AP	1438	* reconnect this AP
1450	*/	1439	*/
1451	if (rtlpriv->link_info.roam_times >= 3) {	1440	if ((rtlpriv->link_info.roam_times >= 3) &&
		1441	!is_zero_ether_addr(rtlpriv->mac80211.bssid)) {
1452	RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,	1442	RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
1453	"AP off, try to reconnect now\n");	1443	"AP off, try to reconnect now\n");
1454	rtlpriv->link_info.roam_times = 0;	1444	rtlpriv->link_info.roam_times = 0;

Lines 77-87 Link Here

(-)linux-2.6/drivers/net/wireless/rtlwifi/wifi.h (-21 / +18 lines)
77	#define RTL_SLOT_TIME_9 9	77	#define RTL_SLOT_TIME_9 9
78	#define RTL_SLOT_TIME_20 20	78	#define RTL_SLOT_TIME_20 20
79		79
80	/related with tcp/ip. /	80	/related to tcp/ip. /
81	/if_ehther.h/
82	#define ETH_P_PAE 0x888E /Port Access Entity (IEEE 802.1X) /
83	#define ETH_P_IP 0x0800 /Internet Protocol packet /
84	#define ETH_P_ARP 0x0806 /Address Resolution packet /
85	#define SNAP_SIZE 6	81	#define SNAP_SIZE 6
86	#define PROTOC_TYPE_SIZE 2	82	#define PROTOC_TYPE_SIZE 2
87		83
Lines 1039-1044 struct rtl_ht_agg { Link Here
1039		1035
1040	struct rssi_sta {	1036	struct rssi_sta {
1041	long undec_sm_pwdb;	1037	long undec_sm_pwdb;
		1038	long undec_sm_cck;
1042	};	1039	};
1043		1040
1044	struct rtl_tid_data {	1041	struct rtl_tid_data {
Lines 1329-1336 struct fast_ant_training { Link Here
1329	struct rtl_dm {	1326	struct rtl_dm {
1330	/PHY status for Dynamic Management /	1327	/PHY status for Dynamic Management /
1331	long entry_min_undec_sm_pwdb;	1328	long entry_min_undec_sm_pwdb;
		1329	long undec_sm_cck;
1332	long undec_sm_pwdb; /out dm /	1330	long undec_sm_pwdb; /out dm /
1333	long entry_max_undec_sm_pwdb;	1331	long entry_max_undec_sm_pwdb;
		1332	s32 ofdm_pkt_cnt;
1334	bool dm_initialgain_enable;	1333	bool dm_initialgain_enable;
1335	bool dynamic_txpower_enable;	1334	bool dynamic_txpower_enable;
1336	bool current_turbo_edca;	1335	bool current_turbo_edca;
Lines 1345-1350 struct rtl_dm { Link Here
1345	bool inform_fw_driverctrldm;	1344	bool inform_fw_driverctrldm;
1346	bool current_mrc_switch;	1345	bool current_mrc_switch;
1347	u8 txpowercount;	1346	u8 txpowercount;
		1347	u8 powerindex_backup[6];
1348		1348
1349	u8 thermalvalue_rxgain;	1349	u8 thermalvalue_rxgain;
1350	u8 thermalvalue_iqk;	1350	u8 thermalvalue_iqk;
Lines 1356-1362 struct rtl_dm { Link Here
1356	bool done_txpower;	1356	bool done_txpower;
1357	u8 dynamic_txhighpower_lvl; /Tx high power level /	1357	u8 dynamic_txhighpower_lvl; /Tx high power level /
1358	u8 dm_flag; /Indicate each dynamic mechanism's status. /	1358	u8 dm_flag; /Indicate each dynamic mechanism's status. /
		1359	u8 dm_flag_tmp;
1359	u8 dm_type;	1360	u8 dm_type;
		1361	u8 dm_rssi_sel;
1360	u8 txpower_track_control;	1362	u8 txpower_track_control;
1361	bool interrupt_migration;	1363	bool interrupt_migration;
1362	bool disable_tx_int;	1364	bool disable_tx_int;
Lines 1810-1815 struct rtl_hal_cfg { Link Here
1810	bool write_readback;	1812	bool write_readback;
1811	char *name;	1813	char *name;
1812	char *fw_name;	1814	char *fw_name;
		1815	char *alt_fw_name;
1813	struct rtl_hal_ops *ops;	1816	struct rtl_hal_ops *ops;
1814	struct rtl_mod_params *mod_params;	1817	struct rtl_mod_params *mod_params;
1815	struct rtl_hal_usbint_cfg *usb_interface_cfg;	1818	struct rtl_hal_usbint_cfg *usb_interface_cfg;
Lines 1954-1959 struct dig_t { Link Here
1954	u8 pre_ccastate;	1957	u8 pre_ccastate;
1955	u8 cur_ccasate;	1958	u8 cur_ccasate;
1956	u8 large_fa_hit;	1959	u8 large_fa_hit;
		1960	u8 dig_dynamic_min;
1957	u8 forbidden_igi;	1961	u8 forbidden_igi;
1958	u8 dig_state;	1962	u8 dig_state;
1959	u8 dig_highpwrstate;	1963	u8 dig_highpwrstate;
Lines 2034-2055 struct rtl_priv { Link Here
2034	struct dig_t dm_digtable;	2038	struct dig_t dm_digtable;
2035	struct ps_t dm_pstable;	2039	struct ps_t dm_pstable;
2036		2040
2037	/* section shared by individual drivers */	2041	u32 reg_874;
2038	union {	2042	u32 reg_c70;
2039	struct { /* data buffer pointer for USB reads */	2043	u32 reg_85c;
2040	__le32 *usb_data;	2044	u32 reg_a74;
2041	int usb_data_index;	2045	bool reg_init; /* true if regs saved */
2042	bool initialized;	2046	bool bt_operation_on;
2043	};	2047	__le32 *usb_data;
2044	struct { /* section for 8723ae */	2048	int usb_data_index;
2045	bool reg_init; /* true if regs saved */	2049	bool initialized;
2046	u32 reg_874;
2047	u32 reg_c70;
2048	u32 reg_85c;
2049	u32 reg_a74;
2050	bool bt_operation_on;
2051	};
2052	};
2053	bool enter_ps; /* true when entering PS */	2050	bool enter_ps; /* true when entering PS */
2054	u8 rate_mask[5];	2051	u8 rate_mask[5];
2055		2052

Lines 46-55 void rtl_fw_cb(const struct firmware *fi Link Here

(-)linux-2.6/drivers/net/wireless/rtlwifi/core.c (+11 lines)
46	"Firmware callback routine entered!\n");	46	"Firmware callback routine entered!\n");
47	complete(&rtlpriv->firmware_loading_complete);	47	complete(&rtlpriv->firmware_loading_complete);
48	if (!firmware) {	48	if (!firmware) {
		49	if (rtlpriv->cfg->alt_fw_name) {
		50	err = request_firmware(&firmware,
		51	rtlpriv->cfg->alt_fw_name,
		52	rtlpriv->io.dev);
		53	pr_info("Loading alternative firmware %s\n",
		54	rtlpriv->cfg->alt_fw_name);
		55	if (!err)
		56	goto found_alt;
		57	}
49	pr_err("Firmware %s not available\n", rtlpriv->cfg->fw_name);	58	pr_err("Firmware %s not available\n", rtlpriv->cfg->fw_name);
50	rtlpriv->max_fw_size = 0;	59	rtlpriv->max_fw_size = 0;
51	return;	60	return;
52	}	61	}
		62	found_alt:
53	if (firmware->size > rtlpriv->max_fw_size) {	63	if (firmware->size > rtlpriv->max_fw_size) {
54	RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,	64	RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
55	"Firmware is too big!\n");	65	"Firmware is too big!\n");
Lines 184-189 static int rtl_op_add_interface(struct i Link Here
184	rtlpriv->cfg->maps	194	rtlpriv->cfg->maps
185	[RTL_IBSS_INT_MASKS]);	195	[RTL_IBSS_INT_MASKS]);
186	}	196	}
		197	mac->link_state = MAC80211_LINKED;
187	break;	198	break;
188	case NL80211_IFTYPE_ADHOC:	199	case NL80211_IFTYPE_ADHOC:
189	RT_TRACE(rtlpriv, COMP_MAC80211, DBG_LOUD,	200	RT_TRACE(rtlpriv, COMP_MAC80211, DBG_LOUD,

Lines 85-101 void rtl92cu_phy_rf6052_set_cck_txpower( Link Here

(-)linux-2.6/drivers/net/wireless/rtlwifi/rtl8192cu/rf.c (-13 / +16 lines)
85	if (mac->act_scanning) {	85	if (mac->act_scanning) {
86	tx_agc[RF90_PATH_A] = 0x3f3f3f3f;	86	tx_agc[RF90_PATH_A] = 0x3f3f3f3f;
87	tx_agc[RF90_PATH_B] = 0x3f3f3f3f;	87	tx_agc[RF90_PATH_B] = 0x3f3f3f3f;
88	if (turbo_scanoff) {	88	for (idx1 = RF90_PATH_A; idx1 <= RF90_PATH_B; idx1++) {
89	for (idx1 = RF90_PATH_A; idx1 <= RF90_PATH_B; idx1++) {	89	tx_agc[idx1] = ppowerlevel[idx1] \|
90	tx_agc[idx1] = ppowerlevel[idx1] \|	90	(ppowerlevel[idx1] << 8) \|
91	(ppowerlevel[idx1] << 8) \|	91	(ppowerlevel[idx1] << 16) \|
92	(ppowerlevel[idx1] << 16) \|	92	(ppowerlevel[idx1] << 24);
93	(ppowerlevel[idx1] << 24);	93	if (rtlhal->interface == INTF_USB) {
94	if (rtlhal->interface == INTF_USB) {	94	if (tx_agc[idx1] > 0x20 &&
95	if (tx_agc[idx1] > 0x20 &&	95	rtlefuse->external_pa)
96	rtlefuse->external_pa)	96	tx_agc[idx1] = 0x20;
97	tx_agc[idx1] = 0x20;
98	}
99	}	97	}
100	}	98	}
101	} else {	99	} else {
Lines 107-113 void rtl92cu_phy_rf6052_set_cck_txpower( Link Here
107	TXHIGHPWRLEVEL_LEVEL2) {	105	TXHIGHPWRLEVEL_LEVEL2) {
108	tx_agc[RF90_PATH_A] = 0x00000000;	106	tx_agc[RF90_PATH_A] = 0x00000000;
109	tx_agc[RF90_PATH_B] = 0x00000000;	107	tx_agc[RF90_PATH_B] = 0x00000000;
110	} else{	108	} else {
111	for (idx1 = RF90_PATH_A; idx1 <= RF90_PATH_B; idx1++) {	109	for (idx1 = RF90_PATH_A; idx1 <= RF90_PATH_B; idx1++) {
112	tx_agc[idx1] = ppowerlevel[idx1] \|	110	tx_agc[idx1] = ppowerlevel[idx1] \|
113	(ppowerlevel[idx1] << 8) \|	111	(ppowerlevel[idx1] << 8) \|
Lines 373-379 static void _rtl92c_write_ofdm_power_reg Link Here
373	regoffset == RTXAGC_B_MCS07_MCS04)	371	regoffset == RTXAGC_B_MCS07_MCS04)
374	regoffset = 0xc98;	372	regoffset = 0xc98;
375	for (i = 0; i < 3; i++) {	373	for (i = 0; i < 3; i++) {
376	writeVal = (writeVal > 6) ? (writeVal - 6) : 0;	374	if (i != 2)
		375	writeVal = (writeVal > 8) ?
		376	(writeVal - 8) : 0;
		377	else
		378	writeVal = (writeVal > 6) ?
		379	(writeVal - 6) : 0;
377	rtl_write_byte(rtlpriv, (u32)(regoffset + i),	380	rtl_write_byte(rtlpriv, (u32)(regoffset + i),
378	(u8)writeVal);	381	(u8)writeVal);
379	}	382	}