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
Loading
Loading
Loading
Loading
+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);
+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;
		}
+161 −161

File changed.

Preview size limit exceeded, changes collapsed.

+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) ;
+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;
Loading