2 * This file contains the handling of command.
3 * It prepares command and sends it to firmware when it is ready.
6 #include <net/iw_handler.h>
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,
23 * @brief Checks whether a command is allowed in Power Save mode
25 * @param command the command ID
26 * @return 1 if allowed, 0 if not allowed
28 static u8 is_command_allowed_in_ps(u16 cmd)
40 * @brief Updates the hardware details like MAC address and regulatory region
42 * @param priv A pointer to struct lbs_private structure
44 * @return 0 on success, error on failure
46 int lbs_update_hw_spec(struct lbs_private *priv)
48 struct cmd_ds_get_hw_spec cmd;
53 lbs_deb_enter(LBS_DEB_CMD);
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);
62 priv->fwcapinfo = le32_to_cpu(cmd.fwcapinfo);
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);
70 /* Some firmware capabilities:
71 * CF card firmware 5.0.16p0: cap 0x00000303
72 * USB dongle firmware 5.110.17p2: cap 0x00000303
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,
81 lbs_deb_cmd("GET_HW_SPEC: hardware interface 0x%x, hardware spec 0x%04x\n",
82 cmd.hwifversion, cmd.version);
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.
88 priv->regioncode = le16_to_cpu(cmd.regioncode) & 0xFF;
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])
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");
102 if (priv->current_addr[0] == 0xff)
103 memmove(priv->current_addr, cmd.permanentaddr, ETH_ALEN);
105 memcpy(priv->dev->dev_addr, priv->current_addr, ETH_ALEN);
107 memcpy(priv->mesh_dev->dev_addr, priv->current_addr, ETH_ALEN);
109 if (lbs_set_regiontable(priv, priv->regioncode, 0)) {
114 if (lbs_set_universaltable(priv, 0)) {
120 lbs_deb_leave(LBS_DEB_CMD);
124 int lbs_host_sleep_cfg(struct lbs_private *priv, uint32_t criteria)
126 struct cmd_ds_host_sleep cmd_config;
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;
134 ret = lbs_cmd_with_response(priv, CMD_802_11_HOST_SLEEP_CFG, &cmd_config);
136 lbs_deb_cmd("Set WOL criteria to %x\n", criteria);
137 priv->wol_criteria = criteria;
139 lbs_pr_info("HOST_SLEEP_CFG failed %d\n", ret);
144 EXPORT_SYMBOL_GPL(lbs_host_sleep_cfg);
146 static int lbs_cmd_802_11_ps_mode(struct lbs_private *priv,
147 struct cmd_ds_command *cmd,
150 struct cmd_ds_802_11_ps_mode *psm = &cmd->params.psmode;
152 lbs_deb_enter(LBS_DEB_CMD);
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) +
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");
163 psm->locallisteninterval = 0;
164 psm->nullpktinterval = 0;
166 cpu_to_le16(MRVDRV_DEFAULT_MULTIPLE_DTIM);
169 case CMD_SUBCMD_EXIT_PS:
170 lbs_deb_cmd("PS command:" "SubCode- Exit PS\n");
173 case CMD_SUBCMD_SLEEP_CONFIRMED:
174 lbs_deb_cmd("PS command: SubCode- sleep confirm\n");
181 lbs_deb_leave(LBS_DEB_CMD);
185 int lbs_cmd_802_11_inactivity_timeout(struct lbs_private *priv,
186 uint16_t cmd_action, uint16_t *timeout)
188 struct cmd_ds_802_11_inactivity_timeout cmd;
191 lbs_deb_enter(LBS_DEB_CMD);
193 cmd.hdr.command = cpu_to_le16(CMD_802_11_INACTIVITY_TIMEOUT);
194 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
196 cmd.action = cpu_to_le16(cmd_action);
198 if (cmd_action == CMD_ACT_SET)
199 cmd.timeout = cpu_to_le16(*timeout);
203 ret = lbs_cmd_with_response(priv, CMD_802_11_INACTIVITY_TIMEOUT, &cmd);
206 *timeout = le16_to_cpu(cmd.timeout);
208 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
212 int lbs_cmd_802_11_sleep_params(struct lbs_private *priv, uint16_t cmd_action,
213 struct sleep_params *sp)
215 struct cmd_ds_802_11_sleep_params cmd;
218 lbs_deb_enter(LBS_DEB_CMD);
220 if (cmd_action == CMD_ACT_GET) {
221 memset(&cmd, 0, sizeof(cmd));
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);
230 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
231 cmd.action = cpu_to_le16(cmd_action);
233 ret = lbs_cmd_with_response(priv, CMD_802_11_SLEEP_PARAMS, &cmd);
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);
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);
250 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
254 int lbs_cmd_802_11_set_wep(struct lbs_private *priv, uint16_t cmd_action,
255 struct assoc_request *assoc)
257 struct cmd_ds_802_11_set_wep cmd;
260 lbs_deb_enter(LBS_DEB_CMD);
262 cmd.hdr.command = cpu_to_le16(CMD_802_11_SET_WEP);
263 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
265 cmd.action = cpu_to_le16(cmd_action);
267 if (cmd_action == CMD_ACT_ADD) {
270 /* default tx key index */
271 cmd.keyindex = cpu_to_le16(assoc->wep_tx_keyidx &
272 CMD_WEP_KEY_INDEX_MASK);
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];
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);
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);
292 lbs_deb_cmd("SET_WEP: invalid key %d, length %d\n",
299 } else if (cmd_action == CMD_ACT_REMOVE) {
300 /* ACT_REMOVE clears _all_ WEP keys */
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);
308 ret = lbs_cmd_with_response(priv, CMD_802_11_SET_WEP, &cmd);
310 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
314 int lbs_cmd_802_11_enable_rsn(struct lbs_private *priv, uint16_t cmd_action,
317 struct cmd_ds_802_11_enable_rsn cmd;
320 lbs_deb_enter(LBS_DEB_CMD);
322 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
323 cmd.action = cpu_to_le16(cmd_action);
325 if (cmd_action == CMD_ACT_SET) {
327 cmd.enable = cpu_to_le16(CMD_ENABLE_RSN);
329 cmd.enable = cpu_to_le16(CMD_DISABLE_RSN);
330 lbs_deb_cmd("ENABLE_RSN: %d\n", *enable);
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);
337 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
341 static void set_one_wpa_key(struct MrvlIEtype_keyParamSet * pkeyparamset,
342 struct enc_key * pkey)
344 lbs_deb_enter(LBS_DEB_CMD);
346 if (pkey->flags & KEY_INFO_WPA_ENABLED) {
347 pkeyparamset->keyinfo |= cpu_to_le16(KEY_INFO_WPA_ENABLED);
349 if (pkey->flags & KEY_INFO_WPA_UNICAST) {
350 pkeyparamset->keyinfo |= cpu_to_le16(KEY_INFO_WPA_UNICAST);
352 if (pkey->flags & KEY_INFO_WPA_MCAST) {
353 pkeyparamset->keyinfo |= cpu_to_le16(KEY_INFO_WPA_MCAST);
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);
367 static int lbs_cmd_802_11_key_material(struct lbs_private *priv,
368 struct cmd_ds_command *cmd,
370 u32 cmd_oid, void *pdata_buf)
372 struct cmd_ds_802_11_key_material *pkeymaterial =
373 &cmd->params.keymaterial;
374 struct assoc_request * assoc_req = pdata_buf;
378 lbs_deb_enter(LBS_DEB_CMD);
380 cmd->command = cpu_to_le16(CMD_802_11_KEY_MATERIAL);
381 pkeymaterial->action = cpu_to_le16(cmd_action);
383 if (cmd_action == CMD_ACT_GET) {
384 cmd->size = cpu_to_le16(S_DS_GEN + sizeof (pkeymaterial->action));
389 memset(&pkeymaterial->keyParamSet, 0, sizeof(pkeymaterial->keyParamSet));
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);
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);
403 cmd->size = cpu_to_le16( S_DS_GEN
404 + sizeof (pkeymaterial->action)
405 + (index * sizeof(struct MrvlIEtype_keyParamSet)));
410 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
414 static int lbs_cmd_802_11_reset(struct lbs_private *priv,
415 struct cmd_ds_command *cmd, int cmd_action)
417 struct cmd_ds_802_11_reset *reset = &cmd->params.reset;
419 lbs_deb_enter(LBS_DEB_CMD);
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);
425 lbs_deb_leave(LBS_DEB_CMD);
429 static int lbs_cmd_802_11_get_log(struct lbs_private *priv,
430 struct cmd_ds_command *cmd)
432 lbs_deb_enter(LBS_DEB_CMD);
433 cmd->command = cpu_to_le16(CMD_802_11_GET_LOG);
435 cpu_to_le16(sizeof(struct cmd_ds_802_11_get_log) + S_DS_GEN);
437 lbs_deb_leave(LBS_DEB_CMD);
441 static int lbs_cmd_802_11_get_stat(struct lbs_private *priv,
442 struct cmd_ds_command *cmd)
444 lbs_deb_enter(LBS_DEB_CMD);
445 cmd->command = cpu_to_le16(CMD_802_11_GET_STAT);
447 cpu_to_le16(sizeof(struct cmd_ds_802_11_get_stat) + S_DS_GEN);
449 lbs_deb_leave(LBS_DEB_CMD);
453 static int lbs_cmd_802_11_snmp_mib(struct lbs_private *priv,
454 struct cmd_ds_command *cmd,
456 int cmd_oid, void *pdata_buf)
458 struct cmd_ds_802_11_snmp_mib *pSNMPMIB = &cmd->params.smib;
461 lbs_deb_enter(LBS_DEB_CMD);
463 lbs_deb_cmd("SNMP_CMD: cmd_oid = 0x%x\n", cmd_oid);
465 cmd->command = cpu_to_le16(CMD_802_11_SNMP_MIB);
466 cmd->size = cpu_to_le16(sizeof(*pSNMPMIB) + S_DS_GEN);
469 case OID_802_11_INFRASTRUCTURE_MODE:
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;
478 /* Infra and Auto modes */
479 ucTemp = SNMP_MIB_VALUE_INFRA;
482 memmove(pSNMPMIB->value, &ucTemp, sizeof(u8));
487 case OID_802_11D_ENABLE:
491 pSNMPMIB->oid = cpu_to_le16((u16) DOT11D_I);
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);
503 case OID_802_11_FRAGMENTATION_THRESHOLD:
507 pSNMPMIB->oid = cpu_to_le16((u16) FRAGTHRESH_I);
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);
523 case OID_802_11_RTS_THRESHOLD:
527 pSNMPMIB->oid = cpu_to_le16(RTSTHRESH_I);
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);
541 case OID_802_11_TX_RETRYCOUNT:
542 pSNMPMIB->oid = cpu_to_le16((u16) SHORT_RETRYLIM_I);
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);
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));
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));
569 lbs_deb_leave(LBS_DEB_CMD);
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)
578 struct cmd_ds_802_11_rf_tx_power *prtp = &cmd->params.txp;
580 lbs_deb_enter(LBS_DEB_CMD);
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);
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));
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;
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);
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);
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));
613 lbs_deb_leave(LBS_DEB_CMD);
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)
621 struct cmd_ds_802_11_monitor_mode *monitor = &cmd->params.monitor;
623 cmd->command = cpu_to_le16(CMD_802_11_MONITOR_MODE);
625 cpu_to_le16(sizeof(struct cmd_ds_802_11_monitor_mode) +
628 monitor->action = cpu_to_le16(cmd_action);
629 if (cmd_action == CMD_ACT_SET) {
631 cpu_to_le16((u16) (*(u32 *) pdata_buf));
637 static int lbs_cmd_802_11_rate_adapt_rateset(struct lbs_private *priv,
638 struct cmd_ds_command *cmd,
641 struct cmd_ds_802_11_rate_adapt_rateset
642 *rateadapt = &cmd->params.rateset;
644 lbs_deb_enter(LBS_DEB_CMD);
646 cpu_to_le16(sizeof(struct cmd_ds_802_11_rate_adapt_rateset)
648 cmd->command = cpu_to_le16(CMD_802_11_RATE_ADAPT_RATESET);
650 rateadapt->action = cpu_to_le16(cmd_action);
651 rateadapt->enablehwauto = cpu_to_le16(priv->enablehwauto);
652 rateadapt->bitmap = cpu_to_le16(priv->ratebitmap);
654 lbs_deb_leave(LBS_DEB_CMD);
659 * @brief Get the current data rate
661 * @param priv A pointer to struct lbs_private structure
663 * @return The data rate on success, error on failure
665 int lbs_get_data_rate(struct lbs_private *priv)
667 struct cmd_ds_802_11_data_rate cmd;
670 lbs_deb_enter(LBS_DEB_CMD);
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);
676 ret = lbs_cmd_with_response(priv, CMD_802_11_DATA_RATE, &cmd);
680 lbs_deb_hex(LBS_DEB_CMD, "DATA_RATE_RESP", (u8 *) &cmd, sizeof (cmd));
682 ret = (int) lbs_fw_index_to_data_rate(cmd.rates[0]);
683 lbs_deb_cmd("DATA_RATE: current rate 0x%02x\n", ret);
686 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
691 * @brief Set the data rate
693 * @param priv A pointer to struct lbs_private structure
694 * @param rate The desired data rate, or 0 to clear a locked rate
696 * @return 0 on success, error on failure
698 int lbs_set_data_rate(struct lbs_private *priv, u8 rate)
700 struct cmd_ds_802_11_data_rate cmd;
703 lbs_deb_enter(LBS_DEB_CMD);
705 memset(&cmd, 0, sizeof(cmd));
706 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
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"
717 lbs_deb_cmd("DATA_RATE: set fixed 0x%02X\n", cmd.rates[0]);
719 cmd.action = cpu_to_le16(CMD_ACT_SET_TX_AUTO);
720 lbs_deb_cmd("DATA_RATE: setting auto\n");
723 ret = lbs_cmd_with_response(priv, CMD_802_11_DATA_RATE, &cmd);
727 lbs_deb_hex(LBS_DEB_CMD, "DATA_RATE_RESP", (u8 *) &cmd, sizeof (cmd));
729 /* FIXME: get actual rates FW can do if this command actually returns
730 * all data rates supported.
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);
736 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
740 static int lbs_cmd_mac_multicast_adr(struct lbs_private *priv,
741 struct cmd_ds_command *cmd,
744 struct cmd_ds_mac_multicast_adr *pMCastAdr = &cmd->params.madr;
746 lbs_deb_enter(LBS_DEB_CMD);
747 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mac_multicast_adr) +
749 cmd->command = cpu_to_le16(CMD_MAC_MULTICAST_ADR);
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);
758 lbs_deb_leave(LBS_DEB_CMD);
763 * @brief Get the radio channel
765 * @param priv A pointer to struct lbs_private structure
767 * @return The channel on success, error on failure
769 int lbs_get_channel(struct lbs_private *priv)
771 struct cmd_ds_802_11_rf_channel cmd;
774 lbs_deb_enter(LBS_DEB_CMD);
776 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
777 cmd.action = cpu_to_le16(CMD_OPT_802_11_RF_CHANNEL_GET);
779 ret = lbs_cmd_with_response(priv, CMD_802_11_RF_CHANNEL, &cmd);
783 ret = le16_to_cpu(cmd.channel);
784 lbs_deb_cmd("current radio channel is %d\n", ret);
787 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
792 * @brief Set the radio channel
794 * @param priv A pointer to struct lbs_private structure
795 * @param channel The desired channel, or 0 to clear a locked channel
797 * @return 0 on success, error on failure
799 int lbs_set_channel(struct lbs_private *priv, u8 channel)
801 struct cmd_ds_802_11_rf_channel cmd;
802 u8 old_channel = priv->curbssparams.channel;
805 lbs_deb_enter(LBS_DEB_CMD);
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);
811 ret = lbs_cmd_with_response(priv, CMD_802_11_RF_CHANNEL, &cmd);
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);
820 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
824 static int lbs_cmd_802_11_rssi(struct lbs_private *priv,
825 struct cmd_ds_command *cmd)
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);
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;
841 lbs_deb_leave(LBS_DEB_CMD);
845 static int lbs_cmd_reg_access(struct lbs_private *priv,
846 struct cmd_ds_command *cmdptr,
847 u8 cmd_action, void *pdata_buf)
849 struct lbs_offset_value *offval;
851 lbs_deb_enter(LBS_DEB_CMD);
853 offval = (struct lbs_offset_value *)pdata_buf;
855 switch (le16_to_cpu(cmdptr->command)) {
856 case CMD_MAC_REG_ACCESS:
858 struct cmd_ds_mac_reg_access *macreg;
861 cpu_to_le16(sizeof (struct cmd_ds_mac_reg_access)
864 (struct cmd_ds_mac_reg_access *)&cmdptr->params.
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);
874 case CMD_BBP_REG_ACCESS:
876 struct cmd_ds_bbp_reg_access *bbpreg;
880 (struct cmd_ds_bbp_reg_access)
883 (struct cmd_ds_bbp_reg_access *)&cmdptr->params.
886 bbpreg->action = cpu_to_le16(cmd_action);
887 bbpreg->offset = cpu_to_le16((u16) offval->offset);
888 bbpreg->value = (u8) offval->value;
893 case CMD_RF_REG_ACCESS:
895 struct cmd_ds_rf_reg_access *rfreg;
899 (struct cmd_ds_rf_reg_access) +
902 (struct cmd_ds_rf_reg_access *)&cmdptr->params.
905 rfreg->action = cpu_to_le16(cmd_action);
906 rfreg->offset = cpu_to_le16((u16) offval->offset);
907 rfreg->value = (u8) offval->value;
916 lbs_deb_leave(LBS_DEB_CMD);
920 static int lbs_cmd_802_11_mac_address(struct lbs_private *priv,
921 struct cmd_ds_command *cmd,
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) +
931 cmd->params.macadd.action = cpu_to_le16(cmd_action);
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);
939 lbs_deb_leave(LBS_DEB_CMD);
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)
947 struct lbs_ioctl_regrdwr *ea = pdata_buf;
949 lbs_deb_enter(LBS_DEB_CMD);
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) +
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;
961 lbs_deb_leave(LBS_DEB_CMD);
965 static int lbs_cmd_bt_access(struct lbs_private *priv,
966 struct cmd_ds_command *cmd,
967 u16 cmd_action, void *pdata_buf)
969 struct cmd_ds_bt_access *bt_access = &cmd->params.bt;
970 lbs_deb_enter_args(LBS_DEB_CMD, "action %d", cmd_action);
972 cmd->command = cpu_to_le16(CMD_BT_ACCESS);
973 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_bt_access) + S_DS_GEN);
975 bt_access->action = cpu_to_le16(cmd_action);
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);
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);
986 case CMD_ACT_BT_ACCESS_LIST:
987 bt_access->id = cpu_to_le32(*(u32 *) pdata_buf);
989 case CMD_ACT_BT_ACCESS_RESET:
991 case CMD_ACT_BT_ACCESS_SET_INVERT:
992 bt_access->id = cpu_to_le32(*(u32 *) pdata_buf);
994 case CMD_ACT_BT_ACCESS_GET_INVERT:
999 lbs_deb_leave(LBS_DEB_CMD);
1003 static int lbs_cmd_fwt_access(struct lbs_private *priv,
1004 struct cmd_ds_command *cmd,
1005 u16 cmd_action, void *pdata_buf)
1007 struct cmd_ds_fwt_access *fwt_access = &cmd->params.fwt;
1008 lbs_deb_enter_args(LBS_DEB_CMD, "action %d", cmd_action);
1010 cmd->command = cpu_to_le16(CMD_FWT_ACCESS);
1011 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_fwt_access) + S_DS_GEN);
1015 memcpy(fwt_access, pdata_buf, sizeof(*fwt_access));
1017 memset(fwt_access, 0, sizeof(*fwt_access));
1019 fwt_access->action = cpu_to_le16(cmd_action);
1021 lbs_deb_leave(LBS_DEB_CMD);
1025 int lbs_mesh_access(struct lbs_private *priv, uint16_t cmd_action,
1026 struct cmd_ds_mesh_access *cmd)
1030 lbs_deb_enter_args(LBS_DEB_CMD, "action %d", cmd_action);
1032 cmd->hdr.command = cpu_to_le16(CMD_MESH_ACCESS);
1033 cmd->hdr.size = cpu_to_le16(sizeof(*cmd));
1034 cmd->hdr.result = 0;
1036 cmd->action = cpu_to_le16(cmd_action);
1038 ret = lbs_cmd_with_response(priv, CMD_MESH_ACCESS, cmd);
1040 lbs_deb_leave(LBS_DEB_CMD);
1043 EXPORT_SYMBOL_GPL(lbs_mesh_access);
1045 int lbs_mesh_config(struct lbs_private *priv, uint16_t enable, uint16_t chan)
1047 struct cmd_ds_mesh_config cmd;
1049 memset(&cmd, 0, sizeof(cmd));
1050 cmd.action = cpu_to_le16(enable);
1051 cmd.channel = cpu_to_le16(chan);
1052 cmd.type = cpu_to_le16(priv->mesh_tlv);
1053 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
1056 cmd.length = cpu_to_le16(priv->mesh_ssid_len);
1057 memcpy(cmd.data, priv->mesh_ssid, priv->mesh_ssid_len);
1059 lbs_deb_cmd("mesh config enable %d TLV %x channel %d SSID %s\n",
1060 enable, priv->mesh_tlv, chan,
1061 escape_essid(priv->mesh_ssid, priv->mesh_ssid_len));
1062 return lbs_cmd_with_response(priv, CMD_MESH_CONFIG, &cmd);
1065 static int lbs_cmd_bcn_ctrl(struct lbs_private * priv,
1066 struct cmd_ds_command *cmd,
1069 struct cmd_ds_802_11_beacon_control
1070 *bcn_ctrl = &cmd->params.bcn_ctrl;
1072 lbs_deb_enter(LBS_DEB_CMD);
1074 cpu_to_le16(sizeof(struct cmd_ds_802_11_beacon_control)
1076 cmd->command = cpu_to_le16(CMD_802_11_BEACON_CTRL);
1078 bcn_ctrl->action = cpu_to_le16(cmd_action);
1079 bcn_ctrl->beacon_enable = cpu_to_le16(priv->beacon_enable);
1080 bcn_ctrl->beacon_period = cpu_to_le16(priv->beacon_period);
1082 lbs_deb_leave(LBS_DEB_CMD);
1086 static void lbs_queue_cmd(struct lbs_private *priv,
1087 struct cmd_ctrl_node *cmdnode)
1089 unsigned long flags;
1092 lbs_deb_enter(LBS_DEB_HOST);
1095 lbs_deb_host("QUEUE_CMD: cmdnode is NULL\n");
1098 if (!cmdnode->cmdbuf->size) {
1099 lbs_deb_host("DNLD_CMD: cmd size is zero\n");
1102 cmdnode->result = 0;
1104 /* Exit_PS command needs to be queued in the header always. */
1105 if (le16_to_cpu(cmdnode->cmdbuf->command) == CMD_802_11_PS_MODE) {
1106 struct cmd_ds_802_11_ps_mode *psm = (void *) &cmdnode->cmdbuf[1];
1108 if (psm->action == cpu_to_le16(CMD_SUBCMD_EXIT_PS)) {
1109 if (priv->psstate != PS_STATE_FULL_POWER)
1114 spin_lock_irqsave(&priv->driver_lock, flags);
1117 list_add_tail(&cmdnode->list, &priv->cmdpendingq);
1119 list_add(&cmdnode->list, &priv->cmdpendingq);
1121 spin_unlock_irqrestore(&priv->driver_lock, flags);
1123 lbs_deb_host("QUEUE_CMD: inserted command 0x%04x into cmdpendingq\n",
1124 le16_to_cpu(cmdnode->cmdbuf->command));
1127 lbs_deb_leave(LBS_DEB_HOST);
1130 static void lbs_submit_command(struct lbs_private *priv,
1131 struct cmd_ctrl_node *cmdnode)
1133 unsigned long flags;
1134 struct cmd_header *cmd;
1140 lbs_deb_enter(LBS_DEB_HOST);
1142 cmd = cmdnode->cmdbuf;
1144 spin_lock_irqsave(&priv->driver_lock, flags);
1145 priv->cur_cmd = cmdnode;
1146 priv->cur_cmd_retcode = 0;
1147 spin_unlock_irqrestore(&priv->driver_lock, flags);
1149 cmdsize = le16_to_cpu(cmd->size);
1150 command = le16_to_cpu(cmd->command);
1152 /* These commands take longer */
1153 if (command == CMD_802_11_SCAN || command == CMD_802_11_ASSOCIATE ||
1154 command == CMD_802_11_AUTHENTICATE)
1157 lbs_deb_host("DNLD_CMD: command 0x%04x, seq %d, size %d, jiffies %lu\n",
1158 command, le16_to_cpu(cmd->seqnum), cmdsize, jiffies);
1159 lbs_deb_hex(LBS_DEB_HOST, "DNLD_CMD", (void *) cmdnode->cmdbuf, cmdsize);
1161 ret = priv->hw_host_to_card(priv, MVMS_CMD, (u8 *) cmd, cmdsize);
1164 lbs_pr_info("DNLD_CMD: hw_host_to_card failed: %d\n", ret);
1165 /* Let the timer kick in and retry, and potentially reset
1166 the whole thing if the condition persists */
1169 lbs_deb_cmd("DNLD_CMD: sent command 0x%04x, jiffies %lu\n",
1172 /* Setup the timer after transmit command */
1173 mod_timer(&priv->command_timer, jiffies + timeo);
1175 lbs_deb_leave(LBS_DEB_HOST);
1178 static int lbs_cmd_mac_control(struct lbs_private *priv,
1179 struct cmd_ds_command *cmd)
1181 struct cmd_ds_mac_control *mac = &cmd->params.macctrl;
1183 lbs_deb_enter(LBS_DEB_CMD);
1185 cmd->command = cpu_to_le16(CMD_MAC_CONTROL);
1186 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_mac_control) + S_DS_GEN);
1187 mac->action = cpu_to_le16(priv->currentpacketfilter);
1189 lbs_deb_cmd("MAC_CONTROL: action 0x%x, size %d\n",
1190 le16_to_cpu(mac->action), le16_to_cpu(cmd->size));
1192 lbs_deb_leave(LBS_DEB_CMD);
1197 * This function inserts command node to cmdfreeq
1198 * after cleans it. Requires priv->driver_lock held.
1200 static void __lbs_cleanup_and_insert_cmd(struct lbs_private *priv,
1201 struct cmd_ctrl_node *cmdnode)
1203 lbs_deb_enter(LBS_DEB_HOST);
1208 cmdnode->callback = NULL;
1209 cmdnode->callback_arg = 0;
1211 memset(cmdnode->cmdbuf, 0, LBS_CMD_BUFFER_SIZE);
1213 list_add_tail(&cmdnode->list, &priv->cmdfreeq);
1215 lbs_deb_leave(LBS_DEB_HOST);
1218 static void lbs_cleanup_and_insert_cmd(struct lbs_private *priv,
1219 struct cmd_ctrl_node *ptempcmd)
1221 unsigned long flags;
1223 spin_lock_irqsave(&priv->driver_lock, flags);
1224 __lbs_cleanup_and_insert_cmd(priv, ptempcmd);
1225 spin_unlock_irqrestore(&priv->driver_lock, flags);
1228 void lbs_complete_command(struct lbs_private *priv, struct cmd_ctrl_node *cmd,
1231 if (cmd == priv->cur_cmd)
1232 priv->cur_cmd_retcode = result;
1234 cmd->result = result;
1235 cmd->cmdwaitqwoken = 1;
1236 wake_up_interruptible(&cmd->cmdwait_q);
1239 __lbs_cleanup_and_insert_cmd(priv, cmd);
1240 priv->cur_cmd = NULL;
1243 int lbs_set_radio_control(struct lbs_private *priv)
1246 struct cmd_ds_802_11_radio_control cmd;
1248 lbs_deb_enter(LBS_DEB_CMD);
1250 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
1251 cmd.action = cpu_to_le16(CMD_ACT_SET);
1253 switch (priv->preamble) {
1254 case CMD_TYPE_SHORT_PREAMBLE:
1255 cmd.control = cpu_to_le16(SET_SHORT_PREAMBLE);
1258 case CMD_TYPE_LONG_PREAMBLE:
1259 cmd.control = cpu_to_le16(SET_LONG_PREAMBLE);
1262 case CMD_TYPE_AUTO_PREAMBLE:
1264 cmd.control = cpu_to_le16(SET_AUTO_PREAMBLE);
1269 cmd.control |= cpu_to_le16(TURN_ON_RF);
1271 cmd.control &= cpu_to_le16(~TURN_ON_RF);
1273 lbs_deb_cmd("RADIO_SET: radio %d, preamble %d\n", priv->radioon,
1276 ret = lbs_cmd_with_response(priv, CMD_802_11_RADIO_CONTROL, &cmd);
1278 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
1282 int lbs_set_mac_packet_filter(struct lbs_private *priv)
1286 lbs_deb_enter(LBS_DEB_CMD);
1288 /* Send MAC control command to station */
1289 ret = lbs_prepare_and_send_command(priv,
1290 CMD_MAC_CONTROL, 0, 0, 0, NULL);
1292 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
1297 * @brief This function prepare the command before send to firmware.
1299 * @param priv A pointer to struct lbs_private structure
1300 * @param cmd_no command number
1301 * @param cmd_action command action: GET or SET
1302 * @param wait_option wait option: wait response or not
1303 * @param cmd_oid cmd oid: treated as sub command
1304 * @param pdata_buf A pointer to informaion buffer
1307 int lbs_prepare_and_send_command(struct lbs_private *priv,
1310 u16 wait_option, u32 cmd_oid, void *pdata_buf)
1313 struct cmd_ctrl_node *cmdnode;
1314 struct cmd_ds_command *cmdptr;
1315 unsigned long flags;
1317 lbs_deb_enter(LBS_DEB_HOST);
1320 lbs_deb_host("PREP_CMD: priv is NULL\n");
1325 if (priv->surpriseremoved) {
1326 lbs_deb_host("PREP_CMD: card removed\n");
1331 cmdnode = lbs_get_cmd_ctrl_node(priv);
1333 if (cmdnode == NULL) {
1334 lbs_deb_host("PREP_CMD: cmdnode is NULL\n");
1336 /* Wake up main thread to execute next command */
1337 wake_up_interruptible(&priv->waitq);
1342 lbs_set_cmd_ctrl_node(priv, cmdnode, pdata_buf);
1344 cmdptr = (struct cmd_ds_command *)cmdnode->cmdbuf;
1346 lbs_deb_host("PREP_CMD: command 0x%04x\n", cmd_no);
1348 /* Set sequence number, command and INT option */
1350 cmdptr->seqnum = cpu_to_le16(priv->seqnum);
1352 cmdptr->command = cpu_to_le16(cmd_no);
1356 case CMD_802_11_PS_MODE:
1357 ret = lbs_cmd_802_11_ps_mode(priv, cmdptr, cmd_action);
1360 case CMD_802_11_SCAN:
1361 ret = lbs_cmd_80211_scan(priv, cmdptr, pdata_buf);
1364 case CMD_MAC_CONTROL:
1365 ret = lbs_cmd_mac_control(priv, cmdptr);
1368 case CMD_802_11_ASSOCIATE:
1369 case CMD_802_11_REASSOCIATE:
1370 ret = lbs_cmd_80211_associate(priv, cmdptr, pdata_buf);
1373 case CMD_802_11_DEAUTHENTICATE:
1374 ret = lbs_cmd_80211_deauthenticate(priv, cmdptr);
1377 case CMD_802_11_AD_HOC_START:
1378 ret = lbs_cmd_80211_ad_hoc_start(priv, cmdptr, pdata_buf);
1383 case CMD_802_11_RESET:
1384 ret = lbs_cmd_802_11_reset(priv, cmdptr, cmd_action);
1387 case CMD_802_11_GET_LOG:
1388 ret = lbs_cmd_802_11_get_log(priv, cmdptr);
1391 case CMD_802_11_AUTHENTICATE:
1392 ret = lbs_cmd_80211_authenticate(priv, cmdptr, pdata_buf);
1395 case CMD_802_11_GET_STAT:
1396 ret = lbs_cmd_802_11_get_stat(priv, cmdptr);
1399 case CMD_802_11_SNMP_MIB:
1400 ret = lbs_cmd_802_11_snmp_mib(priv, cmdptr,
1401 cmd_action, cmd_oid, pdata_buf);
1404 case CMD_MAC_REG_ACCESS:
1405 case CMD_BBP_REG_ACCESS:
1406 case CMD_RF_REG_ACCESS:
1407 ret = lbs_cmd_reg_access(priv, cmdptr, cmd_action, pdata_buf);
1410 case CMD_802_11_RF_TX_POWER:
1411 ret = lbs_cmd_802_11_rf_tx_power(priv, cmdptr,
1412 cmd_action, pdata_buf);
1415 case CMD_802_11_RATE_ADAPT_RATESET:
1416 ret = lbs_cmd_802_11_rate_adapt_rateset(priv,
1417 cmdptr, cmd_action);
1420 case CMD_MAC_MULTICAST_ADR:
1421 ret = lbs_cmd_mac_multicast_adr(priv, cmdptr, cmd_action);
1424 case CMD_802_11_MONITOR_MODE:
1425 ret = lbs_cmd_802_11_monitor_mode(priv, cmdptr,
1426 cmd_action, pdata_buf);
1429 case CMD_802_11_AD_HOC_JOIN:
1430 ret = lbs_cmd_80211_ad_hoc_join(priv, cmdptr, pdata_buf);
1433 case CMD_802_11_RSSI:
1434 ret = lbs_cmd_802_11_rssi(priv, cmdptr);
1437 case CMD_802_11_AD_HOC_STOP:
1438 ret = lbs_cmd_80211_ad_hoc_stop(priv, cmdptr);
1441 case CMD_802_11_KEY_MATERIAL:
1442 ret = lbs_cmd_802_11_key_material(priv, cmdptr, cmd_action,
1443 cmd_oid, pdata_buf);
1446 case CMD_802_11_PAIRWISE_TSC:
1448 case CMD_802_11_GROUP_TSC:
1451 case CMD_802_11_MAC_ADDRESS:
1452 ret = lbs_cmd_802_11_mac_address(priv, cmdptr, cmd_action);
1455 case CMD_802_11_EEPROM_ACCESS:
1456 ret = lbs_cmd_802_11_eeprom_access(priv, cmdptr,
1457 cmd_action, pdata_buf);
1460 case CMD_802_11_SET_AFC:
1461 case CMD_802_11_GET_AFC:
1463 cmdptr->command = cpu_to_le16(cmd_no);
1464 cmdptr->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_afc) +
1467 memmove(&cmdptr->params.afc,
1468 pdata_buf, sizeof(struct cmd_ds_802_11_afc));
1473 case CMD_802_11D_DOMAIN_INFO:
1474 ret = lbs_cmd_802_11d_domain_info(priv, cmdptr,
1475 cmd_no, cmd_action);
1478 case CMD_802_11_TPC_CFG:
1479 cmdptr->command = cpu_to_le16(CMD_802_11_TPC_CFG);
1481 cpu_to_le16(sizeof(struct cmd_ds_802_11_tpc_cfg) +
1484 memmove(&cmdptr->params.tpccfg,
1485 pdata_buf, sizeof(struct cmd_ds_802_11_tpc_cfg));
1489 case CMD_802_11_LED_GPIO_CTRL:
1491 struct mrvlietypes_ledgpio *gpio =
1492 (struct mrvlietypes_ledgpio*)
1493 cmdptr->params.ledgpio.data;
1495 memmove(&cmdptr->params.ledgpio,
1497 sizeof(struct cmd_ds_802_11_led_ctrl));
1500 cpu_to_le16(CMD_802_11_LED_GPIO_CTRL);
1502 #define ACTION_NUMLED_TLVTYPE_LEN_FIELDS_LEN 8
1504 cpu_to_le16(le16_to_cpu(gpio->header.len)
1506 + ACTION_NUMLED_TLVTYPE_LEN_FIELDS_LEN);
1507 gpio->header.len = gpio->header.len;
1513 case CMD_802_11_PWR_CFG:
1514 cmdptr->command = cpu_to_le16(CMD_802_11_PWR_CFG);
1516 cpu_to_le16(sizeof(struct cmd_ds_802_11_pwr_cfg) +
1518 memmove(&cmdptr->params.pwrcfg, pdata_buf,
1519 sizeof(struct cmd_ds_802_11_pwr_cfg));
1524 ret = lbs_cmd_bt_access(priv, cmdptr, cmd_action, pdata_buf);
1527 case CMD_FWT_ACCESS:
1528 ret = lbs_cmd_fwt_access(priv, cmdptr, cmd_action, pdata_buf);
1532 cmdptr->command = cpu_to_le16(CMD_GET_TSF);
1533 cmdptr->size = cpu_to_le16(sizeof(struct cmd_ds_get_tsf) +
1537 case CMD_802_11_BEACON_CTRL:
1538 ret = lbs_cmd_bcn_ctrl(priv, cmdptr, cmd_action);
1541 lbs_deb_host("PREP_CMD: unknown command 0x%04x\n", cmd_no);
1546 /* return error, since the command preparation failed */
1548 lbs_deb_host("PREP_CMD: command preparation failed\n");
1549 lbs_cleanup_and_insert_cmd(priv, cmdnode);
1554 cmdnode->cmdwaitqwoken = 0;
1556 lbs_queue_cmd(priv, cmdnode);
1557 wake_up_interruptible(&priv->waitq);
1559 if (wait_option & CMD_OPTION_WAITFORRSP) {
1560 lbs_deb_host("PREP_CMD: wait for response\n");
1562 wait_event_interruptible(cmdnode->cmdwait_q,
1563 cmdnode->cmdwaitqwoken);
1566 spin_lock_irqsave(&priv->driver_lock, flags);
1567 if (priv->cur_cmd_retcode) {
1568 lbs_deb_host("PREP_CMD: command failed with return code %d\n",
1569 priv->cur_cmd_retcode);
1570 priv->cur_cmd_retcode = 0;
1573 spin_unlock_irqrestore(&priv->driver_lock, flags);
1576 lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
1579 EXPORT_SYMBOL_GPL(lbs_prepare_and_send_command);
1582 * @brief This function allocates the command buffer and link
1583 * it to command free queue.
1585 * @param priv A pointer to struct lbs_private structure
1588 int lbs_allocate_cmd_buffer(struct lbs_private *priv)
1593 struct cmd_ctrl_node *cmdarray;
1595 lbs_deb_enter(LBS_DEB_HOST);
1597 /* Allocate and initialize the command array */
1598 bufsize = sizeof(struct cmd_ctrl_node) * LBS_NUM_CMD_BUFFERS;
1599 if (!(cmdarray = kzalloc(bufsize, GFP_KERNEL))) {
1600 lbs_deb_host("ALLOC_CMD_BUF: tempcmd_array is NULL\n");
1604 priv->cmd_array = cmdarray;
1606 /* Allocate and initialize each command buffer in the command array */
1607 for (i = 0; i < LBS_NUM_CMD_BUFFERS; i++) {
1608 cmdarray[i].cmdbuf = kzalloc(LBS_CMD_BUFFER_SIZE, GFP_KERNEL);
1609 if (!cmdarray[i].cmdbuf) {
1610 lbs_deb_host("ALLOC_CMD_BUF: ptempvirtualaddr is NULL\n");
1616 for (i = 0; i < LBS_NUM_CMD_BUFFERS; i++) {
1617 init_waitqueue_head(&cmdarray[i].cmdwait_q);
1618 lbs_cleanup_and_insert_cmd(priv, &cmdarray[i]);
1623 lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
1628 * @brief This function frees the command buffer.
1630 * @param priv A pointer to struct lbs_private structure
1633 int lbs_free_cmd_buffer(struct lbs_private *priv)
1635 struct cmd_ctrl_node *cmdarray;
1638 lbs_deb_enter(LBS_DEB_HOST);
1640 /* need to check if cmd array is allocated or not */
1641 if (priv->cmd_array == NULL) {
1642 lbs_deb_host("FREE_CMD_BUF: cmd_array is NULL\n");
1646 cmdarray = priv->cmd_array;
1648 /* Release shared memory buffers */
1649 for (i = 0; i < LBS_NUM_CMD_BUFFERS; i++) {
1650 if (cmdarray[i].cmdbuf) {
1651 kfree(cmdarray[i].cmdbuf);
1652 cmdarray[i].cmdbuf = NULL;
1656 /* Release cmd_ctrl_node */
1657 if (priv->cmd_array) {
1658 kfree(priv->cmd_array);
1659 priv->cmd_array = NULL;
1663 lbs_deb_leave(LBS_DEB_HOST);
1668 * @brief This function gets a free command node if available in
1669 * command free queue.
1671 * @param priv A pointer to struct lbs_private structure
1672 * @return cmd_ctrl_node A pointer to cmd_ctrl_node structure or NULL
1674 static struct cmd_ctrl_node *lbs_get_cmd_ctrl_node(struct lbs_private *priv)
1676 struct cmd_ctrl_node *tempnode;
1677 unsigned long flags;
1679 lbs_deb_enter(LBS_DEB_HOST);
1684 spin_lock_irqsave(&priv->driver_lock, flags);
1686 if (!list_empty(&priv->cmdfreeq)) {
1687 tempnode = list_first_entry(&priv->cmdfreeq,
1688 struct cmd_ctrl_node, list);
1689 list_del(&tempnode->list);
1691 lbs_deb_host("GET_CMD_NODE: cmd_ctrl_node is not available\n");
1695 spin_unlock_irqrestore(&priv->driver_lock, flags);
1697 lbs_deb_leave(LBS_DEB_HOST);
1702 * @brief This function cleans command node.
1704 * @param ptempnode A pointer to cmdCtrlNode structure
1709 * @brief This function initializes the command node.
1711 * @param priv A pointer to struct lbs_private structure
1712 * @param ptempnode A pointer to cmd_ctrl_node structure
1713 * @param pdata_buf A pointer to informaion buffer
1716 static void lbs_set_cmd_ctrl_node(struct lbs_private *priv,
1717 struct cmd_ctrl_node *ptempnode,
1720 lbs_deb_enter(LBS_DEB_HOST);
1725 ptempnode->callback = NULL;
1726 ptempnode->callback_arg = (unsigned long)pdata_buf;
1728 lbs_deb_leave(LBS_DEB_HOST);
1732 * @brief This function executes next command in command
1733 * pending queue. It will put fimware back to PS mode
1736 * @param priv A pointer to struct lbs_private structure
1739 int lbs_execute_next_command(struct lbs_private *priv)
1741 struct cmd_ctrl_node *cmdnode = NULL;
1742 struct cmd_header *cmd;
1743 unsigned long flags;
1746 // Debug group is LBS_DEB_THREAD and not LBS_DEB_HOST, because the
1747 // only caller to us is lbs_thread() and we get even when a
1748 // data packet is received
1749 lbs_deb_enter(LBS_DEB_THREAD);
1751 spin_lock_irqsave(&priv->driver_lock, flags);
1753 if (priv->cur_cmd) {
1754 lbs_pr_alert( "EXEC_NEXT_CMD: already processing command!\n");
1755 spin_unlock_irqrestore(&priv->driver_lock, flags);
1760 if (!list_empty(&priv->cmdpendingq)) {
1761 cmdnode = list_first_entry(&priv->cmdpendingq,
1762 struct cmd_ctrl_node, list);
1765 spin_unlock_irqrestore(&priv->driver_lock, flags);
1768 cmd = cmdnode->cmdbuf;
1770 if (is_command_allowed_in_ps(le16_to_cpu(cmd->command))) {
1771 if ((priv->psstate == PS_STATE_SLEEP) ||
1772 (priv->psstate == PS_STATE_PRE_SLEEP)) {
1774 "EXEC_NEXT_CMD: cannot send cmd 0x%04x in psstate %d\n",
1775 le16_to_cpu(cmd->command),
1780 lbs_deb_host("EXEC_NEXT_CMD: OK to send command "
1781 "0x%04x in psstate %d\n",
1782 le16_to_cpu(cmd->command), priv->psstate);
1783 } else if (priv->psstate != PS_STATE_FULL_POWER) {
1785 * 1. Non-PS command:
1786 * Queue it. set needtowakeup to TRUE if current state
1787 * is SLEEP, otherwise call lbs_ps_wakeup to send Exit_PS.
1788 * 2. PS command but not Exit_PS:
1790 * 3. PS command Exit_PS:
1791 * Set needtowakeup to TRUE if current state is SLEEP,
1792 * otherwise send this command down to firmware
1795 if (cmd->command != cpu_to_le16(CMD_802_11_PS_MODE)) {
1796 /* Prepare to send Exit PS,
1797 * this non PS command will be sent later */
1798 if ((priv->psstate == PS_STATE_SLEEP)
1799 || (priv->psstate == PS_STATE_PRE_SLEEP)
1801 /* w/ new scheme, it will not reach here.
1802 since it is blocked in main_thread. */
1803 priv->needtowakeup = 1;
1805 lbs_ps_wakeup(priv, 0);
1811 * PS command. Ignore it if it is not Exit_PS.
1812 * otherwise send it down immediately.
1814 struct cmd_ds_802_11_ps_mode *psm = (void *)&cmd[1];
1817 "EXEC_NEXT_CMD: PS cmd, action 0x%02x\n",
1820 cpu_to_le16(CMD_SUBCMD_EXIT_PS)) {
1822 "EXEC_NEXT_CMD: ignore ENTER_PS cmd\n");
1823 list_del(&cmdnode->list);
1824 spin_lock_irqsave(&priv->driver_lock, flags);
1825 lbs_complete_command(priv, cmdnode, 0);
1826 spin_unlock_irqrestore(&priv->driver_lock, flags);
1832 if ((priv->psstate == PS_STATE_SLEEP) ||
1833 (priv->psstate == PS_STATE_PRE_SLEEP)) {
1835 "EXEC_NEXT_CMD: ignore EXIT_PS cmd in sleep\n");
1836 list_del(&cmdnode->list);
1837 spin_lock_irqsave(&priv->driver_lock, flags);
1838 lbs_complete_command(priv, cmdnode, 0);
1839 spin_unlock_irqrestore(&priv->driver_lock, flags);
1840 priv->needtowakeup = 1;
1847 "EXEC_NEXT_CMD: sending EXIT_PS\n");
1850 list_del(&cmdnode->list);
1851 lbs_deb_host("EXEC_NEXT_CMD: sending command 0x%04x\n",
1852 le16_to_cpu(cmd->command));
1853 lbs_submit_command(priv, cmdnode);
1856 * check if in power save mode, if yes, put the device back
1859 if ((priv->psmode != LBS802_11POWERMODECAM) &&
1860 (priv->psstate == PS_STATE_FULL_POWER) &&
1861 ((priv->connect_status == LBS_CONNECTED) ||
1862 (priv->mesh_connect_status == LBS_CONNECTED))) {
1863 if (priv->secinfo.WPAenabled ||
1864 priv->secinfo.WPA2enabled) {
1865 /* check for valid WPA group keys */
1866 if (priv->wpa_mcast_key.len ||
1867 priv->wpa_unicast_key.len) {
1869 "EXEC_NEXT_CMD: WPA enabled and GTK_SET"
1870 " go back to PS_SLEEP");
1871 lbs_ps_sleep(priv, 0);
1875 "EXEC_NEXT_CMD: cmdpendingq empty, "
1876 "go back to PS_SLEEP");
1877 lbs_ps_sleep(priv, 0);
1884 lbs_deb_leave(LBS_DEB_THREAD);
1888 void lbs_send_iwevcustom_event(struct lbs_private *priv, s8 *str)
1890 union iwreq_data iwrq;
1893 lbs_deb_enter(LBS_DEB_WEXT);
1895 memset(&iwrq, 0, sizeof(union iwreq_data));
1896 memset(buf, 0, sizeof(buf));
1898 snprintf(buf, sizeof(buf) - 1, "%s", str);
1900 iwrq.data.length = strlen(buf) + 1 + IW_EV_LCP_LEN;
1902 /* Send Event to upper layer */
1903 lbs_deb_wext("event indication string %s\n", (char *)buf);
1904 lbs_deb_wext("event indication length %d\n", iwrq.data.length);
1905 lbs_deb_wext("sending wireless event IWEVCUSTOM for %s\n", str);
1907 wireless_send_event(priv->dev, IWEVCUSTOM, &iwrq, buf);
1909 lbs_deb_leave(LBS_DEB_WEXT);
1912 static int sendconfirmsleep(struct lbs_private *priv, u8 *cmdptr, u16 size)
1914 unsigned long flags;
1917 lbs_deb_enter(LBS_DEB_HOST);
1919 lbs_deb_host("SEND_SLEEPC_CMD: before download, cmd size %d\n",
1922 lbs_deb_hex(LBS_DEB_HOST, "sleep confirm command", cmdptr, size);
1924 ret = priv->hw_host_to_card(priv, MVMS_CMD, cmdptr, size);
1926 spin_lock_irqsave(&priv->driver_lock, flags);
1927 if (priv->intcounter || priv->currenttxskb)
1928 lbs_deb_host("SEND_SLEEPC_CMD: intcounter %d, currenttxskb %p\n",
1929 priv->intcounter, priv->currenttxskb);
1930 spin_unlock_irqrestore(&priv->driver_lock, flags);
1934 "SEND_SLEEPC_CMD: Host to Card failed for Confirm Sleep\n");
1936 spin_lock_irqsave(&priv->driver_lock, flags);
1937 if (!priv->intcounter) {
1938 priv->psstate = PS_STATE_SLEEP;
1940 lbs_deb_host("SEND_SLEEPC_CMD: after sent, intcounter %d\n",
1943 spin_unlock_irqrestore(&priv->driver_lock, flags);
1945 lbs_deb_host("SEND_SLEEPC_CMD: sent confirm sleep\n");
1948 lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
1952 void lbs_ps_sleep(struct lbs_private *priv, int wait_option)
1954 lbs_deb_enter(LBS_DEB_HOST);
1957 * PS is currently supported only in Infrastructure mode
1958 * Remove this check if it is to be supported in IBSS mode also
1961 lbs_prepare_and_send_command(priv, CMD_802_11_PS_MODE,
1962 CMD_SUBCMD_ENTER_PS, wait_option, 0, NULL);
1964 lbs_deb_leave(LBS_DEB_HOST);
1968 * @brief This function sends Exit_PS command to firmware.
1970 * @param priv A pointer to struct lbs_private structure
1971 * @param wait_option wait response or not
1974 void lbs_ps_wakeup(struct lbs_private *priv, int wait_option)
1978 lbs_deb_enter(LBS_DEB_HOST);
1980 Localpsmode = cpu_to_le32(LBS802_11POWERMODECAM);
1982 lbs_prepare_and_send_command(priv, CMD_802_11_PS_MODE,
1984 wait_option, 0, &Localpsmode);
1986 lbs_deb_leave(LBS_DEB_HOST);
1990 * @brief This function checks condition and prepares to
1991 * send sleep confirm command to firmware if ok.
1993 * @param priv A pointer to struct lbs_private structure
1994 * @param psmode Power Saving mode
1997 void lbs_ps_confirm_sleep(struct lbs_private *priv, u16 psmode)
1999 unsigned long flags =0;
2002 lbs_deb_enter(LBS_DEB_HOST);
2004 if (priv->dnld_sent) {
2006 lbs_deb_host("dnld_sent was set\n");
2009 spin_lock_irqsave(&priv->driver_lock, flags);
2010 if (priv->cur_cmd) {
2012 lbs_deb_host("cur_cmd was set\n");
2014 if (priv->intcounter > 0) {
2016 lbs_deb_host("intcounter %d\n", priv->intcounter);
2018 spin_unlock_irqrestore(&priv->driver_lock, flags);
2021 lbs_deb_host("sending lbs_ps_confirm_sleep\n");
2022 sendconfirmsleep(priv, (u8 *) & priv->lbs_ps_confirm_sleep,
2023 sizeof(struct PS_CMD_ConfirmSleep));
2025 lbs_deb_host("sleep confirm has been delayed\n");
2028 lbs_deb_leave(LBS_DEB_HOST);
2033 * @brief Simple callback that copies response back into command
2035 * @param priv A pointer to struct lbs_private structure
2036 * @param extra A pointer to the original command structure for which
2037 * 'resp' is a response
2038 * @param resp A pointer to the command response
2040 * @return 0 on success, error on failure
2042 int lbs_cmd_copyback(struct lbs_private *priv, unsigned long extra,
2043 struct cmd_header *resp)
2045 struct cmd_header *buf = (void *)extra;
2048 lbs_deb_enter(LBS_DEB_CMD);
2050 copy_len = min(le16_to_cpu(buf->size), le16_to_cpu(resp->size));
2051 lbs_deb_cmd("Copying back %u bytes; command response was %u bytes, "
2052 "copy back buffer was %u bytes\n", copy_len,
2053 le16_to_cpu(resp->size), le16_to_cpu(buf->size));
2054 memcpy(buf, resp, copy_len);
2056 lbs_deb_leave(LBS_DEB_CMD);
2059 EXPORT_SYMBOL_GPL(lbs_cmd_copyback);
2061 struct cmd_ctrl_node *__lbs_cmd_async(struct lbs_private *priv, uint16_t command,
2062 struct cmd_header *in_cmd, int in_cmd_size,
2063 int (*callback)(struct lbs_private *, unsigned long, struct cmd_header *),
2064 unsigned long callback_arg)
2066 struct cmd_ctrl_node *cmdnode;
2068 lbs_deb_enter(LBS_DEB_HOST);
2070 if (priv->surpriseremoved) {
2071 lbs_deb_host("PREP_CMD: card removed\n");
2072 cmdnode = ERR_PTR(-ENOENT);
2076 cmdnode = lbs_get_cmd_ctrl_node(priv);
2077 if (cmdnode == NULL) {
2078 lbs_deb_host("PREP_CMD: cmdnode is NULL\n");
2080 /* Wake up main thread to execute next command */
2081 wake_up_interruptible(&priv->waitq);
2082 cmdnode = ERR_PTR(-ENOBUFS);
2086 cmdnode->callback = callback;
2087 cmdnode->callback_arg = callback_arg;
2089 /* Copy the incoming command to the buffer */
2090 memcpy(cmdnode->cmdbuf, in_cmd, in_cmd_size);
2092 /* Set sequence number, clean result, move to buffer */
2094 cmdnode->cmdbuf->command = cpu_to_le16(command);
2095 cmdnode->cmdbuf->size = cpu_to_le16(in_cmd_size);
2096 cmdnode->cmdbuf->seqnum = cpu_to_le16(priv->seqnum);
2097 cmdnode->cmdbuf->result = 0;
2099 lbs_deb_host("PREP_CMD: command 0x%04x\n", command);
2101 /* here was the big old switch() statement, which is now obsolete,
2102 * because the caller of lbs_cmd() sets up all of *cmd for us. */
2104 cmdnode->cmdwaitqwoken = 0;
2105 lbs_queue_cmd(priv, cmdnode);
2106 wake_up_interruptible(&priv->waitq);
2109 lbs_deb_leave_args(LBS_DEB_HOST, "ret %p", cmdnode);
2113 int __lbs_cmd(struct lbs_private *priv, uint16_t command,
2114 struct cmd_header *in_cmd, int in_cmd_size,
2115 int (*callback)(struct lbs_private *, unsigned long, struct cmd_header *),
2116 unsigned long callback_arg)
2118 struct cmd_ctrl_node *cmdnode;
2119 unsigned long flags;
2122 lbs_deb_enter(LBS_DEB_HOST);
2124 cmdnode = __lbs_cmd_async(priv, command, in_cmd, in_cmd_size,
2125 callback, callback_arg);
2126 if (IS_ERR(cmdnode)) {
2127 ret = PTR_ERR(cmdnode);
2132 wait_event_interruptible(cmdnode->cmdwait_q, cmdnode->cmdwaitqwoken);
2134 spin_lock_irqsave(&priv->driver_lock, flags);
2135 ret = cmdnode->result;
2137 lbs_pr_info("PREP_CMD: command 0x%04x failed: %d\n",
2140 __lbs_cleanup_and_insert_cmd(priv, cmdnode);
2141 spin_unlock_irqrestore(&priv->driver_lock, flags);
2144 lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
2147 EXPORT_SYMBOL_GPL(__lbs_cmd);