2
* Marvell Wireless LAN device driver: station command handling
4
* Copyright (C) 2011, Marvell International Ltd.
6
* This software file (the "File") is distributed by Marvell International
7
* Ltd. under the terms of the GNU General Public License Version 2, June 1991
8
* (the "License"). You may use, redistribute and/or modify this File in
9
* accordance with the terms and conditions of the License, a copy of which
10
* is available by writing to the Free Software Foundation, Inc.,
11
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
12
* worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
14
* THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
15
* IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
16
* ARE EXPRESSLY DISCLAIMED. The License provides additional details about
17
* this warranty disclaimer.
29
* This function prepares command to set/get RSSI information.
31
* Preparation includes -
32
* - Setting command ID, action and proper size
33
* - Setting data/beacon average factors
34
* - Resetting SNR/NF/RSSI values in private structure
35
* - Ensuring correct endian-ness
38
mwifiex_cmd_802_11_rssi_info(struct mwifiex_private *priv,
39
struct host_cmd_ds_command *cmd, u16 cmd_action)
41
cmd->command = cpu_to_le16(HostCmd_CMD_RSSI_INFO);
42
cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_802_11_rssi_info) +
44
cmd->params.rssi_info.action = cpu_to_le16(cmd_action);
45
cmd->params.rssi_info.ndata = cpu_to_le16(priv->data_avg_factor);
46
cmd->params.rssi_info.nbcn = cpu_to_le16(priv->bcn_avg_factor);
48
/* Reset SNR/NF/RSSI values in private structure */
49
priv->data_rssi_last = 0;
50
priv->data_nf_last = 0;
51
priv->data_rssi_avg = 0;
52
priv->data_nf_avg = 0;
53
priv->bcn_rssi_last = 0;
54
priv->bcn_nf_last = 0;
55
priv->bcn_rssi_avg = 0;
62
* This function prepares command to set MAC control.
64
* Preparation includes -
65
* - Setting command ID, action and proper size
66
* - Ensuring correct endian-ness
68
static int mwifiex_cmd_mac_control(struct mwifiex_private *priv,
69
struct host_cmd_ds_command *cmd,
70
u16 cmd_action, u16 *action)
72
struct host_cmd_ds_mac_control *mac_ctrl = &cmd->params.mac_ctrl;
74
if (cmd_action != HostCmd_ACT_GEN_SET) {
75
dev_err(priv->adapter->dev,
76
"mac_control: only support set cmd\n");
80
cmd->command = cpu_to_le16(HostCmd_CMD_MAC_CONTROL);
82
cpu_to_le16(sizeof(struct host_cmd_ds_mac_control) + S_DS_GEN);
83
mac_ctrl->action = cpu_to_le16(*action);
89
* This function prepares command to set/get SNMP MIB.
91
* Preparation includes -
92
* - Setting command ID, action and proper size
93
* - Setting SNMP MIB OID number and value
95
* - Ensuring correct endian-ness
97
* The following SNMP MIB OIDs are supported -
98
* - FRAG_THRESH_I : Fragmentation threshold
99
* - RTS_THRESH_I : RTS threshold
100
* - SHORT_RETRY_LIM_I : Short retry limit
101
* - DOT11D_I : 11d support
103
static int mwifiex_cmd_802_11_snmp_mib(struct mwifiex_private *priv,
104
struct host_cmd_ds_command *cmd,
105
u16 cmd_action, u32 cmd_oid,
108
struct host_cmd_ds_802_11_snmp_mib *snmp_mib = &cmd->params.smib;
110
dev_dbg(priv->adapter->dev, "cmd: SNMP_CMD: cmd_oid = 0x%x\n", cmd_oid);
111
cmd->command = cpu_to_le16(HostCmd_CMD_802_11_SNMP_MIB);
112
cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_802_11_snmp_mib)
115
if (cmd_action == HostCmd_ACT_GEN_GET) {
116
snmp_mib->query_type = cpu_to_le16(HostCmd_ACT_GEN_GET);
117
snmp_mib->buf_size = cpu_to_le16(MAX_SNMP_BUF_SIZE);
118
cmd->size = cpu_to_le16(le16_to_cpu(cmd->size)
119
+ MAX_SNMP_BUF_SIZE);
124
snmp_mib->oid = cpu_to_le16((u16) FRAG_THRESH_I);
125
if (cmd_action == HostCmd_ACT_GEN_SET) {
126
snmp_mib->query_type = cpu_to_le16(HostCmd_ACT_GEN_SET);
127
snmp_mib->buf_size = cpu_to_le16(sizeof(u16));
128
*((__le16 *) (snmp_mib->value)) =
129
cpu_to_le16((u16) *ul_temp);
130
cmd->size = cpu_to_le16(le16_to_cpu(cmd->size)
135
snmp_mib->oid = cpu_to_le16((u16) RTS_THRESH_I);
136
if (cmd_action == HostCmd_ACT_GEN_SET) {
137
snmp_mib->query_type = cpu_to_le16(HostCmd_ACT_GEN_SET);
138
snmp_mib->buf_size = cpu_to_le16(sizeof(u16));
139
*(__le16 *) (snmp_mib->value) =
140
cpu_to_le16((u16) *ul_temp);
141
cmd->size = cpu_to_le16(le16_to_cpu(cmd->size)
146
case SHORT_RETRY_LIM_I:
147
snmp_mib->oid = cpu_to_le16((u16) SHORT_RETRY_LIM_I);
148
if (cmd_action == HostCmd_ACT_GEN_SET) {
149
snmp_mib->query_type = cpu_to_le16(HostCmd_ACT_GEN_SET);
150
snmp_mib->buf_size = cpu_to_le16(sizeof(u16));
151
*((__le16 *) (snmp_mib->value)) =
152
cpu_to_le16((u16) *ul_temp);
153
cmd->size = cpu_to_le16(le16_to_cpu(cmd->size)
158
snmp_mib->oid = cpu_to_le16((u16) DOT11D_I);
159
if (cmd_action == HostCmd_ACT_GEN_SET) {
160
snmp_mib->query_type = cpu_to_le16(HostCmd_ACT_GEN_SET);
161
snmp_mib->buf_size = cpu_to_le16(sizeof(u16));
162
*((__le16 *) (snmp_mib->value)) =
163
cpu_to_le16((u16) *ul_temp);
164
cmd->size = cpu_to_le16(le16_to_cpu(cmd->size)
171
dev_dbg(priv->adapter->dev,
172
"cmd: SNMP_CMD: Action=0x%x, OID=0x%x, OIDSize=0x%x,"
174
cmd_action, cmd_oid, le16_to_cpu(snmp_mib->buf_size),
175
le16_to_cpu(*(__le16 *) snmp_mib->value));
180
* This function prepares command to get log.
182
* Preparation includes -
183
* - Setting command ID and proper size
184
* - Ensuring correct endian-ness
187
mwifiex_cmd_802_11_get_log(struct host_cmd_ds_command *cmd)
189
cmd->command = cpu_to_le16(HostCmd_CMD_802_11_GET_LOG);
190
cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_802_11_get_log) +
196
* This function prepares command to set/get Tx data rate configuration.
198
* Preparation includes -
199
* - Setting command ID, action and proper size
200
* - Setting configuration index, rate scope and rate drop pattern
201
* parameters (as required)
202
* - Ensuring correct endian-ness
204
static int mwifiex_cmd_tx_rate_cfg(struct mwifiex_private *priv,
205
struct host_cmd_ds_command *cmd,
206
u16 cmd_action, u16 *pbitmap_rates)
208
struct host_cmd_ds_tx_rate_cfg *rate_cfg = &cmd->params.tx_rate_cfg;
209
struct mwifiex_rate_scope *rate_scope;
210
struct mwifiex_rate_drop_pattern *rate_drop;
213
cmd->command = cpu_to_le16(HostCmd_CMD_TX_RATE_CFG);
215
rate_cfg->action = cpu_to_le16(cmd_action);
216
rate_cfg->cfg_index = 0;
218
rate_scope = (struct mwifiex_rate_scope *) ((u8 *) rate_cfg +
219
sizeof(struct host_cmd_ds_tx_rate_cfg));
220
rate_scope->type = cpu_to_le16(TLV_TYPE_RATE_SCOPE);
221
rate_scope->length = cpu_to_le16(sizeof(struct mwifiex_rate_scope) -
222
sizeof(struct mwifiex_ie_types_header));
223
if (pbitmap_rates != NULL) {
224
rate_scope->hr_dsss_rate_bitmap = cpu_to_le16(pbitmap_rates[0]);
225
rate_scope->ofdm_rate_bitmap = cpu_to_le16(pbitmap_rates[1]);
227
i < sizeof(rate_scope->ht_mcs_rate_bitmap) / sizeof(u16);
229
rate_scope->ht_mcs_rate_bitmap[i] =
230
cpu_to_le16(pbitmap_rates[2 + i]);
232
rate_scope->hr_dsss_rate_bitmap =
233
cpu_to_le16(priv->bitmap_rates[0]);
234
rate_scope->ofdm_rate_bitmap =
235
cpu_to_le16(priv->bitmap_rates[1]);
237
i < sizeof(rate_scope->ht_mcs_rate_bitmap) / sizeof(u16);
239
rate_scope->ht_mcs_rate_bitmap[i] =
240
cpu_to_le16(priv->bitmap_rates[2 + i]);
243
rate_drop = (struct mwifiex_rate_drop_pattern *) ((u8 *) rate_scope +
244
sizeof(struct mwifiex_rate_scope));
245
rate_drop->type = cpu_to_le16(TLV_TYPE_RATE_DROP_CONTROL);
246
rate_drop->length = cpu_to_le16(sizeof(rate_drop->rate_drop_mode));
247
rate_drop->rate_drop_mode = 0;
250
cpu_to_le16(S_DS_GEN + sizeof(struct host_cmd_ds_tx_rate_cfg) +
251
sizeof(struct mwifiex_rate_scope) +
252
sizeof(struct mwifiex_rate_drop_pattern));
258
* This function prepares command to set/get Tx power configuration.
260
* Preparation includes -
261
* - Setting command ID, action and proper size
262
* - Setting Tx power mode, power group TLV
264
* - Ensuring correct endian-ness
266
static int mwifiex_cmd_tx_power_cfg(struct host_cmd_ds_command *cmd,
268
struct host_cmd_ds_txpwr_cfg *txp)
270
struct mwifiex_types_power_group *pg_tlv;
271
struct host_cmd_ds_txpwr_cfg *cmd_txp_cfg = &cmd->params.txp_cfg;
273
cmd->command = cpu_to_le16(HostCmd_CMD_TXPWR_CFG);
275
cpu_to_le16(S_DS_GEN + sizeof(struct host_cmd_ds_txpwr_cfg));
276
switch (cmd_action) {
277
case HostCmd_ACT_GEN_SET:
279
pg_tlv = (struct mwifiex_types_power_group
280
*) ((unsigned long) txp +
281
sizeof(struct host_cmd_ds_txpwr_cfg));
282
memmove(cmd_txp_cfg, txp,
283
sizeof(struct host_cmd_ds_txpwr_cfg) +
284
sizeof(struct mwifiex_types_power_group) +
287
pg_tlv = (struct mwifiex_types_power_group *) ((u8 *)
289
sizeof(struct host_cmd_ds_txpwr_cfg));
290
cmd->size = cpu_to_le16(le16_to_cpu(cmd->size) +
291
sizeof(struct mwifiex_types_power_group) +
294
memmove(cmd_txp_cfg, txp, sizeof(*txp));
296
cmd_txp_cfg->action = cpu_to_le16(cmd_action);
298
case HostCmd_ACT_GEN_GET:
299
cmd_txp_cfg->action = cpu_to_le16(cmd_action);
307
* This function prepares command to set Host Sleep configuration.
309
* Preparation includes -
310
* - Setting command ID and proper size
311
* - Setting Host Sleep action, conditions, ARP filters
313
* - Ensuring correct endian-ness
316
mwifiex_cmd_802_11_hs_cfg(struct mwifiex_private *priv,
317
struct host_cmd_ds_command *cmd,
319
struct mwifiex_hs_config_param *hscfg_param)
321
struct mwifiex_adapter *adapter = priv->adapter;
322
struct host_cmd_ds_802_11_hs_cfg_enh *hs_cfg = &cmd->params.opt_hs_cfg;
323
u16 hs_activate = false;
326
/* New Activate command */
328
cmd->command = cpu_to_le16(HostCmd_CMD_802_11_HS_CFG_ENH);
331
(hscfg_param->conditions
332
!= cpu_to_le32(HOST_SLEEP_CFG_CANCEL))
333
&& ((adapter->arp_filter_size > 0)
334
&& (adapter->arp_filter_size <= ARP_FILTER_MAX_BUF_SIZE))) {
335
dev_dbg(adapter->dev,
336
"cmd: Attach %d bytes ArpFilter to HSCfg cmd\n",
337
adapter->arp_filter_size);
338
memcpy(((u8 *) hs_cfg) +
339
sizeof(struct host_cmd_ds_802_11_hs_cfg_enh),
340
adapter->arp_filter, adapter->arp_filter_size);
341
cmd->size = cpu_to_le16(adapter->arp_filter_size +
342
sizeof(struct host_cmd_ds_802_11_hs_cfg_enh)
345
cmd->size = cpu_to_le16(S_DS_GEN + sizeof(struct
346
host_cmd_ds_802_11_hs_cfg_enh));
349
hs_cfg->action = cpu_to_le16(HS_ACTIVATE);
350
hs_cfg->params.hs_activate.resp_ctrl = RESP_NEEDED;
352
hs_cfg->action = cpu_to_le16(HS_CONFIGURE);
353
hs_cfg->params.hs_config.conditions = hscfg_param->conditions;
354
hs_cfg->params.hs_config.gpio = hscfg_param->gpio;
355
hs_cfg->params.hs_config.gap = hscfg_param->gap;
356
dev_dbg(adapter->dev,
357
"cmd: HS_CFG_CMD: condition:0x%x gpio:0x%x gap:0x%x\n",
358
hs_cfg->params.hs_config.conditions,
359
hs_cfg->params.hs_config.gpio,
360
hs_cfg->params.hs_config.gap);
367
* This function prepares command to set/get MAC address.
369
* Preparation includes -
370
* - Setting command ID, action and proper size
371
* - Setting MAC address (for SET only)
372
* - Ensuring correct endian-ness
374
static int mwifiex_cmd_802_11_mac_address(struct mwifiex_private *priv,
375
struct host_cmd_ds_command *cmd,
378
cmd->command = cpu_to_le16(HostCmd_CMD_802_11_MAC_ADDRESS);
379
cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_802_11_mac_address) +
383
cmd->params.mac_addr.action = cpu_to_le16(cmd_action);
385
if (cmd_action == HostCmd_ACT_GEN_SET)
386
memcpy(cmd->params.mac_addr.mac_addr, priv->curr_addr,
392
* This function prepares command to set MAC multicast address.
394
* Preparation includes -
395
* - Setting command ID, action and proper size
396
* - Setting MAC multicast address
397
* - Ensuring correct endian-ness
400
mwifiex_cmd_mac_multicast_adr(struct host_cmd_ds_command *cmd,
402
struct mwifiex_multicast_list *mcast_list)
404
struct host_cmd_ds_mac_multicast_adr *mcast_addr = &cmd->params.mc_addr;
406
cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_mac_multicast_adr) +
408
cmd->command = cpu_to_le16(HostCmd_CMD_MAC_MULTICAST_ADR);
410
mcast_addr->action = cpu_to_le16(cmd_action);
411
mcast_addr->num_of_adrs =
412
cpu_to_le16((u16) mcast_list->num_multicast_addr);
413
memcpy(mcast_addr->mac_list, mcast_list->mac_list,
414
mcast_list->num_multicast_addr * ETH_ALEN);
420
* This function prepares command to deauthenticate.
422
* Preparation includes -
423
* - Setting command ID and proper size
424
* - Setting AP MAC address and reason code
425
* - Ensuring correct endian-ness
427
static int mwifiex_cmd_802_11_deauthenticate(struct mwifiex_private *priv,
428
struct host_cmd_ds_command *cmd,
431
struct host_cmd_ds_802_11_deauthenticate *deauth = &cmd->params.deauth;
433
cmd->command = cpu_to_le16(HostCmd_CMD_802_11_DEAUTHENTICATE);
434
cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_802_11_deauthenticate)
437
/* Set AP MAC address */
438
memcpy(deauth->mac_addr, mac, ETH_ALEN);
440
dev_dbg(priv->adapter->dev, "cmd: Deauth: %pM\n", deauth->mac_addr);
442
deauth->reason_code = cpu_to_le16(WLAN_REASON_DEAUTH_LEAVING);
448
* This function prepares command to stop Ad-Hoc network.
450
* Preparation includes -
451
* - Setting command ID and proper size
452
* - Ensuring correct endian-ness
454
static int mwifiex_cmd_802_11_ad_hoc_stop(struct host_cmd_ds_command *cmd)
456
cmd->command = cpu_to_le16(HostCmd_CMD_802_11_AD_HOC_STOP);
457
cmd->size = cpu_to_le16(S_DS_GEN);
462
* This function sets WEP key(s) to key parameter TLV(s).
464
* Multi-key parameter TLVs are supported, so we can send multiple
465
* WEP keys in a single buffer.
468
mwifiex_set_keyparamset_wep(struct mwifiex_private *priv,
469
struct mwifiex_ie_type_key_param_set *key_param_set,
472
int cur_key_param_len;
475
/* Multi-key_param_set TLV is supported */
476
for (i = 0; i < NUM_WEP_KEYS; i++) {
477
if ((priv->wep_key[i].key_length == WLAN_KEY_LEN_WEP40) ||
478
(priv->wep_key[i].key_length == WLAN_KEY_LEN_WEP104)) {
479
key_param_set->type =
480
cpu_to_le16(TLV_TYPE_KEY_MATERIAL);
481
/* Key_param_set WEP fixed length */
482
#define KEYPARAMSET_WEP_FIXED_LEN 8
483
key_param_set->length = cpu_to_le16((u16)
486
KEYPARAMSET_WEP_FIXED_LEN));
487
key_param_set->key_type_id =
488
cpu_to_le16(KEY_TYPE_ID_WEP);
489
key_param_set->key_info =
490
cpu_to_le16(KEY_ENABLED | KEY_UNICAST |
492
key_param_set->key_len =
493
cpu_to_le16(priv->wep_key[i].key_length);
494
/* Set WEP key index */
495
key_param_set->key[0] = i;
496
/* Set default Tx key flag */
499
wep_key_curr_index & HostCmd_WEP_KEY_INDEX_MASK))
500
key_param_set->key[1] = 1;
502
key_param_set->key[1] = 0;
503
memmove(&key_param_set->key[2],
504
priv->wep_key[i].key_material,
505
priv->wep_key[i].key_length);
507
cur_key_param_len = priv->wep_key[i].key_length +
508
KEYPARAMSET_WEP_FIXED_LEN +
509
sizeof(struct mwifiex_ie_types_header);
510
*key_param_len += (u16) cur_key_param_len;
512
(struct mwifiex_ie_type_key_param_set *)
513
((u8 *)key_param_set +
515
} else if (!priv->wep_key[i].key_length) {
518
dev_err(priv->adapter->dev,
519
"key%d Length = %d is incorrect\n",
520
(i + 1), priv->wep_key[i].key_length);
529
* This function prepares command to set/get/reset network key(s).
531
* Preparation includes -
532
* - Setting command ID, action and proper size
533
* - Setting WEP keys, WAPI keys or WPA keys along with required
534
* encryption (TKIP, AES) (as required)
535
* - Ensuring correct endian-ness
538
mwifiex_cmd_802_11_key_material(struct mwifiex_private *priv,
539
struct host_cmd_ds_command *cmd,
540
u16 cmd_action, u32 cmd_oid,
541
struct mwifiex_ds_encrypt_key *enc_key)
543
struct host_cmd_ds_802_11_key_material *key_material =
544
&cmd->params.key_material;
545
u16 key_param_len = 0;
547
const u8 bc_mac[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
549
cmd->command = cpu_to_le16(HostCmd_CMD_802_11_KEY_MATERIAL);
550
key_material->action = cpu_to_le16(cmd_action);
552
if (cmd_action == HostCmd_ACT_GEN_GET) {
554
cpu_to_le16(sizeof(key_material->action) + S_DS_GEN);
559
memset(&key_material->key_param_set, 0,
561
sizeof(struct mwifiex_ie_type_key_param_set)));
562
ret = mwifiex_set_keyparamset_wep(priv,
563
&key_material->key_param_set,
565
cmd->size = cpu_to_le16(key_param_len +
566
sizeof(key_material->action) + S_DS_GEN);
569
memset(&key_material->key_param_set, 0,
570
sizeof(struct mwifiex_ie_type_key_param_set));
571
if (enc_key->is_wapi_key) {
572
dev_dbg(priv->adapter->dev, "info: Set WAPI Key\n");
573
key_material->key_param_set.key_type_id =
574
cpu_to_le16(KEY_TYPE_ID_WAPI);
575
if (cmd_oid == KEY_INFO_ENABLED)
576
key_material->key_param_set.key_info =
577
cpu_to_le16(KEY_ENABLED);
579
key_material->key_param_set.key_info =
580
cpu_to_le16(!KEY_ENABLED);
582
key_material->key_param_set.key[0] = enc_key->key_index;
583
if (!priv->sec_info.wapi_key_on)
584
key_material->key_param_set.key[1] = 1;
586
/* set 0 when re-key */
587
key_material->key_param_set.key[1] = 0;
589
if (0 != memcmp(enc_key->mac_addr, bc_mac, sizeof(bc_mac))) {
590
/* WAPI pairwise key: unicast */
591
key_material->key_param_set.key_info |=
592
cpu_to_le16(KEY_UNICAST);
593
} else { /* WAPI group key: multicast */
594
key_material->key_param_set.key_info |=
595
cpu_to_le16(KEY_MCAST);
596
priv->sec_info.wapi_key_on = true;
599
key_material->key_param_set.type =
600
cpu_to_le16(TLV_TYPE_KEY_MATERIAL);
601
key_material->key_param_set.key_len =
602
cpu_to_le16(WAPI_KEY_LEN);
603
memcpy(&key_material->key_param_set.key[2],
604
enc_key->key_material, enc_key->key_len);
605
memcpy(&key_material->key_param_set.key[2 + enc_key->key_len],
606
enc_key->wapi_rxpn, WAPI_RXPN_LEN);
607
key_material->key_param_set.length =
608
cpu_to_le16(WAPI_KEY_LEN + KEYPARAMSET_FIXED_LEN);
610
key_param_len = (WAPI_KEY_LEN + KEYPARAMSET_FIXED_LEN) +
611
sizeof(struct mwifiex_ie_types_header);
612
cmd->size = cpu_to_le16(key_param_len +
613
sizeof(key_material->action) + S_DS_GEN);
616
if (enc_key->key_len == WLAN_KEY_LEN_CCMP) {
617
dev_dbg(priv->adapter->dev, "cmd: WPA_AES\n");
618
key_material->key_param_set.key_type_id =
619
cpu_to_le16(KEY_TYPE_ID_AES);
620
if (cmd_oid == KEY_INFO_ENABLED)
621
key_material->key_param_set.key_info =
622
cpu_to_le16(KEY_ENABLED);
624
key_material->key_param_set.key_info =
625
cpu_to_le16(!KEY_ENABLED);
627
if (enc_key->key_index & MWIFIEX_KEY_INDEX_UNICAST)
628
/* AES pairwise key: unicast */
629
key_material->key_param_set.key_info |=
630
cpu_to_le16(KEY_UNICAST);
631
else /* AES group key: multicast */
632
key_material->key_param_set.key_info |=
633
cpu_to_le16(KEY_MCAST);
634
} else if (enc_key->key_len == WLAN_KEY_LEN_TKIP) {
635
dev_dbg(priv->adapter->dev, "cmd: WPA_TKIP\n");
636
key_material->key_param_set.key_type_id =
637
cpu_to_le16(KEY_TYPE_ID_TKIP);
638
key_material->key_param_set.key_info =
639
cpu_to_le16(KEY_ENABLED);
641
if (enc_key->key_index & MWIFIEX_KEY_INDEX_UNICAST)
642
/* TKIP pairwise key: unicast */
643
key_material->key_param_set.key_info |=
644
cpu_to_le16(KEY_UNICAST);
645
else /* TKIP group key: multicast */
646
key_material->key_param_set.key_info |=
647
cpu_to_le16(KEY_MCAST);
650
if (key_material->key_param_set.key_type_id) {
651
key_material->key_param_set.type =
652
cpu_to_le16(TLV_TYPE_KEY_MATERIAL);
653
key_material->key_param_set.key_len =
654
cpu_to_le16((u16) enc_key->key_len);
655
memcpy(key_material->key_param_set.key, enc_key->key_material,
657
key_material->key_param_set.length =
658
cpu_to_le16((u16) enc_key->key_len +
659
KEYPARAMSET_FIXED_LEN);
661
key_param_len = (u16) (enc_key->key_len + KEYPARAMSET_FIXED_LEN)
662
+ sizeof(struct mwifiex_ie_types_header);
664
cmd->size = cpu_to_le16(key_param_len +
665
sizeof(key_material->action) + S_DS_GEN);
672
* This function prepares command to set/get 11d domain information.
674
* Preparation includes -
675
* - Setting command ID, action and proper size
676
* - Setting domain information fields (for SET only)
677
* - Ensuring correct endian-ness
679
static int mwifiex_cmd_802_11d_domain_info(struct mwifiex_private *priv,
680
struct host_cmd_ds_command *cmd,
683
struct mwifiex_adapter *adapter = priv->adapter;
684
struct host_cmd_ds_802_11d_domain_info *domain_info =
685
&cmd->params.domain_info;
686
struct mwifiex_ietypes_domain_param_set *domain =
687
&domain_info->domain;
688
u8 no_of_triplet = adapter->domain_reg.no_of_triplet;
690
dev_dbg(adapter->dev, "info: 11D: no_of_triplet=0x%x\n", no_of_triplet);
692
cmd->command = cpu_to_le16(HostCmd_CMD_802_11D_DOMAIN_INFO);
693
domain_info->action = cpu_to_le16(cmd_action);
694
if (cmd_action == HostCmd_ACT_GEN_GET) {
695
cmd->size = cpu_to_le16(sizeof(domain_info->action) + S_DS_GEN);
699
/* Set domain info fields */
700
domain->header.type = cpu_to_le16(WLAN_EID_COUNTRY);
701
memcpy(domain->country_code, adapter->domain_reg.country_code,
702
sizeof(domain->country_code));
704
domain->header.len = cpu_to_le16((no_of_triplet *
705
sizeof(struct ieee80211_country_ie_triplet)) +
706
sizeof(domain->country_code));
709
memcpy(domain->triplet, adapter->domain_reg.triplet,
711
sizeof(struct ieee80211_country_ie_triplet));
713
cmd->size = cpu_to_le16(sizeof(domain_info->action) +
714
le16_to_cpu(domain->header.len) +
715
sizeof(struct mwifiex_ie_types_header)
718
cmd->size = cpu_to_le16(sizeof(domain_info->action) + S_DS_GEN);
725
* This function prepares command to set/get RF channel.
727
* Preparation includes -
728
* - Setting command ID, action and proper size
729
* - Setting RF type and current RF channel (for SET only)
730
* - Ensuring correct endian-ness
732
static int mwifiex_cmd_802_11_rf_channel(struct mwifiex_private *priv,
733
struct host_cmd_ds_command *cmd,
734
u16 cmd_action, u16 *channel)
736
struct host_cmd_ds_802_11_rf_channel *rf_chan =
737
&cmd->params.rf_channel;
738
uint16_t rf_type = le16_to_cpu(rf_chan->rf_type);
740
cmd->command = cpu_to_le16(HostCmd_CMD_802_11_RF_CHANNEL);
741
cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_802_11_rf_channel)
744
if (cmd_action == HostCmd_ACT_GEN_SET) {
745
if ((priv->adapter->adhoc_start_band & BAND_A)
746
|| (priv->adapter->adhoc_start_band & BAND_AN))
748
cpu_to_le16(HostCmd_SCAN_RADIO_TYPE_A);
750
rf_type = le16_to_cpu(rf_chan->rf_type);
751
SET_SECONDARYCHAN(rf_type, priv->adapter->chan_offset);
752
rf_chan->current_channel = cpu_to_le16(*channel);
754
rf_chan->action = cpu_to_le16(cmd_action);
759
* This function prepares command to set/get IBSS coalescing status.
761
* Preparation includes -
762
* - Setting command ID, action and proper size
763
* - Setting status to enable or disable (for SET only)
764
* - Ensuring correct endian-ness
766
static int mwifiex_cmd_ibss_coalescing_status(struct host_cmd_ds_command *cmd,
767
u16 cmd_action, u16 *enable)
769
struct host_cmd_ds_802_11_ibss_status *ibss_coal =
770
&(cmd->params.ibss_coalescing);
772
cmd->command = cpu_to_le16(HostCmd_CMD_802_11_IBSS_COALESCING_STATUS);
773
cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_802_11_ibss_status) +
776
ibss_coal->action = cpu_to_le16(cmd_action);
778
switch (cmd_action) {
779
case HostCmd_ACT_GEN_SET:
781
ibss_coal->enable = cpu_to_le16(*enable);
783
ibss_coal->enable = 0;
786
/* In other case.. Nothing to do */
787
case HostCmd_ACT_GEN_GET:
796
* This function prepares command to set/get register value.
798
* Preparation includes -
799
* - Setting command ID, action and proper size
800
* - Setting register offset (for both GET and SET) and
801
* register value (for SET only)
802
* - Ensuring correct endian-ness
804
* The following type of registers can be accessed with this function -
812
static int mwifiex_cmd_reg_access(struct host_cmd_ds_command *cmd,
813
u16 cmd_action, void *data_buf)
815
struct mwifiex_ds_reg_rw *reg_rw = data_buf;
817
switch (le16_to_cpu(cmd->command)) {
818
case HostCmd_CMD_MAC_REG_ACCESS:
820
struct host_cmd_ds_mac_reg_access *mac_reg;
822
cmd->size = cpu_to_le16(sizeof(*mac_reg) + S_DS_GEN);
823
mac_reg = (struct host_cmd_ds_mac_reg_access *) &cmd->
825
mac_reg->action = cpu_to_le16(cmd_action);
827
cpu_to_le16((u16) le32_to_cpu(reg_rw->offset));
828
mac_reg->value = reg_rw->value;
831
case HostCmd_CMD_BBP_REG_ACCESS:
833
struct host_cmd_ds_bbp_reg_access *bbp_reg;
835
cmd->size = cpu_to_le16(sizeof(*bbp_reg) + S_DS_GEN);
836
bbp_reg = (struct host_cmd_ds_bbp_reg_access *) &cmd->
838
bbp_reg->action = cpu_to_le16(cmd_action);
840
cpu_to_le16((u16) le32_to_cpu(reg_rw->offset));
841
bbp_reg->value = (u8) le32_to_cpu(reg_rw->value);
844
case HostCmd_CMD_RF_REG_ACCESS:
846
struct host_cmd_ds_rf_reg_access *rf_reg;
848
cmd->size = cpu_to_le16(sizeof(*rf_reg) + S_DS_GEN);
849
rf_reg = (struct host_cmd_ds_rf_reg_access *) &cmd->
851
rf_reg->action = cpu_to_le16(cmd_action);
853
cpu_to_le16((u16) le32_to_cpu(reg_rw->offset));
854
rf_reg->value = (u8) le32_to_cpu(reg_rw->value);
857
case HostCmd_CMD_PMIC_REG_ACCESS:
859
struct host_cmd_ds_pmic_reg_access *pmic_reg;
861
cmd->size = cpu_to_le16(sizeof(*pmic_reg) + S_DS_GEN);
862
pmic_reg = (struct host_cmd_ds_pmic_reg_access *) &cmd->
864
pmic_reg->action = cpu_to_le16(cmd_action);
866
cpu_to_le16((u16) le32_to_cpu(reg_rw->offset));
867
pmic_reg->value = (u8) le32_to_cpu(reg_rw->value);
870
case HostCmd_CMD_CAU_REG_ACCESS:
872
struct host_cmd_ds_rf_reg_access *cau_reg;
874
cmd->size = cpu_to_le16(sizeof(*cau_reg) + S_DS_GEN);
875
cau_reg = (struct host_cmd_ds_rf_reg_access *) &cmd->
877
cau_reg->action = cpu_to_le16(cmd_action);
879
cpu_to_le16((u16) le32_to_cpu(reg_rw->offset));
880
cau_reg->value = (u8) le32_to_cpu(reg_rw->value);
883
case HostCmd_CMD_802_11_EEPROM_ACCESS:
885
struct mwifiex_ds_read_eeprom *rd_eeprom = data_buf;
886
struct host_cmd_ds_802_11_eeprom_access *cmd_eeprom =
887
(struct host_cmd_ds_802_11_eeprom_access *)
890
cmd->size = cpu_to_le16(sizeof(*cmd_eeprom) + S_DS_GEN);
891
cmd_eeprom->action = cpu_to_le16(cmd_action);
892
cmd_eeprom->offset = rd_eeprom->offset;
893
cmd_eeprom->byte_count = rd_eeprom->byte_count;
894
cmd_eeprom->value = 0;
905
* This function prepares command to set PCI-Express
906
* host buffer configuration
908
* Preparation includes -
909
* - Setting command ID, action and proper size
910
* - Setting host buffer configuration
911
* - Ensuring correct endian-ness
914
mwifiex_cmd_pcie_host_spec(struct mwifiex_private *priv,
915
struct host_cmd_ds_command *cmd, u16 action)
917
struct host_cmd_ds_pcie_details *host_spec =
918
&cmd->params.pcie_host_spec;
919
struct pcie_service_card *card = priv->adapter->card;
922
cmd->command = cpu_to_le16(HostCmd_CMD_PCIE_DESC_DETAILS);
923
cmd->size = cpu_to_le16(sizeof(struct
924
host_cmd_ds_pcie_details) + S_DS_GEN);
927
memset(host_spec, 0, sizeof(struct host_cmd_ds_pcie_details));
929
if (action == HostCmd_ACT_GEN_SET) {
930
/* Send the ring base addresses and count to firmware */
931
host_spec->txbd_addr_lo = (u32)(card->txbd_ring_pbase);
932
host_spec->txbd_addr_hi =
933
(u32)(((u64)card->txbd_ring_pbase)>>32);
934
host_spec->txbd_count = MWIFIEX_MAX_TXRX_BD;
935
host_spec->rxbd_addr_lo = (u32)(card->rxbd_ring_pbase);
936
host_spec->rxbd_addr_hi =
937
(u32)(((u64)card->rxbd_ring_pbase)>>32);
938
host_spec->rxbd_count = MWIFIEX_MAX_TXRX_BD;
939
host_spec->evtbd_addr_lo =
940
(u32)(card->evtbd_ring_pbase);
941
host_spec->evtbd_addr_hi =
942
(u32)(((u64)card->evtbd_ring_pbase)>>32);
943
host_spec->evtbd_count = MWIFIEX_MAX_EVT_BD;
944
if (card->sleep_cookie) {
945
buf_pa = MWIFIEX_SKB_PACB(card->sleep_cookie);
946
host_spec->sleep_cookie_addr_lo = (u32) *buf_pa;
947
host_spec->sleep_cookie_addr_hi =
948
(u32) (((u64)*buf_pa) >> 32);
949
dev_dbg(priv->adapter->dev, "sleep_cook_lo phy addr: "
950
"0x%x\n", host_spec->sleep_cookie_addr_lo);
958
* This function prepares the commands before sending them to the firmware.
960
* This is a generic function which calls specific command preparation
961
* routines based upon the command number.
963
int mwifiex_sta_prepare_cmd(struct mwifiex_private *priv, uint16_t cmd_no,
964
u16 cmd_action, u32 cmd_oid,
965
void *data_buf, void *cmd_buf)
967
struct host_cmd_ds_command *cmd_ptr = cmd_buf;
970
/* Prepare command */
972
case HostCmd_CMD_GET_HW_SPEC:
973
ret = mwifiex_cmd_get_hw_spec(priv, cmd_ptr);
975
case HostCmd_CMD_MAC_CONTROL:
976
ret = mwifiex_cmd_mac_control(priv, cmd_ptr, cmd_action,
979
case HostCmd_CMD_802_11_MAC_ADDRESS:
980
ret = mwifiex_cmd_802_11_mac_address(priv, cmd_ptr,
983
case HostCmd_CMD_MAC_MULTICAST_ADR:
984
ret = mwifiex_cmd_mac_multicast_adr(cmd_ptr, cmd_action,
987
case HostCmd_CMD_TX_RATE_CFG:
988
ret = mwifiex_cmd_tx_rate_cfg(priv, cmd_ptr, cmd_action,
991
case HostCmd_CMD_TXPWR_CFG:
992
ret = mwifiex_cmd_tx_power_cfg(cmd_ptr, cmd_action,
995
case HostCmd_CMD_802_11_PS_MODE_ENH:
996
ret = mwifiex_cmd_enh_power_mode(priv, cmd_ptr, cmd_action,
997
(uint16_t)cmd_oid, data_buf);
999
case HostCmd_CMD_802_11_HS_CFG_ENH:
1000
ret = mwifiex_cmd_802_11_hs_cfg(priv, cmd_ptr, cmd_action,
1001
(struct mwifiex_hs_config_param *) data_buf);
1003
case HostCmd_CMD_802_11_SCAN:
1004
ret = mwifiex_cmd_802_11_scan(cmd_ptr, data_buf);
1006
case HostCmd_CMD_802_11_BG_SCAN_QUERY:
1007
ret = mwifiex_cmd_802_11_bg_scan_query(cmd_ptr);
1009
case HostCmd_CMD_802_11_ASSOCIATE:
1010
ret = mwifiex_cmd_802_11_associate(priv, cmd_ptr, data_buf);
1012
case HostCmd_CMD_802_11_DEAUTHENTICATE:
1013
ret = mwifiex_cmd_802_11_deauthenticate(priv, cmd_ptr,
1016
case HostCmd_CMD_802_11_AD_HOC_START:
1017
ret = mwifiex_cmd_802_11_ad_hoc_start(priv, cmd_ptr,
1020
case HostCmd_CMD_802_11_GET_LOG:
1021
ret = mwifiex_cmd_802_11_get_log(cmd_ptr);
1023
case HostCmd_CMD_802_11_AD_HOC_JOIN:
1024
ret = mwifiex_cmd_802_11_ad_hoc_join(priv, cmd_ptr,
1027
case HostCmd_CMD_802_11_AD_HOC_STOP:
1028
ret = mwifiex_cmd_802_11_ad_hoc_stop(cmd_ptr);
1030
case HostCmd_CMD_RSSI_INFO:
1031
ret = mwifiex_cmd_802_11_rssi_info(priv, cmd_ptr, cmd_action);
1033
case HostCmd_CMD_802_11_SNMP_MIB:
1034
ret = mwifiex_cmd_802_11_snmp_mib(priv, cmd_ptr, cmd_action,
1037
case HostCmd_CMD_802_11_TX_RATE_QUERY:
1039
cpu_to_le16(HostCmd_CMD_802_11_TX_RATE_QUERY);
1041
cpu_to_le16(sizeof(struct host_cmd_ds_tx_rate_query) +
1046
case HostCmd_CMD_VERSION_EXT:
1047
cmd_ptr->command = cpu_to_le16(cmd_no);
1048
cmd_ptr->params.verext.version_str_sel =
1049
(u8) (*((u32 *) data_buf));
1050
memcpy(&cmd_ptr->params, data_buf,
1051
sizeof(struct host_cmd_ds_version_ext));
1053
cpu_to_le16(sizeof(struct host_cmd_ds_version_ext) +
1057
case HostCmd_CMD_802_11_RF_CHANNEL:
1058
ret = mwifiex_cmd_802_11_rf_channel(priv, cmd_ptr, cmd_action,
1061
case HostCmd_CMD_FUNC_INIT:
1062
if (priv->adapter->hw_status == MWIFIEX_HW_STATUS_RESET)
1063
priv->adapter->hw_status = MWIFIEX_HW_STATUS_READY;
1064
cmd_ptr->command = cpu_to_le16(cmd_no);
1065
cmd_ptr->size = cpu_to_le16(S_DS_GEN);
1067
case HostCmd_CMD_FUNC_SHUTDOWN:
1068
priv->adapter->hw_status = MWIFIEX_HW_STATUS_RESET;
1069
cmd_ptr->command = cpu_to_le16(cmd_no);
1070
cmd_ptr->size = cpu_to_le16(S_DS_GEN);
1072
case HostCmd_CMD_11N_ADDBA_REQ:
1073
ret = mwifiex_cmd_11n_addba_req(cmd_ptr, data_buf);
1075
case HostCmd_CMD_11N_DELBA:
1076
ret = mwifiex_cmd_11n_delba(cmd_ptr, data_buf);
1078
case HostCmd_CMD_11N_ADDBA_RSP:
1079
ret = mwifiex_cmd_11n_addba_rsp_gen(priv, cmd_ptr, data_buf);
1081
case HostCmd_CMD_802_11_KEY_MATERIAL:
1082
ret = mwifiex_cmd_802_11_key_material(priv, cmd_ptr,
1083
cmd_action, cmd_oid,
1086
case HostCmd_CMD_802_11D_DOMAIN_INFO:
1087
ret = mwifiex_cmd_802_11d_domain_info(priv, cmd_ptr,
1090
case HostCmd_CMD_RECONFIGURE_TX_BUFF:
1091
ret = mwifiex_cmd_recfg_tx_buf(priv, cmd_ptr, cmd_action,
1094
case HostCmd_CMD_AMSDU_AGGR_CTRL:
1095
ret = mwifiex_cmd_amsdu_aggr_ctrl(cmd_ptr, cmd_action,
1098
case HostCmd_CMD_11N_CFG:
1099
ret = mwifiex_cmd_11n_cfg(cmd_ptr, cmd_action,
1102
case HostCmd_CMD_WMM_GET_STATUS:
1103
dev_dbg(priv->adapter->dev,
1104
"cmd: WMM: WMM_GET_STATUS cmd sent\n");
1105
cmd_ptr->command = cpu_to_le16(HostCmd_CMD_WMM_GET_STATUS);
1107
cpu_to_le16(sizeof(struct host_cmd_ds_wmm_get_status) +
1111
case HostCmd_CMD_802_11_IBSS_COALESCING_STATUS:
1112
ret = mwifiex_cmd_ibss_coalescing_status(cmd_ptr, cmd_action,
1115
case HostCmd_CMD_MAC_REG_ACCESS:
1116
case HostCmd_CMD_BBP_REG_ACCESS:
1117
case HostCmd_CMD_RF_REG_ACCESS:
1118
case HostCmd_CMD_PMIC_REG_ACCESS:
1119
case HostCmd_CMD_CAU_REG_ACCESS:
1120
case HostCmd_CMD_802_11_EEPROM_ACCESS:
1121
ret = mwifiex_cmd_reg_access(cmd_ptr, cmd_action, data_buf);
1123
case HostCmd_CMD_SET_BSS_MODE:
1124
cmd_ptr->command = cpu_to_le16(cmd_no);
1125
if (priv->bss_mode == NL80211_IFTYPE_ADHOC)
1126
cmd_ptr->params.bss_mode.con_type =
1127
CONNECTION_TYPE_ADHOC;
1128
else if (priv->bss_mode == NL80211_IFTYPE_STATION)
1129
cmd_ptr->params.bss_mode.con_type =
1130
CONNECTION_TYPE_INFRA;
1131
cmd_ptr->size = cpu_to_le16(sizeof(struct
1132
host_cmd_ds_set_bss_mode) + S_DS_GEN);
1135
case HostCmd_CMD_PCIE_DESC_DETAILS:
1136
ret = mwifiex_cmd_pcie_host_spec(priv, cmd_ptr, cmd_action);
1139
dev_err(priv->adapter->dev,
1140
"PREP_CMD: unknown cmd- %#x\n", cmd_no);
1148
* This function issues commands to initialize firmware.
1150
* This is called after firmware download to bring the card to
1153
* The following commands are issued sequentially -
1154
* - Set PCI-Express host buffer configuration (PCIE only)
1155
* - Function init (for first interface only)
1156
* - Read MAC address (for first interface only)
1157
* - Reconfigure Tx buffer size (for first interface only)
1158
* - Enable auto deep sleep (for first interface only)
1161
* - Set IBSS coalescing status
1162
* - Set AMSDU aggregation control
1164
* - Set MAC control (this must be the last command to initialize firmware)
1166
int mwifiex_sta_init_cmd(struct mwifiex_private *priv, u8 first_sta)
1170
struct mwifiex_ds_11n_amsdu_aggr_ctrl amsdu_aggr_ctrl;
1171
struct mwifiex_ds_auto_ds auto_ds;
1172
enum state_11d_t state_11d;
1173
struct mwifiex_ds_11n_tx_cfg tx_cfg;
1176
if (priv->adapter->iface_type == MWIFIEX_PCIE) {
1177
ret = mwifiex_send_cmd_async(priv,
1178
HostCmd_CMD_PCIE_DESC_DETAILS,
1179
HostCmd_ACT_GEN_SET, 0, NULL);
1184
ret = mwifiex_send_cmd_async(priv, HostCmd_CMD_FUNC_INIT,
1185
HostCmd_ACT_GEN_SET, 0, NULL);
1188
/* Read MAC address from HW */
1189
ret = mwifiex_send_cmd_async(priv, HostCmd_CMD_GET_HW_SPEC,
1190
HostCmd_ACT_GEN_GET, 0, NULL);
1194
/* Reconfigure tx buf size */
1195
ret = mwifiex_send_cmd_async(priv,
1196
HostCmd_CMD_RECONFIGURE_TX_BUFF,
1197
HostCmd_ACT_GEN_SET, 0,
1198
&priv->adapter->tx_buf_size);
1202
/* Enable IEEE PS by default */
1203
priv->adapter->ps_mode = MWIFIEX_802_11_POWER_MODE_PSP;
1204
ret = mwifiex_send_cmd_async(priv,
1205
HostCmd_CMD_802_11_PS_MODE_ENH,
1206
EN_AUTO_PS, BITMAP_STA_PS, NULL);
1212
ret = mwifiex_send_cmd_async(priv, HostCmd_CMD_TX_RATE_CFG,
1213
HostCmd_ACT_GEN_GET, 0, NULL);
1216
priv->data_rate = 0;
1219
ret = mwifiex_send_cmd_async(priv, HostCmd_CMD_TXPWR_CFG,
1220
HostCmd_ACT_GEN_GET, 0, NULL);
1224
/* set ibss coalescing_status */
1225
ret = mwifiex_send_cmd_async(priv,
1226
HostCmd_CMD_802_11_IBSS_COALESCING_STATUS,
1227
HostCmd_ACT_GEN_SET, 0, &enable);
1231
memset(&amsdu_aggr_ctrl, 0, sizeof(amsdu_aggr_ctrl));
1232
amsdu_aggr_ctrl.enable = true;
1233
/* Send request to firmware */
1234
ret = mwifiex_send_cmd_async(priv, HostCmd_CMD_AMSDU_AGGR_CTRL,
1235
HostCmd_ACT_GEN_SET, 0,
1239
/* MAC Control must be the last command in init_fw */
1240
/* set MAC Control */
1241
ret = mwifiex_send_cmd_async(priv, HostCmd_CMD_MAC_CONTROL,
1242
HostCmd_ACT_GEN_SET, 0,
1243
&priv->curr_pkt_filter);
1248
/* Enable auto deep sleep */
1249
auto_ds.auto_ds = DEEP_SLEEP_ON;
1250
auto_ds.idle_time = DEEP_SLEEP_IDLE_TIME;
1251
ret = mwifiex_send_cmd_async(priv,
1252
HostCmd_CMD_802_11_PS_MODE_ENH,
1253
EN_AUTO_PS, BITMAP_AUTO_DS,
1259
/* Send cmd to FW to enable/disable 11D function */
1260
state_11d = ENABLE_11D;
1261
ret = mwifiex_send_cmd_async(priv, HostCmd_CMD_802_11_SNMP_MIB,
1262
HostCmd_ACT_GEN_SET, DOT11D_I, &state_11d);
1264
dev_err(priv->adapter->dev, "11D: failed to enable 11D\n");
1266
/* Send cmd to FW to configure 11n specific configuration
1267
* (Short GI, Channel BW, Green field support etc.) for transmit
1269
tx_cfg.tx_htcap = MWIFIEX_FW_DEF_HTTXCFG;
1270
ret = mwifiex_send_cmd_async(priv, HostCmd_CMD_11N_CFG,
1271
HostCmd_ACT_GEN_SET, 0, &tx_cfg);
1273
/* set last_init_cmd */
1274
priv->adapter->last_init_cmd = HostCmd_CMD_11N_CFG;