?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/rusty/linux-2.6-for-linus
[wrt350n-kernel.git] / drivers / net / wireless / libertas / cmd.c
blobb3c1acbcc655103fe898157dcbb70078d267db6d
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 #include "cmd.h"
15
16 static struct cmd_ctrl_node *lbs_get_cmd_ctrl_node(struct lbs_private *priv);
17 static void lbs_set_cmd_ctrl_node(struct lbs_private *priv,
18 struct cmd_ctrl_node *ptempnode,
19 void *pdata_buf);
20
21
22 /**
23 * @brief Checks whether a command is allowed in Power Save mode
24 *
25 * @param command the command ID
26 * @return 1 if allowed, 0 if not allowed
27 */
28 static u8 is_command_allowed_in_ps(u16 cmd)
29 {
30 switch (cmd) {
31 case CMD_802_11_RSSI:
32 return 1;
33 default:
34 break;
35 }
36 return 0;
37 }
38
39 /**
40 * @brief Updates the hardware details like MAC address and regulatory region
41 *
42 * @param priv A pointer to struct lbs_private structure
43 *
44 * @return 0 on success, error on failure
45 */
46 int lbs_update_hw_spec(struct lbs_private *priv)
47 {
48 struct cmd_ds_get_hw_spec cmd;
49 int ret = -1;
50 u32 i;
51 DECLARE_MAC_BUF(mac);
52
53 lbs_deb_enter(LBS_DEB_CMD);
54
55 memset(&cmd, 0, sizeof(cmd));
56 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
57 memcpy(cmd.permanentaddr, priv->current_addr, ETH_ALEN);
58 ret = lbs_cmd_with_response(priv, CMD_GET_HW_SPEC, &cmd);
59 if (ret)
60 goto out;
61
62 priv->fwcapinfo = le32_to_cpu(cmd.fwcapinfo);
63
64 /* The firmware release is in an interesting format: the patch
65 * level is in the most significant nibble ... so fix that: */
66 priv->fwrelease = le32_to_cpu(cmd.fwrelease);
67 priv->fwrelease = (priv->fwrelease << 8) |
68 (priv->fwrelease >> 24 & 0xff);
69
70 /* Some firmware capabilities:
71 * CF card firmware 5.0.16p0: cap 0x00000303
72 * USB dongle firmware 5.110.17p2: cap 0x00000303
73 */
74 printk("libertas: %s, fw %u.%u.%up%u, cap 0x%08x\n",
75 print_mac(mac, cmd.permanentaddr),
76 priv->fwrelease >> 24 & 0xff,
77 priv->fwrelease >> 16 & 0xff,
78 priv->fwrelease >> 8 & 0xff,
79 priv->fwrelease & 0xff,
80 priv->fwcapinfo);
81 lbs_deb_cmd("GET_HW_SPEC: hardware interface 0x%x, hardware spec 0x%04x\n",
82 cmd.hwifversion, cmd.version);
83
84 /* Clamp region code to 8-bit since FW spec indicates that it should
85 * only ever be 8-bit, even though the field size is 16-bit. Some firmware
86 * returns non-zero high 8 bits here.
87 */
88 priv->regioncode = le16_to_cpu(cmd.regioncode) & 0xFF;
89
90 for (i = 0; i < MRVDRV_MAX_REGION_CODE; i++) {
91 /* use the region code to search for the index */
92 if (priv->regioncode == lbs_region_code_to_index[i])
93 break;
94 }
95
96 /* if it's unidentified region code, use the default (USA) */
97 if (i >= MRVDRV_MAX_REGION_CODE) {
98 priv->regioncode = 0x10;
99 lbs_pr_info("unidentified region code; using the default (USA)\n");
100 }
101
102 if (priv->current_addr[0] == 0xff)
103 memmove(priv->current_addr, cmd.permanentaddr, ETH_ALEN);
104
105 memcpy(priv->dev->dev_addr, priv->current_addr, ETH_ALEN);
106 if (priv->mesh_dev)
107 memcpy(priv->mesh_dev->dev_addr, priv->current_addr, ETH_ALEN);
108
109 if (lbs_set_regiontable(priv, priv->regioncode, 0)) {
110 ret = -1;
111 goto out;
112 }
113
114 if (lbs_set_universaltable(priv, 0)) {
115 ret = -1;
116 goto out;
117 }
118
119 out:
120 lbs_deb_leave(LBS_DEB_CMD);
121 return ret;
122 }
123
124 int lbs_host_sleep_cfg(struct lbs_private *priv, uint32_t criteria)
125 {
126 struct cmd_ds_host_sleep cmd_config;
127 int ret;
128
129 cmd_config.hdr.size = cpu_to_le16(sizeof(cmd_config));
130 cmd_config.criteria = cpu_to_le32(criteria);
131 cmd_config.gpio = priv->wol_gpio;
132 cmd_config.gap = priv->wol_gap;
133
134 ret = lbs_cmd_with_response(priv, CMD_802_11_HOST_SLEEP_CFG, &cmd_config);
135 if (!ret) {
136 lbs_deb_cmd("Set WOL criteria to %x\n", criteria);
137 priv->wol_criteria = criteria;
138 } else {
139 lbs_pr_info("HOST_SLEEP_CFG failed %d\n", ret);
140 }
141
142 return ret;
143 }
144 EXPORT_SYMBOL_GPL(lbs_host_sleep_cfg);
145
146 static int lbs_cmd_802_11_ps_mode(struct lbs_private *priv,
147 struct cmd_ds_command *cmd,
148 u16 cmd_action)
149 {
150 struct cmd_ds_802_11_ps_mode *psm = &cmd->params.psmode;
151
152 lbs_deb_enter(LBS_DEB_CMD);
153
154 cmd->command = cpu_to_le16(CMD_802_11_PS_MODE);
155 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_ps_mode) +
156 S_DS_GEN);
157 psm->action = cpu_to_le16(cmd_action);
158 psm->multipledtim = 0;
159 switch (cmd_action) {
160 case CMD_SUBCMD_ENTER_PS:
161 lbs_deb_cmd("PS command:" "SubCode- Enter PS\n");
162
163 psm->locallisteninterval = 0;
164 psm->nullpktinterval = 0;
165 psm->multipledtim =
166 cpu_to_le16(MRVDRV_DEFAULT_MULTIPLE_DTIM);
167 break;
168
169 case CMD_SUBCMD_EXIT_PS:
170 lbs_deb_cmd("PS command:" "SubCode- Exit PS\n");
171 break;
172
173 case CMD_SUBCMD_SLEEP_CONFIRMED:
174 lbs_deb_cmd("PS command: SubCode- sleep confirm\n");
175 break;
176
177 default:
178 break;
179 }
180
181 lbs_deb_leave(LBS_DEB_CMD);
182 return 0;
183 }
184
185 int lbs_cmd_802_11_inactivity_timeout(struct lbs_private *priv,
186 uint16_t cmd_action, uint16_t *timeout)
187 {
188 struct cmd_ds_802_11_inactivity_timeout cmd;
189 int ret;
190
191 lbs_deb_enter(LBS_DEB_CMD);
192
193 cmd.hdr.command = cpu_to_le16(CMD_802_11_INACTIVITY_TIMEOUT);
194 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
195
196 cmd.action = cpu_to_le16(cmd_action);
197
198 if (cmd_action == CMD_ACT_SET)
199 cmd.timeout = cpu_to_le16(*timeout);
200 else
201 cmd.timeout = 0;
202
203 ret = lbs_cmd_with_response(priv, CMD_802_11_INACTIVITY_TIMEOUT, &cmd);
204
205 if (!ret)
206 *timeout = le16_to_cpu(cmd.timeout);
207
208 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
209 return 0;
210 }
211
212 int lbs_cmd_802_11_sleep_params(struct lbs_private *priv, uint16_t cmd_action,
213 struct sleep_params *sp)
214 {
215 struct cmd_ds_802_11_sleep_params cmd;
216 int ret;
217
218 lbs_deb_enter(LBS_DEB_CMD);
219
220 if (cmd_action == CMD_ACT_GET) {
221 memset(&cmd, 0, sizeof(cmd));
222 } else {
223 cmd.error = cpu_to_le16(sp->sp_error);
224 cmd.offset = cpu_to_le16(sp->sp_offset);
225 cmd.stabletime = cpu_to_le16(sp->sp_stabletime);
226 cmd.calcontrol = sp->sp_calcontrol;
227 cmd.externalsleepclk = sp->sp_extsleepclk;
228 cmd.reserved = cpu_to_le16(sp->sp_reserved);
229 }
230 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
231 cmd.action = cpu_to_le16(cmd_action);
232
233 ret = lbs_cmd_with_response(priv, CMD_802_11_SLEEP_PARAMS, &cmd);
234
235 if (!ret) {
236 lbs_deb_cmd("error 0x%x, offset 0x%x, stabletime 0x%x, "
237 "calcontrol 0x%x extsleepclk 0x%x\n",
238 le16_to_cpu(cmd.error), le16_to_cpu(cmd.offset),
239 le16_to_cpu(cmd.stabletime), cmd.calcontrol,
240 cmd.externalsleepclk);
241
242 sp->sp_error = le16_to_cpu(cmd.error);
243 sp->sp_offset = le16_to_cpu(cmd.offset);
244 sp->sp_stabletime = le16_to_cpu(cmd.stabletime);
245 sp->sp_calcontrol = cmd.calcontrol;
246 sp->sp_extsleepclk = cmd.externalsleepclk;
247 sp->sp_reserved = le16_to_cpu(cmd.reserved);
248 }
249
250 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
251 return 0;
252 }
253
254 int lbs_cmd_802_11_set_wep(struct lbs_private *priv, uint16_t cmd_action,
255 struct assoc_request *assoc)
256 {
257 struct cmd_ds_802_11_set_wep cmd;
258 int ret = 0;
259
260 lbs_deb_enter(LBS_DEB_CMD);
261
262 cmd.hdr.command = cpu_to_le16(CMD_802_11_SET_WEP);
263 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
264
265 cmd.action = cpu_to_le16(cmd_action);
266
267 if (cmd_action == CMD_ACT_ADD) {
268 int i;
269
270 /* default tx key index */
271 cmd.keyindex = cpu_to_le16(assoc->wep_tx_keyidx &
272 CMD_WEP_KEY_INDEX_MASK);
273
274 /* Copy key types and material to host command structure */
275 for (i = 0; i < 4; i++) {
276 struct enc_key *pkey = &assoc->wep_keys[i];
277
278 switch (pkey->len) {
279 case KEY_LEN_WEP_40:
280 cmd.keytype[i] = CMD_TYPE_WEP_40_BIT;
281 memmove(cmd.keymaterial[i], pkey->key, pkey->len);
282 lbs_deb_cmd("SET_WEP: add key %d (40 bit)\n", i);
283 break;
284 case KEY_LEN_WEP_104:
285 cmd.keytype[i] = CMD_TYPE_WEP_104_BIT;
286 memmove(cmd.keymaterial[i], pkey->key, pkey->len);
287 lbs_deb_cmd("SET_WEP: add key %d (104 bit)\n", i);
288 break;
289 case 0:
290 break;
291 default:
292 lbs_deb_cmd("SET_WEP: invalid key %d, length %d\n",
293 i, pkey->len);
294 ret = -1;
295 goto done;
296 break;
297 }
298 }
299 } else if (cmd_action == CMD_ACT_REMOVE) {
300 /* ACT_REMOVE clears _all_ WEP keys */
301
302 /* default tx key index */
303 cmd.keyindex = cpu_to_le16(priv->wep_tx_keyidx &
304 CMD_WEP_KEY_INDEX_MASK);
305 lbs_deb_cmd("SET_WEP: remove key %d\n", priv->wep_tx_keyidx);
306 }
307
308 ret = lbs_cmd_with_response(priv, CMD_802_11_SET_WEP, &cmd);
309 done:
310 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
311 return ret;
312 }
313
314 int lbs_cmd_802_11_enable_rsn(struct lbs_private *priv, uint16_t cmd_action,
315 uint16_t *enable)
316 {
317 struct cmd_ds_802_11_enable_rsn cmd;
318 int ret;
319
320 lbs_deb_enter(LBS_DEB_CMD);
321
322 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
323 cmd.action = cpu_to_le16(cmd_action);
324
325 if (cmd_action == CMD_ACT_SET) {
326 if (*enable)
327 cmd.enable = cpu_to_le16(CMD_ENABLE_RSN);
328 else
329 cmd.enable = cpu_to_le16(CMD_DISABLE_RSN);
330 lbs_deb_cmd("ENABLE_RSN: %d\n", *enable);
331 }
332
333 ret = lbs_cmd_with_response(priv, CMD_802_11_ENABLE_RSN, &cmd);
334 if (!ret && cmd_action == CMD_ACT_GET)
335 *enable = le16_to_cpu(cmd.enable);
336
337 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
338 return ret;
339 }
340
341 static void set_one_wpa_key(struct MrvlIEtype_keyParamSet * pkeyparamset,
342 struct enc_key * pkey)
343 {
344 lbs_deb_enter(LBS_DEB_CMD);
345
346 if (pkey->flags & KEY_INFO_WPA_ENABLED) {
347 pkeyparamset->keyinfo |= cpu_to_le16(KEY_INFO_WPA_ENABLED);
348 }
349 if (pkey->flags & KEY_INFO_WPA_UNICAST) {
350 pkeyparamset->keyinfo |= cpu_to_le16(KEY_INFO_WPA_UNICAST);
351 }
352 if (pkey->flags & KEY_INFO_WPA_MCAST) {
353 pkeyparamset->keyinfo |= cpu_to_le16(KEY_INFO_WPA_MCAST);
354 }
355
356 pkeyparamset->type = cpu_to_le16(TLV_TYPE_KEY_MATERIAL);
357 pkeyparamset->keytypeid = cpu_to_le16(pkey->type);
358 pkeyparamset->keylen = cpu_to_le16(pkey->len);
359 memcpy(pkeyparamset->key, pkey->key, pkey->len);
360 pkeyparamset->length = cpu_to_le16( sizeof(pkeyparamset->keytypeid)
361 + sizeof(pkeyparamset->keyinfo)
362 + sizeof(pkeyparamset->keylen)
363 + sizeof(pkeyparamset->key));
364 lbs_deb_leave(LBS_DEB_CMD);
365 }
366
367 static int lbs_cmd_802_11_key_material(struct lbs_private *priv,
368 struct cmd_ds_command *cmd,
369 u16 cmd_action,
370 u32 cmd_oid, void *pdata_buf)
371 {
372 struct cmd_ds_802_11_key_material *pkeymaterial =
373 &cmd->params.keymaterial;
374 struct assoc_request * assoc_req = pdata_buf;
375 int ret = 0;
376 int index = 0;
377
378 lbs_deb_enter(LBS_DEB_CMD);
379
380 cmd->command = cpu_to_le16(CMD_802_11_KEY_MATERIAL);
381 pkeymaterial->action = cpu_to_le16(cmd_action);
382
383 if (cmd_action == CMD_ACT_GET) {
384 cmd->size = cpu_to_le16(S_DS_GEN + sizeof (pkeymaterial->action));
385 ret = 0;
386 goto done;
387 }
388
389 memset(&pkeymaterial->keyParamSet, 0, sizeof(pkeymaterial->keyParamSet));
390
391 if (test_bit(ASSOC_FLAG_WPA_UCAST_KEY, &assoc_req->flags)) {
392 set_one_wpa_key(&pkeymaterial->keyParamSet[index],
393 &assoc_req->wpa_unicast_key);
394 index++;
395 }
396
397 if (test_bit(ASSOC_FLAG_WPA_MCAST_KEY, &assoc_req->flags)) {
398 set_one_wpa_key(&pkeymaterial->keyParamSet[index],
399 &assoc_req->wpa_mcast_key);
400 index++;
401 }
402
403 cmd->size = cpu_to_le16( S_DS_GEN
404 + sizeof (pkeymaterial->action)
405 + (index * sizeof(struct MrvlIEtype_keyParamSet)));
406
407 ret = 0;
408
409 done:
410 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
411 return ret;
412 }
413
414 static int lbs_cmd_802_11_reset(struct lbs_private *priv,
415 struct cmd_ds_command *cmd, int cmd_action)
416 {
417 struct cmd_ds_802_11_reset *reset = &cmd->params.reset;
418
419 lbs_deb_enter(LBS_DEB_CMD);
420
421 cmd->command = cpu_to_le16(CMD_802_11_RESET);
422 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_reset) + S_DS_GEN);
423 reset->action = cpu_to_le16(cmd_action);
424
425 lbs_deb_leave(LBS_DEB_CMD);
426 return 0;
427 }
428
429 static int lbs_cmd_802_11_get_log(struct lbs_private *priv,
430 struct cmd_ds_command *cmd)
431 {
432 lbs_deb_enter(LBS_DEB_CMD);
433 cmd->command = cpu_to_le16(CMD_802_11_GET_LOG);
434 cmd->size =
435 cpu_to_le16(sizeof(struct cmd_ds_802_11_get_log) + S_DS_GEN);
436
437 lbs_deb_leave(LBS_DEB_CMD);
438 return 0;
439 }
440
441 static int lbs_cmd_802_11_get_stat(struct lbs_private *priv,
442 struct cmd_ds_command *cmd)
443 {
444 lbs_deb_enter(LBS_DEB_CMD);
445 cmd->command = cpu_to_le16(CMD_802_11_GET_STAT);
446 cmd->size =
447 cpu_to_le16(sizeof(struct cmd_ds_802_11_get_stat) + S_DS_GEN);
448
449 lbs_deb_leave(LBS_DEB_CMD);
450 return 0;
451 }
452
453 static int lbs_cmd_802_11_snmp_mib(struct lbs_private *priv,
454 struct cmd_ds_command *cmd,
455 int cmd_action,
456 int cmd_oid, void *pdata_buf)
457 {
458 struct cmd_ds_802_11_snmp_mib *pSNMPMIB = &cmd->params.smib;
459 u8 ucTemp;
460
461 lbs_deb_enter(LBS_DEB_CMD);
462
463 lbs_deb_cmd("SNMP_CMD: cmd_oid = 0x%x\n", cmd_oid);
464
465 cmd->command = cpu_to_le16(CMD_802_11_SNMP_MIB);
466 cmd->size = cpu_to_le16(sizeof(*pSNMPMIB) + S_DS_GEN);
467
468 switch (cmd_oid) {
469 case OID_802_11_INFRASTRUCTURE_MODE:
470 {
471 u8 mode = (u8) (size_t) pdata_buf;
472 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
473 pSNMPMIB->oid = cpu_to_le16((u16) DESIRED_BSSTYPE_I);
474 pSNMPMIB->bufsize = cpu_to_le16(sizeof(u8));
475 if (mode == IW_MODE_ADHOC) {
476 ucTemp = SNMP_MIB_VALUE_ADHOC;
477 } else {
478 /* Infra and Auto modes */
479 ucTemp = SNMP_MIB_VALUE_INFRA;
480 }
481
482 memmove(pSNMPMIB->value, &ucTemp, sizeof(u8));
483
484 break;
485 }
486
487 case OID_802_11D_ENABLE:
488 {
489 u32 ulTemp;
490
491 pSNMPMIB->oid = cpu_to_le16((u16) DOT11D_I);
492
493 if (cmd_action == CMD_ACT_SET) {
494 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
495 pSNMPMIB->bufsize = cpu_to_le16(sizeof(u16));
496 ulTemp = *(u32 *)pdata_buf;
497 *((__le16 *)(pSNMPMIB->value)) =
498 cpu_to_le16((u16) ulTemp);
499 }
500 break;
501 }
502
503 case OID_802_11_FRAGMENTATION_THRESHOLD:
504 {
505 u32 ulTemp;
506
507 pSNMPMIB->oid = cpu_to_le16((u16) FRAGTHRESH_I);
508
509 if (cmd_action == CMD_ACT_GET) {
510 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_GET);
511 } else if (cmd_action == CMD_ACT_SET) {
512 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
513 pSNMPMIB->bufsize = cpu_to_le16(sizeof(u16));
514 ulTemp = *((u32 *) pdata_buf);
515 *((__le16 *)(pSNMPMIB->value)) =
516 cpu_to_le16((u16) ulTemp);
517
518 }
519
520 break;
521 }
522
523 case OID_802_11_RTS_THRESHOLD:
524 {
525
526 u32 ulTemp;
527 pSNMPMIB->oid = cpu_to_le16(RTSTHRESH_I);
528
529 if (cmd_action == CMD_ACT_GET) {
530 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_GET);
531 } else if (cmd_action == CMD_ACT_SET) {
532 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
533 pSNMPMIB->bufsize = cpu_to_le16(sizeof(u16));
534 ulTemp = *((u32 *)pdata_buf);
535 *(__le16 *)(pSNMPMIB->value) =
536 cpu_to_le16((u16) ulTemp);
537
538 }
539 break;
540 }
541 case OID_802_11_TX_RETRYCOUNT:
542 pSNMPMIB->oid = cpu_to_le16((u16) SHORT_RETRYLIM_I);
543
544 if (cmd_action == CMD_ACT_GET) {
545 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_GET);
546 } else if (cmd_action == CMD_ACT_SET) {
547 pSNMPMIB->querytype = cpu_to_le16(CMD_ACT_SET);
548 pSNMPMIB->bufsize = cpu_to_le16(sizeof(u16));
549 *((__le16 *)(pSNMPMIB->value)) =
550 cpu_to_le16((u16) priv->txretrycount);
551 }
552
553 break;
554 default:
555 break;
556 }
557
558 lbs_deb_cmd(
559 "SNMP_CMD: command=0x%x, size=0x%x, seqnum=0x%x, result=0x%x\n",
560 le16_to_cpu(cmd->command), le16_to_cpu(cmd->size),
561 le16_to_cpu(cmd->seqnum), le16_to_cpu(cmd->result));
562
563 lbs_deb_cmd(
564 "SNMP_CMD: action 0x%x, oid 0x%x, oidsize 0x%x, value 0x%x\n",
565 le16_to_cpu(pSNMPMIB->querytype), le16_to_cpu(pSNMPMIB->oid),
566 le16_to_cpu(pSNMPMIB->bufsize),
567 le16_to_cpu(*(__le16 *) pSNMPMIB->value));
568
569 lbs_deb_leave(LBS_DEB_CMD);
570 return 0;
571 }
572
573 static int lbs_cmd_802_11_rf_tx_power(struct lbs_private *priv,
574 struct cmd_ds_command *cmd,
575 u16 cmd_action, void *pdata_buf)
576 {
577
578 struct cmd_ds_802_11_rf_tx_power *prtp = &cmd->params.txp;
579
580 lbs_deb_enter(LBS_DEB_CMD);
581
582 cmd->size =
583 cpu_to_le16((sizeof(struct cmd_ds_802_11_rf_tx_power)) + S_DS_GEN);
584 cmd->command = cpu_to_le16(CMD_802_11_RF_TX_POWER);
585 prtp->action = cpu_to_le16(cmd_action);
586
587 lbs_deb_cmd("RF_TX_POWER_CMD: size:%d cmd:0x%x Act:%d\n",
588 le16_to_cpu(cmd->size), le16_to_cpu(cmd->command),
589 le16_to_cpu(prtp->action));
590
591 switch (cmd_action) {
592 case CMD_ACT_TX_POWER_OPT_GET:
593 prtp->action = cpu_to_le16(CMD_ACT_GET);
594 prtp->currentlevel = 0;
595 break;
596
597 case CMD_ACT_TX_POWER_OPT_SET_HIGH:
598 prtp->action = cpu_to_le16(CMD_ACT_SET);
599 prtp->currentlevel = cpu_to_le16(CMD_ACT_TX_POWER_INDEX_HIGH);
600 break;
601
602 case CMD_ACT_TX_POWER_OPT_SET_MID:
603 prtp->action = cpu_to_le16(CMD_ACT_SET);
604 prtp->currentlevel = cpu_to_le16(CMD_ACT_TX_POWER_INDEX_MID);
605 break;
606
607 case CMD_ACT_TX_POWER_OPT_SET_LOW:
608 prtp->action = cpu_to_le16(CMD_ACT_SET);
609 prtp->currentlevel = cpu_to_le16(*((u16 *) pdata_buf));
610 break;
611 }
612
613 lbs_deb_leave(LBS_DEB_CMD);
614 return 0;
615 }
616
617 static int lbs_cmd_802_11_monitor_mode(struct lbs_private *priv,
618 struct cmd_ds_command *cmd,
619 u16 cmd_action, void *pdata_buf)
620 {
621 struct cmd_ds_802_11_monitor_mode *monitor = &cmd->params.monitor;
622
623 cmd->command = cpu_to_le16(CMD_802_11_MONITOR_MODE);
624 cmd->size =
625 cpu_to_le16(sizeof(struct cmd_ds_802_11_monitor_mode) +
626 S_DS_GEN);
627
628 monitor->action = cpu_to_le16(cmd_action);
629 if (cmd_action == CMD_ACT_SET) {
630 monitor->mode =
631 cpu_to_le16((u16) (*(u32 *) pdata_buf));
632 }
633
634 return 0;
635 }
636
637 static int lbs_cmd_802_11_rate_adapt_rateset(struct lbs_private *priv,
638 struct cmd_ds_command *cmd,
639 u16 cmd_action)
640 {
641 struct cmd_ds_802_11_rate_adapt_rateset
642 *rateadapt = &cmd->params.rateset;
643
644 lbs_deb_enter(LBS_DEB_CMD);
645 cmd->size =
646 cpu_to_le16(sizeof(struct cmd_ds_802_11_rate_adapt_rateset)
647 + S_DS_GEN);
648 cmd->command = cpu_to_le16(CMD_802_11_RATE_ADAPT_RATESET);
649
650 rateadapt->action = cpu_to_le16(cmd_action);
651 rateadapt->enablehwauto = cpu_to_le16(priv->enablehwauto);
652 rateadapt->bitmap = cpu_to_le16(priv->ratebitmap);
653
654 lbs_deb_leave(LBS_DEB_CMD);
655 return 0;
656 }
657
658 /**
659 * @brief Get the current data rate
660 *
661 * @param priv A pointer to struct lbs_private structure
662 *
663 * @return The data rate on success, error on failure
664 */
665 int lbs_get_data_rate(struct lbs_private *priv)
666 {
667 struct cmd_ds_802_11_data_rate cmd;
668 int ret = -1;
669
670 lbs_deb_enter(LBS_DEB_CMD);
671
672 memset(&cmd, 0, sizeof(cmd));
673 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
674 cmd.action = cpu_to_le16(CMD_ACT_GET_TX_RATE);
675
676 ret = lbs_cmd_with_response(priv, CMD_802_11_DATA_RATE, &cmd);
677 if (ret)
678 goto out;
679
680 lbs_deb_hex(LBS_DEB_CMD, "DATA_RATE_RESP", (u8 *) &cmd, sizeof (cmd));
681
682 ret = (int) lbs_fw_index_to_data_rate(cmd.rates[0]);
683 lbs_deb_cmd("DATA_RATE: current rate 0x%02x\n", ret);
684
685 out:
686 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
687 return ret;
688 }
689
690 /**
691 * @brief Set the data rate
692 *
693 * @param priv A pointer to struct lbs_private structure
694 * @param rate The desired data rate, or 0 to clear a locked rate
695 *
696 * @return 0 on success, error on failure
697 */
698 int lbs_set_data_rate(struct lbs_private *priv, u8 rate)
699 {
700 struct cmd_ds_802_11_data_rate cmd;
701 int ret = 0;
702
703 lbs_deb_enter(LBS_DEB_CMD);
704
705 memset(&cmd, 0, sizeof(cmd));
706 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
707
708 if (rate > 0) {
709 cmd.action = cpu_to_le16(CMD_ACT_SET_TX_FIX_RATE);
710 cmd.rates[0] = lbs_data_rate_to_fw_index(rate);
711 if (cmd.rates[0] == 0) {
712 lbs_deb_cmd("DATA_RATE: invalid requested rate of"
713 " 0x%02X\n", rate);
714 ret = 0;
715 goto out;
716 }
717 lbs_deb_cmd("DATA_RATE: set fixed 0x%02X\n", cmd.rates[0]);
718 } else {
719 cmd.action = cpu_to_le16(CMD_ACT_SET_TX_AUTO);
720 lbs_deb_cmd("DATA_RATE: setting auto\n");
721 }
722
723 ret = lbs_cmd_with_response(priv, CMD_802_11_DATA_RATE, &cmd);
724 if (ret)
725 goto out;
726
727 lbs_deb_hex(LBS_DEB_CMD, "DATA_RATE_RESP", (u8 *) &cmd, sizeof (cmd));
728
729 /* FIXME: get actual rates FW can do if this command actually returns
730 * all data rates supported.
731 */
732 priv->cur_rate = lbs_fw_index_to_data_rate(cmd.rates[0]);
733 lbs_deb_cmd("DATA_RATE: current rate is 0x%02x\n", priv->cur_rate);
734
735 out:
736 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
737 return ret;
738 }
739
740 static int lbs_cmd_mac_multicast_adr(struct lbs_private *priv,
741 struct cmd_ds_command *cmd,
742 u16 cmd_action)
743 {
744 struct cmd_ds_mac_multicast_adr *pMCastAdr = &cmd->params.madr;
745
746 lbs_deb_enter(LBS_DEB_CMD);
747 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mac_multicast_adr) +
748 S_DS_GEN);
749 cmd->command = cpu_to_le16(CMD_MAC_MULTICAST_ADR);
750
751 lbs_deb_cmd("MULTICAST_ADR: setting %d addresses\n", pMCastAdr->nr_of_adrs);
752 pMCastAdr->action = cpu_to_le16(cmd_action);
753 pMCastAdr->nr_of_adrs =
754 cpu_to_le16((u16) priv->nr_of_multicastmacaddr);
755 memcpy(pMCastAdr->maclist, priv->multicastlist,
756 priv->nr_of_multicastmacaddr * ETH_ALEN);
757
758 lbs_deb_leave(LBS_DEB_CMD);
759 return 0;
760 }
761
762 /**
763 * @brief Get the radio channel
764 *
765 * @param priv A pointer to struct lbs_private structure
766 *
767 * @return The channel on success, error on failure
768 */
769 int lbs_get_channel(struct lbs_private *priv)
770 {
771 struct cmd_ds_802_11_rf_channel cmd;
772 int ret = 0;
773
774 lbs_deb_enter(LBS_DEB_CMD);
775
776 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
777 cmd.action = cpu_to_le16(CMD_OPT_802_11_RF_CHANNEL_GET);
778
779 ret = lbs_cmd_with_response(priv, CMD_802_11_RF_CHANNEL, &cmd);
780 if (ret)
781 goto out;
782
783 ret = le16_to_cpu(cmd.channel);
784 lbs_deb_cmd("current radio channel is %d\n", ret);
785
786 out:
787 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
788 return ret;
789 }
790
791 /**
792 * @brief Set the radio channel
793 *
794 * @param priv A pointer to struct lbs_private structure
795 * @param channel The desired channel, or 0 to clear a locked channel
796 *
797 * @return 0 on success, error on failure
798 */
799 int lbs_set_channel(struct lbs_private *priv, u8 channel)
800 {
801 struct cmd_ds_802_11_rf_channel cmd;
802 u8 old_channel = priv->curbssparams.channel;
803 int ret = 0;
804
805 lbs_deb_enter(LBS_DEB_CMD);
806
807 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
808 cmd.action = cpu_to_le16(CMD_OPT_802_11_RF_CHANNEL_SET);
809 cmd.channel = cpu_to_le16(channel);
810
811 ret = lbs_cmd_with_response(priv, CMD_802_11_RF_CHANNEL, &cmd);
812 if (ret)
813 goto out;
814
815 priv->curbssparams.channel = (uint8_t) le16_to_cpu(cmd.channel);
816 lbs_deb_cmd("channel switch from %d to %d\n", old_channel,
817 priv->curbssparams.channel);
818
819 out:
820 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
821 return ret;
822 }
823
824 static int lbs_cmd_802_11_rssi(struct lbs_private *priv,
825 struct cmd_ds_command *cmd)
826 {
827
828 lbs_deb_enter(LBS_DEB_CMD);
829 cmd->command = cpu_to_le16(CMD_802_11_RSSI);
830 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_rssi) + S_DS_GEN);
831 cmd->params.rssi.N = cpu_to_le16(DEFAULT_BCN_AVG_FACTOR);
832
833 /* reset Beacon SNR/NF/RSSI values */
834 priv->SNR[TYPE_BEACON][TYPE_NOAVG] = 0;
835 priv->SNR[TYPE_BEACON][TYPE_AVG] = 0;
836 priv->NF[TYPE_BEACON][TYPE_NOAVG] = 0;
837 priv->NF[TYPE_BEACON][TYPE_AVG] = 0;
838 priv->RSSI[TYPE_BEACON][TYPE_NOAVG] = 0;
839 priv->RSSI[TYPE_BEACON][TYPE_AVG] = 0;
840
841 lbs_deb_leave(LBS_DEB_CMD);
842 return 0;
843 }
844
845 static int lbs_cmd_reg_access(struct lbs_private *priv,
846 struct cmd_ds_command *cmdptr,
847 u8 cmd_action, void *pdata_buf)
848 {
849 struct lbs_offset_value *offval;
850
851 lbs_deb_enter(LBS_DEB_CMD);
852
853 offval = (struct lbs_offset_value *)pdata_buf;
854
855 switch (le16_to_cpu(cmdptr->command)) {
856 case CMD_MAC_REG_ACCESS:
857 {
858 struct cmd_ds_mac_reg_access *macreg;
859
860 cmdptr->size =
861 cpu_to_le16(sizeof (struct cmd_ds_mac_reg_access)
862 + S_DS_GEN);
863 macreg =
864 (struct cmd_ds_mac_reg_access *)&cmdptr->params.
865 macreg;
866
867 macreg->action = cpu_to_le16(cmd_action);
868 macreg->offset = cpu_to_le16((u16) offval->offset);
869 macreg->value = cpu_to_le32(offval->value);
870
871 break;
872 }
873
874 case CMD_BBP_REG_ACCESS:
875 {
876 struct cmd_ds_bbp_reg_access *bbpreg;
877
878 cmdptr->size =
879 cpu_to_le16(sizeof
880 (struct cmd_ds_bbp_reg_access)
881 + S_DS_GEN);
882 bbpreg =
883 (struct cmd_ds_bbp_reg_access *)&cmdptr->params.
884 bbpreg;
885
886 bbpreg->action = cpu_to_le16(cmd_action);
887 bbpreg->offset = cpu_to_le16((u16) offval->offset);
888 bbpreg->value = (u8) offval->value;
889
890 break;
891 }
892
893 case CMD_RF_REG_ACCESS:
894 {
895 struct cmd_ds_rf_reg_access *rfreg;
896
897 cmdptr->size =
898 cpu_to_le16(sizeof
899 (struct cmd_ds_rf_reg_access) +
900 S_DS_GEN);
901 rfreg =
902 (struct cmd_ds_rf_reg_access *)&cmdptr->params.
903 rfreg;
904
905 rfreg->action = cpu_to_le16(cmd_action);
906 rfreg->offset = cpu_to_le16((u16) offval->offset);
907 rfreg->value = (u8) offval->value;
908
909 break;
910 }
911
912 default:
913 break;
914 }
915
916 lbs_deb_leave(LBS_DEB_CMD);
917 return 0;
918 }
919
920 static int lbs_cmd_802_11_mac_address(struct lbs_private *priv,
921 struct cmd_ds_command *cmd,
922 u16 cmd_action)
923 {
924
925 lbs_deb_enter(LBS_DEB_CMD);
926 cmd->command = cpu_to_le16(CMD_802_11_MAC_ADDRESS);
927 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_mac_address) +
928 S_DS_GEN);
929 cmd->result = 0;
930
931 cmd->params.macadd.action = cpu_to_le16(cmd_action);
932
933 if (cmd_action == CMD_ACT_SET) {
934 memcpy(cmd->params.macadd.macadd,
935 priv->current_addr, ETH_ALEN);
936 lbs_deb_hex(LBS_DEB_CMD, "SET_CMD: MAC addr", priv->current_addr, 6);
937 }
938
939 lbs_deb_leave(LBS_DEB_CMD);
940 return 0;
941 }
942
943 static int lbs_cmd_802_11_eeprom_access(struct lbs_private *priv,
944 struct cmd_ds_command *cmd,
945 int cmd_action, void *pdata_buf)
946 {
947 struct lbs_ioctl_regrdwr *ea = pdata_buf;
948
949 lbs_deb_enter(LBS_DEB_CMD);
950
951 cmd->command = cpu_to_le16(CMD_802_11_EEPROM_ACCESS);
952 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_eeprom_access) +
953 S_DS_GEN);
954 cmd->result = 0;
955
956 cmd->params.rdeeprom.action = cpu_to_le16(ea->action);
957 cmd->params.rdeeprom.offset = cpu_to_le16(ea->offset);
958 cmd->params.rdeeprom.bytecount = cpu_to_le16(ea->NOB);
959 cmd->params.rdeeprom.value = 0;
960
961 lbs_deb_leave(LBS_DEB_CMD);
962 return 0;
963 }
964
965 static int lbs_cmd_bt_access(struct lbs_private *priv,
966 struct cmd_ds_command *cmd,
967 u16 cmd_action, void *pdata_buf)
968 {
969 struct cmd_ds_bt_access *bt_access = &cmd->params.bt;
970 lbs_deb_enter_args(LBS_DEB_CMD, "action %d", cmd_action);
971
972 cmd->command = cpu_to_le16(CMD_BT_ACCESS);
973 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_bt_access) + S_DS_GEN);
974 cmd->result = 0;
975 bt_access->action = cpu_to_le16(cmd_action);
976
977 switch (cmd_action) {
978 case CMD_ACT_BT_ACCESS_ADD:
979 memcpy(bt_access->addr1, pdata_buf, 2 * ETH_ALEN);
980 lbs_deb_hex(LBS_DEB_MESH, "BT_ADD: blinded MAC addr", bt_access->addr1, 6);
981 break;
982 case CMD_ACT_BT_ACCESS_DEL:
983 memcpy(bt_access->addr1, pdata_buf, 1 * ETH_ALEN);
984 lbs_deb_hex(LBS_DEB_MESH, "BT_DEL: blinded MAC addr", bt_access->addr1, 6);
985 break;
986 case CMD_ACT_BT_ACCESS_LIST:
987 bt_access->id = cpu_to_le32(*(u32 *) pdata_buf);
988 break;
989 case CMD_ACT_BT_ACCESS_RESET:
990 break;
991 case CMD_ACT_BT_ACCESS_SET_INVERT:
992 bt_access->id = cpu_to_le32(*(u32 *) pdata_buf);
993 break;
994 case CMD_ACT_BT_ACCESS_GET_INVERT:
995 break;
996 default:
997 break;
998 }
999 lbs_deb_leave(LBS_DEB_CMD);
1000 return 0;
1001 }
1002
1003 static int lbs_cmd_fwt_access(struct lbs_private *priv,
1004 struct cmd_ds_command *cmd,
1005 u16 cmd_action, void *pdata_buf)
1006 {
1007 struct cmd_ds_fwt_access *fwt_access = &cmd->params.fwt;
1008 lbs_deb_enter_args(LBS_DEB_CMD, "action %d", cmd_action);
1009
1010 cmd->command = cpu_to_le16(CMD_FWT_ACCESS);
1011 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_fwt_access) + S_DS_GEN);
1012 cmd->result = 0;
1013
1014 if (pdata_buf)
1015 memcpy(fwt_access, pdata_buf, sizeof(*fwt_access));
1016 else
1017 memset(fwt_access, 0, sizeof(*fwt_access));
1018
1019 fwt_access->action = cpu_to_le16(cmd_action);
1020
1021 lbs_deb_leave(LBS_DEB_CMD);
1022 return 0;
1023 }
1024
1025 int lbs_mesh_access(struct lbs_private *priv, uint16_t cmd_action,
1026 struct cmd_ds_mesh_access *cmd)
1027 {
1028 int ret;
1029
1030 lbs_deb_enter_args(LBS_DEB_CMD, "action %d", cmd_action);
1031
1032 cmd->hdr.command = cpu_to_le16(CMD_MESH_ACCESS);
1033 cmd->hdr.size = cpu_to_le16(sizeof(*cmd));
1034 cmd->hdr.result = 0;
1035
1036 cmd->action = cpu_to_le16(cmd_action);
1037
1038 ret = lbs_cmd_with_response(priv, CMD_MESH_ACCESS, cmd);
1039
1040 lbs_deb_leave(LBS_DEB_CMD);
1041 return ret;
1042 }
1043
1044 int lbs_mesh_config(struct lbs_private *priv, uint16_t enable, uint16_t chan)
1045 {
1046 struct cmd_ds_mesh_config cmd;
1047
1048 memset(&cmd, 0, sizeof(cmd));
1049 cmd.action = cpu_to_le16(enable);
1050 cmd.channel = cpu_to_le16(chan);
1051 cmd.type = cpu_to_le16(priv->mesh_tlv);
1052 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
1053
1054 if (enable) {
1055 cmd.length = cpu_to_le16(priv->mesh_ssid_len);
1056 memcpy(cmd.data, priv->mesh_ssid, priv->mesh_ssid_len);
1057 }
1058 lbs_deb_cmd("mesh config enable %d TLV %x channel %d SSID %s\n",
1059 enable, priv->mesh_tlv, chan,
1060 escape_essid(priv->mesh_ssid, priv->mesh_ssid_len));
1061 return lbs_cmd_with_response(priv, CMD_MESH_CONFIG, &cmd);
1062 }
1063
1064 static int lbs_cmd_bcn_ctrl(struct lbs_private * priv,
1065 struct cmd_ds_command *cmd,
1066 u16 cmd_action)
1067 {
1068 struct cmd_ds_802_11_beacon_control
1069 *bcn_ctrl = &cmd->params.bcn_ctrl;
1070
1071 lbs_deb_enter(LBS_DEB_CMD);
1072 cmd->size =
1073 cpu_to_le16(sizeof(struct cmd_ds_802_11_beacon_control)
1074 + S_DS_GEN);
1075 cmd->command = cpu_to_le16(CMD_802_11_BEACON_CTRL);
1076
1077 bcn_ctrl->action = cpu_to_le16(cmd_action);
1078 bcn_ctrl->beacon_enable = cpu_to_le16(priv->beacon_enable);
1079 bcn_ctrl->beacon_period = cpu_to_le16(priv->beacon_period);
1080
1081 lbs_deb_leave(LBS_DEB_CMD);
1082 return 0;
1083 }
1084
1085 static void lbs_queue_cmd(struct lbs_private *priv,
1086 struct cmd_ctrl_node *cmdnode)
1087 {
1088 unsigned long flags;
1089 int addtail = 1;
1090
1091 lbs_deb_enter(LBS_DEB_HOST);
1092
1093 if (!cmdnode) {
1094 lbs_deb_host("QUEUE_CMD: cmdnode is NULL\n");
1095 goto done;
1096 }
1097 if (!cmdnode->cmdbuf->size) {
1098 lbs_deb_host("DNLD_CMD: cmd size is zero\n");
1099 goto done;
1100 }
1101 cmdnode->result = 0;
1102
1103 /* Exit_PS command needs to be queued in the header always. */
1104 if (le16_to_cpu(cmdnode->cmdbuf->command) == CMD_802_11_PS_MODE) {
1105 struct cmd_ds_802_11_ps_mode *psm = (void *) &cmdnode->cmdbuf[1];
1106
1107 if (psm->action == cpu_to_le16(CMD_SUBCMD_EXIT_PS)) {
1108 if (priv->psstate != PS_STATE_FULL_POWER)
1109 addtail = 0;
1110 }
1111 }
1112
1113 spin_lock_irqsave(&priv->driver_lock, flags);
1114
1115 if (addtail)
1116 list_add_tail(&cmdnode->list, &priv->cmdpendingq);
1117 else
1118 list_add(&cmdnode->list, &priv->cmdpendingq);
1119
1120 spin_unlock_irqrestore(&priv->driver_lock, flags);
1121
1122 lbs_deb_host("QUEUE_CMD: inserted command 0x%04x into cmdpendingq\n",
1123 le16_to_cpu(cmdnode->cmdbuf->command));
1124
1125 done:
1126 lbs_deb_leave(LBS_DEB_HOST);
1127 }
1128
1129 static void lbs_submit_command(struct lbs_private *priv,
1130 struct cmd_ctrl_node *cmdnode)
1131 {
1132 unsigned long flags;
1133 struct cmd_header *cmd;
1134 uint16_t cmdsize;
1135 uint16_t command;
1136 int timeo = 5 * HZ;
1137 int ret;
1138
1139 lbs_deb_enter(LBS_DEB_HOST);
1140
1141 cmd = cmdnode->cmdbuf;
1142
1143 spin_lock_irqsave(&priv->driver_lock, flags);
1144 priv->cur_cmd = cmdnode;
1145 priv->cur_cmd_retcode = 0;
1146 spin_unlock_irqrestore(&priv->driver_lock, flags);
1147
1148 cmdsize = le16_to_cpu(cmd->size);
1149 command = le16_to_cpu(cmd->command);
1150
1151 /* These commands take longer */
1152 if (command == CMD_802_11_SCAN || command == CMD_802_11_ASSOCIATE ||
1153 command == CMD_802_11_AUTHENTICATE)
1154 timeo = 10 * HZ;
1155
1156 lbs_deb_host("DNLD_CMD: command 0x%04x, seq %d, size %d, jiffies %lu\n",
1157 command, le16_to_cpu(cmd->seqnum), cmdsize, jiffies);
1158 lbs_deb_hex(LBS_DEB_HOST, "DNLD_CMD", (void *) cmdnode->cmdbuf, cmdsize);
1159
1160 ret = priv->hw_host_to_card(priv, MVMS_CMD, (u8 *) cmd, cmdsize);
1161
1162 if (ret) {
1163 lbs_pr_info("DNLD_CMD: hw_host_to_card failed: %d\n", ret);
1164 /* Let the timer kick in and retry, and potentially reset
1165 the whole thing if the condition persists */
1166 timeo = HZ;
1167 } else
1168 lbs_deb_cmd("DNLD_CMD: sent command 0x%04x, jiffies %lu\n",
1169 command, jiffies);
1170
1171 /* Setup the timer after transmit command */
1172 mod_timer(&priv->command_timer, jiffies + timeo);
1173
1174 lbs_deb_leave(LBS_DEB_HOST);
1175 }
1176
1177 static int lbs_cmd_mac_control(struct lbs_private *priv,
1178 struct cmd_ds_command *cmd)
1179 {
1180 struct cmd_ds_mac_control *mac = &cmd->params.macctrl;
1181
1182 lbs_deb_enter(LBS_DEB_CMD);
1183
1184 cmd->command = cpu_to_le16(CMD_MAC_CONTROL);
1185 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mac_control) + S_DS_GEN);
1186 mac->action = cpu_to_le16(priv->currentpacketfilter);
1187
1188 lbs_deb_cmd("MAC_CONTROL: action 0x%x, size %d\n",
1189 le16_to_cpu(mac->action), le16_to_cpu(cmd->size));
1190
1191 lbs_deb_leave(LBS_DEB_CMD);
1192 return 0;
1193 }
1194
1195 /**
1196 * This function inserts command node to cmdfreeq
1197 * after cleans it. Requires priv->driver_lock held.
1198 */
1199 static void __lbs_cleanup_and_insert_cmd(struct lbs_private *priv,
1200 struct cmd_ctrl_node *cmdnode)
1201 {
1202 lbs_deb_enter(LBS_DEB_HOST);
1203
1204 if (!cmdnode)
1205 goto out;
1206
1207 cmdnode->callback = NULL;
1208 cmdnode->callback_arg = 0;
1209
1210 memset(cmdnode->cmdbuf, 0, LBS_CMD_BUFFER_SIZE);
1211
1212 list_add_tail(&cmdnode->list, &priv->cmdfreeq);
1213 out:
1214 lbs_deb_leave(LBS_DEB_HOST);
1215 }
1216
1217 static void lbs_cleanup_and_insert_cmd(struct lbs_private *priv,
1218 struct cmd_ctrl_node *ptempcmd)
1219 {
1220 unsigned long flags;
1221
1222 spin_lock_irqsave(&priv->driver_lock, flags);
1223 __lbs_cleanup_and_insert_cmd(priv, ptempcmd);
1224 spin_unlock_irqrestore(&priv->driver_lock, flags);
1225 }
1226
1227 void lbs_complete_command(struct lbs_private *priv, struct cmd_ctrl_node *cmd,
1228 int result)
1229 {
1230 if (cmd == priv->cur_cmd)
1231 priv->cur_cmd_retcode = result;
1232
1233 cmd->result = result;
1234 cmd->cmdwaitqwoken = 1;
1235 wake_up_interruptible(&cmd->cmdwait_q);
1236
1237 if (!cmd->callback)
1238 __lbs_cleanup_and_insert_cmd(priv, cmd);
1239 priv->cur_cmd = NULL;
1240 }
1241
1242 int lbs_set_radio_control(struct lbs_private *priv)
1243 {
1244 int ret = 0;
1245 struct cmd_ds_802_11_radio_control cmd;
1246
1247 lbs_deb_enter(LBS_DEB_CMD);
1248
1249 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
1250 cmd.action = cpu_to_le16(CMD_ACT_SET);
1251
1252 switch (priv->preamble) {
1253 case CMD_TYPE_SHORT_PREAMBLE:
1254 cmd.control = cpu_to_le16(SET_SHORT_PREAMBLE);
1255 break;
1256
1257 case CMD_TYPE_LONG_PREAMBLE:
1258 cmd.control = cpu_to_le16(SET_LONG_PREAMBLE);
1259 break;
1260
1261 case CMD_TYPE_AUTO_PREAMBLE:
1262 default:
1263 cmd.control = cpu_to_le16(SET_AUTO_PREAMBLE);
1264 break;
1265 }
1266
1267 if (priv->radioon)
1268 cmd.control |= cpu_to_le16(TURN_ON_RF);
1269 else
1270 cmd.control &= cpu_to_le16(~TURN_ON_RF);
1271
1272 lbs_deb_cmd("RADIO_SET: radio %d, preamble %d\n", priv->radioon,
1273 priv->preamble);
1274
1275 ret = lbs_cmd_with_response(priv, CMD_802_11_RADIO_CONTROL, &cmd);
1276
1277 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
1278 return ret;
1279 }
1280
1281 int lbs_set_mac_packet_filter(struct lbs_private *priv)
1282 {
1283 int ret = 0;
1284
1285 lbs_deb_enter(LBS_DEB_CMD);
1286
1287 /* Send MAC control command to station */
1288 ret = lbs_prepare_and_send_command(priv,
1289 CMD_MAC_CONTROL, 0, 0, 0, NULL);
1290
1291 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
1292 return ret;
1293 }
1294
1295 /**
1296 * @brief This function prepare the command before send to firmware.
1297 *
1298 * @param priv A pointer to struct lbs_private structure
1299 * @param cmd_no command number
1300 * @param cmd_action command action: GET or SET
1301 * @param wait_option wait option: wait response or not
1302 * @param cmd_oid cmd oid: treated as sub command
1303 * @param pdata_buf A pointer to informaion buffer
1304 * @return 0 or -1
1305 */
1306 int lbs_prepare_and_send_command(struct lbs_private *priv,
1307 u16 cmd_no,
1308 u16 cmd_action,
1309 u16 wait_option, u32 cmd_oid, void *pdata_buf)
1310 {
1311 int ret = 0;
1312 struct cmd_ctrl_node *cmdnode;
1313 struct cmd_ds_command *cmdptr;
1314 unsigned long flags;
1315
1316 lbs_deb_enter(LBS_DEB_HOST);
1317
1318 if (!priv) {
1319 lbs_deb_host("PREP_CMD: priv is NULL\n");
1320 ret = -1;
1321 goto done;
1322 }
1323
1324 if (priv->surpriseremoved) {
1325 lbs_deb_host("PREP_CMD: card removed\n");
1326 ret = -1;
1327 goto done;
1328 }
1329
1330 cmdnode = lbs_get_cmd_ctrl_node(priv);
1331
1332 if (cmdnode == NULL) {
1333 lbs_deb_host("PREP_CMD: cmdnode is NULL\n");
1334
1335 /* Wake up main thread to execute next command */
1336 wake_up_interruptible(&priv->waitq);
1337 ret = -1;
1338 goto done;
1339 }
1340
1341 lbs_set_cmd_ctrl_node(priv, cmdnode, pdata_buf);
1342
1343 cmdptr = (struct cmd_ds_command *)cmdnode->cmdbuf;
1344
1345 lbs_deb_host("PREP_CMD: command 0x%04x\n", cmd_no);
1346
1347 /* Set sequence number, command and INT option */
1348 priv->seqnum++;
1349 cmdptr->seqnum = cpu_to_le16(priv->seqnum);
1350
1351 cmdptr->command = cpu_to_le16(cmd_no);
1352 cmdptr->result = 0;
1353
1354 switch (cmd_no) {
1355 case CMD_802_11_PS_MODE:
1356 ret = lbs_cmd_802_11_ps_mode(priv, cmdptr, cmd_action);
1357 break;
1358
1359 case CMD_802_11_SCAN:
1360 ret = lbs_cmd_80211_scan(priv, cmdptr, pdata_buf);
1361 break;
1362
1363 case CMD_MAC_CONTROL:
1364 ret = lbs_cmd_mac_control(priv, cmdptr);
1365 break;
1366
1367 case CMD_802_11_ASSOCIATE:
1368 case CMD_802_11_REASSOCIATE:
1369 ret = lbs_cmd_80211_associate(priv, cmdptr, pdata_buf);
1370 break;
1371
1372 case CMD_802_11_DEAUTHENTICATE:
1373 ret = lbs_cmd_80211_deauthenticate(priv, cmdptr);
1374 break;
1375
1376 case CMD_802_11_AD_HOC_START:
1377 ret = lbs_cmd_80211_ad_hoc_start(priv, cmdptr, pdata_buf);
1378 break;
1379 case CMD_CODE_DNLD:
1380 break;
1381
1382 case CMD_802_11_RESET:
1383 ret = lbs_cmd_802_11_reset(priv, cmdptr, cmd_action);
1384 break;
1385
1386 case CMD_802_11_GET_LOG:
1387 ret = lbs_cmd_802_11_get_log(priv, cmdptr);
1388 break;
1389
1390 case CMD_802_11_AUTHENTICATE:
1391 ret = lbs_cmd_80211_authenticate(priv, cmdptr, pdata_buf);
1392 break;
1393
1394 case CMD_802_11_GET_STAT:
1395 ret = lbs_cmd_802_11_get_stat(priv, cmdptr);
1396 break;
1397
1398 case CMD_802_11_SNMP_MIB:
1399 ret = lbs_cmd_802_11_snmp_mib(priv, cmdptr,
1400 cmd_action, cmd_oid, pdata_buf);
1401 break;
1402
1403 case CMD_MAC_REG_ACCESS:
1404 case CMD_BBP_REG_ACCESS:
1405 case CMD_RF_REG_ACCESS:
1406 ret = lbs_cmd_reg_access(priv, cmdptr, cmd_action, pdata_buf);
1407 break;
1408
1409 case CMD_802_11_RF_TX_POWER:
1410 ret = lbs_cmd_802_11_rf_tx_power(priv, cmdptr,
1411 cmd_action, pdata_buf);
1412 break;
1413
1414 case CMD_802_11_RATE_ADAPT_RATESET:
1415 ret = lbs_cmd_802_11_rate_adapt_rateset(priv,
1416 cmdptr, cmd_action);
1417 break;
1418
1419 case CMD_MAC_MULTICAST_ADR:
1420 ret = lbs_cmd_mac_multicast_adr(priv, cmdptr, cmd_action);
1421 break;
1422
1423 case CMD_802_11_MONITOR_MODE:
1424 ret = lbs_cmd_802_11_monitor_mode(priv, cmdptr,
1425 cmd_action, pdata_buf);
1426 break;
1427
1428 case CMD_802_11_AD_HOC_JOIN:
1429 ret = lbs_cmd_80211_ad_hoc_join(priv, cmdptr, pdata_buf);
1430 break;
1431
1432 case CMD_802_11_RSSI:
1433 ret = lbs_cmd_802_11_rssi(priv, cmdptr);
1434 break;
1435
1436 case CMD_802_11_AD_HOC_STOP:
1437 ret = lbs_cmd_80211_ad_hoc_stop(priv, cmdptr);
1438 break;
1439
1440 case CMD_802_11_KEY_MATERIAL:
1441 ret = lbs_cmd_802_11_key_material(priv, cmdptr, cmd_action,
1442 cmd_oid, pdata_buf);
1443 break;
1444
1445 case CMD_802_11_PAIRWISE_TSC:
1446 break;
1447 case CMD_802_11_GROUP_TSC:
1448 break;
1449
1450 case CMD_802_11_MAC_ADDRESS:
1451 ret = lbs_cmd_802_11_mac_address(priv, cmdptr, cmd_action);
1452 break;
1453
1454 case CMD_802_11_EEPROM_ACCESS:
1455 ret = lbs_cmd_802_11_eeprom_access(priv, cmdptr,
1456 cmd_action, pdata_buf);
1457 break;
1458
1459 case CMD_802_11_SET_AFC:
1460 case CMD_802_11_GET_AFC:
1461
1462 cmdptr->command = cpu_to_le16(cmd_no);
1463 cmdptr->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_afc) +
1464 S_DS_GEN);
1465
1466 memmove(&cmdptr->params.afc,
1467 pdata_buf, sizeof(struct cmd_ds_802_11_afc));
1468
1469 ret = 0;
1470 goto done;
1471
1472 case CMD_802_11D_DOMAIN_INFO:
1473 ret = lbs_cmd_802_11d_domain_info(priv, cmdptr,
1474 cmd_no, cmd_action);
1475 break;
1476
1477 case CMD_802_11_TPC_CFG:
1478 cmdptr->command = cpu_to_le16(CMD_802_11_TPC_CFG);
1479 cmdptr->size =
1480 cpu_to_le16(sizeof(struct cmd_ds_802_11_tpc_cfg) +
1481 S_DS_GEN);
1482
1483 memmove(&cmdptr->params.tpccfg,
1484 pdata_buf, sizeof(struct cmd_ds_802_11_tpc_cfg));
1485
1486 ret = 0;
1487 break;
1488 case CMD_802_11_LED_GPIO_CTRL:
1489 {
1490 struct mrvlietypes_ledgpio *gpio =
1491 (struct mrvlietypes_ledgpio*)
1492 cmdptr->params.ledgpio.data;
1493
1494 memmove(&cmdptr->params.ledgpio,
1495 pdata_buf,
1496 sizeof(struct cmd_ds_802_11_led_ctrl));
1497
1498 cmdptr->command =
1499 cpu_to_le16(CMD_802_11_LED_GPIO_CTRL);
1500
1501 #define ACTION_NUMLED_TLVTYPE_LEN_FIELDS_LEN 8
1502 cmdptr->size =
1503 cpu_to_le16(le16_to_cpu(gpio->header.len)
1504 + S_DS_GEN
1505 + ACTION_NUMLED_TLVTYPE_LEN_FIELDS_LEN);
1506 gpio->header.len = gpio->header.len;
1507
1508 ret = 0;
1509 break;
1510 }
1511
1512 case CMD_802_11_PWR_CFG:
1513 cmdptr->command = cpu_to_le16(CMD_802_11_PWR_CFG);
1514 cmdptr->size =
1515 cpu_to_le16(sizeof(struct cmd_ds_802_11_pwr_cfg) +
1516 S_DS_GEN);
1517 memmove(&cmdptr->params.pwrcfg, pdata_buf,
1518 sizeof(struct cmd_ds_802_11_pwr_cfg));
1519
1520 ret = 0;
1521 break;
1522 case CMD_BT_ACCESS:
1523 ret = lbs_cmd_bt_access(priv, cmdptr, cmd_action, pdata_buf);
1524 break;
1525
1526 case CMD_FWT_ACCESS:
1527 ret = lbs_cmd_fwt_access(priv, cmdptr, cmd_action, pdata_buf);
1528 break;
1529
1530 case CMD_GET_TSF:
1531 cmdptr->command = cpu_to_le16(CMD_GET_TSF);
1532 cmdptr->size = cpu_to_le16(sizeof(struct cmd_ds_get_tsf) +
1533 S_DS_GEN);
1534 ret = 0;
1535 break;
1536 case CMD_802_11_BEACON_CTRL:
1537 ret = lbs_cmd_bcn_ctrl(priv, cmdptr, cmd_action);
1538 break;
1539 default:
1540 lbs_deb_host("PREP_CMD: unknown command 0x%04x\n", cmd_no);
1541 ret = -1;
1542 break;
1543 }
1544
1545 /* return error, since the command preparation failed */
1546 if (ret != 0) {
1547 lbs_deb_host("PREP_CMD: command preparation failed\n");
1548 lbs_cleanup_and_insert_cmd(priv, cmdnode);
1549 ret = -1;
1550 goto done;
1551 }
1552
1553 cmdnode->cmdwaitqwoken = 0;
1554
1555 lbs_queue_cmd(priv, cmdnode);
1556 wake_up_interruptible(&priv->waitq);
1557
1558 if (wait_option & CMD_OPTION_WAITFORRSP) {
1559 lbs_deb_host("PREP_CMD: wait for response\n");
1560 might_sleep();
1561 wait_event_interruptible(cmdnode->cmdwait_q,
1562 cmdnode->cmdwaitqwoken);
1563 }
1564
1565 spin_lock_irqsave(&priv->driver_lock, flags);
1566 if (priv->cur_cmd_retcode) {
1567 lbs_deb_host("PREP_CMD: command failed with return code %d\n",
1568 priv->cur_cmd_retcode);
1569 priv->cur_cmd_retcode = 0;
1570 ret = -1;
1571 }
1572 spin_unlock_irqrestore(&priv->driver_lock, flags);
1573
1574 done:
1575 lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
1576 return ret;
1577 }
1578
1579 /**
1580 * @brief This function allocates the command buffer and link
1581 * it to command free queue.
1582 *
1583 * @param priv A pointer to struct lbs_private structure
1584 * @return 0 or -1
1585 */
1586 int lbs_allocate_cmd_buffer(struct lbs_private *priv)
1587 {
1588 int ret = 0;
1589 u32 bufsize;
1590 u32 i;
1591 struct cmd_ctrl_node *cmdarray;
1592
1593 lbs_deb_enter(LBS_DEB_HOST);
1594
1595 /* Allocate and initialize the command array */
1596 bufsize = sizeof(struct cmd_ctrl_node) * LBS_NUM_CMD_BUFFERS;
1597 if (!(cmdarray = kzalloc(bufsize, GFP_KERNEL))) {
1598 lbs_deb_host("ALLOC_CMD_BUF: tempcmd_array is NULL\n");
1599 ret = -1;
1600 goto done;
1601 }
1602 priv->cmd_array = cmdarray;
1603
1604 /* Allocate and initialize each command buffer in the command array */
1605 for (i = 0; i < LBS_NUM_CMD_BUFFERS; i++) {
1606 cmdarray[i].cmdbuf = kzalloc(LBS_CMD_BUFFER_SIZE, GFP_KERNEL);
1607 if (!cmdarray[i].cmdbuf) {
1608 lbs_deb_host("ALLOC_CMD_BUF: ptempvirtualaddr is NULL\n");
1609 ret = -1;
1610 goto done;
1611 }
1612 }
1613
1614 for (i = 0; i < LBS_NUM_CMD_BUFFERS; i++) {
1615 init_waitqueue_head(&cmdarray[i].cmdwait_q);
1616 lbs_cleanup_and_insert_cmd(priv, &cmdarray[i]);
1617 }
1618 ret = 0;
1619
1620 done:
1621 lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
1622 return ret;
1623 }
1624
1625 /**
1626 * @brief This function frees the command buffer.
1627 *
1628 * @param priv A pointer to struct lbs_private structure
1629 * @return 0 or -1
1630 */
1631 int lbs_free_cmd_buffer(struct lbs_private *priv)
1632 {
1633 struct cmd_ctrl_node *cmdarray;
1634 unsigned int i;
1635
1636 lbs_deb_enter(LBS_DEB_HOST);
1637
1638 /* need to check if cmd array is allocated or not */
1639 if (priv->cmd_array == NULL) {
1640 lbs_deb_host("FREE_CMD_BUF: cmd_array is NULL\n");
1641 goto done;
1642 }
1643
1644 cmdarray = priv->cmd_array;
1645
1646 /* Release shared memory buffers */
1647 for (i = 0; i < LBS_NUM_CMD_BUFFERS; i++) {
1648 if (cmdarray[i].cmdbuf) {
1649 kfree(cmdarray[i].cmdbuf);
1650 cmdarray[i].cmdbuf = NULL;
1651 }
1652 }
1653
1654 /* Release cmd_ctrl_node */
1655 if (priv->cmd_array) {
1656 kfree(priv->cmd_array);
1657 priv->cmd_array = NULL;
1658 }
1659
1660 done:
1661 lbs_deb_leave(LBS_DEB_HOST);
1662 return 0;
1663 }
1664
1665 /**
1666 * @brief This function gets a free command node if available in
1667 * command free queue.
1668 *
1669 * @param priv A pointer to struct lbs_private structure
1670 * @return cmd_ctrl_node A pointer to cmd_ctrl_node structure or NULL
1671 */
1672 static struct cmd_ctrl_node *lbs_get_cmd_ctrl_node(struct lbs_private *priv)
1673 {
1674 struct cmd_ctrl_node *tempnode;
1675 unsigned long flags;
1676
1677 lbs_deb_enter(LBS_DEB_HOST);
1678
1679 if (!priv)
1680 return NULL;
1681
1682 spin_lock_irqsave(&priv->driver_lock, flags);
1683
1684 if (!list_empty(&priv->cmdfreeq)) {
1685 tempnode = list_first_entry(&priv->cmdfreeq,
1686 struct cmd_ctrl_node, list);
1687 list_del(&tempnode->list);
1688 } else {
1689 lbs_deb_host("GET_CMD_NODE: cmd_ctrl_node is not available\n");
1690 tempnode = NULL;
1691 }
1692
1693 spin_unlock_irqrestore(&priv->driver_lock, flags);
1694
1695 lbs_deb_leave(LBS_DEB_HOST);
1696 return tempnode;
1697 }
1698
1699 /**
1700 * @brief This function cleans command node.
1701 *
1702 * @param ptempnode A pointer to cmdCtrlNode structure
1703 * @return n/a
1704 */
1705
1706 /**
1707 * @brief This function initializes the command node.
1708 *
1709 * @param priv A pointer to struct lbs_private structure
1710 * @param ptempnode A pointer to cmd_ctrl_node structure
1711 * @param pdata_buf A pointer to informaion buffer
1712 * @return 0 or -1
1713 */
1714 static void lbs_set_cmd_ctrl_node(struct lbs_private *priv,
1715 struct cmd_ctrl_node *ptempnode,
1716 void *pdata_buf)
1717 {
1718 lbs_deb_enter(LBS_DEB_HOST);
1719
1720 if (!ptempnode)
1721 return;
1722
1723 ptempnode->callback = NULL;
1724 ptempnode->callback_arg = (unsigned long)pdata_buf;
1725
1726 lbs_deb_leave(LBS_DEB_HOST);
1727 }
1728
1729 /**
1730 * @brief This function executes next command in command
1731 * pending queue. It will put fimware back to PS mode
1732 * if applicable.
1733 *
1734 * @param priv A pointer to struct lbs_private structure
1735 * @return 0 or -1
1736 */
1737 int lbs_execute_next_command(struct lbs_private *priv)
1738 {
1739 struct cmd_ctrl_node *cmdnode = NULL;
1740 struct cmd_header *cmd;
1741 unsigned long flags;
1742 int ret = 0;
1743
1744 // Debug group is LBS_DEB_THREAD and not LBS_DEB_HOST, because the
1745 // only caller to us is lbs_thread() and we get even when a
1746 // data packet is received
1747 lbs_deb_enter(LBS_DEB_THREAD);
1748
1749 spin_lock_irqsave(&priv->driver_lock, flags);
1750
1751 if (priv->cur_cmd) {
1752 lbs_pr_alert( "EXEC_NEXT_CMD: already processing command!\n");
1753 spin_unlock_irqrestore(&priv->driver_lock, flags);
1754 ret = -1;
1755 goto done;
1756 }
1757
1758 if (!list_empty(&priv->cmdpendingq)) {
1759 cmdnode = list_first_entry(&priv->cmdpendingq,
1760 struct cmd_ctrl_node, list);
1761 }
1762
1763 spin_unlock_irqrestore(&priv->driver_lock, flags);
1764
1765 if (cmdnode) {
1766 cmd = cmdnode->cmdbuf;
1767
1768 if (is_command_allowed_in_ps(le16_to_cpu(cmd->command))) {
1769 if ((priv->psstate == PS_STATE_SLEEP) ||
1770 (priv->psstate == PS_STATE_PRE_SLEEP)) {
1771 lbs_deb_host(
1772 "EXEC_NEXT_CMD: cannot send cmd 0x%04x in psstate %d\n",
1773 le16_to_cpu(cmd->command),
1774 priv->psstate);
1775 ret = -1;
1776 goto done;
1777 }
1778 lbs_deb_host("EXEC_NEXT_CMD: OK to send command "
1779 "0x%04x in psstate %d\n",
1780 le16_to_cpu(cmd->command), priv->psstate);
1781 } else if (priv->psstate != PS_STATE_FULL_POWER) {
1782 /*
1783 * 1. Non-PS command:
1784 * Queue it. set needtowakeup to TRUE if current state
1785 * is SLEEP, otherwise call lbs_ps_wakeup to send Exit_PS.
1786 * 2. PS command but not Exit_PS:
1787 * Ignore it.
1788 * 3. PS command Exit_PS:
1789 * Set needtowakeup to TRUE if current state is SLEEP,
1790 * otherwise send this command down to firmware
1791 * immediately.
1792 */
1793 if (cmd->command != cpu_to_le16(CMD_802_11_PS_MODE)) {
1794 /* Prepare to send Exit PS,
1795 * this non PS command will be sent later */
1796 if ((priv->psstate == PS_STATE_SLEEP)
1797 || (priv->psstate == PS_STATE_PRE_SLEEP)
1798 ) {
1799 /* w/ new scheme, it will not reach here.
1800 since it is blocked in main_thread. */
1801 priv->needtowakeup = 1;
1802 } else
1803 lbs_ps_wakeup(priv, 0);
1804
1805 ret = 0;
1806 goto done;
1807 } else {
1808 /*
1809 * PS command. Ignore it if it is not Exit_PS.
1810 * otherwise send it down immediately.
1811 */
1812 struct cmd_ds_802_11_ps_mode *psm = (void *)&cmd[1];
1813
1814 lbs_deb_host(
1815 "EXEC_NEXT_CMD: PS cmd, action 0x%02x\n",
1816 psm->action);
1817 if (psm->action !=
1818 cpu_to_le16(CMD_SUBCMD_EXIT_PS)) {
1819 lbs_deb_host(
1820 "EXEC_NEXT_CMD: ignore ENTER_PS cmd\n");
1821 list_del(&cmdnode->list);
1822 spin_lock_irqsave(&priv->driver_lock, flags);
1823 lbs_complete_command(priv, cmdnode, 0);
1824 spin_unlock_irqrestore(&priv->driver_lock, flags);
1825
1826 ret = 0;
1827 goto done;
1828 }
1829
1830 if ((priv->psstate == PS_STATE_SLEEP) ||
1831 (priv->psstate == PS_STATE_PRE_SLEEP)) {
1832 lbs_deb_host(
1833 "EXEC_NEXT_CMD: ignore EXIT_PS cmd in sleep\n");
1834 list_del(&cmdnode->list);
1835 spin_lock_irqsave(&priv->driver_lock, flags);
1836 lbs_complete_command(priv, cmdnode, 0);
1837 spin_unlock_irqrestore(&priv->driver_lock, flags);
1838 priv->needtowakeup = 1;
1839
1840 ret = 0;
1841 goto done;
1842 }
1843
1844 lbs_deb_host(
1845 "EXEC_NEXT_CMD: sending EXIT_PS\n");
1846 }
1847 }
1848 list_del(&cmdnode->list);
1849 lbs_deb_host("EXEC_NEXT_CMD: sending command 0x%04x\n",
1850 le16_to_cpu(cmd->command));
1851 lbs_submit_command(priv, cmdnode);
1852 } else {
1853 /*
1854 * check if in power save mode, if yes, put the device back
1855 * to PS mode
1856 */
1857 if ((priv->psmode != LBS802_11POWERMODECAM) &&
1858 (priv->psstate == PS_STATE_FULL_POWER) &&
1859 ((priv->connect_status == LBS_CONNECTED) ||
1860 (priv->mesh_connect_status == LBS_CONNECTED))) {
1861 if (priv->secinfo.WPAenabled ||
1862 priv->secinfo.WPA2enabled) {
1863 /* check for valid WPA group keys */
1864 if (priv->wpa_mcast_key.len ||
1865 priv->wpa_unicast_key.len) {
1866 lbs_deb_host(
1867 "EXEC_NEXT_CMD: WPA enabled and GTK_SET"
1868 " go back to PS_SLEEP");
1869 lbs_ps_sleep(priv, 0);
1870 }
1871 } else {
1872 lbs_deb_host(
1873 "EXEC_NEXT_CMD: cmdpendingq empty, "
1874 "go back to PS_SLEEP");
1875 lbs_ps_sleep(priv, 0);
1876 }
1877 }
1878 }
1879
1880 ret = 0;
1881 done:
1882 lbs_deb_leave(LBS_DEB_THREAD);
1883 return ret;
1884 }
1885
1886 void lbs_send_iwevcustom_event(struct lbs_private *priv, s8 *str)
1887 {
1888 union iwreq_data iwrq;
1889 u8 buf[50];
1890
1891 lbs_deb_enter(LBS_DEB_WEXT);
1892
1893 memset(&iwrq, 0, sizeof(union iwreq_data));
1894 memset(buf, 0, sizeof(buf));
1895
1896 snprintf(buf, sizeof(buf) - 1, "%s", str);
1897
1898 iwrq.data.length = strlen(buf) + 1 + IW_EV_LCP_LEN;
1899
1900 /* Send Event to upper layer */
1901 lbs_deb_wext("event indication string %s\n", (char *)buf);
1902 lbs_deb_wext("event indication length %d\n", iwrq.data.length);
1903 lbs_deb_wext("sending wireless event IWEVCUSTOM for %s\n", str);
1904
1905 wireless_send_event(priv->dev, IWEVCUSTOM, &iwrq, buf);
1906
1907 lbs_deb_leave(LBS_DEB_WEXT);
1908 }
1909
1910 static int sendconfirmsleep(struct lbs_private *priv, u8 *cmdptr, u16 size)
1911 {
1912 unsigned long flags;
1913 int ret = 0;
1914
1915 lbs_deb_enter(LBS_DEB_HOST);
1916
1917 lbs_deb_host("SEND_SLEEPC_CMD: before download, cmd size %d\n",
1918 size);
1919
1920 lbs_deb_hex(LBS_DEB_HOST, "sleep confirm command", cmdptr, size);
1921
1922 ret = priv->hw_host_to_card(priv, MVMS_CMD, cmdptr, size);
1923
1924 spin_lock_irqsave(&priv->driver_lock, flags);
1925 if (priv->intcounter || priv->currenttxskb)
1926 lbs_deb_host("SEND_SLEEPC_CMD: intcounter %d, currenttxskb %p\n",
1927 priv->intcounter, priv->currenttxskb);
1928 spin_unlock_irqrestore(&priv->driver_lock, flags);
1929
1930 if (ret) {
1931 lbs_pr_alert(
1932 "SEND_SLEEPC_CMD: Host to Card failed for Confirm Sleep\n");
1933 } else {
1934 spin_lock_irqsave(&priv->driver_lock, flags);
1935 if (!priv->intcounter) {
1936 priv->psstate = PS_STATE_SLEEP;
1937 } else {
1938 lbs_deb_host("SEND_SLEEPC_CMD: after sent, intcounter %d\n",
1939 priv->intcounter);
1940 }
1941 spin_unlock_irqrestore(&priv->driver_lock, flags);
1942
1943 lbs_deb_host("SEND_SLEEPC_CMD: sent confirm sleep\n");
1944 }
1945
1946 lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
1947 return ret;
1948 }
1949
1950 void lbs_ps_sleep(struct lbs_private *priv, int wait_option)
1951 {
1952 lbs_deb_enter(LBS_DEB_HOST);
1953
1954 /*
1955 * PS is currently supported only in Infrastructure mode
1956 * Remove this check if it is to be supported in IBSS mode also
1957 */
1958
1959 lbs_prepare_and_send_command(priv, CMD_802_11_PS_MODE,
1960 CMD_SUBCMD_ENTER_PS, wait_option, 0, NULL);
1961
1962 lbs_deb_leave(LBS_DEB_HOST);
1963 }
1964
1965 /**
1966 * @brief This function sends Exit_PS command to firmware.
1967 *
1968 * @param priv A pointer to struct lbs_private structure
1969 * @param wait_option wait response or not
1970 * @return n/a
1971 */
1972 void lbs_ps_wakeup(struct lbs_private *priv, int wait_option)
1973 {
1974 __le32 Localpsmode;
1975
1976 lbs_deb_enter(LBS_DEB_HOST);
1977
1978 Localpsmode = cpu_to_le32(LBS802_11POWERMODECAM);
1979
1980 lbs_prepare_and_send_command(priv, CMD_802_11_PS_MODE,
1981 CMD_SUBCMD_EXIT_PS,
1982 wait_option, 0, &Localpsmode);
1983
1984 lbs_deb_leave(LBS_DEB_HOST);
1985 }
1986
1987 /**
1988 * @brief This function checks condition and prepares to
1989 * send sleep confirm command to firmware if ok.
1990 *
1991 * @param priv A pointer to struct lbs_private structure
1992 * @param psmode Power Saving mode
1993 * @return n/a
1994 */
1995 void lbs_ps_confirm_sleep(struct lbs_private *priv, u16 psmode)
1996 {
1997 unsigned long flags =0;
1998 u8 allowed = 1;
1999
2000 lbs_deb_enter(LBS_DEB_HOST);
2001
2002 if (priv->dnld_sent) {
2003 allowed = 0;
2004 lbs_deb_host("dnld_sent was set\n");
2005 }
2006
2007 spin_lock_irqsave(&priv->driver_lock, flags);
2008 if (priv->cur_cmd) {
2009 allowed = 0;
2010 lbs_deb_host("cur_cmd was set\n");
2011 }
2012 if (priv->intcounter > 0) {
2013 allowed = 0;
2014 lbs_deb_host("intcounter %d\n", priv->intcounter);
2015 }
2016 spin_unlock_irqrestore(&priv->driver_lock, flags);
2017
2018 if (allowed) {
2019 lbs_deb_host("sending lbs_ps_confirm_sleep\n");
2020 sendconfirmsleep(priv, (u8 *) & priv->lbs_ps_confirm_sleep,
2021 sizeof(struct PS_CMD_ConfirmSleep));
2022 } else {
2023 lbs_deb_host("sleep confirm has been delayed\n");
2024 }
2025
2026 lbs_deb_leave(LBS_DEB_HOST);
2027 }
2028
2029
2030 /**
2031 * @brief Simple callback that copies response back into command
2032 *
2033 * @param priv A pointer to struct lbs_private structure
2034 * @param extra A pointer to the original command structure for which
2035 * 'resp' is a response
2036 * @param resp A pointer to the command response
2037 *
2038 * @return 0 on success, error on failure
2039 */
2040 int lbs_cmd_copyback(struct lbs_private *priv, unsigned long extra,
2041 struct cmd_header *resp)
2042 {
2043 struct cmd_header *buf = (void *)extra;
2044 uint16_t copy_len;
2045
2046 lbs_deb_enter(LBS_DEB_CMD);
2047
2048 copy_len = min(le16_to_cpu(buf->size), le16_to_cpu(resp->size));
2049 lbs_deb_cmd("Copying back %u bytes; command response was %u bytes, "
2050 "copy back buffer was %u bytes\n", copy_len,
2051 le16_to_cpu(resp->size), le16_to_cpu(buf->size));
2052 memcpy(buf, resp, copy_len);
2053
2054 lbs_deb_leave(LBS_DEB_CMD);
2055 return 0;
2056 }
2057 EXPORT_SYMBOL_GPL(lbs_cmd_copyback);
2058
2059 struct cmd_ctrl_node *__lbs_cmd_async(struct lbs_private *priv, uint16_t command,
2060 struct cmd_header *in_cmd, int in_cmd_size,
2061 int (*callback)(struct lbs_private *, unsigned long, struct cmd_header *),
2062 unsigned long callback_arg)
2063 {
2064 struct cmd_ctrl_node *cmdnode;
2065
2066 lbs_deb_enter(LBS_DEB_HOST);
2067
2068 if (priv->surpriseremoved) {
2069 lbs_deb_host("PREP_CMD: card removed\n");
2070 cmdnode = ERR_PTR(-ENOENT);
2071 goto done;
2072 }
2073
2074 cmdnode = lbs_get_cmd_ctrl_node(priv);
2075 if (cmdnode == NULL) {
2076 lbs_deb_host("PREP_CMD: cmdnode is NULL\n");
2077
2078 /* Wake up main thread to execute next command */
2079 wake_up_interruptible(&priv->waitq);
2080 cmdnode = ERR_PTR(-ENOBUFS);
2081 goto done;
2082 }
2083
2084 cmdnode->callback = callback;
2085 cmdnode->callback_arg = callback_arg;
2086
2087 /* Copy the incoming command to the buffer */
2088 memcpy(cmdnode->cmdbuf, in_cmd, in_cmd_size);
2089
2090 /* Set sequence number, clean result, move to buffer */
2091 priv->seqnum++;
2092 cmdnode->cmdbuf->command = cpu_to_le16(command);
2093 cmdnode->cmdbuf->size = cpu_to_le16(in_cmd_size);
2094 cmdnode->cmdbuf->seqnum = cpu_to_le16(priv->seqnum);
2095 cmdnode->cmdbuf->result = 0;
2096
2097 lbs_deb_host("PREP_CMD: command 0x%04x\n", command);
2098
2099 /* here was the big old switch() statement, which is now obsolete,
2100 * because the caller of lbs_cmd() sets up all of *cmd for us. */
2101
2102 cmdnode->cmdwaitqwoken = 0;
2103 lbs_queue_cmd(priv, cmdnode);
2104 wake_up_interruptible(&priv->waitq);
2105
2106 done:
2107 lbs_deb_leave_args(LBS_DEB_HOST, "ret %p", cmdnode);
2108 return cmdnode;
2109 }
2110
2111 int __lbs_cmd(struct lbs_private *priv, uint16_t command,
2112 struct cmd_header *in_cmd, int in_cmd_size,
2113 int (*callback)(struct lbs_private *, unsigned long, struct cmd_header *),
2114 unsigned long callback_arg)
2115 {
2116 struct cmd_ctrl_node *cmdnode;
2117 unsigned long flags;
2118 int ret = 0;
2119
2120 lbs_deb_enter(LBS_DEB_HOST);
2121
2122 cmdnode = __lbs_cmd_async(priv, command, in_cmd, in_cmd_size,
2123 callback, callback_arg);
2124 if (IS_ERR(cmdnode)) {
2125 ret = PTR_ERR(cmdnode);
2126 goto done;
2127 }
2128
2129 might_sleep();
2130 wait_event_interruptible(cmdnode->cmdwait_q, cmdnode->cmdwaitqwoken);
2131
2132 spin_lock_irqsave(&priv->driver_lock, flags);
2133 ret = cmdnode->result;
2134 if (ret)
2135 lbs_pr_info("PREP_CMD: command 0x%04x failed: %d\n",
2136 command, ret);
2137
2138 __lbs_cleanup_and_insert_cmd(priv, cmdnode);
2139 spin_unlock_irqrestore(&priv->driver_lock, flags);
2140
2141 done:
2142 lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
2143 return ret;
2144 }
2145 EXPORT_SYMBOL_GPL(__lbs_cmd);
2146
2147
WRT350N Kernel Patches