Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * NXP Wireless LAN device driver: station command handling
4 *
5 * Copyright 2011-2020 NXP
6 */
7
8#include "decl.h"
9#include "ioctl.h"
10#include "util.h"
11#include "fw.h"
12#include "main.h"
13#include "wmm.h"
14#include "11n.h"
15#include "11ac.h"
16
17static bool drcs;
18module_param(drcs, bool, 0644);
19MODULE_PARM_DESC(drcs, "multi-channel operation:1, single-channel operation:0");
20
21static bool disable_auto_ds;
22module_param(disable_auto_ds, bool, 0);
23MODULE_PARM_DESC(disable_auto_ds,
24 "deepsleep enabled=0(default), deepsleep disabled=1");
25/*
26 * This function prepares command to set/get RSSI information.
27 *
28 * Preparation includes -
29 * - Setting command ID, action and proper size
30 * - Setting data/beacon average factors
31 * - Resetting SNR/NF/RSSI values in private structure
32 * - Ensuring correct endian-ness
33 */
34static int
35mwifiex_cmd_802_11_rssi_info(struct mwifiex_private *priv,
36 struct host_cmd_ds_command *cmd, u16 cmd_action)
37{
38 cmd->command = cpu_to_le16(HostCmd_CMD_RSSI_INFO);
39 cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_802_11_rssi_info) +
40 S_DS_GEN);
41 cmd->params.rssi_info.action = cpu_to_le16(cmd_action);
42 cmd->params.rssi_info.ndata = cpu_to_le16(priv->data_avg_factor);
43 cmd->params.rssi_info.nbcn = cpu_to_le16(priv->bcn_avg_factor);
44
45 /* Reset SNR/NF/RSSI values in private structure */
46 priv->data_rssi_last = 0;
47 priv->data_nf_last = 0;
48 priv->data_rssi_avg = 0;
49 priv->data_nf_avg = 0;
50 priv->bcn_rssi_last = 0;
51 priv->bcn_nf_last = 0;
52 priv->bcn_rssi_avg = 0;
53 priv->bcn_nf_avg = 0;
54
55 return 0;
56}
57
58/*
59 * This function prepares command to set MAC control.
60 *
61 * Preparation includes -
62 * - Setting command ID, action and proper size
63 * - Ensuring correct endian-ness
64 */
65static int mwifiex_cmd_mac_control(struct mwifiex_private *priv,
66 struct host_cmd_ds_command *cmd,
67 u16 cmd_action, u32 *action)
68{
69 struct host_cmd_ds_mac_control *mac_ctrl = &cmd->params.mac_ctrl;
70
71 if (cmd_action != HostCmd_ACT_GEN_SET) {
72 mwifiex_dbg(priv->adapter, ERROR,
73 "mac_control: only support set cmd\n");
74 return -1;
75 }
76
77 cmd->command = cpu_to_le16(HostCmd_CMD_MAC_CONTROL);
78 cmd->size =
79 cpu_to_le16(sizeof(struct host_cmd_ds_mac_control) + S_DS_GEN);
80 mac_ctrl->action = cpu_to_le32(*action);
81
82 return 0;
83}
84
85/*
86 * This function prepares command to set/get SNMP MIB.
87 *
88 * Preparation includes -
89 * - Setting command ID, action and proper size
90 * - Setting SNMP MIB OID number and value
91 * (as required)
92 * - Ensuring correct endian-ness
93 *
94 * The following SNMP MIB OIDs are supported -
95 * - FRAG_THRESH_I : Fragmentation threshold
96 * - RTS_THRESH_I : RTS threshold
97 * - SHORT_RETRY_LIM_I : Short retry limit
98 * - DOT11D_I : 11d support
99 */
100static int mwifiex_cmd_802_11_snmp_mib(struct mwifiex_private *priv,
101 struct host_cmd_ds_command *cmd,
102 u16 cmd_action, u32 cmd_oid,
103 u16 *ul_temp)
104{
105 struct host_cmd_ds_802_11_snmp_mib *snmp_mib = &cmd->params.smib;
106
107 mwifiex_dbg(priv->adapter, CMD,
108 "cmd: SNMP_CMD: cmd_oid = 0x%x\n", cmd_oid);
109 cmd->command = cpu_to_le16(HostCmd_CMD_802_11_SNMP_MIB);
110 cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_802_11_snmp_mib)
111 - 1 + S_DS_GEN);
112
113 snmp_mib->oid = cpu_to_le16((u16)cmd_oid);
114 if (cmd_action == HostCmd_ACT_GEN_GET) {
115 snmp_mib->query_type = cpu_to_le16(HostCmd_ACT_GEN_GET);
116 snmp_mib->buf_size = cpu_to_le16(MAX_SNMP_BUF_SIZE);
117 le16_unaligned_add_cpu(&cmd->size, MAX_SNMP_BUF_SIZE);
118 } else if (cmd_action == HostCmd_ACT_GEN_SET) {
119 snmp_mib->query_type = cpu_to_le16(HostCmd_ACT_GEN_SET);
120 snmp_mib->buf_size = cpu_to_le16(sizeof(u16));
121 put_unaligned_le16(*ul_temp, snmp_mib->value);
122 le16_unaligned_add_cpu(&cmd->size, sizeof(u16));
123 }
124
125 mwifiex_dbg(priv->adapter, CMD,
126 "cmd: SNMP_CMD: Action=0x%x, OID=0x%x,\t"
127 "OIDSize=0x%x, Value=0x%x\n",
128 cmd_action, cmd_oid, le16_to_cpu(snmp_mib->buf_size),
129 get_unaligned_le16(snmp_mib->value));
130 return 0;
131}
132
133/*
134 * This function prepares command to get log.
135 *
136 * Preparation includes -
137 * - Setting command ID and proper size
138 * - Ensuring correct endian-ness
139 */
140static int
141mwifiex_cmd_802_11_get_log(struct host_cmd_ds_command *cmd)
142{
143 cmd->command = cpu_to_le16(HostCmd_CMD_802_11_GET_LOG);
144 cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_802_11_get_log) +
145 S_DS_GEN);
146 return 0;
147}
148
149/*
150 * This function prepares command to set/get Tx data rate configuration.
151 *
152 * Preparation includes -
153 * - Setting command ID, action and proper size
154 * - Setting configuration index, rate scope and rate drop pattern
155 * parameters (as required)
156 * - Ensuring correct endian-ness
157 */
158static int mwifiex_cmd_tx_rate_cfg(struct mwifiex_private *priv,
159 struct host_cmd_ds_command *cmd,
160 u16 cmd_action, u16 *pbitmap_rates)
161{
162 struct host_cmd_ds_tx_rate_cfg *rate_cfg = &cmd->params.tx_rate_cfg;
163 struct mwifiex_rate_scope *rate_scope;
164 struct mwifiex_rate_drop_pattern *rate_drop;
165 u32 i;
166
167 cmd->command = cpu_to_le16(HostCmd_CMD_TX_RATE_CFG);
168
169 rate_cfg->action = cpu_to_le16(cmd_action);
170 rate_cfg->cfg_index = 0;
171
172 rate_scope = (struct mwifiex_rate_scope *) ((u8 *) rate_cfg +
173 sizeof(struct host_cmd_ds_tx_rate_cfg));
174 rate_scope->type = cpu_to_le16(TLV_TYPE_RATE_SCOPE);
175 rate_scope->length = cpu_to_le16
176 (sizeof(*rate_scope) - sizeof(struct mwifiex_ie_types_header));
177 if (pbitmap_rates != NULL) {
178 rate_scope->hr_dsss_rate_bitmap = cpu_to_le16(pbitmap_rates[0]);
179 rate_scope->ofdm_rate_bitmap = cpu_to_le16(pbitmap_rates[1]);
180 for (i = 0; i < ARRAY_SIZE(rate_scope->ht_mcs_rate_bitmap); i++)
181 rate_scope->ht_mcs_rate_bitmap[i] =
182 cpu_to_le16(pbitmap_rates[2 + i]);
183 if (priv->adapter->fw_api_ver == MWIFIEX_FW_V15) {
184 for (i = 0;
185 i < ARRAY_SIZE(rate_scope->vht_mcs_rate_bitmap);
186 i++)
187 rate_scope->vht_mcs_rate_bitmap[i] =
188 cpu_to_le16(pbitmap_rates[10 + i]);
189 }
190 } else {
191 rate_scope->hr_dsss_rate_bitmap =
192 cpu_to_le16(priv->bitmap_rates[0]);
193 rate_scope->ofdm_rate_bitmap =
194 cpu_to_le16(priv->bitmap_rates[1]);
195 for (i = 0; i < ARRAY_SIZE(rate_scope->ht_mcs_rate_bitmap); i++)
196 rate_scope->ht_mcs_rate_bitmap[i] =
197 cpu_to_le16(priv->bitmap_rates[2 + i]);
198 if (priv->adapter->fw_api_ver == MWIFIEX_FW_V15) {
199 for (i = 0;
200 i < ARRAY_SIZE(rate_scope->vht_mcs_rate_bitmap);
201 i++)
202 rate_scope->vht_mcs_rate_bitmap[i] =
203 cpu_to_le16(priv->bitmap_rates[10 + i]);
204 }
205 }
206
207 rate_drop = (struct mwifiex_rate_drop_pattern *) ((u8 *) rate_scope +
208 sizeof(struct mwifiex_rate_scope));
209 rate_drop->type = cpu_to_le16(TLV_TYPE_RATE_DROP_CONTROL);
210 rate_drop->length = cpu_to_le16(sizeof(rate_drop->rate_drop_mode));
211 rate_drop->rate_drop_mode = 0;
212
213 cmd->size =
214 cpu_to_le16(S_DS_GEN + sizeof(struct host_cmd_ds_tx_rate_cfg) +
215 sizeof(struct mwifiex_rate_scope) +
216 sizeof(struct mwifiex_rate_drop_pattern));
217
218 return 0;
219}
220
221/*
222 * This function prepares command to set/get Tx power configuration.
223 *
224 * Preparation includes -
225 * - Setting command ID, action and proper size
226 * - Setting Tx power mode, power group TLV
227 * (as required)
228 * - Ensuring correct endian-ness
229 */
230static int mwifiex_cmd_tx_power_cfg(struct host_cmd_ds_command *cmd,
231 u16 cmd_action,
232 struct host_cmd_ds_txpwr_cfg *txp)
233{
234 struct mwifiex_types_power_group *pg_tlv;
235 struct host_cmd_ds_txpwr_cfg *cmd_txp_cfg = &cmd->params.txp_cfg;
236
237 cmd->command = cpu_to_le16(HostCmd_CMD_TXPWR_CFG);
238 cmd->size =
239 cpu_to_le16(S_DS_GEN + sizeof(struct host_cmd_ds_txpwr_cfg));
240 switch (cmd_action) {
241 case HostCmd_ACT_GEN_SET:
242 if (txp->mode) {
243 pg_tlv = (struct mwifiex_types_power_group
244 *) ((unsigned long) txp +
245 sizeof(struct host_cmd_ds_txpwr_cfg));
246 memmove(cmd_txp_cfg, txp,
247 sizeof(struct host_cmd_ds_txpwr_cfg) +
248 sizeof(struct mwifiex_types_power_group) +
249 le16_to_cpu(pg_tlv->length));
250
251 pg_tlv = (struct mwifiex_types_power_group *) ((u8 *)
252 cmd_txp_cfg +
253 sizeof(struct host_cmd_ds_txpwr_cfg));
254 cmd->size = cpu_to_le16(le16_to_cpu(cmd->size) +
255 sizeof(struct mwifiex_types_power_group) +
256 le16_to_cpu(pg_tlv->length));
257 } else {
258 memmove(cmd_txp_cfg, txp, sizeof(*txp));
259 }
260 cmd_txp_cfg->action = cpu_to_le16(cmd_action);
261 break;
262 case HostCmd_ACT_GEN_GET:
263 cmd_txp_cfg->action = cpu_to_le16(cmd_action);
264 break;
265 }
266
267 return 0;
268}
269
270/*
271 * This function prepares command to get RF Tx power.
272 */
273static int mwifiex_cmd_rf_tx_power(struct mwifiex_private *priv,
274 struct host_cmd_ds_command *cmd,
275 u16 cmd_action, void *data_buf)
276{
277 struct host_cmd_ds_rf_tx_pwr *txp = &cmd->params.txp;
278
279 cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_rf_tx_pwr)
280 + S_DS_GEN);
281 cmd->command = cpu_to_le16(HostCmd_CMD_RF_TX_PWR);
282 txp->action = cpu_to_le16(cmd_action);
283
284 return 0;
285}
286
287/*
288 * This function prepares command to set rf antenna.
289 */
290static int mwifiex_cmd_rf_antenna(struct mwifiex_private *priv,
291 struct host_cmd_ds_command *cmd,
292 u16 cmd_action,
293 struct mwifiex_ds_ant_cfg *ant_cfg)
294{
295 struct host_cmd_ds_rf_ant_mimo *ant_mimo = &cmd->params.ant_mimo;
296 struct host_cmd_ds_rf_ant_siso *ant_siso = &cmd->params.ant_siso;
297
298 cmd->command = cpu_to_le16(HostCmd_CMD_RF_ANTENNA);
299
300 switch (cmd_action) {
301 case HostCmd_ACT_GEN_SET:
302 if (priv->adapter->hw_dev_mcs_support == HT_STREAM_2X2) {
303 cmd->size = cpu_to_le16(sizeof(struct
304 host_cmd_ds_rf_ant_mimo)
305 + S_DS_GEN);
306 ant_mimo->action_tx = cpu_to_le16(HostCmd_ACT_SET_TX);
307 ant_mimo->tx_ant_mode = cpu_to_le16((u16)ant_cfg->
308 tx_ant);
309 ant_mimo->action_rx = cpu_to_le16(HostCmd_ACT_SET_RX);
310 ant_mimo->rx_ant_mode = cpu_to_le16((u16)ant_cfg->
311 rx_ant);
312 } else {
313 cmd->size = cpu_to_le16(sizeof(struct
314 host_cmd_ds_rf_ant_siso) +
315 S_DS_GEN);
316 ant_siso->action = cpu_to_le16(HostCmd_ACT_SET_BOTH);
317 ant_siso->ant_mode = cpu_to_le16((u16)ant_cfg->tx_ant);
318 }
319 break;
320 case HostCmd_ACT_GEN_GET:
321 if (priv->adapter->hw_dev_mcs_support == HT_STREAM_2X2) {
322 cmd->size = cpu_to_le16(sizeof(struct
323 host_cmd_ds_rf_ant_mimo) +
324 S_DS_GEN);
325 ant_mimo->action_tx = cpu_to_le16(HostCmd_ACT_GET_TX);
326 ant_mimo->action_rx = cpu_to_le16(HostCmd_ACT_GET_RX);
327 } else {
328 cmd->size = cpu_to_le16(sizeof(struct
329 host_cmd_ds_rf_ant_siso) +
330 S_DS_GEN);
331 ant_siso->action = cpu_to_le16(HostCmd_ACT_GET_BOTH);
332 }
333 break;
334 }
335 return 0;
336}
337
338/*
339 * This function prepares command to set Host Sleep configuration.
340 *
341 * Preparation includes -
342 * - Setting command ID and proper size
343 * - Setting Host Sleep action, conditions, ARP filters
344 * (as required)
345 * - Ensuring correct endian-ness
346 */
347static int
348mwifiex_cmd_802_11_hs_cfg(struct mwifiex_private *priv,
349 struct host_cmd_ds_command *cmd,
350 u16 cmd_action,
351 struct mwifiex_hs_config_param *hscfg_param)
352{
353 struct mwifiex_adapter *adapter = priv->adapter;
354 struct host_cmd_ds_802_11_hs_cfg_enh *hs_cfg = &cmd->params.opt_hs_cfg;
355 u8 *tlv = (u8 *)hs_cfg + sizeof(struct host_cmd_ds_802_11_hs_cfg_enh);
356 struct mwifiex_ps_param_in_hs *psparam_tlv = NULL;
357 bool hs_activate = false;
358 u16 size;
359
360 if (!hscfg_param)
361 /* New Activate command */
362 hs_activate = true;
363 cmd->command = cpu_to_le16(HostCmd_CMD_802_11_HS_CFG_ENH);
364
365 if (!hs_activate &&
366 (hscfg_param->conditions != cpu_to_le32(HS_CFG_CANCEL)) &&
367 ((adapter->arp_filter_size > 0) &&
368 (adapter->arp_filter_size <= ARP_FILTER_MAX_BUF_SIZE))) {
369 mwifiex_dbg(adapter, CMD,
370 "cmd: Attach %d bytes ArpFilter to HSCfg cmd\n",
371 adapter->arp_filter_size);
372 memcpy(((u8 *) hs_cfg) +
373 sizeof(struct host_cmd_ds_802_11_hs_cfg_enh),
374 adapter->arp_filter, adapter->arp_filter_size);
375 size = adapter->arp_filter_size +
376 sizeof(struct host_cmd_ds_802_11_hs_cfg_enh)
377 + S_DS_GEN;
378 tlv = (u8 *)hs_cfg
379 + sizeof(struct host_cmd_ds_802_11_hs_cfg_enh)
380 + adapter->arp_filter_size;
381 } else {
382 size = S_DS_GEN + sizeof(struct host_cmd_ds_802_11_hs_cfg_enh);
383 }
384 if (hs_activate) {
385 hs_cfg->action = cpu_to_le16(HS_ACTIVATE);
386 hs_cfg->params.hs_activate.resp_ctrl = cpu_to_le16(RESP_NEEDED);
387
388 adapter->hs_activated_manually = true;
389 mwifiex_dbg(priv->adapter, CMD,
390 "cmd: Activating host sleep manually\n");
391 } else {
392 hs_cfg->action = cpu_to_le16(HS_CONFIGURE);
393 hs_cfg->params.hs_config.conditions = hscfg_param->conditions;
394 hs_cfg->params.hs_config.gpio = hscfg_param->gpio;
395 hs_cfg->params.hs_config.gap = hscfg_param->gap;
396
397 size += sizeof(struct mwifiex_ps_param_in_hs);
398 psparam_tlv = (struct mwifiex_ps_param_in_hs *)tlv;
399 psparam_tlv->header.type =
400 cpu_to_le16(TLV_TYPE_PS_PARAMS_IN_HS);
401 psparam_tlv->header.len =
402 cpu_to_le16(sizeof(struct mwifiex_ps_param_in_hs)
403 - sizeof(struct mwifiex_ie_types_header));
404 psparam_tlv->hs_wake_int = cpu_to_le32(HS_DEF_WAKE_INTERVAL);
405 psparam_tlv->hs_inact_timeout =
406 cpu_to_le32(HS_DEF_INACTIVITY_TIMEOUT);
407
408 mwifiex_dbg(adapter, CMD,
409 "cmd: HS_CFG_CMD: condition:0x%x gpio:0x%x gap:0x%x\n",
410 hs_cfg->params.hs_config.conditions,
411 hs_cfg->params.hs_config.gpio,
412 hs_cfg->params.hs_config.gap);
413 }
414 cmd->size = cpu_to_le16(size);
415
416 return 0;
417}
418
419/*
420 * This function prepares command to set/get MAC address.
421 *
422 * Preparation includes -
423 * - Setting command ID, action and proper size
424 * - Setting MAC address (for SET only)
425 * - Ensuring correct endian-ness
426 */
427static int mwifiex_cmd_802_11_mac_address(struct mwifiex_private *priv,
428 struct host_cmd_ds_command *cmd,
429 u16 cmd_action)
430{
431 cmd->command = cpu_to_le16(HostCmd_CMD_802_11_MAC_ADDRESS);
432 cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_802_11_mac_address) +
433 S_DS_GEN);
434 cmd->result = 0;
435
436 cmd->params.mac_addr.action = cpu_to_le16(cmd_action);
437
438 if (cmd_action == HostCmd_ACT_GEN_SET)
439 memcpy(cmd->params.mac_addr.mac_addr, priv->curr_addr,
440 ETH_ALEN);
441 return 0;
442}
443
444/*
445 * This function prepares command to set MAC multicast address.
446 *
447 * Preparation includes -
448 * - Setting command ID, action and proper size
449 * - Setting MAC multicast address
450 * - Ensuring correct endian-ness
451 */
452static int
453mwifiex_cmd_mac_multicast_adr(struct host_cmd_ds_command *cmd,
454 u16 cmd_action,
455 struct mwifiex_multicast_list *mcast_list)
456{
457 struct host_cmd_ds_mac_multicast_adr *mcast_addr = &cmd->params.mc_addr;
458
459 cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_mac_multicast_adr) +
460 S_DS_GEN);
461 cmd->command = cpu_to_le16(HostCmd_CMD_MAC_MULTICAST_ADR);
462
463 mcast_addr->action = cpu_to_le16(cmd_action);
464 mcast_addr->num_of_adrs =
465 cpu_to_le16((u16) mcast_list->num_multicast_addr);
466 memcpy(mcast_addr->mac_list, mcast_list->mac_list,
467 mcast_list->num_multicast_addr * ETH_ALEN);
468
469 return 0;
470}
471
472/*
473 * This function prepares command to deauthenticate.
474 *
475 * Preparation includes -
476 * - Setting command ID and proper size
477 * - Setting AP MAC address and reason code
478 * - Ensuring correct endian-ness
479 */
480static int mwifiex_cmd_802_11_deauthenticate(struct mwifiex_private *priv,
481 struct host_cmd_ds_command *cmd,
482 u8 *mac)
483{
484 struct host_cmd_ds_802_11_deauthenticate *deauth = &cmd->params.deauth;
485
486 cmd->command = cpu_to_le16(HostCmd_CMD_802_11_DEAUTHENTICATE);
487 cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_802_11_deauthenticate)
488 + S_DS_GEN);
489
490 /* Set AP MAC address */
491 memcpy(deauth->mac_addr, mac, ETH_ALEN);
492
493 mwifiex_dbg(priv->adapter, CMD, "cmd: Deauth: %pM\n", deauth->mac_addr);
494
495 deauth->reason_code = cpu_to_le16(WLAN_REASON_DEAUTH_LEAVING);
496
497 return 0;
498}
499
500/*
501 * This function prepares command to stop Ad-Hoc network.
502 *
503 * Preparation includes -
504 * - Setting command ID and proper size
505 * - Ensuring correct endian-ness
506 */
507static int mwifiex_cmd_802_11_ad_hoc_stop(struct host_cmd_ds_command *cmd)
508{
509 cmd->command = cpu_to_le16(HostCmd_CMD_802_11_AD_HOC_STOP);
510 cmd->size = cpu_to_le16(S_DS_GEN);
511 return 0;
512}
513
514/*
515 * This function sets WEP key(s) to key parameter TLV(s).
516 *
517 * Multi-key parameter TLVs are supported, so we can send multiple
518 * WEP keys in a single buffer.
519 */
520static int
521mwifiex_set_keyparamset_wep(struct mwifiex_private *priv,
522 struct mwifiex_ie_type_key_param_set *key_param_set,
523 u16 *key_param_len)
524{
525 int cur_key_param_len;
526 u8 i;
527
528 /* Multi-key_param_set TLV is supported */
529 for (i = 0; i < NUM_WEP_KEYS; i++) {
530 if ((priv->wep_key[i].key_length == WLAN_KEY_LEN_WEP40) ||
531 (priv->wep_key[i].key_length == WLAN_KEY_LEN_WEP104)) {
532 key_param_set->type =
533 cpu_to_le16(TLV_TYPE_KEY_MATERIAL);
534/* Key_param_set WEP fixed length */
535#define KEYPARAMSET_WEP_FIXED_LEN 8
536 key_param_set->length = cpu_to_le16((u16)
537 (priv->wep_key[i].
538 key_length +
539 KEYPARAMSET_WEP_FIXED_LEN));
540 key_param_set->key_type_id =
541 cpu_to_le16(KEY_TYPE_ID_WEP);
542 key_param_set->key_info =
543 cpu_to_le16(KEY_ENABLED | KEY_UNICAST |
544 KEY_MCAST);
545 key_param_set->key_len =
546 cpu_to_le16(priv->wep_key[i].key_length);
547 /* Set WEP key index */
548 key_param_set->key[0] = i;
549 /* Set default Tx key flag */
550 if (i ==
551 (priv->
552 wep_key_curr_index & HostCmd_WEP_KEY_INDEX_MASK))
553 key_param_set->key[1] = 1;
554 else
555 key_param_set->key[1] = 0;
556 memmove(&key_param_set->key[2],
557 priv->wep_key[i].key_material,
558 priv->wep_key[i].key_length);
559
560 cur_key_param_len = priv->wep_key[i].key_length +
561 KEYPARAMSET_WEP_FIXED_LEN +
562 sizeof(struct mwifiex_ie_types_header);
563 *key_param_len += (u16) cur_key_param_len;
564 key_param_set =
565 (struct mwifiex_ie_type_key_param_set *)
566 ((u8 *)key_param_set +
567 cur_key_param_len);
568 } else if (!priv->wep_key[i].key_length) {
569 continue;
570 } else {
571 mwifiex_dbg(priv->adapter, ERROR,
572 "key%d Length = %d is incorrect\n",
573 (i + 1), priv->wep_key[i].key_length);
574 return -1;
575 }
576 }
577
578 return 0;
579}
580
581/* This function populates key material v2 command
582 * to set network key for AES & CMAC AES.
583 */
584static int mwifiex_set_aes_key_v2(struct mwifiex_private *priv,
585 struct host_cmd_ds_command *cmd,
586 struct mwifiex_ds_encrypt_key *enc_key,
587 struct host_cmd_ds_802_11_key_material_v2 *km)
588{
589 struct mwifiex_adapter *adapter = priv->adapter;
590 u16 size, len = KEY_PARAMS_FIXED_LEN;
591
592 if (enc_key->is_igtk_key) {
593 mwifiex_dbg(adapter, INFO,
594 "%s: Set CMAC AES Key\n", __func__);
595 if (enc_key->is_rx_seq_valid)
596 memcpy(km->key_param_set.key_params.cmac_aes.ipn,
597 enc_key->pn, enc_key->pn_len);
598 km->key_param_set.key_info &= cpu_to_le16(~KEY_MCAST);
599 km->key_param_set.key_info |= cpu_to_le16(KEY_IGTK);
600 km->key_param_set.key_type = KEY_TYPE_ID_AES_CMAC;
601 km->key_param_set.key_params.cmac_aes.key_len =
602 cpu_to_le16(enc_key->key_len);
603 memcpy(km->key_param_set.key_params.cmac_aes.key,
604 enc_key->key_material, enc_key->key_len);
605 len += sizeof(struct mwifiex_cmac_aes_param);
606 } else if (enc_key->is_igtk_def_key) {
607 mwifiex_dbg(adapter, INFO,
608 "%s: Set CMAC default Key index\n", __func__);
609 km->key_param_set.key_type = KEY_TYPE_ID_AES_CMAC_DEF;
610 km->key_param_set.key_idx = enc_key->key_index & KEY_INDEX_MASK;
611 } else {
612 mwifiex_dbg(adapter, INFO,
613 "%s: Set AES Key\n", __func__);
614 if (enc_key->is_rx_seq_valid)
615 memcpy(km->key_param_set.key_params.aes.pn,
616 enc_key->pn, enc_key->pn_len);
617 km->key_param_set.key_type = KEY_TYPE_ID_AES;
618 km->key_param_set.key_params.aes.key_len =
619 cpu_to_le16(enc_key->key_len);
620 memcpy(km->key_param_set.key_params.aes.key,
621 enc_key->key_material, enc_key->key_len);
622 len += sizeof(struct mwifiex_aes_param);
623 }
624
625 km->key_param_set.len = cpu_to_le16(len);
626 size = len + sizeof(struct mwifiex_ie_types_header) +
627 sizeof(km->action) + S_DS_GEN;
628 cmd->size = cpu_to_le16(size);
629
630 return 0;
631}
632
633/* This function prepares command to set/get/reset network key(s).
634 * This function prepares key material command for V2 format.
635 * Preparation includes -
636 * - Setting command ID, action and proper size
637 * - Setting WEP keys, WAPI keys or WPA keys along with required
638 * encryption (TKIP, AES) (as required)
639 * - Ensuring correct endian-ness
640 */
641static int
642mwifiex_cmd_802_11_key_material_v2(struct mwifiex_private *priv,
643 struct host_cmd_ds_command *cmd,
644 u16 cmd_action, u32 cmd_oid,
645 struct mwifiex_ds_encrypt_key *enc_key)
646{
647 struct mwifiex_adapter *adapter = priv->adapter;
648 u8 *mac = enc_key->mac_addr;
649 u16 key_info, len = KEY_PARAMS_FIXED_LEN;
650 struct host_cmd_ds_802_11_key_material_v2 *km =
651 &cmd->params.key_material_v2;
652
653 cmd->command = cpu_to_le16(HostCmd_CMD_802_11_KEY_MATERIAL);
654 km->action = cpu_to_le16(cmd_action);
655
656 if (cmd_action == HostCmd_ACT_GEN_GET) {
657 mwifiex_dbg(adapter, INFO, "%s: Get key\n", __func__);
658 km->key_param_set.key_idx =
659 enc_key->key_index & KEY_INDEX_MASK;
660 km->key_param_set.type = cpu_to_le16(TLV_TYPE_KEY_PARAM_V2);
661 km->key_param_set.len = cpu_to_le16(KEY_PARAMS_FIXED_LEN);
662 memcpy(km->key_param_set.mac_addr, mac, ETH_ALEN);
663
664 if (enc_key->key_index & MWIFIEX_KEY_INDEX_UNICAST)
665 key_info = KEY_UNICAST;
666 else
667 key_info = KEY_MCAST;
668
669 if (enc_key->is_igtk_key)
670 key_info |= KEY_IGTK;
671
672 km->key_param_set.key_info = cpu_to_le16(key_info);
673
674 cmd->size = cpu_to_le16(sizeof(struct mwifiex_ie_types_header) +
675 S_DS_GEN + KEY_PARAMS_FIXED_LEN +
676 sizeof(km->action));
677 return 0;
678 }
679
680 memset(&km->key_param_set, 0,
681 sizeof(struct mwifiex_ie_type_key_param_set_v2));
682
683 if (enc_key->key_disable) {
684 mwifiex_dbg(adapter, INFO, "%s: Remove key\n", __func__);
685 km->action = cpu_to_le16(HostCmd_ACT_GEN_REMOVE);
686 km->key_param_set.type = cpu_to_le16(TLV_TYPE_KEY_PARAM_V2);
687 km->key_param_set.len = cpu_to_le16(KEY_PARAMS_FIXED_LEN);
688 km->key_param_set.key_idx = enc_key->key_index & KEY_INDEX_MASK;
689 key_info = KEY_MCAST | KEY_UNICAST;
690 km->key_param_set.key_info = cpu_to_le16(key_info);
691 memcpy(km->key_param_set.mac_addr, mac, ETH_ALEN);
692 cmd->size = cpu_to_le16(sizeof(struct mwifiex_ie_types_header) +
693 S_DS_GEN + KEY_PARAMS_FIXED_LEN +
694 sizeof(km->action));
695 return 0;
696 }
697
698 km->action = cpu_to_le16(HostCmd_ACT_GEN_SET);
699 km->key_param_set.key_idx = enc_key->key_index & KEY_INDEX_MASK;
700 km->key_param_set.type = cpu_to_le16(TLV_TYPE_KEY_PARAM_V2);
701 key_info = KEY_ENABLED;
702 memcpy(km->key_param_set.mac_addr, mac, ETH_ALEN);
703
704 if (enc_key->key_len <= WLAN_KEY_LEN_WEP104) {
705 mwifiex_dbg(adapter, INFO, "%s: Set WEP Key\n", __func__);
706 len += sizeof(struct mwifiex_wep_param);
707 km->key_param_set.len = cpu_to_le16(len);
708 km->key_param_set.key_type = KEY_TYPE_ID_WEP;
709
710 if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_UAP) {
711 key_info |= KEY_MCAST | KEY_UNICAST;
712 } else {
713 if (enc_key->is_current_wep_key) {
714 key_info |= KEY_MCAST | KEY_UNICAST;
715 if (km->key_param_set.key_idx ==
716 (priv->wep_key_curr_index & KEY_INDEX_MASK))
717 key_info |= KEY_DEFAULT;
718 } else {
719 if (is_broadcast_ether_addr(mac))
720 key_info |= KEY_MCAST;
721 else
722 key_info |= KEY_UNICAST | KEY_DEFAULT;
723 }
724 }
725 km->key_param_set.key_info = cpu_to_le16(key_info);
726
727 km->key_param_set.key_params.wep.key_len =
728 cpu_to_le16(enc_key->key_len);
729 memcpy(km->key_param_set.key_params.wep.key,
730 enc_key->key_material, enc_key->key_len);
731
732 cmd->size = cpu_to_le16(sizeof(struct mwifiex_ie_types_header) +
733 len + sizeof(km->action) + S_DS_GEN);
734 return 0;
735 }
736
737 if (is_broadcast_ether_addr(mac))
738 key_info |= KEY_MCAST | KEY_RX_KEY;
739 else
740 key_info |= KEY_UNICAST | KEY_TX_KEY | KEY_RX_KEY;
741
742 if (enc_key->is_wapi_key) {
743 mwifiex_dbg(adapter, INFO, "%s: Set WAPI Key\n", __func__);
744 km->key_param_set.key_type = KEY_TYPE_ID_WAPI;
745 memcpy(km->key_param_set.key_params.wapi.pn, enc_key->pn,
746 PN_LEN);
747 km->key_param_set.key_params.wapi.key_len =
748 cpu_to_le16(enc_key->key_len);
749 memcpy(km->key_param_set.key_params.wapi.key,
750 enc_key->key_material, enc_key->key_len);
751 if (is_broadcast_ether_addr(mac))
752 priv->sec_info.wapi_key_on = true;
753
754 if (!priv->sec_info.wapi_key_on)
755 key_info |= KEY_DEFAULT;
756 km->key_param_set.key_info = cpu_to_le16(key_info);
757
758 len += sizeof(struct mwifiex_wapi_param);
759 km->key_param_set.len = cpu_to_le16(len);
760 cmd->size = cpu_to_le16(sizeof(struct mwifiex_ie_types_header) +
761 len + sizeof(km->action) + S_DS_GEN);
762 return 0;
763 }
764
765 if (priv->bss_mode == NL80211_IFTYPE_ADHOC) {
766 key_info |= KEY_DEFAULT;
767 /* Enable unicast bit for WPA-NONE/ADHOC_AES */
768 if (!priv->sec_info.wpa2_enabled &&
769 !is_broadcast_ether_addr(mac))
770 key_info |= KEY_UNICAST;
771 } else {
772 /* Enable default key for WPA/WPA2 */
773 if (!priv->wpa_is_gtk_set)
774 key_info |= KEY_DEFAULT;
775 }
776
777 km->key_param_set.key_info = cpu_to_le16(key_info);
778
779 if (enc_key->key_len == WLAN_KEY_LEN_CCMP)
780 return mwifiex_set_aes_key_v2(priv, cmd, enc_key, km);
781
782 if (enc_key->key_len == WLAN_KEY_LEN_TKIP) {
783 mwifiex_dbg(adapter, INFO,
784 "%s: Set TKIP Key\n", __func__);
785 if (enc_key->is_rx_seq_valid)
786 memcpy(km->key_param_set.key_params.tkip.pn,
787 enc_key->pn, enc_key->pn_len);
788 km->key_param_set.key_type = KEY_TYPE_ID_TKIP;
789 km->key_param_set.key_params.tkip.key_len =
790 cpu_to_le16(enc_key->key_len);
791 memcpy(km->key_param_set.key_params.tkip.key,
792 enc_key->key_material, enc_key->key_len);
793
794 len += sizeof(struct mwifiex_tkip_param);
795 km->key_param_set.len = cpu_to_le16(len);
796 cmd->size = cpu_to_le16(sizeof(struct mwifiex_ie_types_header) +
797 len + sizeof(km->action) + S_DS_GEN);
798 }
799
800 return 0;
801}
802
803/*
804 * This function prepares command to set/get/reset network key(s).
805 * This function prepares key material command for V1 format.
806 *
807 * Preparation includes -
808 * - Setting command ID, action and proper size
809 * - Setting WEP keys, WAPI keys or WPA keys along with required
810 * encryption (TKIP, AES) (as required)
811 * - Ensuring correct endian-ness
812 */
813static int
814mwifiex_cmd_802_11_key_material_v1(struct mwifiex_private *priv,
815 struct host_cmd_ds_command *cmd,
816 u16 cmd_action, u32 cmd_oid,
817 struct mwifiex_ds_encrypt_key *enc_key)
818{
819 struct host_cmd_ds_802_11_key_material *key_material =
820 &cmd->params.key_material;
821 struct host_cmd_tlv_mac_addr *tlv_mac;
822 u16 key_param_len = 0, cmd_size;
823 int ret = 0;
824
825 cmd->command = cpu_to_le16(HostCmd_CMD_802_11_KEY_MATERIAL);
826 key_material->action = cpu_to_le16(cmd_action);
827
828 if (cmd_action == HostCmd_ACT_GEN_GET) {
829 cmd->size =
830 cpu_to_le16(sizeof(key_material->action) + S_DS_GEN);
831 return ret;
832 }
833
834 if (!enc_key) {
835 struct host_cmd_ds_802_11_key_material_wep *key_material_wep =
836 (struct host_cmd_ds_802_11_key_material_wep *)key_material;
837 memset(key_material_wep->key_param_set, 0,
838 sizeof(key_material_wep->key_param_set));
839 ret = mwifiex_set_keyparamset_wep(priv,
840 &key_material_wep->key_param_set[0],
841 &key_param_len);
842 cmd->size = cpu_to_le16(key_param_len +
843 sizeof(key_material_wep->action) + S_DS_GEN);
844 return ret;
845 } else
846 memset(&key_material->key_param_set, 0,
847 sizeof(struct mwifiex_ie_type_key_param_set));
848 if (enc_key->is_wapi_key) {
849 struct mwifiex_ie_type_key_param_set *set;
850
851 mwifiex_dbg(priv->adapter, INFO, "info: Set WAPI Key\n");
852 set = &key_material->key_param_set;
853 set->key_type_id = cpu_to_le16(KEY_TYPE_ID_WAPI);
854 if (cmd_oid == KEY_INFO_ENABLED)
855 set->key_info = cpu_to_le16(KEY_ENABLED);
856 else
857 set->key_info = cpu_to_le16(!KEY_ENABLED);
858
859 set->key[0] = enc_key->key_index;
860 if (!priv->sec_info.wapi_key_on)
861 set->key[1] = 1;
862 else
863 /* set 0 when re-key */
864 set->key[1] = 0;
865
866 if (!is_broadcast_ether_addr(enc_key->mac_addr)) {
867 /* WAPI pairwise key: unicast */
868 set->key_info |= cpu_to_le16(KEY_UNICAST);
869 } else { /* WAPI group key: multicast */
870 set->key_info |= cpu_to_le16(KEY_MCAST);
871 priv->sec_info.wapi_key_on = true;
872 }
873
874 set->type = cpu_to_le16(TLV_TYPE_KEY_MATERIAL);
875 set->key_len = cpu_to_le16(WAPI_KEY_LEN);
876 memcpy(&set->key[2], enc_key->key_material, enc_key->key_len);
877 memcpy(&set->key[2 + enc_key->key_len], enc_key->pn, PN_LEN);
878 set->length = cpu_to_le16(WAPI_KEY_LEN + KEYPARAMSET_FIXED_LEN);
879
880 key_param_len = (WAPI_KEY_LEN + KEYPARAMSET_FIXED_LEN) +
881 sizeof(struct mwifiex_ie_types_header);
882 cmd->size = cpu_to_le16(sizeof(key_material->action)
883 + S_DS_GEN + key_param_len);
884 return ret;
885 }
886 if (enc_key->key_len == WLAN_KEY_LEN_CCMP) {
887 if (enc_key->is_igtk_key) {
888 mwifiex_dbg(priv->adapter, CMD, "cmd: CMAC_AES\n");
889 key_material->key_param_set.key_type_id =
890 cpu_to_le16(KEY_TYPE_ID_AES_CMAC);
891 if (cmd_oid == KEY_INFO_ENABLED)
892 key_material->key_param_set.key_info =
893 cpu_to_le16(KEY_ENABLED);
894 else
895 key_material->key_param_set.key_info =
896 cpu_to_le16(!KEY_ENABLED);
897
898 key_material->key_param_set.key_info |=
899 cpu_to_le16(KEY_IGTK);
900 } else {
901 mwifiex_dbg(priv->adapter, CMD, "cmd: WPA_AES\n");
902 key_material->key_param_set.key_type_id =
903 cpu_to_le16(KEY_TYPE_ID_AES);
904 if (cmd_oid == KEY_INFO_ENABLED)
905 key_material->key_param_set.key_info =
906 cpu_to_le16(KEY_ENABLED);
907 else
908 key_material->key_param_set.key_info =
909 cpu_to_le16(!KEY_ENABLED);
910
911 if (enc_key->key_index & MWIFIEX_KEY_INDEX_UNICAST)
912 /* AES pairwise key: unicast */
913 key_material->key_param_set.key_info |=
914 cpu_to_le16(KEY_UNICAST);
915 else /* AES group key: multicast */
916 key_material->key_param_set.key_info |=
917 cpu_to_le16(KEY_MCAST);
918 }
919 } else if (enc_key->key_len == WLAN_KEY_LEN_TKIP) {
920 mwifiex_dbg(priv->adapter, CMD, "cmd: WPA_TKIP\n");
921 key_material->key_param_set.key_type_id =
922 cpu_to_le16(KEY_TYPE_ID_TKIP);
923 key_material->key_param_set.key_info =
924 cpu_to_le16(KEY_ENABLED);
925
926 if (enc_key->key_index & MWIFIEX_KEY_INDEX_UNICAST)
927 /* TKIP pairwise key: unicast */
928 key_material->key_param_set.key_info |=
929 cpu_to_le16(KEY_UNICAST);
930 else /* TKIP group key: multicast */
931 key_material->key_param_set.key_info |=
932 cpu_to_le16(KEY_MCAST);
933 }
934
935 if (key_material->key_param_set.key_type_id) {
936 key_material->key_param_set.type =
937 cpu_to_le16(TLV_TYPE_KEY_MATERIAL);
938 key_material->key_param_set.key_len =
939 cpu_to_le16((u16) enc_key->key_len);
940 memcpy(key_material->key_param_set.key, enc_key->key_material,
941 enc_key->key_len);
942 key_material->key_param_set.length =
943 cpu_to_le16((u16) enc_key->key_len +
944 KEYPARAMSET_FIXED_LEN);
945
946 key_param_len = (u16)(enc_key->key_len + KEYPARAMSET_FIXED_LEN)
947 + sizeof(struct mwifiex_ie_types_header);
948
949 if (le16_to_cpu(key_material->key_param_set.key_type_id) ==
950 KEY_TYPE_ID_AES_CMAC) {
951 struct mwifiex_cmac_param *param =
952 (void *)key_material->key_param_set.key;
953
954 memcpy(param->ipn, enc_key->pn, IGTK_PN_LEN);
955 memcpy(param->key, enc_key->key_material,
956 WLAN_KEY_LEN_AES_CMAC);
957
958 key_param_len = sizeof(struct mwifiex_cmac_param);
959 key_material->key_param_set.key_len =
960 cpu_to_le16(key_param_len);
961 key_param_len += KEYPARAMSET_FIXED_LEN;
962 key_material->key_param_set.length =
963 cpu_to_le16(key_param_len);
964 key_param_len += sizeof(struct mwifiex_ie_types_header);
965 }
966
967 cmd->size = cpu_to_le16(sizeof(key_material->action) + S_DS_GEN
968 + key_param_len);
969
970 if (GET_BSS_ROLE(priv) == MWIFIEX_BSS_ROLE_UAP) {
971 tlv_mac = (void *)((u8 *)&key_material->key_param_set +
972 key_param_len);
973 tlv_mac->header.type =
974 cpu_to_le16(TLV_TYPE_STA_MAC_ADDR);
975 tlv_mac->header.len = cpu_to_le16(ETH_ALEN);
976 memcpy(tlv_mac->mac_addr, enc_key->mac_addr, ETH_ALEN);
977 cmd_size = key_param_len + S_DS_GEN +
978 sizeof(key_material->action) +
979 sizeof(struct host_cmd_tlv_mac_addr);
980 } else {
981 cmd_size = key_param_len + S_DS_GEN +
982 sizeof(key_material->action);
983 }
984 cmd->size = cpu_to_le16(cmd_size);
985 }
986
987 return ret;
988}
989
990/* Wrapper function for setting network key depending upon FW KEY API version */
991static int
992mwifiex_cmd_802_11_key_material(struct mwifiex_private *priv,
993 struct host_cmd_ds_command *cmd,
994 u16 cmd_action, u32 cmd_oid,
995 struct mwifiex_ds_encrypt_key *enc_key)
996{
997 if (priv->adapter->key_api_major_ver == KEY_API_VER_MAJOR_V2)
998 return mwifiex_cmd_802_11_key_material_v2(priv, cmd,
999 cmd_action, cmd_oid,
1000 enc_key);
1001
1002 else
1003 return mwifiex_cmd_802_11_key_material_v1(priv, cmd,
1004 cmd_action, cmd_oid,
1005 enc_key);
1006}
1007
1008/*
1009 * This function prepares command to set/get 11d domain information.
1010 *
1011 * Preparation includes -
1012 * - Setting command ID, action and proper size
1013 * - Setting domain information fields (for SET only)
1014 * - Ensuring correct endian-ness
1015 */
1016static int mwifiex_cmd_802_11d_domain_info(struct mwifiex_private *priv,
1017 struct host_cmd_ds_command *cmd,
1018 u16 cmd_action)
1019{
1020 struct mwifiex_adapter *adapter = priv->adapter;
1021 struct host_cmd_ds_802_11d_domain_info *domain_info =
1022 &cmd->params.domain_info;
1023 struct mwifiex_ietypes_domain_param_set *domain =
1024 &domain_info->domain;
1025 u8 no_of_triplet = adapter->domain_reg.no_of_triplet;
1026
1027 mwifiex_dbg(adapter, INFO,
1028 "info: 11D: no_of_triplet=0x%x\n", no_of_triplet);
1029
1030 cmd->command = cpu_to_le16(HostCmd_CMD_802_11D_DOMAIN_INFO);
1031 domain_info->action = cpu_to_le16(cmd_action);
1032 if (cmd_action == HostCmd_ACT_GEN_GET) {
1033 cmd->size = cpu_to_le16(sizeof(domain_info->action) + S_DS_GEN);
1034 return 0;
1035 }
1036
1037 /* Set domain info fields */
1038 domain->header.type = cpu_to_le16(WLAN_EID_COUNTRY);
1039 memcpy(domain->country_code, adapter->domain_reg.country_code,
1040 sizeof(domain->country_code));
1041
1042 domain->header.len =
1043 cpu_to_le16((no_of_triplet *
1044 sizeof(struct ieee80211_country_ie_triplet))
1045 + sizeof(domain->country_code));
1046
1047 if (no_of_triplet) {
1048 memcpy(domain->triplet, adapter->domain_reg.triplet,
1049 no_of_triplet * sizeof(struct
1050 ieee80211_country_ie_triplet));
1051
1052 cmd->size = cpu_to_le16(sizeof(domain_info->action) +
1053 le16_to_cpu(domain->header.len) +
1054 sizeof(struct mwifiex_ie_types_header)
1055 + S_DS_GEN);
1056 } else {
1057 cmd->size = cpu_to_le16(sizeof(domain_info->action) + S_DS_GEN);
1058 }
1059
1060 return 0;
1061}
1062
1063/*
1064 * This function prepares command to set/get IBSS coalescing status.
1065 *
1066 * Preparation includes -
1067 * - Setting command ID, action and proper size
1068 * - Setting status to enable or disable (for SET only)
1069 * - Ensuring correct endian-ness
1070 */
1071static int mwifiex_cmd_ibss_coalescing_status(struct host_cmd_ds_command *cmd,
1072 u16 cmd_action, u16 *enable)
1073{
1074 struct host_cmd_ds_802_11_ibss_status *ibss_coal =
1075 &(cmd->params.ibss_coalescing);
1076
1077 cmd->command = cpu_to_le16(HostCmd_CMD_802_11_IBSS_COALESCING_STATUS);
1078 cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_802_11_ibss_status) +
1079 S_DS_GEN);
1080 cmd->result = 0;
1081 ibss_coal->action = cpu_to_le16(cmd_action);
1082
1083 switch (cmd_action) {
1084 case HostCmd_ACT_GEN_SET:
1085 if (enable)
1086 ibss_coal->enable = cpu_to_le16(*enable);
1087 else
1088 ibss_coal->enable = 0;
1089 break;
1090
1091 /* In other case.. Nothing to do */
1092 case HostCmd_ACT_GEN_GET:
1093 default:
1094 break;
1095 }
1096
1097 return 0;
1098}
1099
1100/* This function prepares command buffer to get/set memory location value.
1101 */
1102static int
1103mwifiex_cmd_mem_access(struct host_cmd_ds_command *cmd, u16 cmd_action,
1104 void *pdata_buf)
1105{
1106 struct mwifiex_ds_mem_rw *mem_rw = (void *)pdata_buf;
1107 struct host_cmd_ds_mem_access *mem_access = (void *)&cmd->params.mem;
1108
1109 cmd->command = cpu_to_le16(HostCmd_CMD_MEM_ACCESS);
1110 cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_mem_access) +
1111 S_DS_GEN);
1112
1113 mem_access->action = cpu_to_le16(cmd_action);
1114 mem_access->addr = cpu_to_le32(mem_rw->addr);
1115 mem_access->value = cpu_to_le32(mem_rw->value);
1116
1117 return 0;
1118}
1119
1120/*
1121 * This function prepares command to set/get register value.
1122 *
1123 * Preparation includes -
1124 * - Setting command ID, action and proper size
1125 * - Setting register offset (for both GET and SET) and
1126 * register value (for SET only)
1127 * - Ensuring correct endian-ness
1128 *
1129 * The following type of registers can be accessed with this function -
1130 * - MAC register
1131 * - BBP register
1132 * - RF register
1133 * - PMIC register
1134 * - CAU register
1135 * - EEPROM
1136 */
1137static int mwifiex_cmd_reg_access(struct host_cmd_ds_command *cmd,
1138 u16 cmd_action, void *data_buf)
1139{
1140 struct mwifiex_ds_reg_rw *reg_rw = data_buf;
1141
1142 switch (le16_to_cpu(cmd->command)) {
1143 case HostCmd_CMD_MAC_REG_ACCESS:
1144 {
1145 struct host_cmd_ds_mac_reg_access *mac_reg;
1146
1147 cmd->size = cpu_to_le16(sizeof(*mac_reg) + S_DS_GEN);
1148 mac_reg = &cmd->params.mac_reg;
1149 mac_reg->action = cpu_to_le16(cmd_action);
1150 mac_reg->offset = cpu_to_le16((u16) reg_rw->offset);
1151 mac_reg->value = cpu_to_le32(reg_rw->value);
1152 break;
1153 }
1154 case HostCmd_CMD_BBP_REG_ACCESS:
1155 {
1156 struct host_cmd_ds_bbp_reg_access *bbp_reg;
1157
1158 cmd->size = cpu_to_le16(sizeof(*bbp_reg) + S_DS_GEN);
1159 bbp_reg = &cmd->params.bbp_reg;
1160 bbp_reg->action = cpu_to_le16(cmd_action);
1161 bbp_reg->offset = cpu_to_le16((u16) reg_rw->offset);
1162 bbp_reg->value = (u8) reg_rw->value;
1163 break;
1164 }
1165 case HostCmd_CMD_RF_REG_ACCESS:
1166 {
1167 struct host_cmd_ds_rf_reg_access *rf_reg;
1168
1169 cmd->size = cpu_to_le16(sizeof(*rf_reg) + S_DS_GEN);
1170 rf_reg = &cmd->params.rf_reg;
1171 rf_reg->action = cpu_to_le16(cmd_action);
1172 rf_reg->offset = cpu_to_le16((u16) reg_rw->offset);
1173 rf_reg->value = (u8) reg_rw->value;
1174 break;
1175 }
1176 case HostCmd_CMD_PMIC_REG_ACCESS:
1177 {
1178 struct host_cmd_ds_pmic_reg_access *pmic_reg;
1179
1180 cmd->size = cpu_to_le16(sizeof(*pmic_reg) + S_DS_GEN);
1181 pmic_reg = &cmd->params.pmic_reg;
1182 pmic_reg->action = cpu_to_le16(cmd_action);
1183 pmic_reg->offset = cpu_to_le16((u16) reg_rw->offset);
1184 pmic_reg->value = (u8) reg_rw->value;
1185 break;
1186 }
1187 case HostCmd_CMD_CAU_REG_ACCESS:
1188 {
1189 struct host_cmd_ds_rf_reg_access *cau_reg;
1190
1191 cmd->size = cpu_to_le16(sizeof(*cau_reg) + S_DS_GEN);
1192 cau_reg = &cmd->params.rf_reg;
1193 cau_reg->action = cpu_to_le16(cmd_action);
1194 cau_reg->offset = cpu_to_le16((u16) reg_rw->offset);
1195 cau_reg->value = (u8) reg_rw->value;
1196 break;
1197 }
1198 case HostCmd_CMD_802_11_EEPROM_ACCESS:
1199 {
1200 struct mwifiex_ds_read_eeprom *rd_eeprom = data_buf;
1201 struct host_cmd_ds_802_11_eeprom_access *cmd_eeprom =
1202 &cmd->params.eeprom;
1203
1204 cmd->size = cpu_to_le16(sizeof(*cmd_eeprom) + S_DS_GEN);
1205 cmd_eeprom->action = cpu_to_le16(cmd_action);
1206 cmd_eeprom->offset = cpu_to_le16(rd_eeprom->offset);
1207 cmd_eeprom->byte_count = cpu_to_le16(rd_eeprom->byte_count);
1208 cmd_eeprom->value = 0;
1209 break;
1210 }
1211 default:
1212 return -1;
1213 }
1214
1215 return 0;
1216}
1217
1218/*
1219 * This function prepares command to set PCI-Express
1220 * host buffer configuration
1221 *
1222 * Preparation includes -
1223 * - Setting command ID, action and proper size
1224 * - Setting host buffer configuration
1225 * - Ensuring correct endian-ness
1226 */
1227static int
1228mwifiex_cmd_pcie_host_spec(struct mwifiex_private *priv,
1229 struct host_cmd_ds_command *cmd, u16 action)
1230{
1231 struct host_cmd_ds_pcie_details *host_spec =
1232 &cmd->params.pcie_host_spec;
1233 struct pcie_service_card *card = priv->adapter->card;
1234
1235 cmd->command = cpu_to_le16(HostCmd_CMD_PCIE_DESC_DETAILS);
1236 cmd->size = cpu_to_le16(sizeof(struct
1237 host_cmd_ds_pcie_details) + S_DS_GEN);
1238 cmd->result = 0;
1239
1240 memset(host_spec, 0, sizeof(struct host_cmd_ds_pcie_details));
1241
1242 if (action != HostCmd_ACT_GEN_SET)
1243 return 0;
1244
1245 /* Send the ring base addresses and count to firmware */
1246 host_spec->txbd_addr_lo = cpu_to_le32((u32)(card->txbd_ring_pbase));
1247 host_spec->txbd_addr_hi =
1248 cpu_to_le32((u32)(((u64)card->txbd_ring_pbase) >> 32));
1249 host_spec->txbd_count = cpu_to_le32(MWIFIEX_MAX_TXRX_BD);
1250 host_spec->rxbd_addr_lo = cpu_to_le32((u32)(card->rxbd_ring_pbase));
1251 host_spec->rxbd_addr_hi =
1252 cpu_to_le32((u32)(((u64)card->rxbd_ring_pbase) >> 32));
1253 host_spec->rxbd_count = cpu_to_le32(MWIFIEX_MAX_TXRX_BD);
1254 host_spec->evtbd_addr_lo = cpu_to_le32((u32)(card->evtbd_ring_pbase));
1255 host_spec->evtbd_addr_hi =
1256 cpu_to_le32((u32)(((u64)card->evtbd_ring_pbase) >> 32));
1257 host_spec->evtbd_count = cpu_to_le32(MWIFIEX_MAX_EVT_BD);
1258 if (card->sleep_cookie_vbase) {
1259 host_spec->sleep_cookie_addr_lo =
1260 cpu_to_le32((u32)(card->sleep_cookie_pbase));
1261 host_spec->sleep_cookie_addr_hi = cpu_to_le32((u32)(((u64)
1262 (card->sleep_cookie_pbase)) >> 32));
1263 mwifiex_dbg(priv->adapter, INFO,
1264 "sleep_cook_lo phy addr: 0x%x\n",
1265 host_spec->sleep_cookie_addr_lo);
1266 }
1267
1268 return 0;
1269}
1270
1271/*
1272 * This function prepares command for event subscription, configuration
1273 * and query. Events can be subscribed or unsubscribed. Current subscribed
1274 * events can be queried. Also, current subscribed events are reported in
1275 * every FW response.
1276 */
1277static int
1278mwifiex_cmd_802_11_subsc_evt(struct mwifiex_private *priv,
1279 struct host_cmd_ds_command *cmd,
1280 struct mwifiex_ds_misc_subsc_evt *subsc_evt_cfg)
1281{
1282 struct host_cmd_ds_802_11_subsc_evt *subsc_evt = &cmd->params.subsc_evt;
1283 struct mwifiex_ie_types_rssi_threshold *rssi_tlv;
1284 u16 event_bitmap;
1285 u8 *pos;
1286
1287 cmd->command = cpu_to_le16(HostCmd_CMD_802_11_SUBSCRIBE_EVENT);
1288 cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_802_11_subsc_evt) +
1289 S_DS_GEN);
1290
1291 subsc_evt->action = cpu_to_le16(subsc_evt_cfg->action);
1292 mwifiex_dbg(priv->adapter, CMD,
1293 "cmd: action: %d\n", subsc_evt_cfg->action);
1294
1295 /*For query requests, no configuration TLV structures are to be added.*/
1296 if (subsc_evt_cfg->action == HostCmd_ACT_GEN_GET)
1297 return 0;
1298
1299 subsc_evt->events = cpu_to_le16(subsc_evt_cfg->events);
1300
1301 event_bitmap = subsc_evt_cfg->events;
1302 mwifiex_dbg(priv->adapter, CMD, "cmd: event bitmap : %16x\n",
1303 event_bitmap);
1304
1305 if (((subsc_evt_cfg->action == HostCmd_ACT_BITWISE_CLR) ||
1306 (subsc_evt_cfg->action == HostCmd_ACT_BITWISE_SET)) &&
1307 (event_bitmap == 0)) {
1308 mwifiex_dbg(priv->adapter, ERROR,
1309 "Error: No event specified\t"
1310 "for bitwise action type\n");
1311 return -EINVAL;
1312 }
1313
1314 /*
1315 * Append TLV structures for each of the specified events for
1316 * subscribing or re-configuring. This is not required for
1317 * bitwise unsubscribing request.
1318 */
1319 if (subsc_evt_cfg->action == HostCmd_ACT_BITWISE_CLR)
1320 return 0;
1321
1322 pos = ((u8 *)subsc_evt) +
1323 sizeof(struct host_cmd_ds_802_11_subsc_evt);
1324
1325 if (event_bitmap & BITMASK_BCN_RSSI_LOW) {
1326 rssi_tlv = (struct mwifiex_ie_types_rssi_threshold *) pos;
1327
1328 rssi_tlv->header.type = cpu_to_le16(TLV_TYPE_RSSI_LOW);
1329 rssi_tlv->header.len =
1330 cpu_to_le16(sizeof(struct mwifiex_ie_types_rssi_threshold) -
1331 sizeof(struct mwifiex_ie_types_header));
1332 rssi_tlv->abs_value = subsc_evt_cfg->bcn_l_rssi_cfg.abs_value;
1333 rssi_tlv->evt_freq = subsc_evt_cfg->bcn_l_rssi_cfg.evt_freq;
1334
1335 mwifiex_dbg(priv->adapter, EVENT,
1336 "Cfg Beacon Low Rssi event,\t"
1337 "RSSI:-%d dBm, Freq:%d\n",
1338 subsc_evt_cfg->bcn_l_rssi_cfg.abs_value,
1339 subsc_evt_cfg->bcn_l_rssi_cfg.evt_freq);
1340
1341 pos += sizeof(struct mwifiex_ie_types_rssi_threshold);
1342 le16_unaligned_add_cpu(&cmd->size,
1343 sizeof(
1344 struct mwifiex_ie_types_rssi_threshold));
1345 }
1346
1347 if (event_bitmap & BITMASK_BCN_RSSI_HIGH) {
1348 rssi_tlv = (struct mwifiex_ie_types_rssi_threshold *) pos;
1349
1350 rssi_tlv->header.type = cpu_to_le16(TLV_TYPE_RSSI_HIGH);
1351 rssi_tlv->header.len =
1352 cpu_to_le16(sizeof(struct mwifiex_ie_types_rssi_threshold) -
1353 sizeof(struct mwifiex_ie_types_header));
1354 rssi_tlv->abs_value = subsc_evt_cfg->bcn_h_rssi_cfg.abs_value;
1355 rssi_tlv->evt_freq = subsc_evt_cfg->bcn_h_rssi_cfg.evt_freq;
1356
1357 mwifiex_dbg(priv->adapter, EVENT,
1358 "Cfg Beacon High Rssi event,\t"
1359 "RSSI:-%d dBm, Freq:%d\n",
1360 subsc_evt_cfg->bcn_h_rssi_cfg.abs_value,
1361 subsc_evt_cfg->bcn_h_rssi_cfg.evt_freq);
1362
1363 pos += sizeof(struct mwifiex_ie_types_rssi_threshold);
1364 le16_unaligned_add_cpu(&cmd->size,
1365 sizeof(
1366 struct mwifiex_ie_types_rssi_threshold));
1367 }
1368
1369 return 0;
1370}
1371
1372static int
1373mwifiex_cmd_append_rpn_expression(struct mwifiex_private *priv,
1374 struct mwifiex_mef_entry *mef_entry,
1375 u8 **buffer)
1376{
1377 struct mwifiex_mef_filter *filter = mef_entry->filter;
1378 int i, byte_len;
1379 u8 *stack_ptr = *buffer;
1380
1381 for (i = 0; i < MWIFIEX_MEF_MAX_FILTERS; i++) {
1382 filter = &mef_entry->filter[i];
1383 if (!filter->filt_type)
1384 break;
1385 put_unaligned_le32((u32)filter->repeat, stack_ptr);
1386 stack_ptr += 4;
1387 *stack_ptr = TYPE_DNUM;
1388 stack_ptr += 1;
1389
1390 byte_len = filter->byte_seq[MWIFIEX_MEF_MAX_BYTESEQ];
1391 memcpy(stack_ptr, filter->byte_seq, byte_len);
1392 stack_ptr += byte_len;
1393 *stack_ptr = byte_len;
1394 stack_ptr += 1;
1395 *stack_ptr = TYPE_BYTESEQ;
1396 stack_ptr += 1;
1397 put_unaligned_le32((u32)filter->offset, stack_ptr);
1398 stack_ptr += 4;
1399 *stack_ptr = TYPE_DNUM;
1400 stack_ptr += 1;
1401
1402 *stack_ptr = filter->filt_type;
1403 stack_ptr += 1;
1404
1405 if (filter->filt_action) {
1406 *stack_ptr = filter->filt_action;
1407 stack_ptr += 1;
1408 }
1409
1410 if (stack_ptr - *buffer > STACK_NBYTES)
1411 return -1;
1412 }
1413
1414 *buffer = stack_ptr;
1415 return 0;
1416}
1417
1418static int
1419mwifiex_cmd_mef_cfg(struct mwifiex_private *priv,
1420 struct host_cmd_ds_command *cmd,
1421 struct mwifiex_ds_mef_cfg *mef)
1422{
1423 struct host_cmd_ds_mef_cfg *mef_cfg = &cmd->params.mef_cfg;
1424 struct mwifiex_fw_mef_entry *mef_entry = NULL;
1425 u8 *pos = (u8 *)mef_cfg;
1426 u16 i;
1427
1428 cmd->command = cpu_to_le16(HostCmd_CMD_MEF_CFG);
1429
1430 mef_cfg->criteria = cpu_to_le32(mef->criteria);
1431 mef_cfg->num_entries = cpu_to_le16(mef->num_entries);
1432 pos += sizeof(*mef_cfg);
1433
1434 for (i = 0; i < mef->num_entries; i++) {
1435 mef_entry = (struct mwifiex_fw_mef_entry *)pos;
1436 mef_entry->mode = mef->mef_entry[i].mode;
1437 mef_entry->action = mef->mef_entry[i].action;
1438 pos += sizeof(*mef_entry);
1439
1440 if (mwifiex_cmd_append_rpn_expression(priv,
1441 &mef->mef_entry[i], &pos))
1442 return -1;
1443
1444 mef_entry->exprsize =
1445 cpu_to_le16(pos - mef_entry->expr);
1446 }
1447 cmd->size = cpu_to_le16((u16) (pos - (u8 *)mef_cfg) + S_DS_GEN);
1448
1449 return 0;
1450}
1451
1452/* This function parse cal data from ASCII to hex */
1453static u32 mwifiex_parse_cal_cfg(u8 *src, size_t len, u8 *dst)
1454{
1455 u8 *s = src, *d = dst;
1456
1457 while (s - src < len) {
1458 if (*s && (isspace(*s) || *s == '\t')) {
1459 s++;
1460 continue;
1461 }
1462 if (isxdigit(*s)) {
1463 *d++ = simple_strtol(s, NULL, 16);
1464 s += 2;
1465 } else {
1466 s++;
1467 }
1468 }
1469
1470 return d - dst;
1471}
1472
1473int mwifiex_dnld_dt_cfgdata(struct mwifiex_private *priv,
1474 struct device_node *node, const char *prefix)
1475{
1476#ifdef CONFIG_OF
1477 struct property *prop;
1478 size_t len = strlen(prefix);
1479 int ret;
1480
1481 /* look for all matching property names */
1482 for_each_property_of_node(node, prop) {
1483 if (len > strlen(prop->name) ||
1484 strncmp(prop->name, prefix, len))
1485 continue;
1486
1487 /* property header is 6 bytes, data must fit in cmd buffer */
1488 if (prop->value && prop->length > 6 &&
1489 prop->length <= MWIFIEX_SIZE_OF_CMD_BUFFER - S_DS_GEN) {
1490 ret = mwifiex_send_cmd(priv, HostCmd_CMD_CFG_DATA,
1491 HostCmd_ACT_GEN_SET, 0,
1492 prop, true);
1493 if (ret)
1494 return ret;
1495 }
1496 }
1497#endif
1498 return 0;
1499}
1500
1501/* This function prepares command of set_cfg_data. */
1502static int mwifiex_cmd_cfg_data(struct mwifiex_private *priv,
1503 struct host_cmd_ds_command *cmd, void *data_buf)
1504{
1505 struct mwifiex_adapter *adapter = priv->adapter;
1506 struct property *prop = data_buf;
1507 u32 len;
1508 u8 *data = (u8 *)cmd + S_DS_GEN;
1509 int ret;
1510
1511 if (prop) {
1512 len = prop->length;
1513 ret = of_property_read_u8_array(adapter->dt_node, prop->name,
1514 data, len);
1515 if (ret)
1516 return ret;
1517 mwifiex_dbg(adapter, INFO,
1518 "download cfg_data from device tree: %s\n",
1519 prop->name);
1520 } else if (adapter->cal_data->data && adapter->cal_data->size > 0) {
1521 len = mwifiex_parse_cal_cfg((u8 *)adapter->cal_data->data,
1522 adapter->cal_data->size, data);
1523 mwifiex_dbg(adapter, INFO,
1524 "download cfg_data from config file\n");
1525 } else {
1526 return -1;
1527 }
1528
1529 cmd->command = cpu_to_le16(HostCmd_CMD_CFG_DATA);
1530 cmd->size = cpu_to_le16(S_DS_GEN + len);
1531
1532 return 0;
1533}
1534
1535static int
1536mwifiex_cmd_set_mc_policy(struct mwifiex_private *priv,
1537 struct host_cmd_ds_command *cmd,
1538 u16 cmd_action, void *data_buf)
1539{
1540 struct host_cmd_ds_multi_chan_policy *mc_pol = &cmd->params.mc_policy;
1541 const u16 *drcs_info = data_buf;
1542
1543 mc_pol->action = cpu_to_le16(cmd_action);
1544 mc_pol->policy = cpu_to_le16(*drcs_info);
1545 cmd->command = cpu_to_le16(HostCmd_CMD_MC_POLICY);
1546 cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_multi_chan_policy) +
1547 S_DS_GEN);
1548 return 0;
1549}
1550
1551static int mwifiex_cmd_robust_coex(struct mwifiex_private *priv,
1552 struct host_cmd_ds_command *cmd,
1553 u16 cmd_action, bool *is_timeshare)
1554{
1555 struct host_cmd_ds_robust_coex *coex = &cmd->params.coex;
1556 struct mwifiex_ie_types_robust_coex *coex_tlv;
1557
1558 cmd->command = cpu_to_le16(HostCmd_CMD_ROBUST_COEX);
1559 cmd->size = cpu_to_le16(sizeof(*coex) + sizeof(*coex_tlv) + S_DS_GEN);
1560
1561 coex->action = cpu_to_le16(cmd_action);
1562 coex_tlv = (struct mwifiex_ie_types_robust_coex *)
1563 ((u8 *)coex + sizeof(*coex));
1564 coex_tlv->header.type = cpu_to_le16(TLV_TYPE_ROBUST_COEX);
1565 coex_tlv->header.len = cpu_to_le16(sizeof(coex_tlv->mode));
1566
1567 if (coex->action == HostCmd_ACT_GEN_GET)
1568 return 0;
1569
1570 if (*is_timeshare)
1571 coex_tlv->mode = cpu_to_le32(MWIFIEX_COEX_MODE_TIMESHARE);
1572 else
1573 coex_tlv->mode = cpu_to_le32(MWIFIEX_COEX_MODE_SPATIAL);
1574
1575 return 0;
1576}
1577
1578static int mwifiex_cmd_gtk_rekey_offload(struct mwifiex_private *priv,
1579 struct host_cmd_ds_command *cmd,
1580 u16 cmd_action,
1581 struct cfg80211_gtk_rekey_data *data)
1582{
1583 struct host_cmd_ds_gtk_rekey_params *rekey = &cmd->params.rekey;
1584 u64 rekey_ctr;
1585
1586 cmd->command = cpu_to_le16(HostCmd_CMD_GTK_REKEY_OFFLOAD_CFG);
1587 cmd->size = cpu_to_le16(sizeof(*rekey) + S_DS_GEN);
1588
1589 rekey->action = cpu_to_le16(cmd_action);
1590 if (cmd_action == HostCmd_ACT_GEN_SET) {
1591 memcpy(rekey->kek, data->kek, NL80211_KEK_LEN);
1592 memcpy(rekey->kck, data->kck, NL80211_KCK_LEN);
1593 rekey_ctr = be64_to_cpup((__be64 *)data->replay_ctr);
1594 rekey->replay_ctr_low = cpu_to_le32((u32)rekey_ctr);
1595 rekey->replay_ctr_high =
1596 cpu_to_le32((u32)((u64)rekey_ctr >> 32));
1597 }
1598
1599 return 0;
1600}
1601
1602static int mwifiex_cmd_chan_region_cfg(struct mwifiex_private *priv,
1603 struct host_cmd_ds_command *cmd,
1604 u16 cmd_action)
1605{
1606 struct host_cmd_ds_chan_region_cfg *reg = &cmd->params.reg_cfg;
1607
1608 cmd->command = cpu_to_le16(HostCmd_CMD_CHAN_REGION_CFG);
1609 cmd->size = cpu_to_le16(sizeof(*reg) + S_DS_GEN);
1610
1611 if (cmd_action == HostCmd_ACT_GEN_GET)
1612 reg->action = cpu_to_le16(cmd_action);
1613
1614 return 0;
1615}
1616
1617static int
1618mwifiex_cmd_coalesce_cfg(struct mwifiex_private *priv,
1619 struct host_cmd_ds_command *cmd,
1620 u16 cmd_action, void *data_buf)
1621{
1622 struct host_cmd_ds_coalesce_cfg *coalesce_cfg =
1623 &cmd->params.coalesce_cfg;
1624 struct mwifiex_ds_coalesce_cfg *cfg = data_buf;
1625 struct coalesce_filt_field_param *param;
1626 u16 cnt, idx, length;
1627 struct coalesce_receive_filt_rule *rule;
1628
1629 cmd->command = cpu_to_le16(HostCmd_CMD_COALESCE_CFG);
1630 cmd->size = cpu_to_le16(S_DS_GEN);
1631
1632 coalesce_cfg->action = cpu_to_le16(cmd_action);
1633 coalesce_cfg->num_of_rules = cpu_to_le16(cfg->num_of_rules);
1634 rule = (void *)coalesce_cfg->rule_data;
1635
1636 for (cnt = 0; cnt < cfg->num_of_rules; cnt++) {
1637 rule->header.type = cpu_to_le16(TLV_TYPE_COALESCE_RULE);
1638 rule->max_coalescing_delay =
1639 cpu_to_le16(cfg->rule[cnt].max_coalescing_delay);
1640 rule->pkt_type = cfg->rule[cnt].pkt_type;
1641 rule->num_of_fields = cfg->rule[cnt].num_of_fields;
1642
1643 length = 0;
1644
1645 param = rule->params;
1646 for (idx = 0; idx < cfg->rule[cnt].num_of_fields; idx++) {
1647 param->operation = cfg->rule[cnt].params[idx].operation;
1648 param->operand_len =
1649 cfg->rule[cnt].params[idx].operand_len;
1650 param->offset =
1651 cpu_to_le16(cfg->rule[cnt].params[idx].offset);
1652 memcpy(param->operand_byte_stream,
1653 cfg->rule[cnt].params[idx].operand_byte_stream,
1654 param->operand_len);
1655
1656 length += sizeof(struct coalesce_filt_field_param);
1657
1658 param++;
1659 }
1660
1661 /* Total rule length is sizeof max_coalescing_delay(u16),
1662 * num_of_fields(u8), pkt_type(u8) and total length of the all
1663 * params
1664 */
1665 rule->header.len = cpu_to_le16(length + sizeof(u16) +
1666 sizeof(u8) + sizeof(u8));
1667
1668 /* Add the rule length to the command size*/
1669 le16_unaligned_add_cpu(&cmd->size,
1670 le16_to_cpu(rule->header.len) +
1671 sizeof(struct mwifiex_ie_types_header));
1672
1673 rule = (void *)((u8 *)rule->params + length);
1674 }
1675
1676 /* Add sizeof action, num_of_rules to total command length */
1677 le16_unaligned_add_cpu(&cmd->size, sizeof(u16) + sizeof(u16));
1678
1679 return 0;
1680}
1681
1682static int
1683mwifiex_cmd_tdls_config(struct mwifiex_private *priv,
1684 struct host_cmd_ds_command *cmd,
1685 u16 cmd_action, void *data_buf)
1686{
1687 struct host_cmd_ds_tdls_config *tdls_config = &cmd->params.tdls_config;
1688 struct mwifiex_tdls_init_cs_params *config;
1689 struct mwifiex_tdls_config *init_config;
1690 u16 len;
1691
1692 cmd->command = cpu_to_le16(HostCmd_CMD_TDLS_CONFIG);
1693 cmd->size = cpu_to_le16(S_DS_GEN);
1694 tdls_config->tdls_action = cpu_to_le16(cmd_action);
1695 le16_unaligned_add_cpu(&cmd->size, sizeof(tdls_config->tdls_action));
1696
1697 switch (cmd_action) {
1698 case ACT_TDLS_CS_ENABLE_CONFIG:
1699 init_config = data_buf;
1700 len = sizeof(*init_config);
1701 memcpy(tdls_config->tdls_data, init_config, len);
1702 break;
1703 case ACT_TDLS_CS_INIT:
1704 config = data_buf;
1705 len = sizeof(*config);
1706 memcpy(tdls_config->tdls_data, config, len);
1707 break;
1708 case ACT_TDLS_CS_STOP:
1709 len = sizeof(struct mwifiex_tdls_stop_cs_params);
1710 memcpy(tdls_config->tdls_data, data_buf, len);
1711 break;
1712 case ACT_TDLS_CS_PARAMS:
1713 len = sizeof(struct mwifiex_tdls_config_cs_params);
1714 memcpy(tdls_config->tdls_data, data_buf, len);
1715 break;
1716 default:
1717 mwifiex_dbg(priv->adapter, ERROR,
1718 "Unknown TDLS configuration\n");
1719 return -EOPNOTSUPP;
1720 }
1721
1722 le16_unaligned_add_cpu(&cmd->size, len);
1723 return 0;
1724}
1725
1726static int
1727mwifiex_cmd_tdls_oper(struct mwifiex_private *priv,
1728 struct host_cmd_ds_command *cmd,
1729 void *data_buf)
1730{
1731 struct host_cmd_ds_tdls_oper *tdls_oper = &cmd->params.tdls_oper;
1732 struct mwifiex_ds_tdls_oper *oper = data_buf;
1733 struct host_cmd_tlv_rates *tlv_rates;
1734 struct mwifiex_ie_types_htcap *ht_capab;
1735 struct mwifiex_ie_types_qos_info *wmm_qos_info;
1736 struct mwifiex_ie_types_extcap *extcap;
1737 struct mwifiex_ie_types_vhtcap *vht_capab;
1738 struct mwifiex_ie_types_aid *aid;
1739 struct mwifiex_ie_types_tdls_idle_timeout *timeout;
1740 u8 *pos;
1741 u16 config_len = 0;
1742 struct station_parameters *params = priv->sta_params;
1743
1744 cmd->command = cpu_to_le16(HostCmd_CMD_TDLS_OPER);
1745 cmd->size = cpu_to_le16(S_DS_GEN);
1746 le16_unaligned_add_cpu(&cmd->size,
1747 sizeof(struct host_cmd_ds_tdls_oper));
1748
1749 tdls_oper->reason = 0;
1750 memcpy(tdls_oper->peer_mac, oper->peer_mac, ETH_ALEN);
1751
1752 pos = (u8 *)tdls_oper + sizeof(struct host_cmd_ds_tdls_oper);
1753
1754 switch (oper->tdls_action) {
1755 case MWIFIEX_TDLS_DISABLE_LINK:
1756 tdls_oper->tdls_action = cpu_to_le16(ACT_TDLS_DELETE);
1757 break;
1758 case MWIFIEX_TDLS_CREATE_LINK:
1759 tdls_oper->tdls_action = cpu_to_le16(ACT_TDLS_CREATE);
1760 break;
1761 case MWIFIEX_TDLS_CONFIG_LINK:
1762 tdls_oper->tdls_action = cpu_to_le16(ACT_TDLS_CONFIG);
1763
1764 if (!params) {
1765 mwifiex_dbg(priv->adapter, ERROR,
1766 "TDLS config params not available for %pM\n",
1767 oper->peer_mac);
1768 return -ENODATA;
1769 }
1770
1771 put_unaligned_le16(params->capability, pos);
1772 config_len += sizeof(params->capability);
1773
1774 wmm_qos_info = (void *)(pos + config_len);
1775 wmm_qos_info->header.type = cpu_to_le16(WLAN_EID_QOS_CAPA);
1776 wmm_qos_info->header.len =
1777 cpu_to_le16(sizeof(wmm_qos_info->qos_info));
1778 wmm_qos_info->qos_info = 0;
1779 config_len += sizeof(struct mwifiex_ie_types_qos_info);
1780
1781 if (params->link_sta_params.ht_capa) {
1782 ht_capab = (struct mwifiex_ie_types_htcap *)(pos +
1783 config_len);
1784 ht_capab->header.type =
1785 cpu_to_le16(WLAN_EID_HT_CAPABILITY);
1786 ht_capab->header.len =
1787 cpu_to_le16(sizeof(struct ieee80211_ht_cap));
1788 memcpy(&ht_capab->ht_cap, params->link_sta_params.ht_capa,
1789 sizeof(struct ieee80211_ht_cap));
1790 config_len += sizeof(struct mwifiex_ie_types_htcap);
1791 }
1792
1793 if (params->link_sta_params.supported_rates &&
1794 params->link_sta_params.supported_rates_len) {
1795 tlv_rates = (struct host_cmd_tlv_rates *)(pos +
1796 config_len);
1797 tlv_rates->header.type =
1798 cpu_to_le16(WLAN_EID_SUPP_RATES);
1799 tlv_rates->header.len =
1800 cpu_to_le16(params->link_sta_params.supported_rates_len);
1801 memcpy(tlv_rates->rates,
1802 params->link_sta_params.supported_rates,
1803 params->link_sta_params.supported_rates_len);
1804 config_len += sizeof(struct host_cmd_tlv_rates) +
1805 params->link_sta_params.supported_rates_len;
1806 }
1807
1808 if (params->ext_capab && params->ext_capab_len) {
1809 extcap = (struct mwifiex_ie_types_extcap *)(pos +
1810 config_len);
1811 extcap->header.type =
1812 cpu_to_le16(WLAN_EID_EXT_CAPABILITY);
1813 extcap->header.len = cpu_to_le16(params->ext_capab_len);
1814 memcpy(extcap->ext_capab, params->ext_capab,
1815 params->ext_capab_len);
1816 config_len += sizeof(struct mwifiex_ie_types_extcap) +
1817 params->ext_capab_len;
1818 }
1819 if (params->link_sta_params.vht_capa) {
1820 vht_capab = (struct mwifiex_ie_types_vhtcap *)(pos +
1821 config_len);
1822 vht_capab->header.type =
1823 cpu_to_le16(WLAN_EID_VHT_CAPABILITY);
1824 vht_capab->header.len =
1825 cpu_to_le16(sizeof(struct ieee80211_vht_cap));
1826 memcpy(&vht_capab->vht_cap, params->link_sta_params.vht_capa,
1827 sizeof(struct ieee80211_vht_cap));
1828 config_len += sizeof(struct mwifiex_ie_types_vhtcap);
1829 }
1830 if (params->aid) {
1831 aid = (struct mwifiex_ie_types_aid *)(pos + config_len);
1832 aid->header.type = cpu_to_le16(WLAN_EID_AID);
1833 aid->header.len = cpu_to_le16(sizeof(params->aid));
1834 aid->aid = cpu_to_le16(params->aid);
1835 config_len += sizeof(struct mwifiex_ie_types_aid);
1836 }
1837
1838 timeout = (void *)(pos + config_len);
1839 timeout->header.type = cpu_to_le16(TLV_TYPE_TDLS_IDLE_TIMEOUT);
1840 timeout->header.len = cpu_to_le16(sizeof(timeout->value));
1841 timeout->value = cpu_to_le16(MWIFIEX_TDLS_IDLE_TIMEOUT_IN_SEC);
1842 config_len += sizeof(struct mwifiex_ie_types_tdls_idle_timeout);
1843
1844 break;
1845 default:
1846 mwifiex_dbg(priv->adapter, ERROR, "Unknown TDLS operation\n");
1847 return -EOPNOTSUPP;
1848 }
1849
1850 le16_unaligned_add_cpu(&cmd->size, config_len);
1851
1852 return 0;
1853}
1854
1855/* This function prepares command of sdio rx aggr info. */
1856static int mwifiex_cmd_sdio_rx_aggr_cfg(struct host_cmd_ds_command *cmd,
1857 u16 cmd_action, void *data_buf)
1858{
1859 struct host_cmd_sdio_sp_rx_aggr_cfg *cfg =
1860 &cmd->params.sdio_rx_aggr_cfg;
1861
1862 cmd->command = cpu_to_le16(HostCmd_CMD_SDIO_SP_RX_AGGR_CFG);
1863 cmd->size =
1864 cpu_to_le16(sizeof(struct host_cmd_sdio_sp_rx_aggr_cfg) +
1865 S_DS_GEN);
1866 cfg->action = cmd_action;
1867 if (cmd_action == HostCmd_ACT_GEN_SET)
1868 cfg->enable = *(u8 *)data_buf;
1869
1870 return 0;
1871}
1872
1873/* This function prepares command to get HS wakeup reason.
1874 *
1875 * Preparation includes -
1876 * - Setting command ID, action and proper size
1877 * - Ensuring correct endian-ness
1878 */
1879static int mwifiex_cmd_get_wakeup_reason(struct mwifiex_private *priv,
1880 struct host_cmd_ds_command *cmd)
1881{
1882 cmd->command = cpu_to_le16(HostCmd_CMD_HS_WAKEUP_REASON);
1883 cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_wakeup_reason) +
1884 S_DS_GEN);
1885
1886 return 0;
1887}
1888
1889static int mwifiex_cmd_get_chan_info(struct host_cmd_ds_command *cmd,
1890 u16 cmd_action)
1891{
1892 struct host_cmd_ds_sta_configure *sta_cfg_cmd = &cmd->params.sta_cfg;
1893 struct host_cmd_tlv_channel_band *tlv_band_channel =
1894 (struct host_cmd_tlv_channel_band *)sta_cfg_cmd->tlv_buffer;
1895
1896 cmd->command = cpu_to_le16(HostCmd_CMD_STA_CONFIGURE);
1897 cmd->size = cpu_to_le16(sizeof(*sta_cfg_cmd) +
1898 sizeof(*tlv_band_channel) + S_DS_GEN);
1899 sta_cfg_cmd->action = cpu_to_le16(cmd_action);
1900 memset(tlv_band_channel, 0, sizeof(*tlv_band_channel));
1901 tlv_band_channel->header.type = cpu_to_le16(TLV_TYPE_CHANNELBANDLIST);
1902 tlv_band_channel->header.len = cpu_to_le16(sizeof(*tlv_band_channel) -
1903 sizeof(struct mwifiex_ie_types_header));
1904
1905 return 0;
1906}
1907
1908/* This function check if the command is supported by firmware */
1909static int mwifiex_is_cmd_supported(struct mwifiex_private *priv, u16 cmd_no)
1910{
1911 if (!ISSUPP_ADHOC_ENABLED(priv->adapter->fw_cap_info)) {
1912 switch (cmd_no) {
1913 case HostCmd_CMD_802_11_IBSS_COALESCING_STATUS:
1914 case HostCmd_CMD_802_11_AD_HOC_START:
1915 case HostCmd_CMD_802_11_AD_HOC_JOIN:
1916 case HostCmd_CMD_802_11_AD_HOC_STOP:
1917 return -EOPNOTSUPP;
1918 default:
1919 break;
1920 }
1921 }
1922
1923 return 0;
1924}
1925
1926/*
1927 * This function prepares the commands before sending them to the firmware.
1928 *
1929 * This is a generic function which calls specific command preparation
1930 * routines based upon the command number.
1931 */
1932int mwifiex_sta_prepare_cmd(struct mwifiex_private *priv, uint16_t cmd_no,
1933 u16 cmd_action, u32 cmd_oid,
1934 void *data_buf, void *cmd_buf)
1935{
1936 struct host_cmd_ds_command *cmd_ptr = cmd_buf;
1937 int ret = 0;
1938
1939 if (mwifiex_is_cmd_supported(priv, cmd_no)) {
1940 mwifiex_dbg(priv->adapter, ERROR,
1941 "0x%x command not supported by firmware\n",
1942 cmd_no);
1943 return -EOPNOTSUPP;
1944 }
1945
1946 /* Prepare command */
1947 switch (cmd_no) {
1948 case HostCmd_CMD_GET_HW_SPEC:
1949 ret = mwifiex_cmd_get_hw_spec(priv, cmd_ptr);
1950 break;
1951 case HostCmd_CMD_CFG_DATA:
1952 ret = mwifiex_cmd_cfg_data(priv, cmd_ptr, data_buf);
1953 break;
1954 case HostCmd_CMD_MAC_CONTROL:
1955 ret = mwifiex_cmd_mac_control(priv, cmd_ptr, cmd_action,
1956 data_buf);
1957 break;
1958 case HostCmd_CMD_802_11_MAC_ADDRESS:
1959 ret = mwifiex_cmd_802_11_mac_address(priv, cmd_ptr,
1960 cmd_action);
1961 break;
1962 case HostCmd_CMD_MAC_MULTICAST_ADR:
1963 ret = mwifiex_cmd_mac_multicast_adr(cmd_ptr, cmd_action,
1964 data_buf);
1965 break;
1966 case HostCmd_CMD_TX_RATE_CFG:
1967 ret = mwifiex_cmd_tx_rate_cfg(priv, cmd_ptr, cmd_action,
1968 data_buf);
1969 break;
1970 case HostCmd_CMD_TXPWR_CFG:
1971 ret = mwifiex_cmd_tx_power_cfg(cmd_ptr, cmd_action,
1972 data_buf);
1973 break;
1974 case HostCmd_CMD_RF_TX_PWR:
1975 ret = mwifiex_cmd_rf_tx_power(priv, cmd_ptr, cmd_action,
1976 data_buf);
1977 break;
1978 case HostCmd_CMD_RF_ANTENNA:
1979 ret = mwifiex_cmd_rf_antenna(priv, cmd_ptr, cmd_action,
1980 data_buf);
1981 break;
1982 case HostCmd_CMD_802_11_PS_MODE_ENH:
1983 ret = mwifiex_cmd_enh_power_mode(priv, cmd_ptr, cmd_action,
1984 (uint16_t)cmd_oid, data_buf);
1985 break;
1986 case HostCmd_CMD_802_11_HS_CFG_ENH:
1987 ret = mwifiex_cmd_802_11_hs_cfg(priv, cmd_ptr, cmd_action,
1988 (struct mwifiex_hs_config_param *) data_buf);
1989 break;
1990 case HostCmd_CMD_802_11_SCAN:
1991 ret = mwifiex_cmd_802_11_scan(cmd_ptr, data_buf);
1992 break;
1993 case HostCmd_CMD_802_11_BG_SCAN_CONFIG:
1994 ret = mwifiex_cmd_802_11_bg_scan_config(priv, cmd_ptr,
1995 data_buf);
1996 break;
1997 case HostCmd_CMD_802_11_BG_SCAN_QUERY:
1998 ret = mwifiex_cmd_802_11_bg_scan_query(cmd_ptr);
1999 break;
2000 case HostCmd_CMD_802_11_ASSOCIATE:
2001 ret = mwifiex_cmd_802_11_associate(priv, cmd_ptr, data_buf);
2002 break;
2003 case HostCmd_CMD_802_11_DEAUTHENTICATE:
2004 ret = mwifiex_cmd_802_11_deauthenticate(priv, cmd_ptr,
2005 data_buf);
2006 break;
2007 case HostCmd_CMD_802_11_AD_HOC_START:
2008 ret = mwifiex_cmd_802_11_ad_hoc_start(priv, cmd_ptr,
2009 data_buf);
2010 break;
2011 case HostCmd_CMD_802_11_GET_LOG:
2012 ret = mwifiex_cmd_802_11_get_log(cmd_ptr);
2013 break;
2014 case HostCmd_CMD_802_11_AD_HOC_JOIN:
2015 ret = mwifiex_cmd_802_11_ad_hoc_join(priv, cmd_ptr,
2016 data_buf);
2017 break;
2018 case HostCmd_CMD_802_11_AD_HOC_STOP:
2019 ret = mwifiex_cmd_802_11_ad_hoc_stop(cmd_ptr);
2020 break;
2021 case HostCmd_CMD_RSSI_INFO:
2022 ret = mwifiex_cmd_802_11_rssi_info(priv, cmd_ptr, cmd_action);
2023 break;
2024 case HostCmd_CMD_802_11_SNMP_MIB:
2025 ret = mwifiex_cmd_802_11_snmp_mib(priv, cmd_ptr, cmd_action,
2026 cmd_oid, data_buf);
2027 break;
2028 case HostCmd_CMD_802_11_TX_RATE_QUERY:
2029 cmd_ptr->command =
2030 cpu_to_le16(HostCmd_CMD_802_11_TX_RATE_QUERY);
2031 cmd_ptr->size =
2032 cpu_to_le16(sizeof(struct host_cmd_ds_tx_rate_query) +
2033 S_DS_GEN);
2034 priv->tx_rate = 0;
2035 ret = 0;
2036 break;
2037 case HostCmd_CMD_VERSION_EXT:
2038 cmd_ptr->command = cpu_to_le16(cmd_no);
2039 cmd_ptr->params.verext.version_str_sel =
2040 (u8)(get_unaligned((u32 *)data_buf));
2041 memcpy(&cmd_ptr->params, data_buf,
2042 sizeof(struct host_cmd_ds_version_ext));
2043 cmd_ptr->size =
2044 cpu_to_le16(sizeof(struct host_cmd_ds_version_ext) +
2045 S_DS_GEN);
2046 ret = 0;
2047 break;
2048 case HostCmd_CMD_MGMT_FRAME_REG:
2049 cmd_ptr->command = cpu_to_le16(cmd_no);
2050 cmd_ptr->params.reg_mask.action = cpu_to_le16(cmd_action);
2051 cmd_ptr->params.reg_mask.mask = cpu_to_le32(
2052 get_unaligned((u32 *)data_buf));
2053 cmd_ptr->size =
2054 cpu_to_le16(sizeof(struct host_cmd_ds_mgmt_frame_reg) +
2055 S_DS_GEN);
2056 ret = 0;
2057 break;
2058 case HostCmd_CMD_REMAIN_ON_CHAN:
2059 cmd_ptr->command = cpu_to_le16(cmd_no);
2060 memcpy(&cmd_ptr->params, data_buf,
2061 sizeof(struct host_cmd_ds_remain_on_chan));
2062 cmd_ptr->size =
2063 cpu_to_le16(sizeof(struct host_cmd_ds_remain_on_chan) +
2064 S_DS_GEN);
2065 break;
2066 case HostCmd_CMD_11AC_CFG:
2067 ret = mwifiex_cmd_11ac_cfg(priv, cmd_ptr, cmd_action, data_buf);
2068 break;
2069 case HostCmd_CMD_PACKET_AGGR_CTRL:
2070 cmd_ptr->command = cpu_to_le16(cmd_no);
2071 cmd_ptr->params.pkt_aggr_ctrl.action = cpu_to_le16(cmd_action);
2072 cmd_ptr->params.pkt_aggr_ctrl.enable =
2073 cpu_to_le16(*(u16 *)data_buf);
2074 cmd_ptr->size =
2075 cpu_to_le16(sizeof(struct host_cmd_ds_pkt_aggr_ctrl) +
2076 S_DS_GEN);
2077 break;
2078 case HostCmd_CMD_P2P_MODE_CFG:
2079 cmd_ptr->command = cpu_to_le16(cmd_no);
2080 cmd_ptr->params.mode_cfg.action = cpu_to_le16(cmd_action);
2081 cmd_ptr->params.mode_cfg.mode = cpu_to_le16(
2082 get_unaligned((u16 *)data_buf));
2083 cmd_ptr->size =
2084 cpu_to_le16(sizeof(struct host_cmd_ds_p2p_mode_cfg) +
2085 S_DS_GEN);
2086 break;
2087 case HostCmd_CMD_FUNC_INIT:
2088 if (priv->adapter->hw_status == MWIFIEX_HW_STATUS_RESET)
2089 priv->adapter->hw_status = MWIFIEX_HW_STATUS_READY;
2090 cmd_ptr->command = cpu_to_le16(cmd_no);
2091 cmd_ptr->size = cpu_to_le16(S_DS_GEN);
2092 break;
2093 case HostCmd_CMD_FUNC_SHUTDOWN:
2094 priv->adapter->hw_status = MWIFIEX_HW_STATUS_RESET;
2095 cmd_ptr->command = cpu_to_le16(cmd_no);
2096 cmd_ptr->size = cpu_to_le16(S_DS_GEN);
2097 break;
2098 case HostCmd_CMD_11N_ADDBA_REQ:
2099 ret = mwifiex_cmd_11n_addba_req(cmd_ptr, data_buf);
2100 break;
2101 case HostCmd_CMD_11N_DELBA:
2102 ret = mwifiex_cmd_11n_delba(cmd_ptr, data_buf);
2103 break;
2104 case HostCmd_CMD_11N_ADDBA_RSP:
2105 ret = mwifiex_cmd_11n_addba_rsp_gen(priv, cmd_ptr, data_buf);
2106 break;
2107 case HostCmd_CMD_802_11_KEY_MATERIAL:
2108 ret = mwifiex_cmd_802_11_key_material(priv, cmd_ptr,
2109 cmd_action, cmd_oid,
2110 data_buf);
2111 break;
2112 case HostCmd_CMD_802_11D_DOMAIN_INFO:
2113 ret = mwifiex_cmd_802_11d_domain_info(priv, cmd_ptr,
2114 cmd_action);
2115 break;
2116 case HostCmd_CMD_RECONFIGURE_TX_BUFF:
2117 ret = mwifiex_cmd_recfg_tx_buf(priv, cmd_ptr, cmd_action,
2118 data_buf);
2119 break;
2120 case HostCmd_CMD_AMSDU_AGGR_CTRL:
2121 ret = mwifiex_cmd_amsdu_aggr_ctrl(cmd_ptr, cmd_action,
2122 data_buf);
2123 break;
2124 case HostCmd_CMD_11N_CFG:
2125 ret = mwifiex_cmd_11n_cfg(priv, cmd_ptr, cmd_action, data_buf);
2126 break;
2127 case HostCmd_CMD_WMM_GET_STATUS:
2128 mwifiex_dbg(priv->adapter, CMD,
2129 "cmd: WMM: WMM_GET_STATUS cmd sent\n");
2130 cmd_ptr->command = cpu_to_le16(HostCmd_CMD_WMM_GET_STATUS);
2131 cmd_ptr->size =
2132 cpu_to_le16(sizeof(struct host_cmd_ds_wmm_get_status) +
2133 S_DS_GEN);
2134 ret = 0;
2135 break;
2136 case HostCmd_CMD_802_11_IBSS_COALESCING_STATUS:
2137 ret = mwifiex_cmd_ibss_coalescing_status(cmd_ptr, cmd_action,
2138 data_buf);
2139 break;
2140 case HostCmd_CMD_802_11_SCAN_EXT:
2141 ret = mwifiex_cmd_802_11_scan_ext(priv, cmd_ptr, data_buf);
2142 break;
2143 case HostCmd_CMD_MEM_ACCESS:
2144 ret = mwifiex_cmd_mem_access(cmd_ptr, cmd_action, data_buf);
2145 break;
2146 case HostCmd_CMD_MAC_REG_ACCESS:
2147 case HostCmd_CMD_BBP_REG_ACCESS:
2148 case HostCmd_CMD_RF_REG_ACCESS:
2149 case HostCmd_CMD_PMIC_REG_ACCESS:
2150 case HostCmd_CMD_CAU_REG_ACCESS:
2151 case HostCmd_CMD_802_11_EEPROM_ACCESS:
2152 ret = mwifiex_cmd_reg_access(cmd_ptr, cmd_action, data_buf);
2153 break;
2154 case HostCmd_CMD_SET_BSS_MODE:
2155 cmd_ptr->command = cpu_to_le16(cmd_no);
2156 if (priv->bss_mode == NL80211_IFTYPE_ADHOC)
2157 cmd_ptr->params.bss_mode.con_type =
2158 CONNECTION_TYPE_ADHOC;
2159 else if (priv->bss_mode == NL80211_IFTYPE_STATION ||
2160 priv->bss_mode == NL80211_IFTYPE_P2P_CLIENT)
2161 cmd_ptr->params.bss_mode.con_type =
2162 CONNECTION_TYPE_INFRA;
2163 else if (priv->bss_mode == NL80211_IFTYPE_AP ||
2164 priv->bss_mode == NL80211_IFTYPE_P2P_GO)
2165 cmd_ptr->params.bss_mode.con_type = CONNECTION_TYPE_AP;
2166 cmd_ptr->size = cpu_to_le16(sizeof(struct
2167 host_cmd_ds_set_bss_mode) + S_DS_GEN);
2168 ret = 0;
2169 break;
2170 case HostCmd_CMD_PCIE_DESC_DETAILS:
2171 ret = mwifiex_cmd_pcie_host_spec(priv, cmd_ptr, cmd_action);
2172 break;
2173 case HostCmd_CMD_802_11_SUBSCRIBE_EVENT:
2174 ret = mwifiex_cmd_802_11_subsc_evt(priv, cmd_ptr, data_buf);
2175 break;
2176 case HostCmd_CMD_MEF_CFG:
2177 ret = mwifiex_cmd_mef_cfg(priv, cmd_ptr, data_buf);
2178 break;
2179 case HostCmd_CMD_COALESCE_CFG:
2180 ret = mwifiex_cmd_coalesce_cfg(priv, cmd_ptr, cmd_action,
2181 data_buf);
2182 break;
2183 case HostCmd_CMD_TDLS_OPER:
2184 ret = mwifiex_cmd_tdls_oper(priv, cmd_ptr, data_buf);
2185 break;
2186 case HostCmd_CMD_TDLS_CONFIG:
2187 ret = mwifiex_cmd_tdls_config(priv, cmd_ptr, cmd_action,
2188 data_buf);
2189 break;
2190 case HostCmd_CMD_CHAN_REPORT_REQUEST:
2191 ret = mwifiex_cmd_issue_chan_report_request(priv, cmd_ptr,
2192 data_buf);
2193 break;
2194 case HostCmd_CMD_SDIO_SP_RX_AGGR_CFG:
2195 ret = mwifiex_cmd_sdio_rx_aggr_cfg(cmd_ptr, cmd_action,
2196 data_buf);
2197 break;
2198 case HostCmd_CMD_HS_WAKEUP_REASON:
2199 ret = mwifiex_cmd_get_wakeup_reason(priv, cmd_ptr);
2200 break;
2201 case HostCmd_CMD_MC_POLICY:
2202 ret = mwifiex_cmd_set_mc_policy(priv, cmd_ptr, cmd_action,
2203 data_buf);
2204 break;
2205 case HostCmd_CMD_ROBUST_COEX:
2206 ret = mwifiex_cmd_robust_coex(priv, cmd_ptr, cmd_action,
2207 data_buf);
2208 break;
2209 case HostCmd_CMD_GTK_REKEY_OFFLOAD_CFG:
2210 ret = mwifiex_cmd_gtk_rekey_offload(priv, cmd_ptr, cmd_action,
2211 data_buf);
2212 break;
2213 case HostCmd_CMD_CHAN_REGION_CFG:
2214 ret = mwifiex_cmd_chan_region_cfg(priv, cmd_ptr, cmd_action);
2215 break;
2216 case HostCmd_CMD_FW_DUMP_EVENT:
2217 cmd_ptr->command = cpu_to_le16(cmd_no);
2218 cmd_ptr->size = cpu_to_le16(S_DS_GEN);
2219 break;
2220 case HostCmd_CMD_STA_CONFIGURE:
2221 ret = mwifiex_cmd_get_chan_info(cmd_ptr, cmd_action);
2222 break;
2223 default:
2224 mwifiex_dbg(priv->adapter, ERROR,
2225 "PREP_CMD: unknown cmd- %#x\n", cmd_no);
2226 ret = -1;
2227 break;
2228 }
2229 return ret;
2230}
2231
2232/*
2233 * This function issues commands to initialize firmware.
2234 *
2235 * This is called after firmware download to bring the card to
2236 * working state.
2237 * Function is also called during reinitialization of virtual
2238 * interfaces.
2239 *
2240 * The following commands are issued sequentially -
2241 * - Set PCI-Express host buffer configuration (PCIE only)
2242 * - Function init (for first interface only)
2243 * - Read MAC address (for first interface only)
2244 * - Reconfigure Tx buffer size (for first interface only)
2245 * - Enable auto deep sleep (for first interface only)
2246 * - Get Tx rate
2247 * - Get Tx power
2248 * - Set IBSS coalescing status
2249 * - Set AMSDU aggregation control
2250 * - Set 11d control
2251 * - Set MAC control (this must be the last command to initialize firmware)
2252 */
2253int mwifiex_sta_init_cmd(struct mwifiex_private *priv, u8 first_sta, bool init)
2254{
2255 struct mwifiex_adapter *adapter = priv->adapter;
2256 int ret;
2257 struct mwifiex_ds_11n_amsdu_aggr_ctrl amsdu_aggr_ctrl;
2258 struct mwifiex_ds_auto_ds auto_ds;
2259 enum state_11d_t state_11d;
2260 struct mwifiex_ds_11n_tx_cfg tx_cfg;
2261 u8 sdio_sp_rx_aggr_enable;
2262 u16 packet_aggr_enable;
2263 int data;
2264
2265 if (first_sta) {
2266 if (priv->adapter->iface_type == MWIFIEX_PCIE) {
2267 ret = mwifiex_send_cmd(priv,
2268 HostCmd_CMD_PCIE_DESC_DETAILS,
2269 HostCmd_ACT_GEN_SET, 0, NULL,
2270 true);
2271 if (ret)
2272 return -1;
2273 }
2274
2275 ret = mwifiex_send_cmd(priv, HostCmd_CMD_FUNC_INIT,
2276 HostCmd_ACT_GEN_SET, 0, NULL, true);
2277 if (ret)
2278 return -1;
2279
2280 /* Download calibration data to firmware.
2281 * The cal-data can be read from device tree and/or
2282 * a configuration file and downloaded to firmware.
2283 */
2284 if (adapter->dt_node) {
2285 if (of_property_read_u32(adapter->dt_node,
2286 "marvell,wakeup-pin",
2287 &data) == 0) {
2288 pr_debug("Wakeup pin = 0x%x\n", data);
2289 adapter->hs_cfg.gpio = data;
2290 }
2291
2292 mwifiex_dnld_dt_cfgdata(priv, adapter->dt_node,
2293 "marvell,caldata");
2294 }
2295
2296 if (adapter->cal_data)
2297 mwifiex_send_cmd(priv, HostCmd_CMD_CFG_DATA,
2298 HostCmd_ACT_GEN_SET, 0, NULL, true);
2299
2300 /* Read MAC address from HW */
2301 ret = mwifiex_send_cmd(priv, HostCmd_CMD_GET_HW_SPEC,
2302 HostCmd_ACT_GEN_GET, 0, NULL, true);
2303 if (ret)
2304 return -1;
2305
2306 /** Set SDIO Single Port RX Aggr Info */
2307 if (priv->adapter->iface_type == MWIFIEX_SDIO &&
2308 ISSUPP_SDIO_SPA_ENABLED(priv->adapter->fw_cap_info) &&
2309 !priv->adapter->host_disable_sdio_rx_aggr) {
2310 sdio_sp_rx_aggr_enable = true;
2311 ret = mwifiex_send_cmd(priv,
2312 HostCmd_CMD_SDIO_SP_RX_AGGR_CFG,
2313 HostCmd_ACT_GEN_SET, 0,
2314 &sdio_sp_rx_aggr_enable,
2315 true);
2316 if (ret) {
2317 mwifiex_dbg(priv->adapter, ERROR,
2318 "error while enabling SP aggregation..disable it");
2319 adapter->sdio_rx_aggr_enable = false;
2320 }
2321 }
2322
2323 /* Reconfigure tx buf size */
2324 ret = mwifiex_send_cmd(priv, HostCmd_CMD_RECONFIGURE_TX_BUFF,
2325 HostCmd_ACT_GEN_SET, 0,
2326 &priv->adapter->tx_buf_size, true);
2327 if (ret)
2328 return -1;
2329
2330 if (priv->bss_type != MWIFIEX_BSS_TYPE_UAP) {
2331 /* Enable IEEE PS by default */
2332 priv->adapter->ps_mode = MWIFIEX_802_11_POWER_MODE_PSP;
2333 ret = mwifiex_send_cmd(priv,
2334 HostCmd_CMD_802_11_PS_MODE_ENH,
2335 EN_AUTO_PS, BITMAP_STA_PS, NULL,
2336 true);
2337 if (ret)
2338 return -1;
2339 }
2340
2341 if (drcs) {
2342 adapter->drcs_enabled = true;
2343 if (ISSUPP_DRCS_ENABLED(adapter->fw_cap_info))
2344 ret = mwifiex_send_cmd(priv,
2345 HostCmd_CMD_MC_POLICY,
2346 HostCmd_ACT_GEN_SET, 0,
2347 &adapter->drcs_enabled,
2348 true);
2349 if (ret)
2350 return -1;
2351 }
2352
2353 mwifiex_send_cmd(priv, HostCmd_CMD_CHAN_REGION_CFG,
2354 HostCmd_ACT_GEN_GET, 0, NULL, true);
2355 }
2356
2357 /* get tx rate */
2358 ret = mwifiex_send_cmd(priv, HostCmd_CMD_TX_RATE_CFG,
2359 HostCmd_ACT_GEN_GET, 0, NULL, true);
2360 if (ret)
2361 return -1;
2362 priv->data_rate = 0;
2363
2364 /* get tx power */
2365 ret = mwifiex_send_cmd(priv, HostCmd_CMD_RF_TX_PWR,
2366 HostCmd_ACT_GEN_GET, 0, NULL, true);
2367 if (ret)
2368 return -1;
2369
2370 memset(&amsdu_aggr_ctrl, 0, sizeof(amsdu_aggr_ctrl));
2371 amsdu_aggr_ctrl.enable = true;
2372 /* Send request to firmware */
2373 ret = mwifiex_send_cmd(priv, HostCmd_CMD_AMSDU_AGGR_CTRL,
2374 HostCmd_ACT_GEN_SET, 0,
2375 &amsdu_aggr_ctrl, true);
2376 if (ret)
2377 return -1;
2378 /* MAC Control must be the last command in init_fw */
2379 /* set MAC Control */
2380 ret = mwifiex_send_cmd(priv, HostCmd_CMD_MAC_CONTROL,
2381 HostCmd_ACT_GEN_SET, 0,
2382 &priv->curr_pkt_filter, true);
2383 if (ret)
2384 return -1;
2385
2386 if (!disable_auto_ds && first_sta &&
2387 priv->bss_type != MWIFIEX_BSS_TYPE_UAP) {
2388 /* Enable auto deep sleep */
2389 auto_ds.auto_ds = DEEP_SLEEP_ON;
2390 auto_ds.idle_time = DEEP_SLEEP_IDLE_TIME;
2391 ret = mwifiex_send_cmd(priv, HostCmd_CMD_802_11_PS_MODE_ENH,
2392 EN_AUTO_PS, BITMAP_AUTO_DS,
2393 &auto_ds, true);
2394 if (ret)
2395 return -1;
2396 }
2397
2398 if (priv->bss_type != MWIFIEX_BSS_TYPE_UAP) {
2399 /* Send cmd to FW to enable/disable 11D function */
2400 state_11d = ENABLE_11D;
2401 ret = mwifiex_send_cmd(priv, HostCmd_CMD_802_11_SNMP_MIB,
2402 HostCmd_ACT_GEN_SET, DOT11D_I,
2403 &state_11d, true);
2404 if (ret)
2405 mwifiex_dbg(priv->adapter, ERROR,
2406 "11D: failed to enable 11D\n");
2407 }
2408
2409 /* Pacekt aggregation handshake with firmware */
2410 if (aggr_ctrl) {
2411 packet_aggr_enable = true;
2412 mwifiex_send_cmd(priv, HostCmd_CMD_PACKET_AGGR_CTRL,
2413 HostCmd_ACT_GEN_SET, 0,
2414 &packet_aggr_enable, true);
2415 }
2416
2417 /* Send cmd to FW to configure 11n specific configuration
2418 * (Short GI, Channel BW, Green field support etc.) for transmit
2419 */
2420 tx_cfg.tx_htcap = MWIFIEX_FW_DEF_HTTXCFG;
2421 ret = mwifiex_send_cmd(priv, HostCmd_CMD_11N_CFG,
2422 HostCmd_ACT_GEN_SET, 0, &tx_cfg, true);
2423
2424 if (init) {
2425 /* set last_init_cmd before sending the command */
2426 priv->adapter->last_init_cmd = HostCmd_CMD_11N_CFG;
2427 ret = -EINPROGRESS;
2428 }
2429
2430 return ret;
2431}