Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 0aef64d7 authored by Dan Williams's avatar Dan Williams Committed by David S. Miller
Browse files

[PATCH] libertas: re-uppercase command defines and other constants 



For readability.

Signed-off-by: default avatarDan Williams <dcbw@redhat.com>
Signed-off-by: default avatarJohn W. Linville <linville@tuxdriver.com>
parent b44898eb

drivers/net/wireless/libertas/11d.c

+11 −11
Original line number Diff line number Diff line
@@ -422,13 +422,13 @@ static int parse_domain_info_11d(struct ieeetypes_countryinfofullset* 
u8 libertas_get_scan_type_11d(u8 chan,

			  struct parsed_region_chan_11d * parsed_region_chan)

{

	u8 scan_type = cmd_scan_type_passive;

	u8 scan_type = CMD_SCAN_TYPE_PASSIVE;



	lbs_deb_enter(LBS_DEB_11D);



	if (wlan_channel_known_11d(chan, parsed_region_chan)) {

		lbs_deb_11d("11D: Found and do Active Scan\n");

		scan_type = cmd_scan_type_active;

		scan_type = CMD_SCAN_TYPE_ACTIVE;

	} else {

		lbs_deb_11d("11D: Not Find and do Passive Scan\n");

	}
@@ -454,9 +454,9 @@ static int wlan_enable_11d(wlan_private * priv, u8 flag) 


	/* send cmd to FW to enable/disable 11D function in FW */

	ret = libertas_prepare_and_send_command(priv,

				    cmd_802_11_snmp_mib,

				    cmd_act_set,

				    cmd_option_waitforrsp,

				    CMD_802_11_SNMP_MIB,

				    CMD_ACT_SET,

				    CMD_OPTION_WAITFORRSP,

				    OID_802_11D_ENABLE,

				    &priv->adapter->enable11d);

	if (ret)
@@ -479,9 +479,9 @@ static int set_domain_info_11d(wlan_private * priv) 
		return 0;

	}



	ret = libertas_prepare_and_send_command(priv, cmd_802_11d_domain_info,

				    cmd_act_set,

				    cmd_option_waitforrsp, 0, NULL);

	ret = libertas_prepare_and_send_command(priv, CMD_802_11D_DOMAIN_INFO,

				    CMD_ACT_SET,

				    CMD_OPTION_WAITFORRSP, 0, NULL);

	if (ret)

		lbs_deb_11d("11D: Fail to dnld domain Info\n");
@@ -541,7 +541,7 @@ int libertas_cmd_802_11d_domain_info(wlan_private * priv, 


	cmd->command = cpu_to_le16(cmdno);

	pdomaininfo->action = cpu_to_le16(cmdoption);

	if (cmdoption == cmd_act_get) {

	if (cmdoption == CMD_ACT_GET) {

		cmd->size =

		    cpu_to_le16(sizeof(pdomaininfo->action) + S_DS_GEN);

		lbs_dbg_hex("11D: 802_11D_DOMAIN_INFO:", (u8 *) cmd,
@@ -633,10 +633,10 @@ int libertas_ret_802_11d_domain_info(wlan_private * priv, 
	}



	switch (action) {

	case cmd_act_set:	/*Proc Set action */

	case CMD_ACT_SET:	/*Proc Set action */

		break;



	case cmd_act_get:

	case CMD_ACT_GET:

		break;

	default:

		lbs_deb_11d("Invalid action:%d\n", domaininfo->action);

drivers/net/wireless/libertas/assoc.c

+34 −34
Original line number Diff line number Diff line
@@ -175,14 +175,14 @@ static int assoc_helper_mode(wlan_private *priv, 


	if (assoc_req->mode == IW_MODE_INFRA) {

		if (adapter->psstate != PS_STATE_FULL_POWER)

			libertas_ps_wakeup(priv, cmd_option_waitforrsp);

		adapter->psmode = wlan802_11powermodecam;

			libertas_ps_wakeup(priv, CMD_OPTION_WAITFORRSP);

		adapter->psmode = WLAN802_11POWERMODECAM;

	}



	adapter->mode = assoc_req->mode;

	ret = libertas_prepare_and_send_command(priv,

				    cmd_802_11_snmp_mib,

				    0, cmd_option_waitforrsp,

				    CMD_802_11_SNMP_MIB,

				    0, CMD_OPTION_WAITFORRSP,

				    OID_802_11_INFRASTRUCTURE_MODE,

		/* Shoot me now */  (void *) (size_t) assoc_req->mode);
@@ -195,9 +195,9 @@ static int assoc_helper_mode(wlan_private *priv, 
static int update_channel(wlan_private * priv)

{

	/* the channel in f/w could be out of sync, get the current channel */

	return libertas_prepare_and_send_command(priv, cmd_802_11_rf_channel,

				    cmd_opt_802_11_rf_channel_get,

				    cmd_option_waitforrsp, 0, NULL);

	return libertas_prepare_and_send_command(priv, CMD_802_11_RF_CHANNEL,

				    CMD_OPT_802_11_RF_CHANNEL_GET,

				    CMD_OPTION_WAITFORRSP, 0, NULL);

}



void libertas_sync_channel(struct work_struct *work)
@@ -227,9 +227,9 @@ static int assoc_helper_channel(wlan_private *priv, 
	lbs_deb_assoc("ASSOC: channel: %d -> %d\n",

	       adapter->curbssparams.channel, assoc_req->channel);



	ret = libertas_prepare_and_send_command(priv, cmd_802_11_rf_channel,

				cmd_opt_802_11_rf_channel_set,

				cmd_option_waitforrsp, 0, &assoc_req->channel);

	ret = libertas_prepare_and_send_command(priv, CMD_802_11_RF_CHANNEL,

				CMD_OPT_802_11_RF_CHANNEL_SET,

				CMD_OPTION_WAITFORRSP, 0, &assoc_req->channel);

	if (ret < 0) {

		lbs_deb_assoc("ASSOC: channel: error setting channel.");

	}
@@ -278,15 +278,15 @@ static int assoc_helper_wep_keys(wlan_private *priv, 
	    || assoc_req->wep_keys[2].len

	    || assoc_req->wep_keys[3].len) {

		ret = libertas_prepare_and_send_command(priv,

					    cmd_802_11_set_wep,

					    cmd_act_add,

					    cmd_option_waitforrsp,

					    CMD_802_11_SET_WEP,

					    CMD_ACT_ADD,

					    CMD_OPTION_WAITFORRSP,

					    0, assoc_req);

	} else {

		ret = libertas_prepare_and_send_command(priv,

					    cmd_802_11_set_wep,

					    cmd_act_remove,

					    cmd_option_waitforrsp,

					    CMD_802_11_SET_WEP,

					    CMD_ACT_REMOVE,

					    CMD_OPTION_WAITFORRSP,

					    0, NULL);

	}
@@ -295,9 +295,9 @@ static int assoc_helper_wep_keys(wlan_private *priv, 


	/* enable/disable the MAC's WEP packet filter */

	if (assoc_req->secinfo.wep_enabled)

		adapter->currentpacketfilter |= cmd_act_mac_wep_enable;

		adapter->currentpacketfilter |= CMD_ACT_MAC_WEP_ENABLE;

	else

		adapter->currentpacketfilter &= ~cmd_act_mac_wep_enable;

		adapter->currentpacketfilter &= ~CMD_ACT_MAC_WEP_ENABLE;

	ret = libertas_set_mac_packet_filter(priv);

	if (ret)

		goto out;
@@ -342,9 +342,9 @@ static int assoc_helper_secinfo(wlan_private *priv, 


	/* Get RSN enabled/disabled */

	ret = libertas_prepare_and_send_command(priv,

				    cmd_802_11_enable_rsn,

				    cmd_act_set,

				    cmd_option_waitforrsp,

				    CMD_802_11_ENABLE_RSN,

				    CMD_ACT_GET,

				    CMD_OPTION_WAITFORRSP,

				    0, &rsn);

	if (ret) {

		lbs_deb_assoc("Failed to get RSN status: %d", ret);
@@ -359,9 +359,9 @@ static int assoc_helper_secinfo(wlan_private *priv, 
	/* Set RSN enabled/disabled */

	rsn = do_wpa;

	ret = libertas_prepare_and_send_command(priv,

				    cmd_802_11_enable_rsn,

				    cmd_act_set,

				    cmd_option_waitforrsp,

				    CMD_802_11_ENABLE_RSN,

				    CMD_ACT_SET,

				    CMD_OPTION_WAITFORRSP,

				    0, &rsn);



out:
@@ -378,9 +378,9 @@ static int assoc_helper_wpa_keys(wlan_private *priv, 
	lbs_deb_enter(LBS_DEB_ASSOC);



	ret = libertas_prepare_and_send_command(priv,

				    cmd_802_11_key_material,

				    cmd_act_set,

				    cmd_option_waitforrsp,

				    CMD_802_11_KEY_MATERIAL,

				    CMD_ACT_SET,

				    CMD_OPTION_WAITFORRSP,

				    0, assoc_req);



	lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
@@ -412,7 +412,7 @@ static int assoc_helper_wpa_ie(wlan_private *priv, 
static int should_deauth_infrastructure(wlan_adapter *adapter,

                                        struct assoc_request * assoc_req)

{

	if (adapter->connect_status != libertas_connected)

	if (adapter->connect_status != LIBERTAS_CONNECTED)

		return 0;



	if (test_bit(ASSOC_FLAG_SSID, &assoc_req->flags)) {
@@ -453,7 +453,7 @@ static int should_deauth_infrastructure(wlan_adapter *adapter, 
static int should_stop_adhoc(wlan_adapter *adapter,

                             struct assoc_request * assoc_req)

{

	if (adapter->connect_status != libertas_connected)

	if (adapter->connect_status != LIBERTAS_CONNECTED)

		return 0;



	if (libertas_ssid_cmp(adapter->curbssparams.ssid,
@@ -623,7 +623,7 @@ void libertas_association_worker(struct work_struct *work) 
			success = 0;

		}



		if (adapter->connect_status != libertas_connected) {

		if (adapter->connect_status != LIBERTAS_CONNECTED) {

			lbs_deb_assoc("ASSOC: assoication attempt unsuccessful, "

				"not connected.\n");

			success = 0;
@@ -636,12 +636,12 @@ void libertas_association_worker(struct work_struct *work) 
				             adapter->curbssparams.ssid_len),

				MAC_ARG(adapter->curbssparams.bssid));

			libertas_prepare_and_send_command(priv,

				cmd_802_11_rssi,

				0, cmd_option_waitforrsp, 0, NULL);

				CMD_802_11_RSSI,

				0, CMD_OPTION_WAITFORRSP, 0, NULL);



			libertas_prepare_and_send_command(priv,

				cmd_802_11_get_log,

				0, cmd_option_waitforrsp, 0, NULL);

				CMD_802_11_GET_LOG,

				0, CMD_OPTION_WAITFORRSP, 0, NULL);

		} else {

			ret = -1;

		}

drivers/net/wireless/libertas/cmd.c

+161 −161

File changed.

Preview size limit exceeded, changes collapsed.

drivers/net/wireless/libertas/cmdresp.c

+70 −70
Original line number Diff line number Diff line
@@ -28,7 +28,7 @@ void libertas_mac_event_disconnected(wlan_private * priv) 
	wlan_adapter *adapter = priv->adapter;

	union iwreq_data wrqu;



	if (adapter->connect_status != libertas_connected)

	if (adapter->connect_status != LIBERTAS_CONNECTED)

		return;



	lbs_deb_cmd("Handles disconnect event.\n");
@@ -69,7 +69,7 @@ void libertas_mac_event_disconnected(wlan_private * priv) 
	            escape_essid(adapter->prev_ssid, adapter->prev_ssid_len),

	            adapter->prev_ssid_len);



	adapter->connect_status = libertas_disconnected;

	adapter->connect_status = LIBERTAS_DISCONNECTED;



	/* Save previous SSID and BSSID for possible reassociation */

	memcpy(&adapter->prev_ssid, &adapter->curbssparams.ssid,
@@ -124,7 +124,7 @@ static int wlan_ret_reg_access(wlan_private * priv, 
	lbs_deb_enter(LBS_DEB_CMD);



	switch (type) {

	case cmd_ret_mac_reg_access:

	case CMD_RET_MAC_REG_ACCESS:

		{

			struct cmd_ds_mac_reg_access *reg = &resp->params.macreg;
@@ -133,7 +133,7 @@ static int wlan_ret_reg_access(wlan_private * priv, 
			break;

		}



	case cmd_ret_bbp_reg_access:

	case CMD_RET_BBP_REG_ACCESS:

		{

			struct cmd_ds_bbp_reg_access *reg = &resp->params.bbpreg;
@@ -142,7 +142,7 @@ static int wlan_ret_reg_access(wlan_private * priv, 
			break;

		}



	case cmd_ret_rf_reg_access:

	case CMD_RET_RF_REG_ACCESS:

		{

			struct cmd_ds_rf_reg_access *reg = &resp->params.rfreg;
@@ -274,21 +274,21 @@ static int wlan_ret_802_11_snmp_mib(wlan_private * priv, 
	       querytype);

	lbs_deb_cmd("SNMP_RESP: Buf size  = %x\n", le16_to_cpu(smib->bufsize));



	if (querytype == cmd_act_get) {

	if (querytype == CMD_ACT_GET) {

		switch (oid) {

		case fragthresh_i:

		case FRAGTHRESH_I:

			priv->adapter->fragthsd =

				le16_to_cpu(*((__le16 *)(smib->value)));

			lbs_deb_cmd("SNMP_RESP: fragthsd =%u\n",

				    priv->adapter->fragthsd);

			break;

		case rtsthresh_i:

		case RTSTHRESH_I:

			priv->adapter->rtsthsd =

				le16_to_cpu(*((__le16 *)(smib->value)));

			lbs_deb_cmd("SNMP_RESP: rtsthsd =%u\n",

				    priv->adapter->rtsthsd);

			break;

		case short_retrylim_i:

		case SHORT_RETRYLIM_I:

			priv->adapter->txretrycount =

				le16_to_cpu(*((__le16 *)(smib->value)));

			lbs_deb_cmd("SNMP_RESP: txretrycount =%u\n",
@@ -314,7 +314,7 @@ static int wlan_ret_802_11_key_material(wlan_private * priv, 
	lbs_deb_enter(LBS_DEB_CMD);



	/* Copy the returned key to driver private data */

	if (action == cmd_act_get) {

	if (action == CMD_ACT_GET) {

		u8 * buf_ptr = (u8 *) &pkeymaterial->keyParamSet;

		u8 * resp_end = (u8 *) (resp + le16_to_cpu(resp->size));
@@ -396,10 +396,10 @@ static int wlan_ret_802_11_rf_antenna(wlan_private * priv, 
	wlan_adapter *adapter = priv->adapter;

	u16 action = le16_to_cpu(pAntenna->action);



	if (action == cmd_act_get_rx)

	if (action == CMD_ACT_GET_rx)

		adapter->rxantennamode = le16_to_cpu(pAntenna->antennamode);



	if (action == cmd_act_get_tx)

	if (action == CMD_ACT_GET_tx)

		adapter->txantennamode = le16_to_cpu(pAntenna->antennamode);



	lbs_deb_cmd("RF_ANT_RESP: action = 0x%x, mode = 0x%04x\n",
@@ -416,7 +416,7 @@ static int wlan_ret_802_11_rate_adapt_rateset(wlan_private * priv, 


	lbs_deb_enter(LBS_DEB_CMD);



	if (rates->action == cmd_act_get) {

	if (rates->action == CMD_ACT_GET) {

		adapter->enablehwauto = le16_to_cpu(rates->enablehwauto);

		adapter->ratebitmap = le16_to_cpu(rates->bitmap);

	}
@@ -438,7 +438,7 @@ static int wlan_ret_802_11_data_rate(wlan_private * priv, 
		(u8 *) pdatarate, sizeof(struct cmd_ds_802_11_data_rate));



	dot11datarate = pdatarate->datarate[0];

	if (pdatarate->action == cpu_to_le16(cmd_act_get_tx_rate)) {

	if (pdatarate->action == cpu_to_le16(CMD_ACT_GET_tx_rate)) {

		memcpy(adapter->libertas_supported_rates, pdatarate->datarate,

		       sizeof(adapter->libertas_supported_rates));

	}
@@ -458,7 +458,7 @@ static int wlan_ret_802_11_rf_channel(wlan_private * priv, 


	lbs_deb_enter(LBS_DEB_CMD);



	if (action == cmd_opt_802_11_rf_channel_get

	if (action == CMD_OPT_802_11_RF_CHANNEL_GET

	    && adapter->curbssparams.channel != newchannel) {

		lbs_deb_cmd("channel Switch: %d to %d\n",

		       adapter->curbssparams.channel, newchannel);
@@ -547,7 +547,7 @@ static int libertas_ret_802_11_enable_rsn(wlan_private * priv, 


	lbs_deb_enter(LBS_DEB_CMD);



	if (enable_rsn->action == cpu_to_le16(cmd_act_get)) {

	if (enable_rsn->action == cpu_to_le16(CMD_ACT_GET)) {

		if (pdata_buf)

			*pdata_buf = (u32) le16_to_cpu(enable_rsn->enable);

	}
@@ -565,134 +565,134 @@ static inline int handle_cmd_response(u16 respcmd, 
	wlan_adapter *adapter = priv->adapter;



	switch (respcmd) {

	case cmd_ret_mac_reg_access:

	case cmd_ret_bbp_reg_access:

	case cmd_ret_rf_reg_access:

	case CMD_RET_MAC_REG_ACCESS:

	case CMD_RET_BBP_REG_ACCESS:

	case CMD_RET_RF_REG_ACCESS:

		ret = wlan_ret_reg_access(priv, respcmd, resp);

		break;



	case cmd_ret_hw_spec_info:

	case CMD_RET_HW_SPEC_INFO:

		ret = wlan_ret_get_hw_spec(priv, resp);

		break;



	case cmd_ret_802_11_scan:

	case CMD_RET_802_11_SCAN:

		ret = libertas_ret_80211_scan(priv, resp);

		break;



	case cmd_ret_802_11_get_log:

	case CMD_RET_802_11_GET_LOG:

		ret = wlan_ret_get_log(priv, resp);

		break;



	case cmd_ret_802_11_associate:

	case cmd_ret_802_11_reassociate:

	case CMD_RET_802_11_ASSOCIATE:

	case CMD_RET_802_11_REASSOCIATE:

		ret = libertas_ret_80211_associate(priv, resp);

		break;



	case cmd_ret_802_11_disassociate:

	case cmd_ret_802_11_deauthenticate:

	case CMD_RET_802_11_DISASSOCIATE:

	case CMD_RET_802_11_DEAUTHENTICATE:

		ret = libertas_ret_80211_disassociate(priv, resp);

		break;



	case cmd_ret_802_11_ad_hoc_start:

	case cmd_ret_802_11_ad_hoc_join:

	case CMD_RET_802_11_AD_HOC_START:

	case CMD_RET_802_11_AD_HOC_JOIN:

		ret = libertas_ret_80211_ad_hoc_start(priv, resp);

		break;



	case cmd_ret_802_11_stat:

	case CMD_RET_802_11_STAT:

		ret = wlan_ret_802_11_stat(priv, resp);

		break;



	case cmd_ret_802_11_snmp_mib:

	case CMD_RET_802_11_SNMP_MIB:

		ret = wlan_ret_802_11_snmp_mib(priv, resp);

		break;



	case cmd_ret_802_11_rf_tx_power:

	case CMD_RET_802_11_RF_TX_POWER:

		ret = wlan_ret_802_11_rf_tx_power(priv, resp);

		break;



	case cmd_ret_802_11_set_afc:

	case cmd_ret_802_11_get_afc:

	case CMD_RET_802_11_SET_AFC:

	case CMD_RET_802_11_GET_AFC:

		spin_lock_irqsave(&adapter->driver_lock, flags);

		memmove(adapter->cur_cmd->pdata_buf, &resp->params.afc,

			sizeof(struct cmd_ds_802_11_afc));

		spin_unlock_irqrestore(&adapter->driver_lock, flags);



		break;

	case cmd_ret_802_11_rf_antenna:

	case CMD_RET_802_11_RF_ANTENNA:

		ret = wlan_ret_802_11_rf_antenna(priv, resp);

		break;



	case cmd_ret_mac_multicast_adr:

	case cmd_ret_mac_control:

	case cmd_ret_802_11_set_wep:

	case cmd_ret_802_11_reset:

	case cmd_ret_802_11_authenticate:

	case cmd_ret_802_11_radio_control:

	case cmd_ret_802_11_beacon_stop:

	case CMD_RET_MAC_MULTICAST_ADR:

	case CMD_RET_MAC_CONTROL:

	case CMD_RET_802_11_SET_WEP:

	case CMD_RET_802_11_RESET:

	case CMD_RET_802_11_AUTHENTICATE:

	case CMD_RET_802_11_RADIO_CONTROL:

	case CMD_RET_802_11_BEACON_STOP:

		break;



	case cmd_ret_802_11_enable_rsn:

	case CMD_RET_802_11_ENABLE_RSN:

		ret = libertas_ret_802_11_enable_rsn(priv, resp);

		break;



	case cmd_ret_802_11_data_rate:

	case CMD_RET_802_11_DATA_RATE:

		ret = wlan_ret_802_11_data_rate(priv, resp);

		break;

	case cmd_ret_802_11_rate_adapt_rateset:

	case CMD_RET_802_11_RATE_ADAPT_RATESET:

		ret = wlan_ret_802_11_rate_adapt_rateset(priv, resp);

		break;

	case cmd_ret_802_11_rf_channel:

	case CMD_RET_802_11_RF_CHANNEL:

		ret = wlan_ret_802_11_rf_channel(priv, resp);

		break;



	case cmd_ret_802_11_rssi:

	case CMD_RET_802_11_RSSI:

		ret = wlan_ret_802_11_rssi(priv, resp);

		break;



	case cmd_ret_802_11_mac_address:

	case CMD_RET_802_11_MAC_ADDRESS:

		ret = wlan_ret_802_11_mac_address(priv, resp);

		break;



	case cmd_ret_802_11_ad_hoc_stop:

	case CMD_RET_802_11_AD_HOC_STOP:

		ret = libertas_ret_80211_ad_hoc_stop(priv, resp);

		break;



	case cmd_ret_802_11_key_material:

	case CMD_RET_802_11_KEY_MATERIAL:

		lbs_deb_cmd("CMD_RESP: KEY_MATERIAL command response\n");

		ret = wlan_ret_802_11_key_material(priv, resp);

		break;



	case cmd_ret_802_11_eeprom_access:

	case CMD_RET_802_11_EEPROM_ACCESS:

		ret = wlan_ret_802_11_eeprom_access(priv, resp);

		break;



	case cmd_ret_802_11d_domain_info:

	case CMD_RET_802_11D_DOMAIN_INFO:

		ret = libertas_ret_802_11d_domain_info(priv, resp);

		break;



	case cmd_ret_802_11_sleep_params:

	case CMD_RET_802_11_SLEEP_PARAMS:

		ret = wlan_ret_802_11_sleep_params(priv, resp);

		break;

	case cmd_ret_802_11_inactivity_timeout:

	case CMD_RET_802_11_INACTIVITY_TIMEOUT:

		spin_lock_irqsave(&adapter->driver_lock, flags);

		*((u16 *) adapter->cur_cmd->pdata_buf) =

		    le16_to_cpu(resp->params.inactivity_timeout.timeout);

		spin_unlock_irqrestore(&adapter->driver_lock, flags);

		break;



	case cmd_ret_802_11_tpc_cfg:

	case CMD_RET_802_11_TPC_CFG:

		spin_lock_irqsave(&adapter->driver_lock, flags);

		memmove(adapter->cur_cmd->pdata_buf, &resp->params.tpccfg,

			sizeof(struct cmd_ds_802_11_tpc_cfg));

		spin_unlock_irqrestore(&adapter->driver_lock, flags);

		break;

	case cmd_ret_802_11_led_gpio_ctrl:

	case CMD_RET_802_11_LED_GPIO_CTRL:

		spin_lock_irqsave(&adapter->driver_lock, flags);

		memmove(adapter->cur_cmd->pdata_buf, &resp->params.ledgpio,

			sizeof(struct cmd_ds_802_11_led_ctrl));

		spin_unlock_irqrestore(&adapter->driver_lock, flags);

		break;

	case cmd_ret_802_11_pwr_cfg:

	case CMD_RET_802_11_PWR_CFG:

		spin_lock_irqsave(&adapter->driver_lock, flags);

		memmove(adapter->cur_cmd->pdata_buf, &resp->params.pwrcfg,

			sizeof(struct cmd_ds_802_11_pwr_cfg));
@@ -700,32 +700,32 @@ static inline int handle_cmd_response(u16 respcmd, 


		break;



	case cmd_ret_get_tsf:

	case CMD_RET_GET_TSF:

		spin_lock_irqsave(&adapter->driver_lock, flags);

		memcpy(priv->adapter->cur_cmd->pdata_buf,

		       &resp->params.gettsf.tsfvalue, sizeof(u64));

		spin_unlock_irqrestore(&adapter->driver_lock, flags);

		break;

	case cmd_ret_bt_access:

	case CMD_RET_BT_ACCESS:

		spin_lock_irqsave(&adapter->driver_lock, flags);

		if (adapter->cur_cmd->pdata_buf)

			memcpy(adapter->cur_cmd->pdata_buf,

			       &resp->params.bt.addr1, 2 * ETH_ALEN);

		spin_unlock_irqrestore(&adapter->driver_lock, flags);

		break;

	case cmd_ret_fwt_access:

	case CMD_RET_FWT_ACCESS:

		spin_lock_irqsave(&adapter->driver_lock, flags);

		if (adapter->cur_cmd->pdata_buf)

			memcpy(adapter->cur_cmd->pdata_buf, &resp->params.fwt,

			       sizeof(resp->params.fwt));

		spin_unlock_irqrestore(&adapter->driver_lock, flags);

		break;

	case cmd_ret_mesh_access:

	case CMD_RET_MESH_ACCESS:

		if (adapter->cur_cmd->pdata_buf)

			memcpy(adapter->cur_cmd->pdata_buf, &resp->params.mesh,

			       sizeof(resp->params.mesh));

		break;

	case cmd_rte_802_11_tx_rate_query:

	case CMD_RTE_802_11_TX_RATE_QUERY:

		priv->adapter->txrate = resp->params.txrate.txrate;

		break;

	default:
@@ -787,7 +787,7 @@ int libertas_process_rx_command(wlan_private * priv) 
	/* Store the response code to cur_cmd_retcode. */

	adapter->cur_cmd_retcode = result;;



	if (respcmd == cmd_ret_802_11_ps_mode) {

	if (respcmd == CMD_RET_802_11_PS_MODE) {

		struct cmd_ds_802_11_ps_mode *psmode = &resp->params.psmode;

		u16 action = le16_to_cpu(psmode->action);
@@ -804,14 +804,14 @@ int libertas_process_rx_command(wlan_private * priv) 
			 * libertas_execute_next_command().

			 */

			if (adapter->mode == IW_MODE_ADHOC &&

			    action == cmd_subcmd_enter_ps)

				adapter->psmode = wlan802_11powermodecam;

		} else if (action == cmd_subcmd_enter_ps) {

			    action == CMD_SUBCMD_ENTER_PS)

				adapter->psmode = WLAN802_11POWERMODECAM;

		} else if (action == CMD_SUBCMD_ENTER_PS) {

			adapter->needtowakeup = 0;

			adapter->psstate = PS_STATE_AWAKE;



			lbs_deb_cmd("CMD_RESP: Enter_PS command response\n");

			if (adapter->connect_status != libertas_connected) {

			if (adapter->connect_status != LIBERTAS_CONNECTED) {

				/*

				 * When Deauth Event received before Enter_PS command

				 * response, We need to wake up the firmware.
@@ -825,7 +825,7 @@ int libertas_process_rx_command(wlan_private * priv) 
				mutex_lock(&adapter->lock);

				spin_lock_irqsave(&adapter->driver_lock, flags);

			}

		} else if (action == cmd_subcmd_exit_ps) {

		} else if (action == CMD_SUBCMD_EXIT_PS) {

			adapter->needtowakeup = 0;

			adapter->psstate = PS_STATE_FULL_POWER;

			lbs_deb_cmd("CMD_RESP: Exit_PS command response\n");
@@ -857,8 +857,8 @@ int libertas_process_rx_command(wlan_private * priv) 
		 * Handling errors here

		 */

		switch (respcmd) {

		case cmd_ret_hw_spec_info:

		case cmd_ret_802_11_reset:

		case CMD_RET_HW_SPEC_INFO:

		case CMD_RET_802_11_RESET:

			lbs_deb_cmd("CMD_RESP: Reset command failed\n");

			break;
@@ -1003,7 +1003,7 @@ int libertas_process_event(wlan_private * priv) 


	case MACREG_INT_CODE_MESH_AUTO_STARTED:

		lbs_pr_alert( "EVENT: MESH_AUTO_STARTED\n");

		adapter->connect_status = libertas_connected ;

		adapter->connect_status = LIBERTAS_CONNECTED ;

		if (priv->mesh_open == 1) {

			netif_wake_queue(priv->mesh_dev) ;

			netif_carrier_on(priv->mesh_dev) ;

drivers/net/wireless/libertas/debugfs.c

+46 −46
Original line number Diff line number Diff line
@@ -125,9 +125,9 @@ static ssize_t libertas_sleepparams_write(struct file *file, 
	priv->adapter->sp.sp_reserved = p6;



        res = libertas_prepare_and_send_command(priv,

				cmd_802_11_sleep_params,

				cmd_act_set,

				cmd_option_waitforrsp, 0, NULL);

				CMD_802_11_SLEEP_PARAMS,

				CMD_ACT_SET,

				CMD_OPTION_WAITFORRSP, 0, NULL);



	if (!res)

		res = count;
@@ -150,9 +150,9 @@ static ssize_t libertas_sleepparams_read(struct file *file, char __user *userbuf 
	char *buf = (char *)addr;



        res = libertas_prepare_and_send_command(priv,

				cmd_802_11_sleep_params,

				cmd_act_get,

				cmd_option_waitforrsp, 0, NULL);

				CMD_802_11_SLEEP_PARAMS,

				CMD_ACT_GET,

				CMD_OPTION_WAITFORRSP, 0, NULL);

	if (res) {

		res = -EFAULT;

		goto out_unlock;
@@ -386,7 +386,7 @@ static int libertas_event_initcmd(wlan_private *priv, void **response_buf, 
			struct cmd_ctrl_node **cmdnode,

			struct cmd_ds_command **cmd)

{

	u16 wait_option = cmd_option_waitforrsp;

	u16 wait_option = CMD_OPTION_WAITFORRSP;



	if (!(*cmdnode = libertas_get_free_cmd_ctrl_node(priv))) {

		lbs_deb_debugfs("failed libertas_get_free_cmd_ctrl_node\n");
@@ -402,7 +402,7 @@ static int libertas_event_initcmd(wlan_private *priv, void **response_buf, 
	(*cmdnode)->cmdflags |= CMD_F_HOSTCMD;

	(*cmdnode)->cmdwaitqwoken = 0;

	*cmd = (struct cmd_ds_command *)(*cmdnode)->bufvirtualaddr;

	(*cmd)->command = cpu_to_le16(cmd_802_11_subscribe_event);

	(*cmd)->command = cpu_to_le16(CMD_802_11_SUBSCRIBE_EVENT);

	(*cmd)->seqnum = cpu_to_le16(++priv->adapter->seqnum);

	(*cmd)->result = 0;

	return 0;
@@ -429,7 +429,7 @@ static ssize_t libertas_lowrssi_read(struct file *file, char __user *userbuf, 
	}



	event = &pcmdptr->params.subscribe_event;

	event->action = cpu_to_le16(cmd_act_get);

	event->action = cpu_to_le16(CMD_ACT_GET);

	pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);

	libertas_queue_cmd(adapter, pcmdnode, 1);

	wake_up_interruptible(&priv->mainthread.waitq);
@@ -447,7 +447,7 @@ static ssize_t libertas_lowrssi_read(struct file *file, char __user *userbuf, 
		return 0;

	}



	if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {

	if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {

		lbs_pr_err("command response incorrect!\n");

		kfree(response_buf);

		free_page(addr);
@@ -493,7 +493,7 @@ static u16 libertas_get_events_bitmap(wlan_private *priv) 
		return res;



	event = &pcmdptr->params.subscribe_event;

	event->action = cpu_to_le16(cmd_act_get);

	event->action = cpu_to_le16(CMD_ACT_GET);

	pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);

	libertas_queue_cmd(adapter, pcmdnode, 1);

	wake_up_interruptible(&priv->mainthread.waitq);
@@ -511,7 +511,7 @@ static u16 libertas_get_events_bitmap(wlan_private *priv) 
		return 0;

	}



	if (pcmdptr->command != cmd_ret_802_11_subscribe_event) {

	if (pcmdptr->command != CMD_RET_802_11_SUBSCRIBE_EVENT) {

		lbs_pr_err("command response incorrect!\n");

		kfree(response_buf);

		return 0;
@@ -559,7 +559,7 @@ static ssize_t libertas_lowrssi_write(struct file *file, 
		goto out_unlock;



	event = &pcmdptr->params.subscribe_event;

	event->action = cpu_to_le16(cmd_act_set);

	event->action = cpu_to_le16(CMD_ACT_SET);

	pcmdptr->size = cpu_to_le16(S_DS_GEN +

		sizeof(struct cmd_ds_802_11_subscribe_event) +

		sizeof(struct mrvlietypes_rssithreshold));
@@ -591,7 +591,7 @@ static ssize_t libertas_lowrssi_write(struct file *file, 
		return 0;

	}



	if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {

	if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {

		lbs_pr_err("command response incorrect!\n");

		kfree(response_buf);

		free_page(addr);
@@ -625,7 +625,7 @@ static ssize_t libertas_lowsnr_read(struct file *file, char __user *userbuf, 
	}



	event = &pcmdptr->params.subscribe_event;

	event->action = cpu_to_le16(cmd_act_get);

	event->action = cpu_to_le16(CMD_ACT_GET);

	pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);

	libertas_queue_cmd(adapter, pcmdnode, 1);

	wake_up_interruptible(&priv->mainthread.waitq);
@@ -644,7 +644,7 @@ static ssize_t libertas_lowsnr_read(struct file *file, char __user *userbuf, 
		return 0;

	}



	if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {

	if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {

		lbs_pr_err("command response incorrect!\n");

		kfree(response_buf);

		free_page(addr);
@@ -712,7 +712,7 @@ static ssize_t libertas_lowsnr_write(struct file *file, 
		goto out_unlock;



	event = &pcmdptr->params.subscribe_event;

	event->action = cpu_to_le16(cmd_act_set);

	event->action = cpu_to_le16(CMD_ACT_SET);

	pcmdptr->size = cpu_to_le16(S_DS_GEN +

		sizeof(struct cmd_ds_802_11_subscribe_event) +

		sizeof(struct mrvlietypes_snrthreshold));
@@ -743,7 +743,7 @@ static ssize_t libertas_lowsnr_write(struct file *file, 
		return 0;

	}



	if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {

	if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {

		lbs_pr_err("command response incorrect!\n");

		kfree(response_buf);

		free_page(addr);
@@ -778,7 +778,7 @@ static ssize_t libertas_failcount_read(struct file *file, char __user *userbuf, 
	}



	event = &pcmdptr->params.subscribe_event;

	event->action = cpu_to_le16(cmd_act_get);

	event->action = cpu_to_le16(CMD_ACT_GET);

	pcmdptr->size =	cpu_to_le16(sizeof(*event) + S_DS_GEN);

	libertas_queue_cmd(adapter, pcmdnode, 1);

	wake_up_interruptible(&priv->mainthread.waitq);
@@ -797,7 +797,7 @@ static ssize_t libertas_failcount_read(struct file *file, char __user *userbuf, 
		return 0;

	}



	if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {

	if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {

		lbs_pr_err("command response incorrect!\n");

		kfree(response_buf);

		free_page(addr);
@@ -864,7 +864,7 @@ static ssize_t libertas_failcount_write(struct file *file, 
		goto out_unlock;



	event = &pcmdptr->params.subscribe_event;

	event->action = cpu_to_le16(cmd_act_set);

	event->action = cpu_to_le16(CMD_ACT_SET);

	pcmdptr->size = cpu_to_le16(S_DS_GEN +

		sizeof(struct cmd_ds_802_11_subscribe_event) +

		sizeof(struct mrvlietypes_failurecount));
@@ -895,7 +895,7 @@ static ssize_t libertas_failcount_write(struct file *file, 
		return 0;

	}



	if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {

	if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {

		lbs_pr_err("command response incorrect!\n");

		kfree(response_buf);

		free_page(addr);
@@ -929,7 +929,7 @@ static ssize_t libertas_bcnmiss_read(struct file *file, char __user *userbuf, 
	}



	event = &pcmdptr->params.subscribe_event;

	event->action = cpu_to_le16(cmd_act_get);

	event->action = cpu_to_le16(CMD_ACT_GET);

	pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);

	libertas_queue_cmd(adapter, pcmdnode, 1);

	wake_up_interruptible(&priv->mainthread.waitq);
@@ -948,7 +948,7 @@ static ssize_t libertas_bcnmiss_read(struct file *file, char __user *userbuf, 
		return 0;

	}



	if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {

	if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {

		lbs_pr_err("command response incorrect!\n");

		free_page(addr);

		kfree(response_buf);
@@ -1015,7 +1015,7 @@ static ssize_t libertas_bcnmiss_write(struct file *file, 
		goto out_unlock;



	event = &pcmdptr->params.subscribe_event;

	event->action = cpu_to_le16(cmd_act_set);

	event->action = cpu_to_le16(CMD_ACT_SET);

	pcmdptr->size = cpu_to_le16(S_DS_GEN +

		sizeof(struct cmd_ds_802_11_subscribe_event) +

		sizeof(struct mrvlietypes_beaconsmissed));
@@ -1045,7 +1045,7 @@ static ssize_t libertas_bcnmiss_write(struct file *file, 
		return 0;

	}



	if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {

	if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {

		lbs_pr_err("command response incorrect!\n");

		free_page(addr);

		kfree(response_buf);
@@ -1079,7 +1079,7 @@ static ssize_t libertas_highrssi_read(struct file *file, char __user *userbuf, 
	}



	event = &pcmdptr->params.subscribe_event;

	event->action = cpu_to_le16(cmd_act_get);

	event->action = cpu_to_le16(CMD_ACT_GET);

	pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);

	libertas_queue_cmd(adapter, pcmdnode, 1);

	wake_up_interruptible(&priv->mainthread.waitq);
@@ -1098,7 +1098,7 @@ static ssize_t libertas_highrssi_read(struct file *file, char __user *userbuf, 
		return 0;

	}



	if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {

	if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {

		lbs_pr_err("command response incorrect!\n");

		kfree(response_buf);

		free_page(addr);
@@ -1166,7 +1166,7 @@ static ssize_t libertas_highrssi_write(struct file *file, 
		goto out_unlock;



	event = &pcmdptr->params.subscribe_event;

	event->action = cpu_to_le16(cmd_act_set);

	event->action = cpu_to_le16(CMD_ACT_SET);

	pcmdptr->size = cpu_to_le16(S_DS_GEN +

		sizeof(struct cmd_ds_802_11_subscribe_event) +

		sizeof(struct mrvlietypes_rssithreshold));
@@ -1196,7 +1196,7 @@ static ssize_t libertas_highrssi_write(struct file *file, 
		return 0;

	}



	if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {

	if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {

		lbs_pr_err("command response incorrect!\n");

		kfree(response_buf);

		return 0;
@@ -1229,7 +1229,7 @@ static ssize_t libertas_highsnr_read(struct file *file, char __user *userbuf, 
	}



	event = &pcmdptr->params.subscribe_event;

	event->action = cpu_to_le16(cmd_act_get);

	event->action = cpu_to_le16(CMD_ACT_GET);

	pcmdptr->size = cpu_to_le16(sizeof(*event) + S_DS_GEN);

	libertas_queue_cmd(adapter, pcmdnode, 1);

	wake_up_interruptible(&priv->mainthread.waitq);
@@ -1248,7 +1248,7 @@ static ssize_t libertas_highsnr_read(struct file *file, char __user *userbuf, 
		return 0;

	}



	if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {

	if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {

		lbs_pr_err("command response incorrect!\n");

		kfree(response_buf);

		free_page(addr);
@@ -1316,7 +1316,7 @@ static ssize_t libertas_highsnr_write(struct file *file, 
		goto out_unlock;



	event = &pcmdptr->params.subscribe_event;

	event->action = cpu_to_le16(cmd_act_set);

	event->action = cpu_to_le16(CMD_ACT_SET);

	pcmdptr->size = cpu_to_le16(S_DS_GEN +

		sizeof(struct cmd_ds_802_11_subscribe_event) +

		sizeof(struct mrvlietypes_snrthreshold));
@@ -1347,7 +1347,7 @@ static ssize_t libertas_highsnr_write(struct file *file, 
		return 0;

	}



	if (pcmdptr->command != cpu_to_le16(cmd_ret_802_11_subscribe_event)) {

	if (pcmdptr->command != cpu_to_le16(CMD_RET_802_11_SUBSCRIBE_EVENT)) {

		lbs_pr_err("command response incorrect!\n");

		kfree(response_buf);

		free_page(addr);
@@ -1375,8 +1375,8 @@ static ssize_t libertas_rdmac_read(struct file *file, char __user *userbuf, 
	offval.value = 0;



	ret = libertas_prepare_and_send_command(priv,

				cmd_mac_reg_access, 0,

				cmd_option_waitforrsp, 0, &offval);

				CMD_MAC_REG_ACCESS, 0,

				CMD_OPTION_WAITFORRSP, 0, &offval);

	mdelay(10);

	pos += snprintf(buf+pos, len-pos, "MAC[0x%x] = 0x%08x\n",

				priv->mac_offset, adapter->offsetvalue.value);
@@ -1433,8 +1433,8 @@ static ssize_t libertas_wrmac_write(struct file *file, 
	offval.offset = offset;

	offval.value = value;

	res = libertas_prepare_and_send_command(priv,

				cmd_mac_reg_access, 1,

				cmd_option_waitforrsp, 0, &offval);

				CMD_MAC_REG_ACCESS, 1,

				CMD_OPTION_WAITFORRSP, 0, &offval);

	mdelay(10);



	res = count;
@@ -1458,8 +1458,8 @@ static ssize_t libertas_rdbbp_read(struct file *file, char __user *userbuf, 
	offval.value = 0;



	ret = libertas_prepare_and_send_command(priv,

				cmd_bbp_reg_access, 0,

				cmd_option_waitforrsp, 0, &offval);

				CMD_BBP_REG_ACCESS, 0,

				CMD_OPTION_WAITFORRSP, 0, &offval);

	mdelay(10);

	pos += snprintf(buf+pos, len-pos, "BBP[0x%x] = 0x%08x\n",

				priv->bbp_offset, adapter->offsetvalue.value);
@@ -1517,8 +1517,8 @@ static ssize_t libertas_wrbbp_write(struct file *file, 
	offval.offset = offset;

	offval.value = value;

	res = libertas_prepare_and_send_command(priv,

				cmd_bbp_reg_access, 1,

				cmd_option_waitforrsp, 0, &offval);

				CMD_BBP_REG_ACCESS, 1,

				CMD_OPTION_WAITFORRSP, 0, &offval);

	mdelay(10);



	res = count;
@@ -1542,8 +1542,8 @@ static ssize_t libertas_rdrf_read(struct file *file, char __user *userbuf, 
	offval.value = 0;



	ret = libertas_prepare_and_send_command(priv,

				cmd_rf_reg_access, 0,

				cmd_option_waitforrsp, 0, &offval);

				CMD_RF_REG_ACCESS, 0,

				CMD_OPTION_WAITFORRSP, 0, &offval);

	mdelay(10);

	pos += snprintf(buf+pos, len-pos, "RF[0x%x] = 0x%08x\n",

				priv->rf_offset, adapter->offsetvalue.value);
@@ -1601,8 +1601,8 @@ static ssize_t libertas_wrrf_write(struct file *file, 
	offval.offset = offset;

	offval.value = value;

	res = libertas_prepare_and_send_command(priv,

				cmd_rf_reg_access, 1,

				cmd_option_waitforrsp, 0, &offval);

				CMD_RF_REG_ACCESS, 1,

				CMD_OPTION_WAITFORRSP, 0, &offval);

	mdelay(10);



	res = count;