?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Revert "Merge branch 'ath6kl-next' of master.kernel.org:/pub/scm/linux/kernel/git...
[linux-2.6/next.git] / drivers / net / wireless / mwifiex / sta_cmd.c
blobc54ee287b8785a85fbfbc91ef05c0736dcde9af0
1 /*
2 * Marvell Wireless LAN device driver: station command handling
3 *
4 * Copyright (C) 2011, Marvell International Ltd.
5 *
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.
13 *
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.
18 */
19
20 #include "decl.h"
21 #include "ioctl.h"
22 #include "util.h"
23 #include "fw.h"
24 #include "main.h"
25 #include "wmm.h"
26 #include "11n.h"
27
28 /*
29 * This function prepares command to set/get RSSI information.
30 *
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
36 */
37 static int
38 mwifiex_cmd_802_11_rssi_info(struct mwifiex_private *priv,
39 struct host_cmd_ds_command *cmd, u16 cmd_action)
40 {
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) +
43 S_DS_GEN);
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);
47
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;
56 priv->bcn_nf_avg = 0;
57
58 return 0;
59 }
60
61 /*
62 * This function prepares command to set MAC control.
63 *
64 * Preparation includes -
65 * - Setting command ID, action and proper size
66 * - Ensuring correct endian-ness
67 */
68 static int mwifiex_cmd_mac_control(struct mwifiex_private *priv,
69 struct host_cmd_ds_command *cmd,
70 u16 cmd_action, u16 *action)
71 {
72 struct host_cmd_ds_mac_control *mac_ctrl = &cmd->params.mac_ctrl;
73
74 if (cmd_action != HostCmd_ACT_GEN_SET) {
75 dev_err(priv->adapter->dev,
76 "mac_control: only support set cmd\n");
77 return -1;
78 }
79
80 cmd->command = cpu_to_le16(HostCmd_CMD_MAC_CONTROL);
81 cmd->size =
82 cpu_to_le16(sizeof(struct host_cmd_ds_mac_control) + S_DS_GEN);
83 mac_ctrl->action = cpu_to_le16(*action);
84
85 return 0;
86 }
87
88 /*
89 * This function prepares command to set/get SNMP MIB.
90 *
91 * Preparation includes -
92 * - Setting command ID, action and proper size
93 * - Setting SNMP MIB OID number and value
94 * (as required)
95 * - Ensuring correct endian-ness
96 *
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
102 */
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,
106 u32 *ul_temp)
107 {
108 struct host_cmd_ds_802_11_snmp_mib *snmp_mib = &cmd->params.smib;
109
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)
113 - 1 + S_DS_GEN);
114
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);
120 }
121
122 switch (cmd_oid) {
123 case FRAG_THRESH_I:
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)
131 + sizeof(u16));
132 }
133 break;
134 case RTS_THRESH_I:
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)
142 + sizeof(u16));
143 }
144 break;
145
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)
154 + sizeof(u16));
155 }
156 break;
157 case DOT11D_I:
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)
165 + sizeof(u16));
166 }
167 break;
168 default:
169 break;
170 }
171 dev_dbg(priv->adapter->dev,
172 "cmd: SNMP_CMD: Action=0x%x, OID=0x%x, OIDSize=0x%x,"
173 " Value=0x%x\n",
174 cmd_action, cmd_oid, le16_to_cpu(snmp_mib->buf_size),
175 le16_to_cpu(*(__le16 *) snmp_mib->value));
176 return 0;
177 }
178
179 /*
180 * This function prepares command to get log.
181 *
182 * Preparation includes -
183 * - Setting command ID and proper size
184 * - Ensuring correct endian-ness
185 */
186 static int
187 mwifiex_cmd_802_11_get_log(struct host_cmd_ds_command *cmd)
188 {
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) +
191 S_DS_GEN);
192 return 0;
193 }
194
195 /*
196 * This function prepares command to set/get Tx data rate configuration.
197 *
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
203 */
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)
207 {
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;
211 u32 i;
212
213 cmd->command = cpu_to_le16(HostCmd_CMD_TX_RATE_CFG);
214
215 rate_cfg->action = cpu_to_le16(cmd_action);
216 rate_cfg->cfg_index = 0;
217
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]);
226 for (i = 0;
227 i < sizeof(rate_scope->ht_mcs_rate_bitmap) / sizeof(u16);
228 i++)
229 rate_scope->ht_mcs_rate_bitmap[i] =
230 cpu_to_le16(pbitmap_rates[2 + i]);
231 } else {
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]);
236 for (i = 0;
237 i < sizeof(rate_scope->ht_mcs_rate_bitmap) / sizeof(u16);
238 i++)
239 rate_scope->ht_mcs_rate_bitmap[i] =
240 cpu_to_le16(priv->bitmap_rates[2 + i]);
241 }
242
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;
248
249 cmd->size =
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));
253
254 return 0;
255 }
256
257 /*
258 * This function prepares command to set/get Tx power configuration.
259 *
260 * Preparation includes -
261 * - Setting command ID, action and proper size
262 * - Setting Tx power mode, power group TLV
263 * (as required)
264 * - Ensuring correct endian-ness
265 */
266 static int mwifiex_cmd_tx_power_cfg(struct host_cmd_ds_command *cmd,
267 u16 cmd_action,
268 struct host_cmd_ds_txpwr_cfg *txp)
269 {
270 struct mwifiex_types_power_group *pg_tlv;
271 struct host_cmd_ds_txpwr_cfg *cmd_txp_cfg = &cmd->params.txp_cfg;
272
273 cmd->command = cpu_to_le16(HostCmd_CMD_TXPWR_CFG);
274 cmd->size =
275 cpu_to_le16(S_DS_GEN + sizeof(struct host_cmd_ds_txpwr_cfg));
276 switch (cmd_action) {
277 case HostCmd_ACT_GEN_SET:
278 if (txp->mode) {
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) +
285 pg_tlv->length);
286
287 pg_tlv = (struct mwifiex_types_power_group *) ((u8 *)
288 cmd_txp_cfg +
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) +
292 pg_tlv->length);
293 } else {
294 memmove(cmd_txp_cfg, txp, sizeof(*txp));
295 }
296 cmd_txp_cfg->action = cpu_to_le16(cmd_action);
297 break;
298 case HostCmd_ACT_GEN_GET:
299 cmd_txp_cfg->action = cpu_to_le16(cmd_action);
300 break;
301 }
302
303 return 0;
304 }
305
306 /*
307 * This function prepares command to set Host Sleep configuration.
308 *
309 * Preparation includes -
310 * - Setting command ID and proper size
311 * - Setting Host Sleep action, conditions, ARP filters
312 * (as required)
313 * - Ensuring correct endian-ness
314 */
315 static int
316 mwifiex_cmd_802_11_hs_cfg(struct mwifiex_private *priv,
317 struct host_cmd_ds_command *cmd,
318 u16 cmd_action,
319 struct mwifiex_hs_config_param *hscfg_param)
320 {
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;
324
325 if (!hscfg_param)
326 /* New Activate command */
327 hs_activate = true;
328 cmd->command = cpu_to_le16(HostCmd_CMD_802_11_HS_CFG_ENH);
329
330 if (!hs_activate &&
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)
343 + S_DS_GEN);
344 } else {
345 cmd->size = cpu_to_le16(S_DS_GEN + sizeof(struct
346 host_cmd_ds_802_11_hs_cfg_enh));
347 }
348 if (hs_activate) {
349 hs_cfg->action = cpu_to_le16(HS_ACTIVATE);
350 hs_cfg->params.hs_activate.resp_ctrl = RESP_NEEDED;
351 } else {
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);
361 }
362
363 return 0;
364 }
365
366 /*
367 * This function prepares command to set/get MAC address.
368 *
369 * Preparation includes -
370 * - Setting command ID, action and proper size
371 * - Setting MAC address (for SET only)
372 * - Ensuring correct endian-ness
373 */
374 static int mwifiex_cmd_802_11_mac_address(struct mwifiex_private *priv,
375 struct host_cmd_ds_command *cmd,
376 u16 cmd_action)
377 {
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) +
380 S_DS_GEN);
381 cmd->result = 0;
382
383 cmd->params.mac_addr.action = cpu_to_le16(cmd_action);
384
385 if (cmd_action == HostCmd_ACT_GEN_SET)
386 memcpy(cmd->params.mac_addr.mac_addr, priv->curr_addr,
387 ETH_ALEN);
388 return 0;
389 }
390
391 /*
392 * This function prepares command to set MAC multicast address.
393 *
394 * Preparation includes -
395 * - Setting command ID, action and proper size
396 * - Setting MAC multicast address
397 * - Ensuring correct endian-ness
398 */
399 static int
400 mwifiex_cmd_mac_multicast_adr(struct host_cmd_ds_command *cmd,
401 u16 cmd_action,
402 struct mwifiex_multicast_list *mcast_list)
403 {
404 struct host_cmd_ds_mac_multicast_adr *mcast_addr = &cmd->params.mc_addr;
405
406 cmd->size = cpu_to_le16(sizeof(struct host_cmd_ds_mac_multicast_adr) +
407 S_DS_GEN);
408 cmd->command = cpu_to_le16(HostCmd_CMD_MAC_MULTICAST_ADR);
409
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);
415
416 return 0;
417 }
418
419 /*
420 * This function prepares command to deauthenticate.
421 *
422 * Preparation includes -
423 * - Setting command ID and proper size
424 * - Setting AP MAC address and reason code
425 * - Ensuring correct endian-ness
426 */
427 static int mwifiex_cmd_802_11_deauthenticate(struct mwifiex_private *priv,
428 struct host_cmd_ds_command *cmd,
429 u8 *mac)
430 {
431 struct host_cmd_ds_802_11_deauthenticate *deauth = &cmd->params.deauth;
432
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)
435 + S_DS_GEN);
436
437 /* Set AP MAC address */
438 memcpy(deauth->mac_addr, mac, ETH_ALEN);
439
440 dev_dbg(priv->adapter->dev, "cmd: Deauth: %pM\n", deauth->mac_addr);
441
442 deauth->reason_code = cpu_to_le16(WLAN_REASON_DEAUTH_LEAVING);
443
444 return 0;
445 }
446
447 /*
448 * This function prepares command to stop Ad-Hoc network.
449 *
450 * Preparation includes -
451 * - Setting command ID and proper size
452 * - Ensuring correct endian-ness
453 */
454 static int mwifiex_cmd_802_11_ad_hoc_stop(struct host_cmd_ds_command *cmd)
455 {
456 cmd->command = cpu_to_le16(HostCmd_CMD_802_11_AD_HOC_STOP);
457 cmd->size = cpu_to_le16(S_DS_GEN);
458 return 0;
459 }
460
461 /*
462 * This function sets WEP key(s) to key parameter TLV(s).
463 *
464 * Multi-key parameter TLVs are supported, so we can send multiple
465 * WEP keys in a single buffer.
466 */
467 static int
468 mwifiex_set_keyparamset_wep(struct mwifiex_private *priv,
469 struct mwifiex_ie_type_key_param_set *key_param_set,
470 u16 *key_param_len)
471 {
472 int cur_key_param_len;
473 u8 i;
474
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)
484 (priv->wep_key[i].
485 key_length +
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 |
491 KEY_MCAST);
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 */
497 if (i ==
498 (priv->
499 wep_key_curr_index & HostCmd_WEP_KEY_INDEX_MASK))
500 key_param_set->key[1] = 1;
501 else
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);
506
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;
511 key_param_set =
512 (struct mwifiex_ie_type_key_param_set *)
513 ((u8 *)key_param_set +
514 cur_key_param_len);
515 } else if (!priv->wep_key[i].key_length) {
516 continue;
517 } else {
518 dev_err(priv->adapter->dev,
519 "key%d Length = %d is incorrect\n",
520 (i + 1), priv->wep_key[i].key_length);
521 return -1;
522 }
523 }
524
525 return 0;
526 }
527
528 /*
529 * This function prepares command to set/get/reset network key(s).
530 *
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
536 */
537 static int
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)
542 {
543 struct host_cmd_ds_802_11_key_material *key_material =
544 &cmd->params.key_material;
545 u16 key_param_len = 0;
546 int ret = 0;
547 const u8 bc_mac[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
548
549 cmd->command = cpu_to_le16(HostCmd_CMD_802_11_KEY_MATERIAL);
550 key_material->action = cpu_to_le16(cmd_action);
551
552 if (cmd_action == HostCmd_ACT_GEN_GET) {
553 cmd->size =
554 cpu_to_le16(sizeof(key_material->action) + S_DS_GEN);
555 return ret;
556 }
557
558 if (!enc_key) {
559 memset(&key_material->key_param_set, 0,
560 (NUM_WEP_KEYS *
561 sizeof(struct mwifiex_ie_type_key_param_set)));
562 ret = mwifiex_set_keyparamset_wep(priv,
563 &key_material->key_param_set,
564 &key_param_len);
565 cmd->size = cpu_to_le16(key_param_len +
566 sizeof(key_material->action) + S_DS_GEN);
567 return ret;
568 } else
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);
578 else
579 key_material->key_param_set.key_info =
580 cpu_to_le16(!KEY_ENABLED);
581
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;
585 else
586 /* set 0 when re-key */
587 key_material->key_param_set.key[1] = 0;
588
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;
597 }
598
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);
609
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);
614 return ret;
615 }
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);
623 else
624 key_material->key_param_set.key_info =
625 cpu_to_le16(!KEY_ENABLED);
626
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);
640
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);
648 }
649
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,
656 enc_key->key_len);
657 key_material->key_param_set.length =
658 cpu_to_le16((u16) enc_key->key_len +
659 KEYPARAMSET_FIXED_LEN);
660
661 key_param_len = (u16) (enc_key->key_len + KEYPARAMSET_FIXED_LEN)
662 + sizeof(struct mwifiex_ie_types_header);
663
664 cmd->size = cpu_to_le16(key_param_len +
665 sizeof(key_material->action) + S_DS_GEN);
666 }
667
668 return ret;
669 }
670
671 /*
672 * This function prepares command to set/get 11d domain information.
673 *
674 * Preparation includes -
675 * - Setting command ID, action and proper size
676 * - Setting domain information fields (for SET only)
677 * - Ensuring correct endian-ness
678 */
679 static int mwifiex_cmd_802_11d_domain_info(struct mwifiex_private *priv,
680 struct host_cmd_ds_command *cmd,
681 u16 cmd_action)
682 {
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;
689
690 dev_dbg(adapter->dev, "info: 11D: no_of_triplet=0x%x\n", no_of_triplet);
691
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);
696 return 0;
697 }
698
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));
703
704 domain->header.len = cpu_to_le16((no_of_triplet *
705 sizeof(struct ieee80211_country_ie_triplet)) +
706 sizeof(domain->country_code));
707
708 if (no_of_triplet) {
709 memcpy(domain->triplet, adapter->domain_reg.triplet,
710 no_of_triplet *
711 sizeof(struct ieee80211_country_ie_triplet));
712
713 cmd->size = cpu_to_le16(sizeof(domain_info->action) +
714 le16_to_cpu(domain->header.len) +
715 sizeof(struct mwifiex_ie_types_header)
716 + S_DS_GEN);
717 } else {
718 cmd->size = cpu_to_le16(sizeof(domain_info->action) + S_DS_GEN);
719 }
720
721 return 0;
722 }
723
724 /*
725 * This function prepares command to set/get RF channel.
726 *
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
731 */
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)
735 {
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);
739
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)
742 + S_DS_GEN);
743
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))
747 rf_chan->rf_type =
748 cpu_to_le16(HostCmd_SCAN_RADIO_TYPE_A);
749
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);
753 }
754 rf_chan->action = cpu_to_le16(cmd_action);
755 return 0;
756 }
757
758 /*
759 * This function prepares command to set/get IBSS coalescing status.
760 *
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
765 */
766 static int mwifiex_cmd_ibss_coalescing_status(struct host_cmd_ds_command *cmd,
767 u16 cmd_action, u16 *enable)
768 {
769 struct host_cmd_ds_802_11_ibss_status *ibss_coal =
770 &(cmd->params.ibss_coalescing);
771
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) +
774 S_DS_GEN);
775 cmd->result = 0;
776 ibss_coal->action = cpu_to_le16(cmd_action);
777
778 switch (cmd_action) {
779 case HostCmd_ACT_GEN_SET:
780 if (enable)
781 ibss_coal->enable = cpu_to_le16(*enable);
782 else
783 ibss_coal->enable = 0;
784 break;
785
786 /* In other case.. Nothing to do */
787 case HostCmd_ACT_GEN_GET:
788 default:
789 break;
790 }
791
792 return 0;
793 }
794
795 /*
796 * This function prepares command to set/get register value.
797 *
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
803 *
804 * The following type of registers can be accessed with this function -
805 * - MAC register
806 * - BBP register
807 * - RF register
808 * - PMIC register
809 * - CAU register
810 * - EEPROM
811 */
812 static int mwifiex_cmd_reg_access(struct host_cmd_ds_command *cmd,
813 u16 cmd_action, void *data_buf)
814 {
815 struct mwifiex_ds_reg_rw *reg_rw = data_buf;
816
817 switch (le16_to_cpu(cmd->command)) {
818 case HostCmd_CMD_MAC_REG_ACCESS:
819 {
820 struct host_cmd_ds_mac_reg_access *mac_reg;
821
822 cmd->size = cpu_to_le16(sizeof(*mac_reg) + S_DS_GEN);
823 mac_reg = (struct host_cmd_ds_mac_reg_access *) &cmd->
824 params.mac_reg;
825 mac_reg->action = cpu_to_le16(cmd_action);
826 mac_reg->offset =
827 cpu_to_le16((u16) le32_to_cpu(reg_rw->offset));
828 mac_reg->value = reg_rw->value;
829 break;
830 }
831 case HostCmd_CMD_BBP_REG_ACCESS:
832 {
833 struct host_cmd_ds_bbp_reg_access *bbp_reg;
834
835 cmd->size = cpu_to_le16(sizeof(*bbp_reg) + S_DS_GEN);
836 bbp_reg = (struct host_cmd_ds_bbp_reg_access *) &cmd->
837 params.bbp_reg;
838 bbp_reg->action = cpu_to_le16(cmd_action);
839 bbp_reg->offset =
840 cpu_to_le16((u16) le32_to_cpu(reg_rw->offset));
841 bbp_reg->value = (u8) le32_to_cpu(reg_rw->value);
842 break;
843 }
844 case HostCmd_CMD_RF_REG_ACCESS:
845 {
846 struct host_cmd_ds_rf_reg_access *rf_reg;
847
848 cmd->size = cpu_to_le16(sizeof(*rf_reg) + S_DS_GEN);
849 rf_reg = (struct host_cmd_ds_rf_reg_access *) &cmd->
850 params.rf_reg;
851 rf_reg->action = cpu_to_le16(cmd_action);
852 rf_reg->offset =
853 cpu_to_le16((u16) le32_to_cpu(reg_rw->offset));
854 rf_reg->value = (u8) le32_to_cpu(reg_rw->value);
855 break;
856 }
857 case HostCmd_CMD_PMIC_REG_ACCESS:
858 {
859 struct host_cmd_ds_pmic_reg_access *pmic_reg;
860
861 cmd->size = cpu_to_le16(sizeof(*pmic_reg) + S_DS_GEN);
862 pmic_reg = (struct host_cmd_ds_pmic_reg_access *) &cmd->
863 params.pmic_reg;
864 pmic_reg->action = cpu_to_le16(cmd_action);
865 pmic_reg->offset =
866 cpu_to_le16((u16) le32_to_cpu(reg_rw->offset));
867 pmic_reg->value = (u8) le32_to_cpu(reg_rw->value);
868 break;
869 }
870 case HostCmd_CMD_CAU_REG_ACCESS:
871 {
872 struct host_cmd_ds_rf_reg_access *cau_reg;
873
874 cmd->size = cpu_to_le16(sizeof(*cau_reg) + S_DS_GEN);
875 cau_reg = (struct host_cmd_ds_rf_reg_access *) &cmd->
876 params.rf_reg;
877 cau_reg->action = cpu_to_le16(cmd_action);
878 cau_reg->offset =
879 cpu_to_le16((u16) le32_to_cpu(reg_rw->offset));
880 cau_reg->value = (u8) le32_to_cpu(reg_rw->value);
881 break;
882 }
883 case HostCmd_CMD_802_11_EEPROM_ACCESS:
884 {
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 *)
888 &cmd->params.eeprom;
889
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;
895 break;
896 }
897 default:
898 return -1;
899 }
900
901 return 0;
902 }
903
904 /*
905 * This function prepares the commands before sending them to the firmware.
906 *
907 * This is a generic function which calls specific command preparation
908 * routines based upon the command number.
909 */
910 int mwifiex_sta_prepare_cmd(struct mwifiex_private *priv, uint16_t cmd_no,
911 u16 cmd_action, u32 cmd_oid,
912 void *data_buf, void *cmd_buf)
913 {
914 struct host_cmd_ds_command *cmd_ptr = cmd_buf;
915 int ret = 0;
916
917 /* Prepare command */
918 switch (cmd_no) {
919 case HostCmd_CMD_GET_HW_SPEC:
920 ret = mwifiex_cmd_get_hw_spec(priv, cmd_ptr);
921 break;
922 case HostCmd_CMD_MAC_CONTROL:
923 ret = mwifiex_cmd_mac_control(priv, cmd_ptr, cmd_action,
924 data_buf);
925 break;
926 case HostCmd_CMD_802_11_MAC_ADDRESS:
927 ret = mwifiex_cmd_802_11_mac_address(priv, cmd_ptr,
928 cmd_action);
929 break;
930 case HostCmd_CMD_MAC_MULTICAST_ADR:
931 ret = mwifiex_cmd_mac_multicast_adr(cmd_ptr, cmd_action,
932 data_buf);
933 break;
934 case HostCmd_CMD_TX_RATE_CFG:
935 ret = mwifiex_cmd_tx_rate_cfg(priv, cmd_ptr, cmd_action,
936 data_buf);
937 break;
938 case HostCmd_CMD_TXPWR_CFG:
939 ret = mwifiex_cmd_tx_power_cfg(cmd_ptr, cmd_action,
940 data_buf);
941 break;
942 case HostCmd_CMD_802_11_PS_MODE_ENH:
943 ret = mwifiex_cmd_enh_power_mode(priv, cmd_ptr, cmd_action,
944 (uint16_t)cmd_oid, data_buf);
945 break;
946 case HostCmd_CMD_802_11_HS_CFG_ENH:
947 ret = mwifiex_cmd_802_11_hs_cfg(priv, cmd_ptr, cmd_action,
948 (struct mwifiex_hs_config_param *) data_buf);
949 break;
950 case HostCmd_CMD_802_11_SCAN:
951 ret = mwifiex_cmd_802_11_scan(cmd_ptr, data_buf);
952 break;
953 case HostCmd_CMD_802_11_BG_SCAN_QUERY:
954 ret = mwifiex_cmd_802_11_bg_scan_query(cmd_ptr);
955 break;
956 case HostCmd_CMD_802_11_ASSOCIATE:
957 ret = mwifiex_cmd_802_11_associate(priv, cmd_ptr, data_buf);
958 break;
959 case HostCmd_CMD_802_11_DEAUTHENTICATE:
960 ret = mwifiex_cmd_802_11_deauthenticate(priv, cmd_ptr,
961 data_buf);
962 break;
963 case HostCmd_CMD_802_11_AD_HOC_START:
964 ret = mwifiex_cmd_802_11_ad_hoc_start(priv, cmd_ptr,
965 data_buf);
966 break;
967 case HostCmd_CMD_802_11_GET_LOG:
968 ret = mwifiex_cmd_802_11_get_log(cmd_ptr);
969 break;
970 case HostCmd_CMD_802_11_AD_HOC_JOIN:
971 ret = mwifiex_cmd_802_11_ad_hoc_join(priv, cmd_ptr,
972 data_buf);
973 break;
974 case HostCmd_CMD_802_11_AD_HOC_STOP:
975 ret = mwifiex_cmd_802_11_ad_hoc_stop(cmd_ptr);
976 break;
977 case HostCmd_CMD_RSSI_INFO:
978 ret = mwifiex_cmd_802_11_rssi_info(priv, cmd_ptr, cmd_action);
979 break;
980 case HostCmd_CMD_802_11_SNMP_MIB:
981 ret = mwifiex_cmd_802_11_snmp_mib(priv, cmd_ptr, cmd_action,
982 cmd_oid, data_buf);
983 break;
984 case HostCmd_CMD_802_11_TX_RATE_QUERY:
985 cmd_ptr->command =
986 cpu_to_le16(HostCmd_CMD_802_11_TX_RATE_QUERY);
987 cmd_ptr->size =
988 cpu_to_le16(sizeof(struct host_cmd_ds_tx_rate_query) +
989 S_DS_GEN);
990 priv->tx_rate = 0;
991 ret = 0;
992 break;
993 case HostCmd_CMD_VERSION_EXT:
994 cmd_ptr->command = cpu_to_le16(cmd_no);
995 cmd_ptr->params.verext.version_str_sel =
996 (u8) (*((u32 *) data_buf));
997 memcpy(&cmd_ptr->params, data_buf,
998 sizeof(struct host_cmd_ds_version_ext));
999 cmd_ptr->size =
1000 cpu_to_le16(sizeof(struct host_cmd_ds_version_ext) +
1001 S_DS_GEN);
1002 ret = 0;
1003 break;
1004 case HostCmd_CMD_802_11_RF_CHANNEL:
1005 ret = mwifiex_cmd_802_11_rf_channel(priv, cmd_ptr, cmd_action,
1006 data_buf);
1007 break;
1008 case HostCmd_CMD_FUNC_INIT:
1009 if (priv->adapter->hw_status == MWIFIEX_HW_STATUS_RESET)
1010 priv->adapter->hw_status = MWIFIEX_HW_STATUS_READY;
1011 cmd_ptr->command = cpu_to_le16(cmd_no);
1012 cmd_ptr->size = cpu_to_le16(S_DS_GEN);
1013 break;
1014 case HostCmd_CMD_FUNC_SHUTDOWN:
1015 priv->adapter->hw_status = MWIFIEX_HW_STATUS_RESET;
1016 cmd_ptr->command = cpu_to_le16(cmd_no);
1017 cmd_ptr->size = cpu_to_le16(S_DS_GEN);
1018 break;
1019 case HostCmd_CMD_11N_ADDBA_REQ:
1020 ret = mwifiex_cmd_11n_addba_req(cmd_ptr, data_buf);
1021 break;
1022 case HostCmd_CMD_11N_DELBA:
1023 ret = mwifiex_cmd_11n_delba(cmd_ptr, data_buf);
1024 break;
1025 case HostCmd_CMD_11N_ADDBA_RSP:
1026 ret = mwifiex_cmd_11n_addba_rsp_gen(priv, cmd_ptr, data_buf);
1027 break;
1028 case HostCmd_CMD_802_11_KEY_MATERIAL:
1029 ret = mwifiex_cmd_802_11_key_material(priv, cmd_ptr,
1030 cmd_action, cmd_oid,
1031 data_buf);
1032 break;
1033 case HostCmd_CMD_802_11D_DOMAIN_INFO:
1034 ret = mwifiex_cmd_802_11d_domain_info(priv, cmd_ptr,
1035 cmd_action);
1036 break;
1037 case HostCmd_CMD_RECONFIGURE_TX_BUFF:
1038 ret = mwifiex_cmd_recfg_tx_buf(priv, cmd_ptr, cmd_action,
1039 data_buf);
1040 break;
1041 case HostCmd_CMD_AMSDU_AGGR_CTRL:
1042 ret = mwifiex_cmd_amsdu_aggr_ctrl(cmd_ptr, cmd_action,
1043 data_buf);
1044 break;
1045 case HostCmd_CMD_11N_CFG:
1046 ret = mwifiex_cmd_11n_cfg(cmd_ptr, cmd_action,
1047 data_buf);
1048 break;
1049 case HostCmd_CMD_WMM_GET_STATUS:
1050 dev_dbg(priv->adapter->dev,
1051 "cmd: WMM: WMM_GET_STATUS cmd sent\n");
1052 cmd_ptr->command = cpu_to_le16(HostCmd_CMD_WMM_GET_STATUS);
1053 cmd_ptr->size =
1054 cpu_to_le16(sizeof(struct host_cmd_ds_wmm_get_status) +
1055 S_DS_GEN);
1056 ret = 0;
1057 break;
1058 case HostCmd_CMD_802_11_IBSS_COALESCING_STATUS:
1059 ret = mwifiex_cmd_ibss_coalescing_status(cmd_ptr, cmd_action,
1060 data_buf);
1061 break;
1062 case HostCmd_CMD_MAC_REG_ACCESS:
1063 case HostCmd_CMD_BBP_REG_ACCESS:
1064 case HostCmd_CMD_RF_REG_ACCESS:
1065 case HostCmd_CMD_PMIC_REG_ACCESS:
1066 case HostCmd_CMD_CAU_REG_ACCESS:
1067 case HostCmd_CMD_802_11_EEPROM_ACCESS:
1068 ret = mwifiex_cmd_reg_access(cmd_ptr, cmd_action, data_buf);
1069 break;
1070 case HostCmd_CMD_SET_BSS_MODE:
1071 cmd_ptr->command = cpu_to_le16(cmd_no);
1072 if (priv->bss_mode == NL80211_IFTYPE_ADHOC)
1073 cmd_ptr->params.bss_mode.con_type =
1074 CONNECTION_TYPE_ADHOC;
1075 else if (priv->bss_mode == NL80211_IFTYPE_STATION)
1076 cmd_ptr->params.bss_mode.con_type =
1077 CONNECTION_TYPE_INFRA;
1078 cmd_ptr->size = cpu_to_le16(sizeof(struct
1079 host_cmd_ds_set_bss_mode) + S_DS_GEN);
1080 ret = 0;
1081 break;
1082 default:
1083 dev_err(priv->adapter->dev,
1084 "PREP_CMD: unknown cmd- %#x\n", cmd_no);
1085 ret = -1;
1086 break;
1087 }
1088 return ret;
1089 }
1090
1091 /*
1092 * This function issues commands to initialize firmware.
1093 *
1094 * This is called after firmware download to bring the card to
1095 * working state.
1096 *
1097 * The following commands are issued sequentially -
1098 * - Function init (for first interface only)
1099 * - Read MAC address (for first interface only)
1100 * - Reconfigure Tx buffer size (for first interface only)
1101 * - Enable auto deep sleep (for first interface only)
1102 * - Get Tx rate
1103 * - Get Tx power
1104 * - Set IBSS coalescing status
1105 * - Set AMSDU aggregation control
1106 * - Set 11d control
1107 * - Set MAC control (this must be the last command to initialize firmware)
1108 */
1109 int mwifiex_sta_init_cmd(struct mwifiex_private *priv, u8 first_sta)
1110 {
1111 int ret;
1112 u16 enable = true;
1113 struct mwifiex_ds_11n_amsdu_aggr_ctrl amsdu_aggr_ctrl;
1114 struct mwifiex_ds_auto_ds auto_ds;
1115 enum state_11d_t state_11d;
1116 struct mwifiex_ds_11n_tx_cfg tx_cfg;
1117
1118 if (first_sta) {
1119
1120 ret = mwifiex_send_cmd_async(priv, HostCmd_CMD_FUNC_INIT,
1121 HostCmd_ACT_GEN_SET, 0, NULL);
1122 if (ret)
1123 return -1;
1124 /* Read MAC address from HW */
1125 ret = mwifiex_send_cmd_async(priv, HostCmd_CMD_GET_HW_SPEC,
1126 HostCmd_ACT_GEN_GET, 0, NULL);
1127 if (ret)
1128 return -1;
1129
1130 /* Reconfigure tx buf size */
1131 ret = mwifiex_send_cmd_async(priv,
1132 HostCmd_CMD_RECONFIGURE_TX_BUFF,
1133 HostCmd_ACT_GEN_SET, 0,
1134 &priv->adapter->tx_buf_size);
1135 if (ret)
1136 return -1;
1137
1138 /* Enable IEEE PS by default */
1139 priv->adapter->ps_mode = MWIFIEX_802_11_POWER_MODE_PSP;
1140 ret = mwifiex_send_cmd_async(priv,
1141 HostCmd_CMD_802_11_PS_MODE_ENH,
1142 EN_AUTO_PS, BITMAP_STA_PS, NULL);
1143 if (ret)
1144 return -1;
1145 }
1146
1147 /* get tx rate */
1148 ret = mwifiex_send_cmd_async(priv, HostCmd_CMD_TX_RATE_CFG,
1149 HostCmd_ACT_GEN_GET, 0, NULL);
1150 if (ret)
1151 return -1;
1152 priv->data_rate = 0;
1153
1154 /* get tx power */
1155 ret = mwifiex_send_cmd_async(priv, HostCmd_CMD_TXPWR_CFG,
1156 HostCmd_ACT_GEN_GET, 0, NULL);
1157 if (ret)
1158 return -1;
1159
1160 /* set ibss coalescing_status */
1161 ret = mwifiex_send_cmd_async(priv,
1162 HostCmd_CMD_802_11_IBSS_COALESCING_STATUS,
1163 HostCmd_ACT_GEN_SET, 0, &enable);
1164 if (ret)
1165 return -1;
1166
1167 memset(&amsdu_aggr_ctrl, 0, sizeof(amsdu_aggr_ctrl));
1168 amsdu_aggr_ctrl.enable = true;
1169 /* Send request to firmware */
1170 ret = mwifiex_send_cmd_async(priv, HostCmd_CMD_AMSDU_AGGR_CTRL,
1171 HostCmd_ACT_GEN_SET, 0,
1172 &amsdu_aggr_ctrl);
1173 if (ret)
1174 return -1;
1175 /* MAC Control must be the last command in init_fw */
1176 /* set MAC Control */
1177 ret = mwifiex_send_cmd_async(priv, HostCmd_CMD_MAC_CONTROL,
1178 HostCmd_ACT_GEN_SET, 0,
1179 &priv->curr_pkt_filter);
1180 if (ret)
1181 return -1;
1182
1183 if (first_sta) {
1184 /* Enable auto deep sleep */
1185 auto_ds.auto_ds = DEEP_SLEEP_ON;
1186 auto_ds.idle_time = DEEP_SLEEP_IDLE_TIME;
1187 ret = mwifiex_send_cmd_async(priv,
1188 HostCmd_CMD_802_11_PS_MODE_ENH,
1189 EN_AUTO_PS, BITMAP_AUTO_DS,
1190 &auto_ds);
1191 if (ret)
1192 return -1;
1193 }
1194
1195 /* Send cmd to FW to enable/disable 11D function */
1196 state_11d = ENABLE_11D;
1197 ret = mwifiex_send_cmd_async(priv, HostCmd_CMD_802_11_SNMP_MIB,
1198 HostCmd_ACT_GEN_SET, DOT11D_I, &state_11d);
1199 if (ret)
1200 dev_err(priv->adapter->dev, "11D: failed to enable 11D\n");
1201
1202 /* Send cmd to FW to configure 11n specific configuration
1203 * (Short GI, Channel BW, Green field support etc.) for transmit
1204 */
1205 tx_cfg.tx_htcap = MWIFIEX_FW_DEF_HTTXCFG;
1206 ret = mwifiex_send_cmd_async(priv, HostCmd_CMD_11N_CFG,
1207 HostCmd_ACT_GEN_SET, 0, &tx_cfg);
1208
1209 /* set last_init_cmd */
1210 priv->adapter->last_init_cmd = HostCmd_CMD_11N_CFG;
1211 ret = -EINPROGRESS;
1212
1213 return ret;
1214 }
linux-next