2 * This file contains the handling of command.
3 * It prepares command and sends it to firmware when it is ready.
6 #include <linux/kfifo.h>
7 #include <linux/sched.h>
19 static struct cmd_ctrl_node *lbs_get_cmd_ctrl_node(struct lbs_private *priv);
22 * @brief Simple callback that copies response back into command
24 * @param priv A pointer to struct lbs_private structure
25 * @param extra A pointer to the original command structure for which
26 * 'resp' is a response
27 * @param resp A pointer to the command response
29 * @return 0 on success, error on failure
31 int lbs_cmd_copyback(struct lbs_private *priv, unsigned long extra,
32 struct cmd_header *resp)
34 struct cmd_header *buf = (void *)extra;
37 copy_len = min(le16_to_cpu(buf->size), le16_to_cpu(resp->size));
38 memcpy(buf, resp, copy_len);
41 EXPORT_SYMBOL_GPL(lbs_cmd_copyback);
44 * @brief Simple callback that ignores the result. Use this if
45 * you just want to send a command to the hardware, but don't
46 * care for the result.
49 * @param extra ignored
52 * @return 0 for success
54 static int lbs_cmd_async_callback(struct lbs_private *priv, unsigned long extra,
55 struct cmd_header *resp)
62 * @brief Checks whether a command is allowed in Power Save mode
64 * @param command the command ID
65 * @return 1 if allowed, 0 if not allowed
67 static u8 is_command_allowed_in_ps(u16 cmd)
79 * @brief This function checks if the command is allowed.
81 * @param priv A pointer to lbs_private structure
82 * @return allowed or not allowed.
85 static int lbs_is_cmd_allowed(struct lbs_private *priv)
89 lbs_deb_enter(LBS_DEB_CMD);
91 if (!priv->is_auto_deep_sleep_enabled) {
92 if (priv->is_deep_sleep) {
93 lbs_deb_cmd("command not allowed in deep sleep\n");
98 lbs_deb_leave(LBS_DEB_CMD);
103 * @brief Updates the hardware details like MAC address and regulatory region
105 * @param priv A pointer to struct lbs_private structure
107 * @return 0 on success, error on failure
109 int lbs_update_hw_spec(struct lbs_private *priv)
111 struct cmd_ds_get_hw_spec cmd;
115 lbs_deb_enter(LBS_DEB_CMD);
117 memset(&cmd, 0, sizeof(cmd));
118 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
119 memcpy(cmd.permanentaddr, priv->current_addr, ETH_ALEN);
120 ret = lbs_cmd_with_response(priv, CMD_GET_HW_SPEC, &cmd);
124 priv->fwcapinfo = le32_to_cpu(cmd.fwcapinfo);
126 /* The firmware release is in an interesting format: the patch
127 * level is in the most significant nibble ... so fix that: */
128 priv->fwrelease = le32_to_cpu(cmd.fwrelease);
129 priv->fwrelease = (priv->fwrelease << 8) |
130 (priv->fwrelease >> 24 & 0xff);
132 /* Some firmware capabilities:
133 * CF card firmware 5.0.16p0: cap 0x00000303
134 * USB dongle firmware 5.110.17p2: cap 0x00000303
136 lbs_pr_info("%pM, fw %u.%u.%up%u, cap 0x%08x\n",
138 priv->fwrelease >> 24 & 0xff,
139 priv->fwrelease >> 16 & 0xff,
140 priv->fwrelease >> 8 & 0xff,
141 priv->fwrelease & 0xff,
143 lbs_deb_cmd("GET_HW_SPEC: hardware interface 0x%x, hardware spec 0x%04x\n",
144 cmd.hwifversion, cmd.version);
146 /* Determine mesh_fw_ver from fwrelease and fwcapinfo */
147 /* 5.0.16p0 9.0.0.p0 is known to NOT support any mesh */
148 /* 5.110.22 have mesh command with 0xa3 command id */
149 /* 10.0.0.p0 FW brings in mesh config command with different id */
150 /* Check FW version MSB and initialize mesh_fw_ver */
151 if (MRVL_FW_MAJOR_REV(priv->fwrelease) == MRVL_FW_V5)
152 priv->mesh_fw_ver = MESH_FW_OLD;
153 else if ((MRVL_FW_MAJOR_REV(priv->fwrelease) >= MRVL_FW_V10) &&
154 (priv->fwcapinfo & MESH_CAPINFO_ENABLE_MASK))
155 priv->mesh_fw_ver = MESH_FW_NEW;
157 priv->mesh_fw_ver = MESH_NONE;
159 /* Clamp region code to 8-bit since FW spec indicates that it should
160 * only ever be 8-bit, even though the field size is 16-bit. Some firmware
161 * returns non-zero high 8 bits here.
163 * Firmware version 4.0.102 used in CF8381 has region code shifted. We
164 * need to check for this problem and handle it properly.
166 if (MRVL_FW_MAJOR_REV(priv->fwrelease) == MRVL_FW_V4)
167 priv->regioncode = (le16_to_cpu(cmd.regioncode) >> 8) & 0xFF;
169 priv->regioncode = le16_to_cpu(cmd.regioncode) & 0xFF;
171 for (i = 0; i < MRVDRV_MAX_REGION_CODE; i++) {
172 /* use the region code to search for the index */
173 if (priv->regioncode == lbs_region_code_to_index[i])
177 /* if it's unidentified region code, use the default (USA) */
178 if (i >= MRVDRV_MAX_REGION_CODE) {
179 priv->regioncode = 0x10;
180 lbs_pr_info("unidentified region code; using the default (USA)\n");
183 if (priv->current_addr[0] == 0xff)
184 memmove(priv->current_addr, cmd.permanentaddr, ETH_ALEN);
186 memcpy(priv->dev->dev_addr, priv->current_addr, ETH_ALEN);
188 memcpy(priv->mesh_dev->dev_addr, priv->current_addr, ETH_ALEN);
190 if (lbs_set_regiontable(priv, priv->regioncode, 0)) {
196 lbs_deb_leave(LBS_DEB_CMD);
200 int lbs_host_sleep_cfg(struct lbs_private *priv, uint32_t criteria,
201 struct wol_config *p_wol_config)
203 struct cmd_ds_host_sleep cmd_config;
206 cmd_config.hdr.size = cpu_to_le16(sizeof(cmd_config));
207 cmd_config.criteria = cpu_to_le32(criteria);
208 cmd_config.gpio = priv->wol_gpio;
209 cmd_config.gap = priv->wol_gap;
211 if (p_wol_config != NULL)
212 memcpy((uint8_t *)&cmd_config.wol_conf, (uint8_t *)p_wol_config,
213 sizeof(struct wol_config));
215 cmd_config.wol_conf.action = CMD_ACT_ACTION_NONE;
217 ret = lbs_cmd_with_response(priv, CMD_802_11_HOST_SLEEP_CFG, &cmd_config);
220 lbs_deb_cmd("Set WOL criteria to %x\n", criteria);
221 priv->wol_criteria = criteria;
223 memcpy((uint8_t *) p_wol_config,
224 (uint8_t *)&cmd_config.wol_conf,
225 sizeof(struct wol_config));
227 lbs_pr_info("HOST_SLEEP_CFG failed %d\n", ret);
232 EXPORT_SYMBOL_GPL(lbs_host_sleep_cfg);
234 static int lbs_cmd_802_11_ps_mode(struct cmd_ds_command *cmd,
237 struct cmd_ds_802_11_ps_mode *psm = &cmd->params.psmode;
239 lbs_deb_enter(LBS_DEB_CMD);
241 cmd->command = cpu_to_le16(CMD_802_11_PS_MODE);
242 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_ps_mode) +
243 sizeof(struct cmd_header));
244 psm->action = cpu_to_le16(cmd_action);
245 psm->multipledtim = 0;
246 switch (cmd_action) {
247 case CMD_SUBCMD_ENTER_PS:
248 lbs_deb_cmd("PS command:" "SubCode- Enter PS\n");
250 psm->locallisteninterval = 0;
251 psm->nullpktinterval = 0;
253 cpu_to_le16(MRVDRV_DEFAULT_MULTIPLE_DTIM);
256 case CMD_SUBCMD_EXIT_PS:
257 lbs_deb_cmd("PS command:" "SubCode- Exit PS\n");
260 case CMD_SUBCMD_SLEEP_CONFIRMED:
261 lbs_deb_cmd("PS command: SubCode- sleep confirm\n");
268 lbs_deb_leave(LBS_DEB_CMD);
272 int lbs_cmd_802_11_sleep_params(struct lbs_private *priv, uint16_t cmd_action,
273 struct sleep_params *sp)
275 struct cmd_ds_802_11_sleep_params cmd;
278 lbs_deb_enter(LBS_DEB_CMD);
280 if (cmd_action == CMD_ACT_GET) {
281 memset(&cmd, 0, sizeof(cmd));
283 cmd.error = cpu_to_le16(sp->sp_error);
284 cmd.offset = cpu_to_le16(sp->sp_offset);
285 cmd.stabletime = cpu_to_le16(sp->sp_stabletime);
286 cmd.calcontrol = sp->sp_calcontrol;
287 cmd.externalsleepclk = sp->sp_extsleepclk;
288 cmd.reserved = cpu_to_le16(sp->sp_reserved);
290 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
291 cmd.action = cpu_to_le16(cmd_action);
293 ret = lbs_cmd_with_response(priv, CMD_802_11_SLEEP_PARAMS, &cmd);
296 lbs_deb_cmd("error 0x%x, offset 0x%x, stabletime 0x%x, "
297 "calcontrol 0x%x extsleepclk 0x%x\n",
298 le16_to_cpu(cmd.error), le16_to_cpu(cmd.offset),
299 le16_to_cpu(cmd.stabletime), cmd.calcontrol,
300 cmd.externalsleepclk);
302 sp->sp_error = le16_to_cpu(cmd.error);
303 sp->sp_offset = le16_to_cpu(cmd.offset);
304 sp->sp_stabletime = le16_to_cpu(cmd.stabletime);
305 sp->sp_calcontrol = cmd.calcontrol;
306 sp->sp_extsleepclk = cmd.externalsleepclk;
307 sp->sp_reserved = le16_to_cpu(cmd.reserved);
310 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
314 static int lbs_wait_for_ds_awake(struct lbs_private *priv)
318 lbs_deb_enter(LBS_DEB_CMD);
320 if (priv->is_deep_sleep) {
321 if (!wait_event_interruptible_timeout(priv->ds_awake_q,
322 !priv->is_deep_sleep, (10 * HZ))) {
323 lbs_pr_err("ds_awake_q: timer expired\n");
328 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
332 int lbs_set_deep_sleep(struct lbs_private *priv, int deep_sleep)
336 lbs_deb_enter(LBS_DEB_CMD);
339 if (priv->is_deep_sleep != 1) {
340 lbs_deb_cmd("deep sleep: sleep\n");
341 BUG_ON(!priv->enter_deep_sleep);
342 ret = priv->enter_deep_sleep(priv);
344 netif_stop_queue(priv->dev);
345 netif_carrier_off(priv->dev);
348 lbs_pr_err("deep sleep: already enabled\n");
351 if (priv->is_deep_sleep) {
352 lbs_deb_cmd("deep sleep: wakeup\n");
353 BUG_ON(!priv->exit_deep_sleep);
354 ret = priv->exit_deep_sleep(priv);
356 ret = lbs_wait_for_ds_awake(priv);
358 lbs_pr_err("deep sleep: wakeup"
364 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
369 * @brief Set an SNMP MIB value
371 * @param priv A pointer to struct lbs_private structure
372 * @param oid The OID to set in the firmware
373 * @param val Value to set the OID to
375 * @return 0 on success, error on failure
377 int lbs_set_snmp_mib(struct lbs_private *priv, u32 oid, u16 val)
379 struct cmd_ds_802_11_snmp_mib cmd;
382 lbs_deb_enter(LBS_DEB_CMD);
384 memset(&cmd, 0, sizeof (cmd));
385 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
386 cmd.action = cpu_to_le16(CMD_ACT_SET);
387 cmd.oid = cpu_to_le16((u16) oid);
390 case SNMP_MIB_OID_BSS_TYPE:
391 cmd.bufsize = cpu_to_le16(sizeof(u8));
394 case SNMP_MIB_OID_11D_ENABLE:
395 case SNMP_MIB_OID_FRAG_THRESHOLD:
396 case SNMP_MIB_OID_RTS_THRESHOLD:
397 case SNMP_MIB_OID_SHORT_RETRY_LIMIT:
398 case SNMP_MIB_OID_LONG_RETRY_LIMIT:
399 cmd.bufsize = cpu_to_le16(sizeof(u16));
400 *((__le16 *)(&cmd.value)) = cpu_to_le16(val);
403 lbs_deb_cmd("SNMP_CMD: (set) unhandled OID 0x%x\n", oid);
408 lbs_deb_cmd("SNMP_CMD: (set) oid 0x%x, oid size 0x%x, value 0x%x\n",
409 le16_to_cpu(cmd.oid), le16_to_cpu(cmd.bufsize), val);
411 ret = lbs_cmd_with_response(priv, CMD_802_11_SNMP_MIB, &cmd);
414 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
419 * @brief Get an SNMP MIB value
421 * @param priv A pointer to struct lbs_private structure
422 * @param oid The OID to retrieve from the firmware
423 * @param out_val Location for the returned value
425 * @return 0 on success, error on failure
427 int lbs_get_snmp_mib(struct lbs_private *priv, u32 oid, u16 *out_val)
429 struct cmd_ds_802_11_snmp_mib cmd;
432 lbs_deb_enter(LBS_DEB_CMD);
434 memset(&cmd, 0, sizeof (cmd));
435 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
436 cmd.action = cpu_to_le16(CMD_ACT_GET);
437 cmd.oid = cpu_to_le16(oid);
439 ret = lbs_cmd_with_response(priv, CMD_802_11_SNMP_MIB, &cmd);
443 switch (le16_to_cpu(cmd.bufsize)) {
445 *out_val = cmd.value[0];
448 *out_val = le16_to_cpu(*((__le16 *)(&cmd.value)));
451 lbs_deb_cmd("SNMP_CMD: (get) unhandled OID 0x%x size %d\n",
452 oid, le16_to_cpu(cmd.bufsize));
457 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
462 * @brief Get the min, max, and current TX power
464 * @param priv A pointer to struct lbs_private structure
465 * @param curlevel Current power level in dBm
466 * @param minlevel Minimum supported power level in dBm (optional)
467 * @param maxlevel Maximum supported power level in dBm (optional)
469 * @return 0 on success, error on failure
471 int lbs_get_tx_power(struct lbs_private *priv, s16 *curlevel, s16 *minlevel,
474 struct cmd_ds_802_11_rf_tx_power cmd;
477 lbs_deb_enter(LBS_DEB_CMD);
479 memset(&cmd, 0, sizeof(cmd));
480 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
481 cmd.action = cpu_to_le16(CMD_ACT_GET);
483 ret = lbs_cmd_with_response(priv, CMD_802_11_RF_TX_POWER, &cmd);
485 *curlevel = le16_to_cpu(cmd.curlevel);
487 *minlevel = cmd.minlevel;
489 *maxlevel = cmd.maxlevel;
492 lbs_deb_leave(LBS_DEB_CMD);
497 * @brief Set the TX power
499 * @param priv A pointer to struct lbs_private structure
500 * @param dbm The desired power level in dBm
502 * @return 0 on success, error on failure
504 int lbs_set_tx_power(struct lbs_private *priv, s16 dbm)
506 struct cmd_ds_802_11_rf_tx_power cmd;
509 lbs_deb_enter(LBS_DEB_CMD);
511 memset(&cmd, 0, sizeof(cmd));
512 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
513 cmd.action = cpu_to_le16(CMD_ACT_SET);
514 cmd.curlevel = cpu_to_le16(dbm);
516 lbs_deb_cmd("SET_RF_TX_POWER: %d dBm\n", dbm);
518 ret = lbs_cmd_with_response(priv, CMD_802_11_RF_TX_POWER, &cmd);
520 lbs_deb_leave(LBS_DEB_CMD);
524 static int lbs_cmd_802_11_monitor_mode(struct cmd_ds_command *cmd,
525 u16 cmd_action, void *pdata_buf)
527 struct cmd_ds_802_11_monitor_mode *monitor = &cmd->params.monitor;
529 cmd->command = cpu_to_le16(CMD_802_11_MONITOR_MODE);
531 cpu_to_le16(sizeof(struct cmd_ds_802_11_monitor_mode) +
532 sizeof(struct cmd_header));
534 monitor->action = cpu_to_le16(cmd_action);
535 if (cmd_action == CMD_ACT_SET) {
537 cpu_to_le16((u16) (*(u32 *) pdata_buf));
544 * @brief Get the radio channel
546 * @param priv A pointer to struct lbs_private structure
548 * @return The channel on success, error on failure
550 static int lbs_get_channel(struct lbs_private *priv)
552 struct cmd_ds_802_11_rf_channel cmd;
555 lbs_deb_enter(LBS_DEB_CMD);
557 memset(&cmd, 0, sizeof(cmd));
558 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
559 cmd.action = cpu_to_le16(CMD_OPT_802_11_RF_CHANNEL_GET);
561 ret = lbs_cmd_with_response(priv, CMD_802_11_RF_CHANNEL, &cmd);
565 ret = le16_to_cpu(cmd.channel);
566 lbs_deb_cmd("current radio channel is %d\n", ret);
569 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
573 int lbs_update_channel(struct lbs_private *priv)
577 /* the channel in f/w could be out of sync; get the current channel */
578 lbs_deb_enter(LBS_DEB_ASSOC);
580 ret = lbs_get_channel(priv);
585 lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
590 * @brief Set the radio channel
592 * @param priv A pointer to struct lbs_private structure
593 * @param channel The desired channel, or 0 to clear a locked channel
595 * @return 0 on success, error on failure
597 int lbs_set_channel(struct lbs_private *priv, u8 channel)
599 struct cmd_ds_802_11_rf_channel cmd;
601 u8 old_channel = priv->channel;
605 lbs_deb_enter(LBS_DEB_CMD);
607 memset(&cmd, 0, sizeof(cmd));
608 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
609 cmd.action = cpu_to_le16(CMD_OPT_802_11_RF_CHANNEL_SET);
610 cmd.channel = cpu_to_le16(channel);
612 ret = lbs_cmd_with_response(priv, CMD_802_11_RF_CHANNEL, &cmd);
616 priv->channel = (uint8_t) le16_to_cpu(cmd.channel);
617 lbs_deb_cmd("channel switch from %d to %d\n", old_channel,
621 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
625 static int lbs_cmd_reg_access(struct cmd_ds_command *cmdptr,
626 u8 cmd_action, void *pdata_buf)
628 struct lbs_offset_value *offval;
630 lbs_deb_enter(LBS_DEB_CMD);
632 offval = (struct lbs_offset_value *)pdata_buf;
634 switch (le16_to_cpu(cmdptr->command)) {
635 case CMD_MAC_REG_ACCESS:
637 struct cmd_ds_mac_reg_access *macreg;
640 cpu_to_le16(sizeof (struct cmd_ds_mac_reg_access)
641 + sizeof(struct cmd_header));
643 (struct cmd_ds_mac_reg_access *)&cmdptr->params.
646 macreg->action = cpu_to_le16(cmd_action);
647 macreg->offset = cpu_to_le16((u16) offval->offset);
648 macreg->value = cpu_to_le32(offval->value);
653 case CMD_BBP_REG_ACCESS:
655 struct cmd_ds_bbp_reg_access *bbpreg;
659 (struct cmd_ds_bbp_reg_access)
660 + sizeof(struct cmd_header));
662 (struct cmd_ds_bbp_reg_access *)&cmdptr->params.
665 bbpreg->action = cpu_to_le16(cmd_action);
666 bbpreg->offset = cpu_to_le16((u16) offval->offset);
667 bbpreg->value = (u8) offval->value;
672 case CMD_RF_REG_ACCESS:
674 struct cmd_ds_rf_reg_access *rfreg;
678 (struct cmd_ds_rf_reg_access) +
679 sizeof(struct cmd_header));
681 (struct cmd_ds_rf_reg_access *)&cmdptr->params.
684 rfreg->action = cpu_to_le16(cmd_action);
685 rfreg->offset = cpu_to_le16((u16) offval->offset);
686 rfreg->value = (u8) offval->value;
695 lbs_deb_leave(LBS_DEB_CMD);
699 static void lbs_queue_cmd(struct lbs_private *priv,
700 struct cmd_ctrl_node *cmdnode)
705 lbs_deb_enter(LBS_DEB_HOST);
708 lbs_deb_host("QUEUE_CMD: cmdnode is NULL\n");
711 if (!cmdnode->cmdbuf->size) {
712 lbs_deb_host("DNLD_CMD: cmd size is zero\n");
717 /* Exit_PS command needs to be queued in the header always. */
718 if (le16_to_cpu(cmdnode->cmdbuf->command) == CMD_802_11_PS_MODE) {
719 struct cmd_ds_802_11_ps_mode *psm = (void *) &cmdnode->cmdbuf[1];
721 if (psm->action == cpu_to_le16(CMD_SUBCMD_EXIT_PS)) {
722 if (priv->psstate != PS_STATE_FULL_POWER)
727 spin_lock_irqsave(&priv->driver_lock, flags);
730 list_add_tail(&cmdnode->list, &priv->cmdpendingq);
732 list_add(&cmdnode->list, &priv->cmdpendingq);
734 spin_unlock_irqrestore(&priv->driver_lock, flags);
736 lbs_deb_host("QUEUE_CMD: inserted command 0x%04x into cmdpendingq\n",
737 le16_to_cpu(cmdnode->cmdbuf->command));
740 lbs_deb_leave(LBS_DEB_HOST);
743 static void lbs_submit_command(struct lbs_private *priv,
744 struct cmd_ctrl_node *cmdnode)
747 struct cmd_header *cmd;
753 lbs_deb_enter(LBS_DEB_HOST);
755 cmd = cmdnode->cmdbuf;
757 spin_lock_irqsave(&priv->driver_lock, flags);
758 priv->cur_cmd = cmdnode;
759 priv->cur_cmd_retcode = 0;
760 spin_unlock_irqrestore(&priv->driver_lock, flags);
762 cmdsize = le16_to_cpu(cmd->size);
763 command = le16_to_cpu(cmd->command);
765 /* These commands take longer */
766 if (command == CMD_802_11_SCAN || command == CMD_802_11_ASSOCIATE)
769 lbs_deb_cmd("DNLD_CMD: command 0x%04x, seq %d, size %d\n",
770 command, le16_to_cpu(cmd->seqnum), cmdsize);
771 lbs_deb_hex(LBS_DEB_CMD, "DNLD_CMD", (void *) cmdnode->cmdbuf, cmdsize);
773 ret = priv->hw_host_to_card(priv, MVMS_CMD, (u8 *) cmd, cmdsize);
776 lbs_pr_info("DNLD_CMD: hw_host_to_card failed: %d\n", ret);
777 /* Let the timer kick in and retry, and potentially reset
778 the whole thing if the condition persists */
782 if (command == CMD_802_11_DEEP_SLEEP) {
783 if (priv->is_auto_deep_sleep_enabled) {
784 priv->wakeup_dev_required = 1;
787 priv->is_deep_sleep = 1;
788 lbs_complete_command(priv, cmdnode, 0);
790 /* Setup the timer after transmit command */
791 mod_timer(&priv->command_timer, jiffies + timeo);
794 lbs_deb_leave(LBS_DEB_HOST);
798 * This function inserts command node to cmdfreeq
799 * after cleans it. Requires priv->driver_lock held.
801 static void __lbs_cleanup_and_insert_cmd(struct lbs_private *priv,
802 struct cmd_ctrl_node *cmdnode)
804 lbs_deb_enter(LBS_DEB_HOST);
809 cmdnode->callback = NULL;
810 cmdnode->callback_arg = 0;
812 memset(cmdnode->cmdbuf, 0, LBS_CMD_BUFFER_SIZE);
814 list_add_tail(&cmdnode->list, &priv->cmdfreeq);
816 lbs_deb_leave(LBS_DEB_HOST);
819 static void lbs_cleanup_and_insert_cmd(struct lbs_private *priv,
820 struct cmd_ctrl_node *ptempcmd)
824 spin_lock_irqsave(&priv->driver_lock, flags);
825 __lbs_cleanup_and_insert_cmd(priv, ptempcmd);
826 spin_unlock_irqrestore(&priv->driver_lock, flags);
829 void lbs_complete_command(struct lbs_private *priv, struct cmd_ctrl_node *cmd,
832 if (cmd == priv->cur_cmd)
833 priv->cur_cmd_retcode = result;
835 cmd->result = result;
836 cmd->cmdwaitqwoken = 1;
837 wake_up_interruptible(&cmd->cmdwait_q);
839 if (!cmd->callback || cmd->callback == lbs_cmd_async_callback)
840 __lbs_cleanup_and_insert_cmd(priv, cmd);
841 priv->cur_cmd = NULL;
844 int lbs_set_radio(struct lbs_private *priv, u8 preamble, u8 radio_on)
846 struct cmd_ds_802_11_radio_control cmd;
849 lbs_deb_enter(LBS_DEB_CMD);
851 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
852 cmd.action = cpu_to_le16(CMD_ACT_SET);
854 /* Only v8 and below support setting the preamble */
855 if (priv->fwrelease < 0x09000000) {
857 case RADIO_PREAMBLE_SHORT:
858 if (!(priv->capability & WLAN_CAPABILITY_SHORT_PREAMBLE))
861 case RADIO_PREAMBLE_AUTO:
862 case RADIO_PREAMBLE_LONG:
863 cmd.control = cpu_to_le16(preamble);
871 cmd.control |= cpu_to_le16(0x1);
873 cmd.control &= cpu_to_le16(~0x1);
874 priv->txpower_cur = 0;
877 lbs_deb_cmd("RADIO_CONTROL: radio %s, preamble %d\n",
878 radio_on ? "ON" : "OFF", preamble);
880 priv->radio_on = radio_on;
882 ret = lbs_cmd_with_response(priv, CMD_802_11_RADIO_CONTROL, &cmd);
885 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
889 void lbs_set_mac_control(struct lbs_private *priv)
891 struct cmd_ds_mac_control cmd;
893 lbs_deb_enter(LBS_DEB_CMD);
895 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
896 cmd.action = cpu_to_le16(priv->mac_control);
899 lbs_cmd_async(priv, CMD_MAC_CONTROL, &cmd.hdr, sizeof(cmd));
901 lbs_deb_leave(LBS_DEB_CMD);
905 * @brief This function prepare the command before send to firmware.
907 * @param priv A pointer to struct lbs_private structure
908 * @param cmd_no command number
909 * @param cmd_action command action: GET or SET
910 * @param wait_option wait option: wait response or not
911 * @param cmd_oid cmd oid: treated as sub command
912 * @param pdata_buf A pointer to informaion buffer
915 int lbs_prepare_and_send_command(struct lbs_private *priv,
918 u16 wait_option, u32 cmd_oid, void *pdata_buf)
921 struct cmd_ctrl_node *cmdnode;
922 struct cmd_ds_command *cmdptr;
925 lbs_deb_enter(LBS_DEB_HOST);
928 lbs_deb_host("PREP_CMD: priv is NULL\n");
933 if (priv->surpriseremoved) {
934 lbs_deb_host("PREP_CMD: card removed\n");
939 if (!lbs_is_cmd_allowed(priv)) {
944 cmdnode = lbs_get_cmd_ctrl_node(priv);
946 if (cmdnode == NULL) {
947 lbs_deb_host("PREP_CMD: cmdnode is NULL\n");
949 /* Wake up main thread to execute next command */
950 wake_up_interruptible(&priv->waitq);
955 cmdnode->callback = NULL;
956 cmdnode->callback_arg = (unsigned long)pdata_buf;
958 cmdptr = (struct cmd_ds_command *)cmdnode->cmdbuf;
960 lbs_deb_host("PREP_CMD: command 0x%04x\n", cmd_no);
962 /* Set sequence number, command and INT option */
964 cmdptr->seqnum = cpu_to_le16(priv->seqnum);
966 cmdptr->command = cpu_to_le16(cmd_no);
970 case CMD_802_11_PS_MODE:
971 ret = lbs_cmd_802_11_ps_mode(cmdptr, cmd_action);
974 case CMD_MAC_REG_ACCESS:
975 case CMD_BBP_REG_ACCESS:
976 case CMD_RF_REG_ACCESS:
977 ret = lbs_cmd_reg_access(cmdptr, cmd_action, pdata_buf);
980 case CMD_802_11_MONITOR_MODE:
981 ret = lbs_cmd_802_11_monitor_mode(cmdptr,
982 cmd_action, pdata_buf);
985 case CMD_802_11_RSSI:
986 ret = lbs_cmd_802_11_rssi(priv, cmdptr);
989 case CMD_802_11_SET_AFC:
990 case CMD_802_11_GET_AFC:
992 cmdptr->command = cpu_to_le16(cmd_no);
993 cmdptr->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_afc) +
994 sizeof(struct cmd_header));
996 memmove(&cmdptr->params.afc,
997 pdata_buf, sizeof(struct cmd_ds_802_11_afc));
1002 case CMD_802_11_TPC_CFG:
1003 cmdptr->command = cpu_to_le16(CMD_802_11_TPC_CFG);
1005 cpu_to_le16(sizeof(struct cmd_ds_802_11_tpc_cfg) +
1006 sizeof(struct cmd_header));
1008 memmove(&cmdptr->params.tpccfg,
1009 pdata_buf, sizeof(struct cmd_ds_802_11_tpc_cfg));
1015 ret = lbs_cmd_bt_access(cmdptr, cmd_action, pdata_buf);
1018 case CMD_FWT_ACCESS:
1019 ret = lbs_cmd_fwt_access(cmdptr, cmd_action, pdata_buf);
1022 case CMD_802_11_BEACON_CTRL:
1023 ret = lbs_cmd_bcn_ctrl(priv, cmdptr, cmd_action);
1025 case CMD_802_11_DEEP_SLEEP:
1026 cmdptr->command = cpu_to_le16(CMD_802_11_DEEP_SLEEP);
1027 cmdptr->size = cpu_to_le16(sizeof(struct cmd_header));
1030 lbs_pr_err("PREP_CMD: unknown command 0x%04x\n", cmd_no);
1035 /* return error, since the command preparation failed */
1037 lbs_deb_host("PREP_CMD: command preparation failed\n");
1038 lbs_cleanup_and_insert_cmd(priv, cmdnode);
1043 cmdnode->cmdwaitqwoken = 0;
1045 lbs_queue_cmd(priv, cmdnode);
1046 wake_up_interruptible(&priv->waitq);
1048 if (wait_option & CMD_OPTION_WAITFORRSP) {
1049 lbs_deb_host("PREP_CMD: wait for response\n");
1051 wait_event_interruptible(cmdnode->cmdwait_q,
1052 cmdnode->cmdwaitqwoken);
1055 spin_lock_irqsave(&priv->driver_lock, flags);
1056 if (priv->cur_cmd_retcode) {
1057 lbs_deb_host("PREP_CMD: command failed with return code %d\n",
1058 priv->cur_cmd_retcode);
1059 priv->cur_cmd_retcode = 0;
1062 spin_unlock_irqrestore(&priv->driver_lock, flags);
1065 lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
1070 * @brief This function allocates the command buffer and link
1071 * it to command free queue.
1073 * @param priv A pointer to struct lbs_private structure
1076 int lbs_allocate_cmd_buffer(struct lbs_private *priv)
1081 struct cmd_ctrl_node *cmdarray;
1083 lbs_deb_enter(LBS_DEB_HOST);
1085 /* Allocate and initialize the command array */
1086 bufsize = sizeof(struct cmd_ctrl_node) * LBS_NUM_CMD_BUFFERS;
1087 if (!(cmdarray = kzalloc(bufsize, GFP_KERNEL))) {
1088 lbs_deb_host("ALLOC_CMD_BUF: tempcmd_array is NULL\n");
1092 priv->cmd_array = cmdarray;
1094 /* Allocate and initialize each command buffer in the command array */
1095 for (i = 0; i < LBS_NUM_CMD_BUFFERS; i++) {
1096 cmdarray[i].cmdbuf = kzalloc(LBS_CMD_BUFFER_SIZE, GFP_KERNEL);
1097 if (!cmdarray[i].cmdbuf) {
1098 lbs_deb_host("ALLOC_CMD_BUF: ptempvirtualaddr is NULL\n");
1104 for (i = 0; i < LBS_NUM_CMD_BUFFERS; i++) {
1105 init_waitqueue_head(&cmdarray[i].cmdwait_q);
1106 lbs_cleanup_and_insert_cmd(priv, &cmdarray[i]);
1111 lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
1116 * @brief This function frees the command buffer.
1118 * @param priv A pointer to struct lbs_private structure
1121 int lbs_free_cmd_buffer(struct lbs_private *priv)
1123 struct cmd_ctrl_node *cmdarray;
1126 lbs_deb_enter(LBS_DEB_HOST);
1128 /* need to check if cmd array is allocated or not */
1129 if (priv->cmd_array == NULL) {
1130 lbs_deb_host("FREE_CMD_BUF: cmd_array is NULL\n");
1134 cmdarray = priv->cmd_array;
1136 /* Release shared memory buffers */
1137 for (i = 0; i < LBS_NUM_CMD_BUFFERS; i++) {
1138 if (cmdarray[i].cmdbuf) {
1139 kfree(cmdarray[i].cmdbuf);
1140 cmdarray[i].cmdbuf = NULL;
1144 /* Release cmd_ctrl_node */
1145 if (priv->cmd_array) {
1146 kfree(priv->cmd_array);
1147 priv->cmd_array = NULL;
1151 lbs_deb_leave(LBS_DEB_HOST);
1156 * @brief This function gets a free command node if available in
1157 * command free queue.
1159 * @param priv A pointer to struct lbs_private structure
1160 * @return cmd_ctrl_node A pointer to cmd_ctrl_node structure or NULL
1162 static struct cmd_ctrl_node *lbs_get_cmd_ctrl_node(struct lbs_private *priv)
1164 struct cmd_ctrl_node *tempnode;
1165 unsigned long flags;
1167 lbs_deb_enter(LBS_DEB_HOST);
1172 spin_lock_irqsave(&priv->driver_lock, flags);
1174 if (!list_empty(&priv->cmdfreeq)) {
1175 tempnode = list_first_entry(&priv->cmdfreeq,
1176 struct cmd_ctrl_node, list);
1177 list_del(&tempnode->list);
1179 lbs_deb_host("GET_CMD_NODE: cmd_ctrl_node is not available\n");
1183 spin_unlock_irqrestore(&priv->driver_lock, flags);
1185 lbs_deb_leave(LBS_DEB_HOST);
1190 * @brief This function executes next command in command
1191 * pending queue. It will put firmware back to PS mode
1194 * @param priv A pointer to struct lbs_private structure
1197 int lbs_execute_next_command(struct lbs_private *priv)
1199 struct cmd_ctrl_node *cmdnode = NULL;
1200 struct cmd_header *cmd;
1201 unsigned long flags;
1204 /* Debug group is LBS_DEB_THREAD and not LBS_DEB_HOST, because the
1205 * only caller to us is lbs_thread() and we get even when a
1206 * data packet is received */
1207 lbs_deb_enter(LBS_DEB_THREAD);
1209 spin_lock_irqsave(&priv->driver_lock, flags);
1211 if (priv->cur_cmd) {
1212 lbs_pr_alert( "EXEC_NEXT_CMD: already processing command!\n");
1213 spin_unlock_irqrestore(&priv->driver_lock, flags);
1218 if (!list_empty(&priv->cmdpendingq)) {
1219 cmdnode = list_first_entry(&priv->cmdpendingq,
1220 struct cmd_ctrl_node, list);
1223 spin_unlock_irqrestore(&priv->driver_lock, flags);
1226 cmd = cmdnode->cmdbuf;
1228 if (is_command_allowed_in_ps(le16_to_cpu(cmd->command))) {
1229 if ((priv->psstate == PS_STATE_SLEEP) ||
1230 (priv->psstate == PS_STATE_PRE_SLEEP)) {
1232 "EXEC_NEXT_CMD: cannot send cmd 0x%04x in psstate %d\n",
1233 le16_to_cpu(cmd->command),
1238 lbs_deb_host("EXEC_NEXT_CMD: OK to send command "
1239 "0x%04x in psstate %d\n",
1240 le16_to_cpu(cmd->command), priv->psstate);
1241 } else if (priv->psstate != PS_STATE_FULL_POWER) {
1243 * 1. Non-PS command:
1244 * Queue it. set needtowakeup to TRUE if current state
1245 * is SLEEP, otherwise call lbs_ps_wakeup to send Exit_PS.
1246 * 2. PS command but not Exit_PS:
1248 * 3. PS command Exit_PS:
1249 * Set needtowakeup to TRUE if current state is SLEEP,
1250 * otherwise send this command down to firmware
1253 if (cmd->command != cpu_to_le16(CMD_802_11_PS_MODE)) {
1254 /* Prepare to send Exit PS,
1255 * this non PS command will be sent later */
1256 if ((priv->psstate == PS_STATE_SLEEP)
1257 || (priv->psstate == PS_STATE_PRE_SLEEP)
1259 /* w/ new scheme, it will not reach here.
1260 since it is blocked in main_thread. */
1261 priv->needtowakeup = 1;
1263 lbs_ps_wakeup(priv, 0);
1269 * PS command. Ignore it if it is not Exit_PS.
1270 * otherwise send it down immediately.
1272 struct cmd_ds_802_11_ps_mode *psm = (void *)&cmd[1];
1275 "EXEC_NEXT_CMD: PS cmd, action 0x%02x\n",
1278 cpu_to_le16(CMD_SUBCMD_EXIT_PS)) {
1280 "EXEC_NEXT_CMD: ignore ENTER_PS cmd\n");
1281 list_del(&cmdnode->list);
1282 spin_lock_irqsave(&priv->driver_lock, flags);
1283 lbs_complete_command(priv, cmdnode, 0);
1284 spin_unlock_irqrestore(&priv->driver_lock, flags);
1290 if ((priv->psstate == PS_STATE_SLEEP) ||
1291 (priv->psstate == PS_STATE_PRE_SLEEP)) {
1293 "EXEC_NEXT_CMD: ignore EXIT_PS cmd in sleep\n");
1294 list_del(&cmdnode->list);
1295 spin_lock_irqsave(&priv->driver_lock, flags);
1296 lbs_complete_command(priv, cmdnode, 0);
1297 spin_unlock_irqrestore(&priv->driver_lock, flags);
1298 priv->needtowakeup = 1;
1305 "EXEC_NEXT_CMD: sending EXIT_PS\n");
1308 list_del(&cmdnode->list);
1309 lbs_deb_host("EXEC_NEXT_CMD: sending command 0x%04x\n",
1310 le16_to_cpu(cmd->command));
1311 lbs_submit_command(priv, cmdnode);
1314 * check if in power save mode, if yes, put the device back
1317 if ((priv->psmode != LBS802_11POWERMODECAM) &&
1318 (priv->psstate == PS_STATE_FULL_POWER) &&
1319 ((priv->connect_status == LBS_CONNECTED) ||
1320 (priv->mesh_connect_status == LBS_CONNECTED))) {
1321 if (priv->secinfo.WPAenabled ||
1322 priv->secinfo.WPA2enabled) {
1323 /* check for valid WPA group keys */
1324 if (priv->wpa_mcast_key.len ||
1325 priv->wpa_unicast_key.len) {
1327 "EXEC_NEXT_CMD: WPA enabled and GTK_SET"
1328 " go back to PS_SLEEP");
1329 lbs_ps_sleep(priv, 0);
1333 "EXEC_NEXT_CMD: cmdpendingq empty, "
1334 "go back to PS_SLEEP");
1335 lbs_ps_sleep(priv, 0);
1342 lbs_deb_leave(LBS_DEB_THREAD);
1346 static void lbs_send_confirmsleep(struct lbs_private *priv)
1348 unsigned long flags;
1351 lbs_deb_enter(LBS_DEB_HOST);
1352 lbs_deb_hex(LBS_DEB_HOST, "sleep confirm", (u8 *) &confirm_sleep,
1353 sizeof(confirm_sleep));
1355 ret = priv->hw_host_to_card(priv, MVMS_CMD, (u8 *) &confirm_sleep,
1356 sizeof(confirm_sleep));
1358 lbs_pr_alert("confirm_sleep failed\n");
1362 spin_lock_irqsave(&priv->driver_lock, flags);
1364 /* We don't get a response on the sleep-confirmation */
1365 priv->dnld_sent = DNLD_RES_RECEIVED;
1367 /* If nothing to do, go back to sleep (?) */
1368 if (!kfifo_len(&priv->event_fifo) && !priv->resp_len[priv->resp_idx])
1369 priv->psstate = PS_STATE_SLEEP;
1371 spin_unlock_irqrestore(&priv->driver_lock, flags);
1374 lbs_deb_leave(LBS_DEB_HOST);
1377 void lbs_ps_sleep(struct lbs_private *priv, int wait_option)
1379 lbs_deb_enter(LBS_DEB_HOST);
1382 * PS is currently supported only in Infrastructure mode
1383 * Remove this check if it is to be supported in IBSS mode also
1386 lbs_prepare_and_send_command(priv, CMD_802_11_PS_MODE,
1387 CMD_SUBCMD_ENTER_PS, wait_option, 0, NULL);
1389 lbs_deb_leave(LBS_DEB_HOST);
1393 * @brief This function sends Exit_PS command to firmware.
1395 * @param priv A pointer to struct lbs_private structure
1396 * @param wait_option wait response or not
1399 void lbs_ps_wakeup(struct lbs_private *priv, int wait_option)
1403 lbs_deb_enter(LBS_DEB_HOST);
1405 Localpsmode = cpu_to_le32(LBS802_11POWERMODECAM);
1407 lbs_prepare_and_send_command(priv, CMD_802_11_PS_MODE,
1409 wait_option, 0, &Localpsmode);
1411 lbs_deb_leave(LBS_DEB_HOST);
1415 * @brief This function checks condition and prepares to
1416 * send sleep confirm command to firmware if ok.
1418 * @param priv A pointer to struct lbs_private structure
1419 * @param psmode Power Saving mode
1422 void lbs_ps_confirm_sleep(struct lbs_private *priv)
1424 unsigned long flags =0;
1427 lbs_deb_enter(LBS_DEB_HOST);
1429 spin_lock_irqsave(&priv->driver_lock, flags);
1430 if (priv->dnld_sent) {
1432 lbs_deb_host("dnld_sent was set\n");
1435 /* In-progress command? */
1436 if (priv->cur_cmd) {
1438 lbs_deb_host("cur_cmd was set\n");
1441 /* Pending events or command responses? */
1442 if (kfifo_len(&priv->event_fifo) || priv->resp_len[priv->resp_idx]) {
1444 lbs_deb_host("pending events or command responses\n");
1446 spin_unlock_irqrestore(&priv->driver_lock, flags);
1449 lbs_deb_host("sending lbs_ps_confirm_sleep\n");
1450 lbs_send_confirmsleep(priv);
1452 lbs_deb_host("sleep confirm has been delayed\n");
1455 lbs_deb_leave(LBS_DEB_HOST);
1460 * @brief Configures the transmission power control functionality.
1462 * @param priv A pointer to struct lbs_private structure
1463 * @param enable Transmission power control enable
1464 * @param p0 Power level when link quality is good (dBm).
1465 * @param p1 Power level when link quality is fair (dBm).
1466 * @param p2 Power level when link quality is poor (dBm).
1467 * @param usesnr Use Signal to Noise Ratio in TPC
1469 * @return 0 on success
1471 int lbs_set_tpc_cfg(struct lbs_private *priv, int enable, int8_t p0, int8_t p1,
1472 int8_t p2, int usesnr)
1474 struct cmd_ds_802_11_tpc_cfg cmd;
1477 memset(&cmd, 0, sizeof(cmd));
1478 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
1479 cmd.action = cpu_to_le16(CMD_ACT_SET);
1480 cmd.enable = !!enable;
1481 cmd.usesnr = !!usesnr;
1486 ret = lbs_cmd_with_response(priv, CMD_802_11_TPC_CFG, &cmd);
1492 * @brief Configures the power adaptation settings.
1494 * @param priv A pointer to struct lbs_private structure
1495 * @param enable Power adaptation enable
1496 * @param p0 Power level for 1, 2, 5.5 and 11 Mbps (dBm).
1497 * @param p1 Power level for 6, 9, 12, 18, 22, 24 and 36 Mbps (dBm).
1498 * @param p2 Power level for 48 and 54 Mbps (dBm).
1500 * @return 0 on Success
1503 int lbs_set_power_adapt_cfg(struct lbs_private *priv, int enable, int8_t p0,
1504 int8_t p1, int8_t p2)
1506 struct cmd_ds_802_11_pa_cfg cmd;
1509 memset(&cmd, 0, sizeof(cmd));
1510 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
1511 cmd.action = cpu_to_le16(CMD_ACT_SET);
1512 cmd.enable = !!enable;
1517 ret = lbs_cmd_with_response(priv, CMD_802_11_PA_CFG , &cmd);
1523 struct cmd_ctrl_node *__lbs_cmd_async(struct lbs_private *priv,
1524 uint16_t command, struct cmd_header *in_cmd, int in_cmd_size,
1525 int (*callback)(struct lbs_private *, unsigned long, struct cmd_header *),
1526 unsigned long callback_arg)
1528 struct cmd_ctrl_node *cmdnode;
1530 lbs_deb_enter(LBS_DEB_HOST);
1532 if (priv->surpriseremoved) {
1533 lbs_deb_host("PREP_CMD: card removed\n");
1534 cmdnode = ERR_PTR(-ENOENT);
1538 if (!lbs_is_cmd_allowed(priv)) {
1539 cmdnode = ERR_PTR(-EBUSY);
1543 cmdnode = lbs_get_cmd_ctrl_node(priv);
1544 if (cmdnode == NULL) {
1545 lbs_deb_host("PREP_CMD: cmdnode is NULL\n");
1547 /* Wake up main thread to execute next command */
1548 wake_up_interruptible(&priv->waitq);
1549 cmdnode = ERR_PTR(-ENOBUFS);
1553 cmdnode->callback = callback;
1554 cmdnode->callback_arg = callback_arg;
1556 /* Copy the incoming command to the buffer */
1557 memcpy(cmdnode->cmdbuf, in_cmd, in_cmd_size);
1559 /* Set sequence number, clean result, move to buffer */
1561 cmdnode->cmdbuf->command = cpu_to_le16(command);
1562 cmdnode->cmdbuf->size = cpu_to_le16(in_cmd_size);
1563 cmdnode->cmdbuf->seqnum = cpu_to_le16(priv->seqnum);
1564 cmdnode->cmdbuf->result = 0;
1566 lbs_deb_host("PREP_CMD: command 0x%04x\n", command);
1568 cmdnode->cmdwaitqwoken = 0;
1569 lbs_queue_cmd(priv, cmdnode);
1570 wake_up_interruptible(&priv->waitq);
1573 lbs_deb_leave_args(LBS_DEB_HOST, "ret %p", cmdnode);
1577 void lbs_cmd_async(struct lbs_private *priv, uint16_t command,
1578 struct cmd_header *in_cmd, int in_cmd_size)
1580 lbs_deb_enter(LBS_DEB_CMD);
1581 __lbs_cmd_async(priv, command, in_cmd, in_cmd_size,
1582 lbs_cmd_async_callback, 0);
1583 lbs_deb_leave(LBS_DEB_CMD);
1586 int __lbs_cmd(struct lbs_private *priv, uint16_t command,
1587 struct cmd_header *in_cmd, int in_cmd_size,
1588 int (*callback)(struct lbs_private *, unsigned long, struct cmd_header *),
1589 unsigned long callback_arg)
1591 struct cmd_ctrl_node *cmdnode;
1592 unsigned long flags;
1595 lbs_deb_enter(LBS_DEB_HOST);
1597 cmdnode = __lbs_cmd_async(priv, command, in_cmd, in_cmd_size,
1598 callback, callback_arg);
1599 if (IS_ERR(cmdnode)) {
1600 ret = PTR_ERR(cmdnode);
1605 wait_event_interruptible(cmdnode->cmdwait_q, cmdnode->cmdwaitqwoken);
1607 spin_lock_irqsave(&priv->driver_lock, flags);
1608 ret = cmdnode->result;
1610 lbs_pr_info("PREP_CMD: command 0x%04x failed: %d\n",
1613 __lbs_cleanup_and_insert_cmd(priv, cmdnode);
1614 spin_unlock_irqrestore(&priv->driver_lock, flags);
1617 lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
1620 EXPORT_SYMBOL_GPL(__lbs_cmd);