?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] libertas: fix more mixed-case abuse
[linux-2.6/kmemtrace.git] / drivers / net / wireless / libertas / cmd.c
blobc96ced963d69f05da3f9c032c50a5809eb03ddcb
1 /**
2 * This file contains the handling of command.
3 * It prepares command and sends it to firmware when it is ready.
4 */
5
6 #include <net/iw_handler.h>
7 #include "host.h"
8 #include "hostcmd.h"
9 #include "decl.h"
10 #include "defs.h"
11 #include "dev.h"
12 #include "join.h"
13 #include "wext.h"
14
15 static void cleanup_cmdnode(struct cmd_ctrl_node *ptempnode);
16
17 static u16 commands_allowed_in_ps[] = {
18 CMD_802_11_RSSI,
19 };
20
21 /**
22 * @brief This function checks if the commans is allowed
23 * in PS mode not.
24 *
25 * @param command the command ID
26 * @return TRUE or FALSE
27 */
28 static u8 is_command_allowed_in_ps(__le16 command)
29 {
30 int i;
31
32 for (i = 0; i < ARRAY_SIZE(commands_allowed_in_ps); i++) {
33 if (command == cpu_to_le16(commands_allowed_in_ps[i]))
34 return 1;
35 }
36
37 return 0;
38 }
39
40 static int wlan_cmd_hw_spec(wlan_private * priv, struct cmd_ds_command *cmd)
41 {
42 struct cmd_ds_get_hw_spec *hwspec = &cmd->params.hwspec;
43
44 lbs_deb_enter(LBS_DEB_CMD);
45
46 cmd->command = cpu_to_le16(CMD_GET_HW_SPEC);
47 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_get_hw_spec) + S_DS_GEN);
48 memcpy(hwspec->permanentaddr, priv->adapter->current_addr, ETH_ALEN);
49
50 lbs_deb_leave(LBS_DEB_CMD);
51 return 0;
52 }
53
54 static int wlan_cmd_802_11_ps_mode(wlan_private * priv,
55 struct cmd_ds_command *cmd,
56 u16 cmd_action)
57 {
58 struct cmd_ds_802_11_ps_mode *psm = &cmd->params.psmode;
59 wlan_adapter *adapter = priv->adapter;
60
61 lbs_deb_enter(LBS_DEB_CMD);
62
63 cmd->command = cpu_to_le16(CMD_802_11_PS_MODE);
64 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_ps_mode) +
65 S_DS_GEN);
66 psm->action = cpu_to_le16(cmd_action);
67 psm->multipledtim = 0;
68 switch (cmd_action) {
69 case CMD_SUBCMD_ENTER_PS:
70 lbs_deb_cmd("PS command:" "SubCode- Enter PS\n");
71 lbs_deb_cmd("locallisteninterval = %d\n",
72 adapter->locallisteninterval);
73
74 psm->locallisteninterval =
75 cpu_to_le16(adapter->locallisteninterval);
76 psm->nullpktinterval =
77 cpu_to_le16(adapter->nullpktinterval);
78 psm->multipledtim =
79 cpu_to_le16(priv->adapter->multipledtim);
80 break;
81
82 case CMD_SUBCMD_EXIT_PS:
83 lbs_deb_cmd("PS command:" "SubCode- Exit PS\n");
84 break;
85
86 case CMD_SUBCMD_SLEEP_CONFIRMED:
87 lbs_deb_cmd("PS command: SubCode- sleep confirm\n");
88 break;
89
90 default:
91 break;
92 }
93
94 lbs_deb_leave(LBS_DEB_CMD);
95 return 0;
96 }
97
98 static int wlan_cmd_802_11_inactivity_timeout(wlan_private * priv,
99 struct cmd_ds_command *cmd,
100 u16 cmd_action, void *pdata_buf)
101 {
102 u16 *timeout = pdata_buf;
103
104 cmd->command = cpu_to_le16(CMD_802_11_INACTIVITY_TIMEOUT);
105 cmd->size =
106 cpu_to_le16(sizeof(struct cmd_ds_802_11_inactivity_timeout)
107 + S_DS_GEN);
108
109 cmd->params.inactivity_timeout.action = cpu_to_le16(cmd_action);
110
111 if (cmd_action)
112 cmd->params.inactivity_timeout.timeout = cpu_to_le16(*timeout);
113 else
114 cmd->params.inactivity_timeout.timeout = 0;
115
116 return 0;
117 }
118
119 static int wlan_cmd_802_11_sleep_params(wlan_private * priv,
120 struct cmd_ds_command *cmd,
121 u16 cmd_action)
122 {
123 wlan_adapter *adapter = priv->adapter;
124 struct cmd_ds_802_11_sleep_params *sp = &cmd->params.sleep_params;
125
126 lbs_deb_enter(LBS_DEB_CMD);
127
128 cmd->size = cpu_to_le16((sizeof(struct cmd_ds_802_11_sleep_params)) +
129 S_DS_GEN);
130 cmd->command = cpu_to_le16(CMD_802_11_SLEEP_PARAMS);
131
132 if (cmd_action == CMD_ACT_GET) {
133 memset(&adapter->sp, 0, sizeof(struct sleep_params));
134 memset(sp, 0, sizeof(struct cmd_ds_802_11_sleep_params));
135 sp->action = cpu_to_le16(cmd_action);
136 } else if (cmd_action == CMD_ACT_SET) {
137 sp->action = cpu_to_le16(cmd_action);
138 sp->error = cpu_to_le16(adapter->sp.sp_error);
139 sp->offset = cpu_to_le16(adapter->sp.sp_offset);
140 sp->stabletime = cpu_to_le16(adapter->sp.sp_stabletime);
141 sp->calcontrol = (u8) adapter->sp.sp_calcontrol;
142 sp->externalsleepclk = (u8) adapter->sp.sp_extsleepclk;
143 sp->reserved = cpu_to_le16(adapter->sp.sp_reserved);
144 }
145
146 lbs_deb_leave(LBS_DEB_CMD);
147 return 0;
148 }
149
150 static int wlan_cmd_802_11_set_wep(wlan_private * priv,
151 struct cmd_ds_command *cmd,
152 u32 cmd_act,
153 void * pdata_buf)
154 {
155 struct cmd_ds_802_11_set_wep *wep = &cmd->params.wep;
156 wlan_adapter *adapter = priv->adapter;
157 int ret = 0;
158 struct assoc_request * assoc_req = pdata_buf;
159
160 lbs_deb_enter(LBS_DEB_CMD);
161
162 cmd->command = cpu_to_le16(CMD_802_11_SET_WEP);
163 cmd->size = cpu_to_le16(sizeof(*wep) + S_DS_GEN);
164
165 if (cmd_act == CMD_ACT_ADD) {
166 int i;
167
168 if (!assoc_req) {
169 lbs_deb_cmd("Invalid association request!");
170 ret = -1;
171 goto done;
172 }
173
174 wep->action = cpu_to_le16(CMD_ACT_ADD);
175
176 /* default tx key index */
177 wep->keyindex = cpu_to_le16((u16)(assoc_req->wep_tx_keyidx &
178 (u32)CMD_WEP_KEY_INDEX_MASK));
179
180 lbs_deb_cmd("Tx key Index: %u\n", le16_to_cpu(wep->keyindex));
181
182 /* Copy key types and material to host command structure */
183 for (i = 0; i < 4; i++) {
184 struct enc_key * pkey = &assoc_req->wep_keys[i];
185
186 switch (pkey->len) {
187 case KEY_LEN_WEP_40:
188 wep->keytype[i] =
189 cpu_to_le16(CMD_TYPE_WEP_40_BIT);
190 memmove(&wep->keymaterial[i], pkey->key,
191 pkey->len);
192 break;
193 case KEY_LEN_WEP_104:
194 wep->keytype[i] =
195 cpu_to_le16(CMD_TYPE_WEP_104_BIT);
196 memmove(&wep->keymaterial[i], pkey->key,
197 pkey->len);
198 break;
199 case 0:
200 break;
201 default:
202 lbs_deb_cmd("Invalid WEP key %d length of %d\n",
203 i, pkey->len);
204 ret = -1;
205 goto done;
206 break;
207 }
208 }
209 } else if (cmd_act == CMD_ACT_REMOVE) {
210 /* ACT_REMOVE clears _all_ WEP keys */
211 wep->action = cpu_to_le16(CMD_ACT_REMOVE);
212
213 /* default tx key index */
214 wep->keyindex = cpu_to_le16((u16)(adapter->wep_tx_keyidx &
215 (u32)CMD_WEP_KEY_INDEX_MASK));
216 }
217
218 ret = 0;
219
220 done:
221 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
222 return ret;
223 }
224
225 static int wlan_cmd_802_11_enable_rsn(wlan_private * priv,
226 struct cmd_ds_command *cmd,
227 u16 cmd_action,
228 void * pdata_buf)
229 {
230 struct cmd_ds_802_11_enable_rsn *penableRSN = &cmd->params.enbrsn;
231 u32 * enable = pdata_buf;
232
233 lbs_deb_enter(LBS_DEB_CMD);
234
235 cmd->command = cpu_to_le16(CMD_802_11_ENABLE_RSN);
236 cmd->size = cpu_to_le16(sizeof(*penableRSN) + S_DS_GEN);
237 penableRSN->action = cpu_to_le16(cmd_action);
238
239 if (cmd_action == CMD_ACT_SET) {
240 if (*enable)
241 penableRSN->enable = cpu_to_le16(CMD_ENABLE_RSN);
242 else
243 penableRSN->enable = cpu_to_le16(CMD_DISABLE_RSN);
244 }
245
246 lbs_deb_leave(LBS_DEB_CMD);
247 return 0;
248 }
249
250
251 static void set_one_wpa_key(struct MrvlIEtype_keyParamSet * pkeyparamset,
252 struct enc_key * pkey)
253 {
254 if (pkey->flags & KEY_INFO_WPA_ENABLED) {
255 pkeyparamset->keyinfo |= cpu_to_le16(KEY_INFO_WPA_ENABLED);
256 }
257 if (pkey->flags & KEY_INFO_WPA_UNICAST) {
258 pkeyparamset->keyinfo |= cpu_to_le16(KEY_INFO_WPA_UNICAST);
259 }
260 if (pkey->flags & KEY_INFO_WPA_MCAST) {
261 pkeyparamset->keyinfo |= cpu_to_le16(KEY_INFO_WPA_MCAST);
262 }
263
264 pkeyparamset->type = cpu_to_le16(TLV_TYPE_KEY_MATERIAL);
265 pkeyparamset->keytypeid = cpu_to_le16(pkey->type);
266 pkeyparamset->keylen = cpu_to_le16(pkey->len);
267 memcpy(pkeyparamset->key, pkey->key, pkey->len);
268 pkeyparamset->length = cpu_to_le16( sizeof(pkeyparamset->keytypeid)
269 + sizeof(pkeyparamset->keyinfo)
270 + sizeof(pkeyparamset->keylen)
271 + sizeof(pkeyparamset->key));
272 }
273
274 static int wlan_cmd_802_11_key_material(wlan_private * priv,
275 struct cmd_ds_command *cmd,
276 u16 cmd_action,
277 u32 cmd_oid, void *pdata_buf)
278 {
279 struct cmd_ds_802_11_key_material *pkeymaterial =
280 &cmd->params.keymaterial;
281 struct assoc_request * assoc_req = pdata_buf;
282 int ret = 0;
283 int index = 0;
284
285 lbs_deb_enter(LBS_DEB_CMD);
286
287 cmd->command = cpu_to_le16(CMD_802_11_KEY_MATERIAL);
288 pkeymaterial->action = cpu_to_le16(cmd_action);
289
290 if (cmd_action == CMD_ACT_GET) {
291 cmd->size = cpu_to_le16(S_DS_GEN + sizeof (pkeymaterial->action));
292 ret = 0;
293 goto done;
294 }
295
296 memset(&pkeymaterial->keyParamSet, 0, sizeof(pkeymaterial->keyParamSet));
297
298 if (test_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags)) {
299 set_one_wpa_key(&pkeymaterial->keyParamSet[index],
300 &assoc_req->wpa_unicast_key);
301 index++;
302 }
303
304 if (test_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags)) {
305 set_one_wpa_key(&pkeymaterial->keyParamSet[index],
306 &assoc_req->wpa_mcast_key);
307 index++;
308 }
309
310 cmd->size = cpu_to_le16( S_DS_GEN
311 + sizeof (pkeymaterial->action)
312 + (index * sizeof(struct MrvlIEtype_keyParamSet)));
313
314 ret = 0;
315
316 done:
317 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
318 return ret;
319 }
320
321 static int wlan_cmd_802_11_reset(wlan_private * priv,
322 struct cmd_ds_command *cmd, int cmd_action)
323 {
324 struct cmd_ds_802_11_reset *reset = &cmd->params.reset;
325
326 cmd->command = cpu_to_le16(CMD_802_11_RESET);
327 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_reset) + S_DS_GEN);
328 reset->action = cpu_to_le16(cmd_action);
329
330 return 0;
331 }
332
333 static int wlan_cmd_802_11_get_log(wlan_private * priv,
334 struct cmd_ds_command *cmd)
335 {
336 cmd->command = cpu_to_le16(CMD_802_11_GET_LOG);
337 cmd->size =
338 cpu_to_le16(sizeof(struct cmd_ds_802_11_get_log) + S_DS_GEN);
339
340 return 0;
341 }
342
343 static int wlan_cmd_802_11_get_stat(wlan_private * priv,
344 struct cmd_ds_command *cmd)
345 {
346 cmd->command = cpu_to_le16(CMD_802_11_GET_STAT);
347 cmd->size =
348 cpu_to_le16(sizeof(struct cmd_ds_802_11_get_stat) + S_DS_GEN);
349
350 return 0;
351 }
352
353 static int wlan_cmd_802_11_snmp_mib(wlan_private * priv,
354 struct cmd_ds_command *cmd,
355 int cmd_action,
356 int cmd_oid, void *pdata_buf)
357 {
358 struct cmd_ds_802_11_snmp_mib *pSNMPMIB = &cmd->params.smib;
359 wlan_adapter *adapter = priv->adapter;
360 u8 ucTemp;
361
362 lbs_deb_enter(LBS_DEB_CMD);
363
364 lbs_deb_cmd("SNMP_CMD: cmd_oid = 0x%x\n", cmd_oid);
365
366 cmd->command = cpu_to_le16(CMD_802_11_SNMP_MIB);
367 cmd->size = cpu_to_le16(sizeof(*pSNMPMIB) + S_DS_GEN);
368
369 switch (cmd_oid) {
370 case OID_802_11_INFRASTRUCTURE_MODE:
371 {
372 u8 mode = (u8) (size_t) pdata_buf;
373 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
374 pSNMPMIB->oid = cpu_to_le16((u16) DESIRED_BSSTYPE_I);
375 pSNMPMIB->bufsize = sizeof(u8);
376 if (mode == IW_MODE_ADHOC) {
377 ucTemp = SNMP_MIB_VALUE_ADHOC;
378 } else {
379 /* Infra and Auto modes */
380 ucTemp = SNMP_MIB_VALUE_INFRA;
381 }
382
383 memmove(pSNMPMIB->value, &ucTemp, sizeof(u8));
384
385 break;
386 }
387
388 case OID_802_11D_ENABLE:
389 {
390 u32 ulTemp;
391
392 pSNMPMIB->oid = cpu_to_le16((u16) DOT11D_I);
393
394 if (cmd_action == CMD_ACT_SET) {
395 pSNMPMIB->querytype = CMD_ACT_SET;
396 pSNMPMIB->bufsize = sizeof(u16);
397 ulTemp = *(u32 *)pdata_buf;
398 *((__le16 *)(pSNMPMIB->value)) =
399 cpu_to_le16((u16) ulTemp);
400 }
401 break;
402 }
403
404 case OID_802_11_FRAGMENTATION_THRESHOLD:
405 {
406 u32 ulTemp;
407
408 pSNMPMIB->oid = cpu_to_le16((u16) FRAGTHRESH_I);
409
410 if (cmd_action == CMD_ACT_GET) {
411 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_GET);
412 } else if (cmd_action == CMD_ACT_SET) {
413 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
414 pSNMPMIB->bufsize = cpu_to_le16(sizeof(u16));
415 ulTemp = *((u32 *) pdata_buf);
416 *((__le16 *)(pSNMPMIB->value)) =
417 cpu_to_le16((u16) ulTemp);
418
419 }
420
421 break;
422 }
423
424 case OID_802_11_RTS_THRESHOLD:
425 {
426
427 u32 ulTemp;
428 pSNMPMIB->oid = le16_to_cpu((u16) RTSTHRESH_I);
429
430 if (cmd_action == CMD_ACT_GET) {
431 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_GET);
432 } else if (cmd_action == CMD_ACT_SET) {
433 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
434 pSNMPMIB->bufsize = cpu_to_le16(sizeof(u16));
435 ulTemp = *((u32 *)pdata_buf);
436 *(__le16 *)(pSNMPMIB->value) =
437 cpu_to_le16((u16) ulTemp);
438
439 }
440 break;
441 }
442 case OID_802_11_TX_RETRYCOUNT:
443 pSNMPMIB->oid = cpu_to_le16((u16) SHORT_RETRYLIM_I);
444
445 if (cmd_action == CMD_ACT_GET) {
446 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_GET);
447 } else if (cmd_action == CMD_ACT_SET) {
448 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
449 pSNMPMIB->bufsize = cpu_to_le16(sizeof(u16));
450 *((__le16 *)(pSNMPMIB->value)) =
451 cpu_to_le16((u16) adapter->txretrycount);
452 }
453
454 break;
455 default:
456 break;
457 }
458
459 lbs_deb_cmd(
460 "SNMP_CMD: command=0x%x, size=0x%x, seqnum=0x%x, result=0x%x\n",
461 le16_to_cpu(cmd->command), le16_to_cpu(cmd->size),
462 le16_to_cpu(cmd->seqnum), le16_to_cpu(cmd->result));
463
464 lbs_deb_cmd(
465 "SNMP_CMD: action=0x%x, oid=0x%x, oidsize=0x%x, value=0x%x\n",
466 le16_to_cpu(pSNMPMIB->querytype), le16_to_cpu(pSNMPMIB->oid),
467 le16_to_cpu(pSNMPMIB->bufsize),
468 le16_to_cpu(*(__le16 *) pSNMPMIB->value));
469
470 lbs_deb_leave(LBS_DEB_CMD);
471 return 0;
472 }
473
474 static int wlan_cmd_802_11_radio_control(wlan_private * priv,
475 struct cmd_ds_command *cmd,
476 int cmd_action)
477 {
478 wlan_adapter *adapter = priv->adapter;
479 struct cmd_ds_802_11_radio_control *pradiocontrol = &cmd->params.radio;
480
481 lbs_deb_enter(LBS_DEB_CMD);
482
483 cmd->size =
484 cpu_to_le16((sizeof(struct cmd_ds_802_11_radio_control)) +
485 S_DS_GEN);
486 cmd->command = cpu_to_le16(CMD_802_11_RADIO_CONTROL);
487
488 pradiocontrol->action = cpu_to_le16(cmd_action);
489
490 switch (adapter->preamble) {
491 case CMD_TYPE_SHORT_PREAMBLE:
492 pradiocontrol->control = cpu_to_le16(SET_SHORT_PREAMBLE);
493 break;
494
495 case CMD_TYPE_LONG_PREAMBLE:
496 pradiocontrol->control = cpu_to_le16(SET_LONG_PREAMBLE);
497 break;
498
499 case CMD_TYPE_AUTO_PREAMBLE:
500 default:
501 pradiocontrol->control = cpu_to_le16(SET_AUTO_PREAMBLE);
502 break;
503 }
504
505 if (adapter->radioon)
506 pradiocontrol->control |= cpu_to_le16(TURN_ON_RF);
507 else
508 pradiocontrol->control &= cpu_to_le16(~TURN_ON_RF);
509
510 lbs_deb_leave(LBS_DEB_CMD);
511 return 0;
512 }
513
514 static int wlan_cmd_802_11_rf_tx_power(wlan_private * priv,
515 struct cmd_ds_command *cmd,
516 u16 cmd_action, void *pdata_buf)
517 {
518
519 struct cmd_ds_802_11_rf_tx_power *prtp = &cmd->params.txp;
520
521 lbs_deb_enter(LBS_DEB_CMD);
522
523 cmd->size =
524 cpu_to_le16((sizeof(struct cmd_ds_802_11_rf_tx_power)) + S_DS_GEN);
525 cmd->command = cpu_to_le16(CMD_802_11_RF_TX_POWER);
526 prtp->action = cpu_to_le16(cmd_action);
527
528 lbs_deb_cmd("RF_TX_POWER_CMD: size:%d cmd:0x%x Act:%d\n",
529 le16_to_cpu(cmd->size), le16_to_cpu(cmd->command),
530 le16_to_cpu(prtp->action));
531
532 switch (cmd_action) {
533 case CMD_ACT_TX_POWER_OPT_GET:
534 prtp->action = cpu_to_le16(CMD_ACT_GET);
535 prtp->currentlevel = 0;
536 break;
537
538 case CMD_ACT_TX_POWER_OPT_SET_HIGH:
539 prtp->action = cpu_to_le16(CMD_ACT_SET);
540 prtp->currentlevel = cpu_to_le16(CMD_ACT_TX_POWER_INDEX_HIGH);
541 break;
542
543 case CMD_ACT_TX_POWER_OPT_SET_MID:
544 prtp->action = cpu_to_le16(CMD_ACT_SET);
545 prtp->currentlevel = cpu_to_le16(CMD_ACT_TX_POWER_INDEX_MID);
546 break;
547
548 case CMD_ACT_TX_POWER_OPT_SET_LOW:
549 prtp->action = cpu_to_le16(CMD_ACT_SET);
550 prtp->currentlevel = cpu_to_le16(*((u16 *) pdata_buf));
551 break;
552 }
553
554 lbs_deb_leave(LBS_DEB_CMD);
555 return 0;
556 }
557
558 static int wlan_cmd_802_11_rf_antenna(wlan_private * priv,
559 struct cmd_ds_command *cmd,
560 u16 cmd_action, void *pdata_buf)
561 {
562 struct cmd_ds_802_11_rf_antenna *rant = &cmd->params.rant;
563
564 cmd->command = cpu_to_le16(CMD_802_11_RF_ANTENNA);
565 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_rf_antenna) +
566 S_DS_GEN);
567
568 rant->action = cpu_to_le16(cmd_action);
569 if ((cmd_action == CMD_ACT_SET_RX) || (cmd_action == CMD_ACT_SET_TX)) {
570 rant->antennamode = cpu_to_le16((u16) (*(u32 *) pdata_buf));
571 }
572
573 return 0;
574 }
575
576 static int wlan_cmd_802_11_rate_adapt_rateset(wlan_private * priv,
577 struct cmd_ds_command *cmd,
578 u16 cmd_action)
579 {
580 struct cmd_ds_802_11_rate_adapt_rateset
581 *rateadapt = &cmd->params.rateset;
582 wlan_adapter *adapter = priv->adapter;
583
584 cmd->size =
585 cpu_to_le16(sizeof(struct cmd_ds_802_11_rate_adapt_rateset)
586 + S_DS_GEN);
587 cmd->command = cpu_to_le16(CMD_802_11_RATE_ADAPT_RATESET);
588
589 lbs_deb_enter(LBS_DEB_CMD);
590
591 rateadapt->action = cpu_to_le16(cmd_action);
592 rateadapt->enablehwauto = cpu_to_le16(adapter->enablehwauto);
593 rateadapt->bitmap = cpu_to_le16(adapter->ratebitmap);
594
595 lbs_deb_leave(LBS_DEB_CMD);
596 return 0;
597 }
598
599 static int wlan_cmd_802_11_data_rate(wlan_private * priv,
600 struct cmd_ds_command *cmd,
601 u16 cmd_action)
602 {
603 struct cmd_ds_802_11_data_rate *pdatarate = &cmd->params.drate;
604 wlan_adapter *adapter = priv->adapter;
605
606 lbs_deb_enter(LBS_DEB_CMD);
607
608 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_data_rate) +
609 S_DS_GEN);
610
611 cmd->command = cpu_to_le16(CMD_802_11_DATA_RATE);
612
613 memset(pdatarate, 0, sizeof(struct cmd_ds_802_11_data_rate));
614
615 pdatarate->action = cpu_to_le16(cmd_action);
616
617 if (cmd_action == CMD_ACT_SET_TX_FIX_RATE) {
618 pdatarate->datarate[0] = libertas_data_rate_to_index(adapter->datarate);
619 lbs_deb_cmd("Setting FW for fixed rate 0x%02X\n",
620 adapter->datarate);
621 } else if (cmd_action == CMD_ACT_SET_TX_AUTO) {
622 lbs_deb_cmd("Setting FW for AUTO rate\n");
623 }
624
625 lbs_deb_leave(LBS_DEB_CMD);
626 return 0;
627 }
628
629 static int wlan_cmd_mac_multicast_adr(wlan_private * priv,
630 struct cmd_ds_command *cmd,
631 u16 cmd_action)
632 {
633 struct cmd_ds_mac_multicast_adr *pMCastAdr = &cmd->params.madr;
634 wlan_adapter *adapter = priv->adapter;
635
636 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mac_multicast_adr) +
637 S_DS_GEN);
638 cmd->command = cpu_to_le16(CMD_MAC_MULTICAST_ADR);
639
640 pMCastAdr->action = cpu_to_le16(cmd_action);
641 pMCastAdr->nr_of_adrs =
642 cpu_to_le16((u16) adapter->nr_of_multicastmacaddr);
643 memcpy(pMCastAdr->maclist, adapter->multicastlist,
644 adapter->nr_of_multicastmacaddr * ETH_ALEN);
645
646 return 0;
647 }
648
649 static int wlan_cmd_802_11_rf_channel(wlan_private * priv,
650 struct cmd_ds_command *cmd,
651 int option, void *pdata_buf)
652 {
653 struct cmd_ds_802_11_rf_channel *rfchan = &cmd->params.rfchannel;
654
655 cmd->command = cpu_to_le16(CMD_802_11_RF_CHANNEL);
656 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_rf_channel) +
657 S_DS_GEN);
658
659 if (option == CMD_OPT_802_11_RF_CHANNEL_SET) {
660 rfchan->currentchannel = cpu_to_le16(*((u16 *) pdata_buf));
661 }
662
663 rfchan->action = cpu_to_le16(option);
664
665 return 0;
666 }
667
668 static int wlan_cmd_802_11_rssi(wlan_private * priv,
669 struct cmd_ds_command *cmd)
670 {
671 wlan_adapter *adapter = priv->adapter;
672
673 cmd->command = cpu_to_le16(CMD_802_11_RSSI);
674 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_rssi) + S_DS_GEN);
675 cmd->params.rssi.N = cpu_to_le16(priv->adapter->bcn_avg_factor);
676
677 /* reset Beacon SNR/NF/RSSI values */
678 adapter->SNR[TYPE_BEACON][TYPE_NOAVG] = 0;
679 adapter->SNR[TYPE_BEACON][TYPE_AVG] = 0;
680 adapter->NF[TYPE_BEACON][TYPE_NOAVG] = 0;
681 adapter->NF[TYPE_BEACON][TYPE_AVG] = 0;
682 adapter->RSSI[TYPE_BEACON][TYPE_NOAVG] = 0;
683 adapter->RSSI[TYPE_BEACON][TYPE_AVG] = 0;
684
685 return 0;
686 }
687
688 static int wlan_cmd_reg_access(wlan_private * priv,
689 struct cmd_ds_command *cmdptr,
690 u8 cmd_action, void *pdata_buf)
691 {
692 struct wlan_offset_value *offval;
693
694 lbs_deb_enter(LBS_DEB_CMD);
695
696 offval = (struct wlan_offset_value *)pdata_buf;
697
698 switch (cmdptr->command) {
699 case CMD_MAC_REG_ACCESS:
700 {
701 struct cmd_ds_mac_reg_access *macreg;
702
703 cmdptr->size =
704 cpu_to_le16(sizeof (struct cmd_ds_mac_reg_access)
705 + S_DS_GEN);
706 macreg =
707 (struct cmd_ds_mac_reg_access *)&cmdptr->params.
708 macreg;
709
710 macreg->action = cpu_to_le16(cmd_action);
711 macreg->offset = cpu_to_le16((u16) offval->offset);
712 macreg->value = cpu_to_le32(offval->value);
713
714 break;
715 }
716
717 case CMD_BBP_REG_ACCESS:
718 {
719 struct cmd_ds_bbp_reg_access *bbpreg;
720
721 cmdptr->size =
722 cpu_to_le16(sizeof
723 (struct cmd_ds_bbp_reg_access)
724 + S_DS_GEN);
725 bbpreg =
726 (struct cmd_ds_bbp_reg_access *)&cmdptr->params.
727 bbpreg;
728
729 bbpreg->action = cpu_to_le16(cmd_action);
730 bbpreg->offset = cpu_to_le16((u16) offval->offset);
731 bbpreg->value = (u8) offval->value;
732
733 break;
734 }
735
736 case CMD_RF_REG_ACCESS:
737 {
738 struct cmd_ds_rf_reg_access *rfreg;
739
740 cmdptr->size =
741 cpu_to_le16(sizeof
742 (struct cmd_ds_rf_reg_access) +
743 S_DS_GEN);
744 rfreg =
745 (struct cmd_ds_rf_reg_access *)&cmdptr->params.
746 rfreg;
747
748 rfreg->action = cpu_to_le16(cmd_action);
749 rfreg->offset = cpu_to_le16((u16) offval->offset);
750 rfreg->value = (u8) offval->value;
751
752 break;
753 }
754
755 default:
756 break;
757 }
758
759 lbs_deb_leave(LBS_DEB_CMD);
760 return 0;
761 }
762
763 static int wlan_cmd_802_11_mac_address(wlan_private * priv,
764 struct cmd_ds_command *cmd,
765 u16 cmd_action)
766 {
767 wlan_adapter *adapter = priv->adapter;
768
769 cmd->command = cpu_to_le16(CMD_802_11_MAC_ADDRESS);
770 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_mac_address) +
771 S_DS_GEN);
772 cmd->result = 0;
773
774 cmd->params.macadd.action = cpu_to_le16(cmd_action);
775
776 if (cmd_action == CMD_ACT_SET) {
777 memcpy(cmd->params.macadd.macadd,
778 adapter->current_addr, ETH_ALEN);
779 lbs_dbg_hex("SET_CMD: MAC ADDRESS-", adapter->current_addr, 6);
780 }
781
782 return 0;
783 }
784
785 static int wlan_cmd_802_11_eeprom_access(wlan_private * priv,
786 struct cmd_ds_command *cmd,
787 int cmd_action, void *pdata_buf)
788 {
789 struct wlan_ioctl_regrdwr *ea = pdata_buf;
790
791 lbs_deb_enter(LBS_DEB_CMD);
792
793 cmd->command = cpu_to_le16(CMD_802_11_EEPROM_ACCESS);
794 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_eeprom_access) +
795 S_DS_GEN);
796 cmd->result = 0;
797
798 cmd->params.rdeeprom.action = cpu_to_le16(ea->action);
799 cmd->params.rdeeprom.offset = cpu_to_le16(ea->offset);
800 cmd->params.rdeeprom.bytecount = cpu_to_le16(ea->NOB);
801 cmd->params.rdeeprom.value = 0;
802
803 return 0;
804 }
805
806 static int wlan_cmd_bt_access(wlan_private * priv,
807 struct cmd_ds_command *cmd,
808 u16 cmd_action, void *pdata_buf)
809 {
810 struct cmd_ds_bt_access *bt_access = &cmd->params.bt;
811 lbs_deb_cmd("BT CMD(%d)\n", cmd_action);
812
813 cmd->command = cpu_to_le16(CMD_BT_ACCESS);
814 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_bt_access) + S_DS_GEN);
815 cmd->result = 0;
816 bt_access->action = cpu_to_le16(cmd_action);
817
818 switch (cmd_action) {
819 case CMD_ACT_BT_ACCESS_ADD:
820 memcpy(bt_access->addr1, pdata_buf, 2 * ETH_ALEN);
821 lbs_dbg_hex("BT_ADD: blinded mac address-", bt_access->addr1, 6);
822 break;
823 case CMD_ACT_BT_ACCESS_DEL:
824 memcpy(bt_access->addr1, pdata_buf, 1 * ETH_ALEN);
825 lbs_dbg_hex("BT_DEL: blinded mac address-", bt_access->addr1, 6);
826 break;
827 case CMD_ACT_BT_ACCESS_LIST:
828 bt_access->id = cpu_to_le32(*(u32 *) pdata_buf);
829 break;
830 case CMD_ACT_BT_ACCESS_RESET:
831 break;
832 case CMD_ACT_BT_ACCESS_SET_INVERT:
833 bt_access->id = cpu_to_le32(*(u32 *) pdata_buf);
834 break;
835 case CMD_ACT_BT_ACCESS_GET_INVERT:
836 break;
837 default:
838 break;
839 }
840 return 0;
841 }
842
843 static int wlan_cmd_fwt_access(wlan_private * priv,
844 struct cmd_ds_command *cmd,
845 u16 cmd_action, void *pdata_buf)
846 {
847 struct cmd_ds_fwt_access *fwt_access = &cmd->params.fwt;
848 lbs_deb_cmd("FWT CMD(%d)\n", cmd_action);
849
850 cmd->command = cpu_to_le16(CMD_FWT_ACCESS);
851 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_fwt_access) + S_DS_GEN);
852 cmd->result = 0;
853
854 if (pdata_buf)
855 memcpy(fwt_access, pdata_buf, sizeof(*fwt_access));
856 else
857 memset(fwt_access, 0, sizeof(*fwt_access));
858
859 fwt_access->action = cpu_to_le16(cmd_action);
860
861 return 0;
862 }
863
864 static int wlan_cmd_mesh_access(wlan_private * priv,
865 struct cmd_ds_command *cmd,
866 u16 cmd_action, void *pdata_buf)
867 {
868 struct cmd_ds_mesh_access *mesh_access = &cmd->params.mesh;
869 lbs_deb_cmd("FWT CMD(%d)\n", cmd_action);
870
871 cmd->command = cpu_to_le16(CMD_MESH_ACCESS);
872 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mesh_access) + S_DS_GEN);
873 cmd->result = 0;
874
875 if (pdata_buf)
876 memcpy(mesh_access, pdata_buf, sizeof(*mesh_access));
877 else
878 memset(mesh_access, 0, sizeof(*mesh_access));
879
880 mesh_access->action = cpu_to_le16(cmd_action);
881
882 return 0;
883 }
884
885 void libertas_queue_cmd(wlan_adapter * adapter, struct cmd_ctrl_node *cmdnode, u8 addtail)
886 {
887 unsigned long flags;
888 struct cmd_ds_command *cmdptr;
889
890 lbs_deb_enter(LBS_DEB_CMD);
891
892 if (!cmdnode) {
893 lbs_deb_cmd("QUEUE_CMD: cmdnode is NULL\n");
894 goto done;
895 }
896
897 cmdptr = (struct cmd_ds_command *)cmdnode->bufvirtualaddr;
898 if (!cmdptr) {
899 lbs_deb_cmd("QUEUE_CMD: cmdptr is NULL\n");
900 goto done;
901 }
902
903 /* Exit_PS command needs to be queued in the header always. */
904 if (cmdptr->command == CMD_802_11_PS_MODE) {
905 struct cmd_ds_802_11_ps_mode *psm = &cmdptr->params.psmode;
906 if (psm->action == cpu_to_le16(CMD_SUBCMD_EXIT_PS)) {
907 if (adapter->psstate != PS_STATE_FULL_POWER)
908 addtail = 0;
909 }
910 }
911
912 spin_lock_irqsave(&adapter->driver_lock, flags);
913
914 if (addtail)
915 list_add_tail((struct list_head *)cmdnode,
916 &adapter->cmdpendingq);
917 else
918 list_add((struct list_head *)cmdnode, &adapter->cmdpendingq);
919
920 spin_unlock_irqrestore(&adapter->driver_lock, flags);
921
922 lbs_deb_cmd("QUEUE_CMD: Inserted node=%p, cmd=0x%x in cmdpendingq\n",
923 cmdnode,
924 le16_to_cpu(((struct cmd_ds_gen*)cmdnode->bufvirtualaddr)->command));
925
926 done:
927 lbs_deb_leave(LBS_DEB_CMD);
928 }
929
930 /*
931 * TODO: Fix the issue when DownloadcommandToStation is being called the
932 * second time when the command timesout. All the cmdptr->xxx are in little
933 * endian and therefore all the comparissions will fail.
934 * For now - we are not performing the endian conversion the second time - but
935 * for PS and DEEP_SLEEP we need to worry
936 */
937 static int DownloadcommandToStation(wlan_private * priv,
938 struct cmd_ctrl_node *cmdnode)
939 {
940 unsigned long flags;
941 struct cmd_ds_command *cmdptr;
942 wlan_adapter *adapter = priv->adapter;
943 int ret = 0;
944 u16 cmdsize;
945 u16 command;
946
947 lbs_deb_enter(LBS_DEB_CMD);
948
949 if (!adapter || !cmdnode) {
950 lbs_deb_cmd("DNLD_CMD: adapter = %p, cmdnode = %p\n",
951 adapter, cmdnode);
952 if (cmdnode) {
953 spin_lock_irqsave(&adapter->driver_lock, flags);
954 __libertas_cleanup_and_insert_cmd(priv, cmdnode);
955 spin_unlock_irqrestore(&adapter->driver_lock, flags);
956 }
957 ret = -1;
958 goto done;
959 }
960
961 cmdptr = (struct cmd_ds_command *)cmdnode->bufvirtualaddr;
962
963
964 spin_lock_irqsave(&adapter->driver_lock, flags);
965 if (!cmdptr || !cmdptr->size) {
966 lbs_deb_cmd("DNLD_CMD: cmdptr is Null or cmd size is Zero, "
967 "Not sending\n");
968 __libertas_cleanup_and_insert_cmd(priv, cmdnode);
969 spin_unlock_irqrestore(&adapter->driver_lock, flags);
970 ret = -1;
971 goto done;
972 }
973
974 adapter->cur_cmd = cmdnode;
975 adapter->cur_cmd_retcode = 0;
976 spin_unlock_irqrestore(&adapter->driver_lock, flags);
977 lbs_deb_cmd("DNLD_CMD:: Before download, size of cmd = %d\n",
978 le16_to_cpu(cmdptr->size));
979
980 cmdsize = cmdptr->size;
981
982 command = cpu_to_le16(cmdptr->command);
983
984 cmdnode->cmdwaitqwoken = 0;
985 cmdsize = cpu_to_le16(cmdsize);
986
987 ret = priv->hw_host_to_card(priv, MVMS_CMD, (u8 *) cmdptr, cmdsize);
988
989 if (ret != 0) {
990 lbs_deb_cmd("DNLD_CMD: Host to Card failed\n");
991 spin_lock_irqsave(&adapter->driver_lock, flags);
992 __libertas_cleanup_and_insert_cmd(priv, adapter->cur_cmd);
993 adapter->cur_cmd = NULL;
994 spin_unlock_irqrestore(&adapter->driver_lock, flags);
995 ret = -1;
996 goto done;
997 }
998
999 lbs_deb_cmd("DNLD_CMD: Sent command 0x%x @ %lu\n", command, jiffies);
1000 lbs_dbg_hex("DNLD_CMD: command", cmdnode->bufvirtualaddr, cmdsize);
1001
1002 /* Setup the timer after transmit command */
1003 if (command == CMD_802_11_SCAN || command == CMD_802_11_AUTHENTICATE
1004 || command == CMD_802_11_ASSOCIATE)
1005 mod_timer(&adapter->command_timer, jiffies + (10*HZ));
1006 else
1007 mod_timer(&adapter->command_timer, jiffies + (5*HZ));
1008
1009 ret = 0;
1010
1011 done:
1012 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
1013 return ret;
1014 }
1015
1016 static int wlan_cmd_mac_control(wlan_private * priv,
1017 struct cmd_ds_command *cmd)
1018 {
1019 struct cmd_ds_mac_control *mac = &cmd->params.macctrl;
1020
1021 lbs_deb_enter(LBS_DEB_CMD);
1022
1023 cmd->command = cpu_to_le16(CMD_MAC_CONTROL);
1024 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mac_control) + S_DS_GEN);
1025 mac->action = cpu_to_le16(priv->adapter->currentpacketfilter);
1026
1027 lbs_deb_cmd("wlan_cmd_mac_control(): action=0x%X size=%d\n",
1028 le16_to_cpu(mac->action), le16_to_cpu(cmd->size));
1029
1030 lbs_deb_leave(LBS_DEB_CMD);
1031 return 0;
1032 }
1033
1034 /**
1035 * This function inserts command node to cmdfreeq
1036 * after cleans it. Requires adapter->driver_lock held.
1037 */
1038 void __libertas_cleanup_and_insert_cmd(wlan_private * priv, struct cmd_ctrl_node *ptempcmd)
1039 {
1040 wlan_adapter *adapter = priv->adapter;
1041
1042 if (!ptempcmd)
1043 goto done;
1044
1045 cleanup_cmdnode(ptempcmd);
1046 list_add_tail((struct list_head *)ptempcmd, &adapter->cmdfreeq);
1047 done:
1048 return;
1049 }
1050
1051 void libertas_cleanup_and_insert_cmd(wlan_private * priv, struct cmd_ctrl_node *ptempcmd)
1052 {
1053 unsigned long flags;
1054
1055 spin_lock_irqsave(&priv->adapter->driver_lock, flags);
1056 __libertas_cleanup_and_insert_cmd(priv, ptempcmd);
1057 spin_unlock_irqrestore(&priv->adapter->driver_lock, flags);
1058 }
1059
1060 int libertas_set_radio_control(wlan_private * priv)
1061 {
1062 int ret = 0;
1063
1064 lbs_deb_enter(LBS_DEB_CMD);
1065
1066 ret = libertas_prepare_and_send_command(priv,
1067 CMD_802_11_RADIO_CONTROL,
1068 CMD_ACT_SET,
1069 CMD_OPTION_WAITFORRSP, 0, NULL);
1070
1071 lbs_deb_cmd("RADIO_SET: on or off: 0x%X, preamble = 0x%X\n",
1072 priv->adapter->radioon, priv->adapter->preamble);
1073
1074 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
1075 return ret;
1076 }
1077
1078 int libertas_set_mac_packet_filter(wlan_private * priv)
1079 {
1080 int ret = 0;
1081
1082 lbs_deb_enter(LBS_DEB_CMD);
1083
1084 lbs_deb_cmd("libertas_set_mac_packet_filter value = %x\n",
1085 priv->adapter->currentpacketfilter);
1086
1087 /* Send MAC control command to station */
1088 ret = libertas_prepare_and_send_command(priv,
1089 CMD_MAC_CONTROL, 0, 0, 0, NULL);
1090
1091 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
1092 return ret;
1093 }
1094
1095 /**
1096 * @brief This function prepare the command before send to firmware.
1097 *
1098 * @param priv A pointer to wlan_private structure
1099 * @param cmd_no command number
1100 * @param cmd_action command action: GET or SET
1101 * @param wait_option wait option: wait response or not
1102 * @param cmd_oid cmd oid: treated as sub command
1103 * @param pdata_buf A pointer to informaion buffer
1104 * @return 0 or -1
1105 */
1106 int libertas_prepare_and_send_command(wlan_private * priv,
1107 u16 cmd_no,
1108 u16 cmd_action,
1109 u16 wait_option, u32 cmd_oid, void *pdata_buf)
1110 {
1111 int ret = 0;
1112 wlan_adapter *adapter = priv->adapter;
1113 struct cmd_ctrl_node *cmdnode;
1114 struct cmd_ds_command *cmdptr;
1115 unsigned long flags;
1116
1117 lbs_deb_enter(LBS_DEB_CMD);
1118
1119 if (!adapter) {
1120 lbs_deb_cmd("PREP_CMD: adapter is Null\n");
1121 ret = -1;
1122 goto done;
1123 }
1124
1125 if (adapter->surpriseremoved) {
1126 lbs_deb_cmd("PREP_CMD: Card is Removed\n");
1127 ret = -1;
1128 goto done;
1129 }
1130
1131 cmdnode = libertas_get_free_cmd_ctrl_node(priv);
1132
1133 if (cmdnode == NULL) {
1134 lbs_deb_cmd("PREP_CMD: No free cmdnode\n");
1135
1136 /* Wake up main thread to execute next command */
1137 wake_up_interruptible(&priv->waitq);
1138 ret = -1;
1139 goto done;
1140 }
1141
1142 libertas_set_cmd_ctrl_node(priv, cmdnode, cmd_oid, wait_option, pdata_buf);
1143
1144 cmdptr = (struct cmd_ds_command *)cmdnode->bufvirtualaddr;
1145
1146 lbs_deb_cmd("PREP_CMD: Val of cmd ptr=%p, command=0x%X\n",
1147 cmdptr, cmd_no);
1148
1149 if (!cmdptr) {
1150 lbs_deb_cmd("PREP_CMD: bufvirtualaddr of cmdnode is NULL\n");
1151 libertas_cleanup_and_insert_cmd(priv, cmdnode);
1152 ret = -1;
1153 goto done;
1154 }
1155
1156 /* Set sequence number, command and INT option */
1157 adapter->seqnum++;
1158 cmdptr->seqnum = cpu_to_le16(adapter->seqnum);
1159
1160 cmdptr->command = cpu_to_le16(cmd_no);
1161 cmdptr->result = 0;
1162
1163 switch (cmd_no) {
1164 case CMD_GET_HW_SPEC:
1165 ret = wlan_cmd_hw_spec(priv, cmdptr);
1166 break;
1167 case CMD_802_11_PS_MODE:
1168 ret = wlan_cmd_802_11_ps_mode(priv, cmdptr, cmd_action);
1169 break;
1170
1171 case CMD_802_11_SCAN:
1172 ret = libertas_cmd_80211_scan(priv, cmdptr, pdata_buf);
1173 break;
1174
1175 case CMD_MAC_CONTROL:
1176 ret = wlan_cmd_mac_control(priv, cmdptr);
1177 break;
1178
1179 case CMD_802_11_ASSOCIATE:
1180 case CMD_802_11_REASSOCIATE:
1181 ret = libertas_cmd_80211_associate(priv, cmdptr, pdata_buf);
1182 break;
1183
1184 case CMD_802_11_DEAUTHENTICATE:
1185 ret = libertas_cmd_80211_deauthenticate(priv, cmdptr);
1186 break;
1187
1188 case CMD_802_11_SET_WEP:
1189 ret = wlan_cmd_802_11_set_wep(priv, cmdptr, cmd_action, pdata_buf);
1190 break;
1191
1192 case CMD_802_11_AD_HOC_START:
1193 ret = libertas_cmd_80211_ad_hoc_start(priv, cmdptr, pdata_buf);
1194 break;
1195 case CMD_CODE_DNLD:
1196 break;
1197
1198 case CMD_802_11_RESET:
1199 ret = wlan_cmd_802_11_reset(priv, cmdptr, cmd_action);
1200 break;
1201
1202 case CMD_802_11_GET_LOG:
1203 ret = wlan_cmd_802_11_get_log(priv, cmdptr);
1204 break;
1205
1206 case CMD_802_11_AUTHENTICATE:
1207 ret = libertas_cmd_80211_authenticate(priv, cmdptr, pdata_buf);
1208 break;
1209
1210 case CMD_802_11_GET_STAT:
1211 ret = wlan_cmd_802_11_get_stat(priv, cmdptr);
1212 break;
1213
1214 case CMD_802_11_SNMP_MIB:
1215 ret = wlan_cmd_802_11_snmp_mib(priv, cmdptr,
1216 cmd_action, cmd_oid, pdata_buf);
1217 break;
1218
1219 case CMD_MAC_REG_ACCESS:
1220 case CMD_BBP_REG_ACCESS:
1221 case CMD_RF_REG_ACCESS:
1222 ret = wlan_cmd_reg_access(priv, cmdptr, cmd_action, pdata_buf);
1223 break;
1224
1225 case CMD_802_11_RF_CHANNEL:
1226 ret = wlan_cmd_802_11_rf_channel(priv, cmdptr,
1227 cmd_action, pdata_buf);
1228 break;
1229
1230 case CMD_802_11_RF_TX_POWER:
1231 ret = wlan_cmd_802_11_rf_tx_power(priv, cmdptr,
1232 cmd_action, pdata_buf);
1233 break;
1234
1235 case CMD_802_11_RADIO_CONTROL:
1236 ret = wlan_cmd_802_11_radio_control(priv, cmdptr, cmd_action);
1237 break;
1238
1239 case CMD_802_11_RF_ANTENNA:
1240 ret = wlan_cmd_802_11_rf_antenna(priv, cmdptr,
1241 cmd_action, pdata_buf);
1242 break;
1243
1244 case CMD_802_11_DATA_RATE:
1245 ret = wlan_cmd_802_11_data_rate(priv, cmdptr, cmd_action);
1246 break;
1247 case CMD_802_11_RATE_ADAPT_RATESET:
1248 ret = wlan_cmd_802_11_rate_adapt_rateset(priv,
1249 cmdptr, cmd_action);
1250 break;
1251
1252 case CMD_MAC_MULTICAST_ADR:
1253 ret = wlan_cmd_mac_multicast_adr(priv, cmdptr, cmd_action);
1254 break;
1255
1256 case CMD_802_11_AD_HOC_JOIN:
1257 ret = libertas_cmd_80211_ad_hoc_join(priv, cmdptr, pdata_buf);
1258 break;
1259
1260 case CMD_802_11_RSSI:
1261 ret = wlan_cmd_802_11_rssi(priv, cmdptr);
1262 break;
1263
1264 case CMD_802_11_AD_HOC_STOP:
1265 ret = libertas_cmd_80211_ad_hoc_stop(priv, cmdptr);
1266 break;
1267
1268 case CMD_802_11_ENABLE_RSN:
1269 ret = wlan_cmd_802_11_enable_rsn(priv, cmdptr, cmd_action,
1270 pdata_buf);
1271 break;
1272
1273 case CMD_802_11_KEY_MATERIAL:
1274 ret = wlan_cmd_802_11_key_material(priv, cmdptr, cmd_action,
1275 cmd_oid, pdata_buf);
1276 break;
1277
1278 case CMD_802_11_PAIRWISE_TSC:
1279 break;
1280 case CMD_802_11_GROUP_TSC:
1281 break;
1282
1283 case CMD_802_11_MAC_ADDRESS:
1284 ret = wlan_cmd_802_11_mac_address(priv, cmdptr, cmd_action);
1285 break;
1286
1287 case CMD_802_11_EEPROM_ACCESS:
1288 ret = wlan_cmd_802_11_eeprom_access(priv, cmdptr,
1289 cmd_action, pdata_buf);
1290 break;
1291
1292 case CMD_802_11_SET_AFC:
1293 case CMD_802_11_GET_AFC:
1294
1295 cmdptr->command = cpu_to_le16(cmd_no);
1296 cmdptr->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_afc) +
1297 S_DS_GEN);
1298
1299 memmove(&cmdptr->params.afc,
1300 pdata_buf, sizeof(struct cmd_ds_802_11_afc));
1301
1302 ret = 0;
1303 goto done;
1304
1305 case CMD_802_11D_DOMAIN_INFO:
1306 ret = libertas_cmd_802_11d_domain_info(priv, cmdptr,
1307 cmd_no, cmd_action);
1308 break;
1309
1310 case CMD_802_11_SLEEP_PARAMS:
1311 ret = wlan_cmd_802_11_sleep_params(priv, cmdptr, cmd_action);
1312 break;
1313 case CMD_802_11_INACTIVITY_TIMEOUT:
1314 ret = wlan_cmd_802_11_inactivity_timeout(priv, cmdptr,
1315 cmd_action, pdata_buf);
1316 libertas_set_cmd_ctrl_node(priv, cmdnode, 0, 0, pdata_buf);
1317 break;
1318
1319 case CMD_802_11_TPC_CFG:
1320 cmdptr->command = cpu_to_le16(CMD_802_11_TPC_CFG);
1321 cmdptr->size =
1322 cpu_to_le16(sizeof(struct cmd_ds_802_11_tpc_cfg) +
1323 S_DS_GEN);
1324
1325 memmove(&cmdptr->params.tpccfg,
1326 pdata_buf, sizeof(struct cmd_ds_802_11_tpc_cfg));
1327
1328 ret = 0;
1329 break;
1330 case CMD_802_11_LED_GPIO_CTRL:
1331 {
1332 struct mrvlietypes_ledgpio *gpio =
1333 (struct mrvlietypes_ledgpio*)
1334 cmdptr->params.ledgpio.data;
1335
1336 memmove(&cmdptr->params.ledgpio,
1337 pdata_buf,
1338 sizeof(struct cmd_ds_802_11_led_ctrl));
1339
1340 cmdptr->command =
1341 cpu_to_le16(CMD_802_11_LED_GPIO_CTRL);
1342
1343 #define ACTION_NUMLED_TLVTYPE_LEN_FIELDS_LEN 8
1344 cmdptr->size =
1345 cpu_to_le16(gpio->header.len + S_DS_GEN +
1346 ACTION_NUMLED_TLVTYPE_LEN_FIELDS_LEN);
1347 gpio->header.len = cpu_to_le16(gpio->header.len);
1348
1349 ret = 0;
1350 break;
1351 }
1352 case CMD_802_11_PWR_CFG:
1353 cmdptr->command = cpu_to_le16(CMD_802_11_PWR_CFG);
1354 cmdptr->size =
1355 cpu_to_le16(sizeof(struct cmd_ds_802_11_pwr_cfg) +
1356 S_DS_GEN);
1357 memmove(&cmdptr->params.pwrcfg, pdata_buf,
1358 sizeof(struct cmd_ds_802_11_pwr_cfg));
1359
1360 ret = 0;
1361 break;
1362 case CMD_BT_ACCESS:
1363 ret = wlan_cmd_bt_access(priv, cmdptr, cmd_action, pdata_buf);
1364 break;
1365
1366 case CMD_FWT_ACCESS:
1367 ret = wlan_cmd_fwt_access(priv, cmdptr, cmd_action, pdata_buf);
1368 break;
1369
1370 case CMD_MESH_ACCESS:
1371 ret = wlan_cmd_mesh_access(priv, cmdptr, cmd_action, pdata_buf);
1372 break;
1373
1374 case CMD_GET_TSF:
1375 cmdptr->command = cpu_to_le16(CMD_GET_TSF);
1376 cmdptr->size = cpu_to_le16(sizeof(struct cmd_ds_get_tsf) +
1377 S_DS_GEN);
1378 ret = 0;
1379 break;
1380 case CMD_802_11_TX_RATE_QUERY:
1381 cmdptr->command = cpu_to_le16(CMD_802_11_TX_RATE_QUERY);
1382 cmdptr->size = cpu_to_le16(sizeof(struct cmd_tx_rate_query) +
1383 S_DS_GEN);
1384 adapter->txrate = 0;
1385 ret = 0;
1386 break;
1387 default:
1388 lbs_deb_cmd("PREP_CMD: unknown command- %#x\n", cmd_no);
1389 ret = -1;
1390 break;
1391 }
1392
1393 /* return error, since the command preparation failed */
1394 if (ret != 0) {
1395 lbs_deb_cmd("PREP_CMD: command preparation failed\n");
1396 libertas_cleanup_and_insert_cmd(priv, cmdnode);
1397 ret = -1;
1398 goto done;
1399 }
1400
1401 cmdnode->cmdwaitqwoken = 0;
1402
1403 libertas_queue_cmd(adapter, cmdnode, 1);
1404 adapter->nr_cmd_pending++;
1405 wake_up_interruptible(&priv->waitq);
1406
1407 if (wait_option & CMD_OPTION_WAITFORRSP) {
1408 lbs_deb_cmd("PREP_CMD: Wait for CMD response\n");
1409 might_sleep();
1410 wait_event_interruptible(cmdnode->cmdwait_q,
1411 cmdnode->cmdwaitqwoken);
1412 }
1413
1414 spin_lock_irqsave(&adapter->driver_lock, flags);
1415 if (adapter->cur_cmd_retcode) {
1416 lbs_deb_cmd("PREP_CMD: command failed with return code=%d\n",
1417 adapter->cur_cmd_retcode);
1418 adapter->cur_cmd_retcode = 0;
1419 ret = -1;
1420 }
1421 spin_unlock_irqrestore(&adapter->driver_lock, flags);
1422
1423 done:
1424 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
1425 return ret;
1426 }
1427 EXPORT_SYMBOL_GPL(libertas_prepare_and_send_command);
1428
1429 /**
1430 * @brief This function allocates the command buffer and link
1431 * it to command free queue.
1432 *
1433 * @param priv A pointer to wlan_private structure
1434 * @return 0 or -1
1435 */
1436 int libertas_allocate_cmd_buffer(wlan_private * priv)
1437 {
1438 int ret = 0;
1439 u32 ulbufsize;
1440 u32 i;
1441 struct cmd_ctrl_node *tempcmd_array;
1442 u8 *ptempvirtualaddr;
1443 wlan_adapter *adapter = priv->adapter;
1444
1445 lbs_deb_enter(LBS_DEB_CMD);
1446
1447 /* Allocate and initialize cmdCtrlNode */
1448 ulbufsize = sizeof(struct cmd_ctrl_node) * MRVDRV_NUM_OF_CMD_BUFFER;
1449
1450 if (!(tempcmd_array = kzalloc(ulbufsize, GFP_KERNEL))) {
1451 lbs_deb_cmd(
1452 "ALLOC_CMD_BUF: failed to allocate tempcmd_array\n");
1453 ret = -1;
1454 goto done;
1455 }
1456 adapter->cmd_array = tempcmd_array;
1457
1458 /* Allocate and initialize command buffers */
1459 ulbufsize = MRVDRV_SIZE_OF_CMD_BUFFER;
1460 for (i = 0; i < MRVDRV_NUM_OF_CMD_BUFFER; i++) {
1461 if (!(ptempvirtualaddr = kzalloc(ulbufsize, GFP_KERNEL))) {
1462 lbs_deb_cmd(
1463 "ALLOC_CMD_BUF: ptempvirtualaddr: out of memory\n");
1464 ret = -1;
1465 goto done;
1466 }
1467
1468 /* Update command buffer virtual */
1469 tempcmd_array[i].bufvirtualaddr = ptempvirtualaddr;
1470 }
1471
1472 for (i = 0; i < MRVDRV_NUM_OF_CMD_BUFFER; i++) {
1473 init_waitqueue_head(&tempcmd_array[i].cmdwait_q);
1474 libertas_cleanup_and_insert_cmd(priv, &tempcmd_array[i]);
1475 }
1476
1477 ret = 0;
1478
1479 done:
1480 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
1481 return ret;
1482 }
1483
1484 /**
1485 * @brief This function frees the command buffer.
1486 *
1487 * @param priv A pointer to wlan_private structure
1488 * @return 0 or -1
1489 */
1490 int libertas_free_cmd_buffer(wlan_private * priv)
1491 {
1492 u32 ulbufsize; /* Someone needs to die for this. Slowly and painfully */
1493 unsigned int i;
1494 struct cmd_ctrl_node *tempcmd_array;
1495 wlan_adapter *adapter = priv->adapter;
1496
1497 lbs_deb_enter(LBS_DEB_CMD);
1498
1499 /* need to check if cmd array is allocated or not */
1500 if (adapter->cmd_array == NULL) {
1501 lbs_deb_cmd("FREE_CMD_BUF: cmd_array is Null\n");
1502 goto done;
1503 }
1504
1505 tempcmd_array = adapter->cmd_array;
1506
1507 /* Release shared memory buffers */
1508 ulbufsize = MRVDRV_SIZE_OF_CMD_BUFFER;
1509 for (i = 0; i < MRVDRV_NUM_OF_CMD_BUFFER; i++) {
1510 if (tempcmd_array[i].bufvirtualaddr) {
1511 lbs_deb_cmd("Free all the array\n");
1512 kfree(tempcmd_array[i].bufvirtualaddr);
1513 tempcmd_array[i].bufvirtualaddr = NULL;
1514 }
1515 }
1516
1517 /* Release cmd_ctrl_node */
1518 if (adapter->cmd_array) {
1519 lbs_deb_cmd("Free cmd_array\n");
1520 kfree(adapter->cmd_array);
1521 adapter->cmd_array = NULL;
1522 }
1523
1524 done:
1525 lbs_deb_leave(LBS_DEB_CMD);
1526 return 0;
1527 }
1528
1529 /**
1530 * @brief This function gets a free command node if available in
1531 * command free queue.
1532 *
1533 * @param priv A pointer to wlan_private structure
1534 * @return cmd_ctrl_node A pointer to cmd_ctrl_node structure or NULL
1535 */
1536 struct cmd_ctrl_node *libertas_get_free_cmd_ctrl_node(wlan_private * priv)
1537 {
1538 struct cmd_ctrl_node *tempnode;
1539 wlan_adapter *adapter = priv->adapter;
1540 unsigned long flags;
1541
1542 if (!adapter)
1543 return NULL;
1544
1545 spin_lock_irqsave(&adapter->driver_lock, flags);
1546
1547 if (!list_empty(&adapter->cmdfreeq)) {
1548 tempnode = (struct cmd_ctrl_node *)adapter->cmdfreeq.next;
1549 list_del((struct list_head *)tempnode);
1550 } else {
1551 lbs_deb_cmd("GET_CMD_NODE: cmd_ctrl_node is not available\n");
1552 tempnode = NULL;
1553 }
1554
1555 spin_unlock_irqrestore(&adapter->driver_lock, flags);
1556
1557 if (tempnode) {
1558 /*
1559 lbs_pr_debug(3, "GET_CMD_NODE: cmdCtrlNode available\n");
1560 lbs_pr_debug(3, "GET_CMD_NODE: cmdCtrlNode Address = %p\n",
1561 tempnode);
1562 */
1563 cleanup_cmdnode(tempnode);
1564 }
1565
1566 return tempnode;
1567 }
1568
1569 /**
1570 * @brief This function cleans command node.
1571 *
1572 * @param ptempnode A pointer to cmdCtrlNode structure
1573 * @return n/a
1574 */
1575 static void cleanup_cmdnode(struct cmd_ctrl_node *ptempnode)
1576 {
1577 if (!ptempnode)
1578 return;
1579 ptempnode->cmdwaitqwoken = 1;
1580 wake_up_interruptible(&ptempnode->cmdwait_q);
1581 ptempnode->status = 0;
1582 ptempnode->cmd_oid = (u32) 0;
1583 ptempnode->wait_option = 0;
1584 ptempnode->pdata_buf = NULL;
1585
1586 if (ptempnode->bufvirtualaddr != NULL)
1587 memset(ptempnode->bufvirtualaddr, 0, MRVDRV_SIZE_OF_CMD_BUFFER);
1588 return;
1589 }
1590
1591 /**
1592 * @brief This function initializes the command node.
1593 *
1594 * @param priv A pointer to wlan_private structure
1595 * @param ptempnode A pointer to cmd_ctrl_node structure
1596 * @param cmd_oid cmd oid: treated as sub command
1597 * @param wait_option wait option: wait response or not
1598 * @param pdata_buf A pointer to informaion buffer
1599 * @return 0 or -1
1600 */
1601 void libertas_set_cmd_ctrl_node(wlan_private * priv,
1602 struct cmd_ctrl_node *ptempnode,
1603 u32 cmd_oid, u16 wait_option, void *pdata_buf)
1604 {
1605 lbs_deb_enter(LBS_DEB_CMD);
1606
1607 if (!ptempnode)
1608 return;
1609
1610 ptempnode->cmd_oid = cmd_oid;
1611 ptempnode->wait_option = wait_option;
1612 ptempnode->pdata_buf = pdata_buf;
1613
1614 lbs_deb_leave(LBS_DEB_CMD);
1615 }
1616
1617 /**
1618 * @brief This function executes next command in command
1619 * pending queue. It will put fimware back to PS mode
1620 * if applicable.
1621 *
1622 * @param priv A pointer to wlan_private structure
1623 * @return 0 or -1
1624 */
1625 int libertas_execute_next_command(wlan_private * priv)
1626 {
1627 wlan_adapter *adapter = priv->adapter;
1628 struct cmd_ctrl_node *cmdnode = NULL;
1629 struct cmd_ds_command *cmdptr;
1630 unsigned long flags;
1631 int ret = 0;
1632
1633 lbs_deb_enter(LBS_DEB_CMD);
1634
1635 spin_lock_irqsave(&adapter->driver_lock, flags);
1636
1637 if (adapter->cur_cmd) {
1638 lbs_pr_alert( "EXEC_NEXT_CMD: there is command in processing!\n");
1639 spin_unlock_irqrestore(&adapter->driver_lock, flags);
1640 ret = -1;
1641 goto done;
1642 }
1643
1644 if (!list_empty(&adapter->cmdpendingq)) {
1645 cmdnode = (struct cmd_ctrl_node *)
1646 adapter->cmdpendingq.next;
1647 }
1648
1649 spin_unlock_irqrestore(&adapter->driver_lock, flags);
1650
1651 if (cmdnode) {
1652 lbs_deb_cmd(
1653 "EXEC_NEXT_CMD: Got next command from cmdpendingq\n");
1654 cmdptr = (struct cmd_ds_command *)cmdnode->bufvirtualaddr;
1655
1656 if (is_command_allowed_in_ps(cmdptr->command)) {
1657 if ((adapter->psstate == PS_STATE_SLEEP) ||
1658 (adapter->psstate == PS_STATE_PRE_SLEEP)) {
1659 lbs_deb_cmd(
1660 "EXEC_NEXT_CMD: Cannot send cmd 0x%x in psstate %d\n",
1661 le16_to_cpu(cmdptr->command),
1662 adapter->psstate);
1663 ret = -1;
1664 goto done;
1665 }
1666 lbs_deb_cmd("EXEC_NEXT_CMD: OK to send command "
1667 "0x%x in psstate %d\n",
1668 le16_to_cpu(cmdptr->command),
1669 adapter->psstate);
1670 } else if (adapter->psstate != PS_STATE_FULL_POWER) {
1671 /*
1672 * 1. Non-PS command:
1673 * Queue it. set needtowakeup to TRUE if current state
1674 * is SLEEP, otherwise call libertas_ps_wakeup to send Exit_PS.
1675 * 2. PS command but not Exit_PS:
1676 * Ignore it.
1677 * 3. PS command Exit_PS:
1678 * Set needtowakeup to TRUE if current state is SLEEP,
1679 * otherwise send this command down to firmware
1680 * immediately.
1681 */
1682 if (cmdptr->command !=
1683 cpu_to_le16(CMD_802_11_PS_MODE)) {
1684 /* Prepare to send Exit PS,
1685 * this non PS command will be sent later */
1686 if ((adapter->psstate == PS_STATE_SLEEP)
1687 || (adapter->psstate == PS_STATE_PRE_SLEEP)
1688 ) {
1689 /* w/ new scheme, it will not reach here.
1690 since it is blocked in main_thread. */
1691 adapter->needtowakeup = 1;
1692 } else
1693 libertas_ps_wakeup(priv, 0);
1694
1695 ret = 0;
1696 goto done;
1697 } else {
1698 /*
1699 * PS command. Ignore it if it is not Exit_PS.
1700 * otherwise send it down immediately.
1701 */
1702 struct cmd_ds_802_11_ps_mode *psm =
1703 &cmdptr->params.psmode;
1704
1705 lbs_deb_cmd(
1706 "EXEC_NEXT_CMD: PS cmd- action=0x%x\n",
1707 psm->action);
1708 if (psm->action !=
1709 cpu_to_le16(CMD_SUBCMD_EXIT_PS)) {
1710 lbs_deb_cmd(
1711 "EXEC_NEXT_CMD: Ignore Enter PS cmd\n");
1712 list_del((struct list_head *)cmdnode);
1713 libertas_cleanup_and_insert_cmd(priv, cmdnode);
1714
1715 ret = 0;
1716 goto done;
1717 }
1718
1719 if ((adapter->psstate == PS_STATE_SLEEP) ||
1720 (adapter->psstate == PS_STATE_PRE_SLEEP)) {
1721 lbs_deb_cmd(
1722 "EXEC_NEXT_CMD: Ignore ExitPS cmd in sleep\n");
1723 list_del((struct list_head *)cmdnode);
1724 libertas_cleanup_and_insert_cmd(priv, cmdnode);
1725 adapter->needtowakeup = 1;
1726
1727 ret = 0;
1728 goto done;
1729 }
1730
1731 lbs_deb_cmd(
1732 "EXEC_NEXT_CMD: Sending Exit_PS down...\n");
1733 }
1734 }
1735 list_del((struct list_head *)cmdnode);
1736 lbs_deb_cmd("EXEC_NEXT_CMD: Sending 0x%04X command\n",
1737 le16_to_cpu(cmdptr->command));
1738 DownloadcommandToStation(priv, cmdnode);
1739 } else {
1740 /*
1741 * check if in power save mode, if yes, put the device back
1742 * to PS mode
1743 */
1744 if ((adapter->psmode != WLAN802_11POWERMODECAM) &&
1745 (adapter->psstate == PS_STATE_FULL_POWER) &&
1746 (adapter->connect_status == LIBERTAS_CONNECTED)) {
1747 if (adapter->secinfo.WPAenabled ||
1748 adapter->secinfo.WPA2enabled) {
1749 /* check for valid WPA group keys */
1750 if (adapter->wpa_mcast_key.len ||
1751 adapter->wpa_unicast_key.len) {
1752 lbs_deb_cmd(
1753 "EXEC_NEXT_CMD: WPA enabled and GTK_SET"
1754 " go back to PS_SLEEP");
1755 libertas_ps_sleep(priv, 0);
1756 }
1757 } else {
1758 lbs_deb_cmd(
1759 "EXEC_NEXT_CMD: command PendQ is empty,"
1760 " go back to PS_SLEEP");
1761 libertas_ps_sleep(priv, 0);
1762 }
1763 }
1764 }
1765
1766 ret = 0;
1767 done:
1768 lbs_deb_leave(LBS_DEB_CMD);
1769 return ret;
1770 }
1771
1772 void libertas_send_iwevcustom_event(wlan_private * priv, s8 * str)
1773 {
1774 union iwreq_data iwrq;
1775 u8 buf[50];
1776
1777 lbs_deb_enter(LBS_DEB_CMD);
1778
1779 memset(&iwrq, 0, sizeof(union iwreq_data));
1780 memset(buf, 0, sizeof(buf));
1781
1782 snprintf(buf, sizeof(buf) - 1, "%s", str);
1783
1784 iwrq.data.length = strlen(buf) + 1 + IW_EV_LCP_LEN;
1785
1786 /* Send Event to upper layer */
1787 lbs_deb_cmd("Event Indication string = %s\n", (char *)buf);
1788 lbs_deb_cmd("Event Indication String length = %d\n", iwrq.data.length);
1789
1790 lbs_deb_cmd("Sending wireless event IWEVCUSTOM for %s\n", str);
1791 wireless_send_event(priv->dev, IWEVCUSTOM, &iwrq, buf);
1792
1793 lbs_deb_leave(LBS_DEB_CMD);
1794 }
1795
1796 static int sendconfirmsleep(wlan_private * priv, u8 * cmdptr, u16 size)
1797 {
1798 unsigned long flags;
1799 wlan_adapter *adapter = priv->adapter;
1800 int ret = 0;
1801
1802 lbs_deb_enter(LBS_DEB_CMD);
1803
1804 lbs_deb_cmd("SEND_SLEEPC_CMD: Before download, size of cmd = %d\n",
1805 size);
1806
1807 lbs_dbg_hex("SEND_SLEEPC_CMD: Sleep confirm command", cmdptr, size);
1808
1809 ret = priv->hw_host_to_card(priv, MVMS_CMD, cmdptr, size);
1810 priv->dnld_sent = DNLD_RES_RECEIVED;
1811
1812 spin_lock_irqsave(&adapter->driver_lock, flags);
1813 if (adapter->intcounter || adapter->currenttxskb)
1814 lbs_deb_cmd("SEND_SLEEPC_CMD: intcounter=%d currenttxskb=%p\n",
1815 adapter->intcounter, adapter->currenttxskb);
1816 spin_unlock_irqrestore(&adapter->driver_lock, flags);
1817
1818 if (ret) {
1819 lbs_pr_alert(
1820 "SEND_SLEEPC_CMD: Host to Card failed for Confirm Sleep\n");
1821 } else {
1822 spin_lock_irqsave(&adapter->driver_lock, flags);
1823 if (!adapter->intcounter) {
1824 adapter->psstate = PS_STATE_SLEEP;
1825 } else {
1826 lbs_deb_cmd("SEND_SLEEPC_CMD: After sent,IntC=%d\n",
1827 adapter->intcounter);
1828 }
1829 spin_unlock_irqrestore(&adapter->driver_lock, flags);
1830
1831 lbs_deb_cmd("SEND_SLEEPC_CMD: Sent Confirm Sleep command\n");
1832 lbs_deb_cmd("+");
1833 }
1834
1835 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
1836 return ret;
1837 }
1838
1839 void libertas_ps_sleep(wlan_private * priv, int wait_option)
1840 {
1841 lbs_deb_enter(LBS_DEB_CMD);
1842
1843 /*
1844 * PS is currently supported only in Infrastructure mode
1845 * Remove this check if it is to be supported in IBSS mode also
1846 */
1847
1848 libertas_prepare_and_send_command(priv, CMD_802_11_PS_MODE,
1849 CMD_SUBCMD_ENTER_PS, wait_option, 0, NULL);
1850
1851 lbs_deb_leave(LBS_DEB_CMD);
1852 }
1853
1854 /**
1855 * @brief This function sends Eixt_PS command to firmware.
1856 *
1857 * @param priv A pointer to wlan_private structure
1858 * @param wait_option wait response or not
1859 * @return n/a
1860 */
1861 void libertas_ps_wakeup(wlan_private * priv, int wait_option)
1862 {
1863 __le32 Localpsmode;
1864
1865 lbs_deb_enter(LBS_DEB_CMD);
1866
1867 Localpsmode = cpu_to_le32(WLAN802_11POWERMODECAM);
1868
1869 lbs_deb_cmd("Exit_PS: Localpsmode = %d\n", WLAN802_11POWERMODECAM);
1870
1871 libertas_prepare_and_send_command(priv, CMD_802_11_PS_MODE,
1872 CMD_SUBCMD_EXIT_PS,
1873 wait_option, 0, &Localpsmode);
1874
1875 lbs_deb_leave(LBS_DEB_CMD);
1876 }
1877
1878 /**
1879 * @brief This function checks condition and prepares to
1880 * send sleep confirm command to firmware if ok.
1881 *
1882 * @param priv A pointer to wlan_private structure
1883 * @param psmode Power Saving mode
1884 * @return n/a
1885 */
1886 void libertas_ps_confirm_sleep(wlan_private * priv, u16 psmode)
1887 {
1888 unsigned long flags =0;
1889 wlan_adapter *adapter = priv->adapter;
1890 u8 allowed = 1;
1891
1892 lbs_deb_enter(LBS_DEB_CMD);
1893
1894 if (priv->dnld_sent) {
1895 allowed = 0;
1896 lbs_deb_cmd("D");
1897 }
1898
1899 spin_lock_irqsave(&adapter->driver_lock, flags);
1900 if (adapter->cur_cmd) {
1901 allowed = 0;
1902 lbs_deb_cmd("C");
1903 }
1904 if (adapter->intcounter > 0) {
1905 allowed = 0;
1906 lbs_deb_cmd("I%d", adapter->intcounter);
1907 }
1908 spin_unlock_irqrestore(&adapter->driver_lock, flags);
1909
1910 if (allowed) {
1911 lbs_deb_cmd("Sending libertas_ps_confirm_sleep\n");
1912 sendconfirmsleep(priv, (u8 *) & adapter->libertas_ps_confirm_sleep,
1913 sizeof(struct PS_CMD_ConfirmSleep));
1914 } else {
1915 lbs_deb_cmd("Sleep Confirm has been delayed\n");
1916 }
1917
1918 lbs_deb_leave(LBS_DEB_CMD);
1919 }
kmemtrace - Kernel memory tracer