blob: cdb9b9650d73aaf1de0114966e398defa4cae8d1 [file] [log] [blame]
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001/**
2 * This file contains the handling of command.
3 * It prepares command and sends it to firmware when it is ready.
4 */
5
Holger Schurig7919b892008-04-01 14:50:43 +02006#include <linux/kfifo.h>
Holger Schurige93156e2009-10-22 15:30:58 +02007#include <linux/sched.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +09008#include <linux/slab.h>
Holger Schurige93156e2009-10-22 15:30:58 +02009
Marcelo Tosatti876c9d32007-02-10 12:25:27 -020010#include "host.h"
Marcelo Tosatti876c9d32007-02-10 12:25:27 -020011#include "decl.h"
12#include "defs.h"
13#include "dev.h"
Holger Schurig697900a2008-04-02 16:27:10 +020014#include "assoc.h"
Marcelo Tosatti876c9d32007-02-10 12:25:27 -020015#include "wext.h"
Holger Schurig2d465022009-10-22 15:30:48 +020016#include "scan.h"
Dan Williams6e66f032007-12-11 12:42:16 -050017#include "cmd.h"
Marcelo Tosatti876c9d32007-02-10 12:25:27 -020018
Holger Schurige93156e2009-10-22 15:30:58 +020019
David Woodhouse2fd6cfe2007-12-11 17:44:10 -050020static struct cmd_ctrl_node *lbs_get_cmd_ctrl_node(struct lbs_private *priv);
Holger Schurig0d61d042007-12-05 17:58:06 +010021
Marcelo Tosatti876c9d32007-02-10 12:25:27 -020022/**
Holger Schurig8db4a2b2008-03-19 10:11:00 +010023 * @brief Simple callback that copies response back into command
24 *
25 * @param priv A pointer to struct lbs_private structure
26 * @param extra A pointer to the original command structure for which
27 * 'resp' is a response
28 * @param resp A pointer to the command response
29 *
30 * @return 0 on success, error on failure
31 */
32int lbs_cmd_copyback(struct lbs_private *priv, unsigned long extra,
33 struct cmd_header *resp)
34{
35 struct cmd_header *buf = (void *)extra;
36 uint16_t copy_len;
37
38 copy_len = min(le16_to_cpu(buf->size), le16_to_cpu(resp->size));
39 memcpy(buf, resp, copy_len);
40 return 0;
41}
42EXPORT_SYMBOL_GPL(lbs_cmd_copyback);
43
44/**
45 * @brief Simple callback that ignores the result. Use this if
46 * you just want to send a command to the hardware, but don't
47 * care for the result.
48 *
49 * @param priv ignored
50 * @param extra ignored
51 * @param resp ignored
52 *
53 * @return 0 for success
54 */
55static int lbs_cmd_async_callback(struct lbs_private *priv, unsigned long extra,
56 struct cmd_header *resp)
57{
58 return 0;
59}
60
61
62/**
Dan Williams852e1f22007-12-10 15:24:47 -050063 * @brief Checks whether a command is allowed in Power Save mode
Marcelo Tosatti876c9d32007-02-10 12:25:27 -020064 *
65 * @param command the command ID
Dan Williams852e1f22007-12-10 15:24:47 -050066 * @return 1 if allowed, 0 if not allowed
Marcelo Tosatti876c9d32007-02-10 12:25:27 -020067 */
Dan Williams852e1f22007-12-10 15:24:47 -050068static u8 is_command_allowed_in_ps(u16 cmd)
Marcelo Tosatti876c9d32007-02-10 12:25:27 -020069{
Dan Williams852e1f22007-12-10 15:24:47 -050070 switch (cmd) {
71 case CMD_802_11_RSSI:
72 return 1;
73 default:
74 break;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -020075 }
Marcelo Tosatti876c9d32007-02-10 12:25:27 -020076 return 0;
77}
78
Dan Williams6e66f032007-12-11 12:42:16 -050079/**
Amitkumar Karwar63f275d2009-10-06 19:20:28 -070080 * @brief This function checks if the command is allowed.
81 *
82 * @param priv A pointer to lbs_private structure
83 * @return allowed or not allowed.
84 */
85
86static int lbs_is_cmd_allowed(struct lbs_private *priv)
87{
88 int ret = 1;
89
90 lbs_deb_enter(LBS_DEB_CMD);
91
92 if (!priv->is_auto_deep_sleep_enabled) {
93 if (priv->is_deep_sleep) {
94 lbs_deb_cmd("command not allowed in deep sleep\n");
95 ret = 0;
96 }
97 }
98
99 lbs_deb_leave(LBS_DEB_CMD);
100 return ret;
101}
102
103/**
Dan Williams6e66f032007-12-11 12:42:16 -0500104 * @brief Updates the hardware details like MAC address and regulatory region
105 *
106 * @param priv A pointer to struct lbs_private structure
107 *
108 * @return 0 on success, error on failure
109 */
110int lbs_update_hw_spec(struct lbs_private *priv)
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200111{
Dan Williams6e66f032007-12-11 12:42:16 -0500112 struct cmd_ds_get_hw_spec cmd;
113 int ret = -1;
114 u32 i;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200115
Holger Schurig9012b282007-05-25 11:27:16 -0400116 lbs_deb_enter(LBS_DEB_CMD);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200117
Dan Williams6e66f032007-12-11 12:42:16 -0500118 memset(&cmd, 0, sizeof(cmd));
119 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
120 memcpy(cmd.permanentaddr, priv->current_addr, ETH_ALEN);
David Woodhouse689442d2007-12-12 16:00:42 -0500121 ret = lbs_cmd_with_response(priv, CMD_GET_HW_SPEC, &cmd);
Dan Williams6e66f032007-12-11 12:42:16 -0500122 if (ret)
123 goto out;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200124
Dan Williams6e66f032007-12-11 12:42:16 -0500125 priv->fwcapinfo = le32_to_cpu(cmd.fwcapinfo);
Dan Williams6e66f032007-12-11 12:42:16 -0500126
Holger Schurigdac10a92008-01-16 15:55:22 +0100127 /* The firmware release is in an interesting format: the patch
128 * level is in the most significant nibble ... so fix that: */
129 priv->fwrelease = le32_to_cpu(cmd.fwrelease);
130 priv->fwrelease = (priv->fwrelease << 8) |
131 (priv->fwrelease >> 24 & 0xff);
132
133 /* Some firmware capabilities:
134 * CF card firmware 5.0.16p0: cap 0x00000303
135 * USB dongle firmware 5.110.17p2: cap 0x00000303
136 */
Johannes Berge1749612008-10-27 15:59:26 -0700137 lbs_pr_info("%pM, fw %u.%u.%up%u, cap 0x%08x\n",
138 cmd.permanentaddr,
Holger Schurigdac10a92008-01-16 15:55:22 +0100139 priv->fwrelease >> 24 & 0xff,
140 priv->fwrelease >> 16 & 0xff,
141 priv->fwrelease >> 8 & 0xff,
142 priv->fwrelease & 0xff,
143 priv->fwcapinfo);
Dan Williams6e66f032007-12-11 12:42:16 -0500144 lbs_deb_cmd("GET_HW_SPEC: hardware interface 0x%x, hardware spec 0x%04x\n",
145 cmd.hwifversion, cmd.version);
146
147 /* Clamp region code to 8-bit since FW spec indicates that it should
148 * only ever be 8-bit, even though the field size is 16-bit. Some firmware
149 * returns non-zero high 8 bits here.
Marek Vasut15483992009-07-16 19:19:53 +0200150 *
151 * Firmware version 4.0.102 used in CF8381 has region code shifted. We
152 * need to check for this problem and handle it properly.
Dan Williams6e66f032007-12-11 12:42:16 -0500153 */
Marek Vasut15483992009-07-16 19:19:53 +0200154 if (MRVL_FW_MAJOR_REV(priv->fwrelease) == MRVL_FW_V4)
155 priv->regioncode = (le16_to_cpu(cmd.regioncode) >> 8) & 0xFF;
156 else
157 priv->regioncode = le16_to_cpu(cmd.regioncode) & 0xFF;
Dan Williams6e66f032007-12-11 12:42:16 -0500158
159 for (i = 0; i < MRVDRV_MAX_REGION_CODE; i++) {
160 /* use the region code to search for the index */
161 if (priv->regioncode == lbs_region_code_to_index[i])
162 break;
163 }
164
165 /* if it's unidentified region code, use the default (USA) */
166 if (i >= MRVDRV_MAX_REGION_CODE) {
167 priv->regioncode = 0x10;
168 lbs_pr_info("unidentified region code; using the default (USA)\n");
169 }
170
171 if (priv->current_addr[0] == 0xff)
172 memmove(priv->current_addr, cmd.permanentaddr, ETH_ALEN);
173
174 memcpy(priv->dev->dev_addr, priv->current_addr, ETH_ALEN);
175 if (priv->mesh_dev)
176 memcpy(priv->mesh_dev->dev_addr, priv->current_addr, ETH_ALEN);
177
178 if (lbs_set_regiontable(priv, priv->regioncode, 0)) {
179 ret = -1;
180 goto out;
181 }
182
Dan Williams6e66f032007-12-11 12:42:16 -0500183out:
Holger Schurig9012b282007-05-25 11:27:16 -0400184 lbs_deb_leave(LBS_DEB_CMD);
Dan Williams6e66f032007-12-11 12:42:16 -0500185 return ret;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200186}
187
Anna Neal582c1b52008-10-20 16:46:56 -0700188int lbs_host_sleep_cfg(struct lbs_private *priv, uint32_t criteria,
189 struct wol_config *p_wol_config)
David Woodhouse6ce4fd22007-12-12 15:19:29 -0500190{
191 struct cmd_ds_host_sleep cmd_config;
192 int ret;
193
David Woodhouse9fae8992007-12-15 03:46:44 -0500194 cmd_config.hdr.size = cpu_to_le16(sizeof(cmd_config));
David Woodhouse6ce4fd22007-12-12 15:19:29 -0500195 cmd_config.criteria = cpu_to_le32(criteria);
David Woodhouse506e9022007-12-12 20:06:06 -0500196 cmd_config.gpio = priv->wol_gpio;
197 cmd_config.gap = priv->wol_gap;
David Woodhouse6ce4fd22007-12-12 15:19:29 -0500198
Anna Neal582c1b52008-10-20 16:46:56 -0700199 if (p_wol_config != NULL)
200 memcpy((uint8_t *)&cmd_config.wol_conf, (uint8_t *)p_wol_config,
201 sizeof(struct wol_config));
202 else
203 cmd_config.wol_conf.action = CMD_ACT_ACTION_NONE;
204
David Woodhouse689442d2007-12-12 16:00:42 -0500205 ret = lbs_cmd_with_response(priv, CMD_802_11_HOST_SLEEP_CFG, &cmd_config);
David Woodhouse506e9022007-12-12 20:06:06 -0500206 if (!ret) {
Anna Neal582c1b52008-10-20 16:46:56 -0700207 if (criteria) {
208 lbs_deb_cmd("Set WOL criteria to %x\n", criteria);
209 priv->wol_criteria = criteria;
210 } else
211 memcpy((uint8_t *) p_wol_config,
212 (uint8_t *)&cmd_config.wol_conf,
213 sizeof(struct wol_config));
David Woodhouse506e9022007-12-12 20:06:06 -0500214 } else {
David Woodhouse6ce4fd22007-12-12 15:19:29 -0500215 lbs_pr_info("HOST_SLEEP_CFG failed %d\n", ret);
David Woodhouse6ce4fd22007-12-12 15:19:29 -0500216 }
David Woodhouse506e9022007-12-12 20:06:06 -0500217
David Woodhouse6ce4fd22007-12-12 15:19:29 -0500218 return ret;
219}
220EXPORT_SYMBOL_GPL(lbs_host_sleep_cfg);
221
Holger Schurige98a88d2008-03-19 14:25:58 +0100222static int lbs_cmd_802_11_ps_mode(struct cmd_ds_command *cmd,
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200223 u16 cmd_action)
224{
225 struct cmd_ds_802_11_ps_mode *psm = &cmd->params.psmode;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200226
Holger Schurig9012b282007-05-25 11:27:16 -0400227 lbs_deb_enter(LBS_DEB_CMD);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200228
Dan Williams0aef64d2007-08-02 11:31:18 -0400229 cmd->command = cpu_to_le16(CMD_802_11_PS_MODE);
David Woodhouse981f1872007-05-25 23:36:54 -0400230 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_ps_mode) +
Holger Schurig8ec97cc2009-10-22 15:30:55 +0200231 sizeof(struct cmd_header));
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200232 psm->action = cpu_to_le16(cmd_action);
233 psm->multipledtim = 0;
David Woodhouse981f1872007-05-25 23:36:54 -0400234 switch (cmd_action) {
Dan Williams0aef64d2007-08-02 11:31:18 -0400235 case CMD_SUBCMD_ENTER_PS:
Holger Schurig9012b282007-05-25 11:27:16 -0400236 lbs_deb_cmd("PS command:" "SubCode- Enter PS\n");
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200237
Holger Schurig252cf0d2007-08-02 13:09:34 -0400238 psm->locallisteninterval = 0;
Holger Schurig97605c32007-08-02 13:09:15 -0400239 psm->nullpktinterval = 0;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200240 psm->multipledtim =
Holger Schurig56c46562007-08-02 13:09:49 -0400241 cpu_to_le16(MRVDRV_DEFAULT_MULTIPLE_DTIM);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200242 break;
243
Dan Williams0aef64d2007-08-02 11:31:18 -0400244 case CMD_SUBCMD_EXIT_PS:
Holger Schurig9012b282007-05-25 11:27:16 -0400245 lbs_deb_cmd("PS command:" "SubCode- Exit PS\n");
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200246 break;
247
Dan Williams0aef64d2007-08-02 11:31:18 -0400248 case CMD_SUBCMD_SLEEP_CONFIRMED:
Holger Schurig9012b282007-05-25 11:27:16 -0400249 lbs_deb_cmd("PS command: SubCode- sleep confirm\n");
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200250 break;
251
252 default:
253 break;
254 }
255
Holger Schurig9012b282007-05-25 11:27:16 -0400256 lbs_deb_leave(LBS_DEB_CMD);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200257 return 0;
258}
259
David Woodhouse3fbe1042007-12-17 23:48:31 -0500260int lbs_cmd_802_11_sleep_params(struct lbs_private *priv, uint16_t cmd_action,
261 struct sleep_params *sp)
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200262{
David Woodhouse3fbe1042007-12-17 23:48:31 -0500263 struct cmd_ds_802_11_sleep_params cmd;
264 int ret;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200265
Holger Schurig9012b282007-05-25 11:27:16 -0400266 lbs_deb_enter(LBS_DEB_CMD);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200267
Dan Williams0aef64d2007-08-02 11:31:18 -0400268 if (cmd_action == CMD_ACT_GET) {
David Woodhouse3fbe1042007-12-17 23:48:31 -0500269 memset(&cmd, 0, sizeof(cmd));
270 } else {
271 cmd.error = cpu_to_le16(sp->sp_error);
272 cmd.offset = cpu_to_le16(sp->sp_offset);
273 cmd.stabletime = cpu_to_le16(sp->sp_stabletime);
274 cmd.calcontrol = sp->sp_calcontrol;
275 cmd.externalsleepclk = sp->sp_extsleepclk;
276 cmd.reserved = cpu_to_le16(sp->sp_reserved);
277 }
278 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
279 cmd.action = cpu_to_le16(cmd_action);
280
281 ret = lbs_cmd_with_response(priv, CMD_802_11_SLEEP_PARAMS, &cmd);
282
283 if (!ret) {
284 lbs_deb_cmd("error 0x%x, offset 0x%x, stabletime 0x%x, "
285 "calcontrol 0x%x extsleepclk 0x%x\n",
286 le16_to_cpu(cmd.error), le16_to_cpu(cmd.offset),
287 le16_to_cpu(cmd.stabletime), cmd.calcontrol,
288 cmd.externalsleepclk);
289
290 sp->sp_error = le16_to_cpu(cmd.error);
291 sp->sp_offset = le16_to_cpu(cmd.offset);
292 sp->sp_stabletime = le16_to_cpu(cmd.stabletime);
293 sp->sp_calcontrol = cmd.calcontrol;
294 sp->sp_extsleepclk = cmd.externalsleepclk;
295 sp->sp_reserved = le16_to_cpu(cmd.reserved);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200296 }
297
David Woodhouse3fbe1042007-12-17 23:48:31 -0500298 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200299 return 0;
300}
301
Amitkumar Karwar49125452009-09-30 20:04:38 -0700302static int lbs_wait_for_ds_awake(struct lbs_private *priv)
303{
304 int ret = 0;
305
306 lbs_deb_enter(LBS_DEB_CMD);
307
308 if (priv->is_deep_sleep) {
309 if (!wait_event_interruptible_timeout(priv->ds_awake_q,
310 !priv->is_deep_sleep, (10 * HZ))) {
311 lbs_pr_err("ds_awake_q: timer expired\n");
312 ret = -1;
313 }
314 }
315
316 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
317 return ret;
318}
319
320int lbs_set_deep_sleep(struct lbs_private *priv, int deep_sleep)
321{
322 int ret = 0;
323
324 lbs_deb_enter(LBS_DEB_CMD);
325
326 if (deep_sleep) {
327 if (priv->is_deep_sleep != 1) {
328 lbs_deb_cmd("deep sleep: sleep\n");
329 BUG_ON(!priv->enter_deep_sleep);
330 ret = priv->enter_deep_sleep(priv);
331 if (!ret) {
332 netif_stop_queue(priv->dev);
333 netif_carrier_off(priv->dev);
334 }
335 } else {
336 lbs_pr_err("deep sleep: already enabled\n");
337 }
338 } else {
339 if (priv->is_deep_sleep) {
340 lbs_deb_cmd("deep sleep: wakeup\n");
341 BUG_ON(!priv->exit_deep_sleep);
342 ret = priv->exit_deep_sleep(priv);
343 if (!ret) {
344 ret = lbs_wait_for_ds_awake(priv);
345 if (ret)
346 lbs_pr_err("deep sleep: wakeup"
347 "failed\n");
348 }
349 }
350 }
351
352 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
353 return ret;
354}
355
Dan Williams39fcf7a2008-09-10 12:49:00 -0400356/**
357 * @brief Set an SNMP MIB value
358 *
359 * @param priv A pointer to struct lbs_private structure
360 * @param oid The OID to set in the firmware
361 * @param val Value to set the OID to
362 *
363 * @return 0 on success, error on failure
364 */
365int lbs_set_snmp_mib(struct lbs_private *priv, u32 oid, u16 val)
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200366{
Dan Williams39fcf7a2008-09-10 12:49:00 -0400367 struct cmd_ds_802_11_snmp_mib cmd;
368 int ret;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200369
Holger Schurig9012b282007-05-25 11:27:16 -0400370 lbs_deb_enter(LBS_DEB_CMD);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200371
Dan Williams39fcf7a2008-09-10 12:49:00 -0400372 memset(&cmd, 0, sizeof (cmd));
373 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
374 cmd.action = cpu_to_le16(CMD_ACT_SET);
375 cmd.oid = cpu_to_le16((u16) oid);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200376
Dan Williams39fcf7a2008-09-10 12:49:00 -0400377 switch (oid) {
378 case SNMP_MIB_OID_BSS_TYPE:
379 cmd.bufsize = cpu_to_le16(sizeof(u8));
Holger Schurigfef06402009-10-22 15:30:59 +0200380 cmd.value[0] = val;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200381 break;
Dan Williams39fcf7a2008-09-10 12:49:00 -0400382 case SNMP_MIB_OID_11D_ENABLE:
383 case SNMP_MIB_OID_FRAG_THRESHOLD:
384 case SNMP_MIB_OID_RTS_THRESHOLD:
385 case SNMP_MIB_OID_SHORT_RETRY_LIMIT:
386 case SNMP_MIB_OID_LONG_RETRY_LIMIT:
387 cmd.bufsize = cpu_to_le16(sizeof(u16));
388 *((__le16 *)(&cmd.value)) = cpu_to_le16(val);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200389 break;
390 default:
Dan Williams39fcf7a2008-09-10 12:49:00 -0400391 lbs_deb_cmd("SNMP_CMD: (set) unhandled OID 0x%x\n", oid);
392 ret = -EINVAL;
393 goto out;
394 }
395
396 lbs_deb_cmd("SNMP_CMD: (set) oid 0x%x, oid size 0x%x, value 0x%x\n",
397 le16_to_cpu(cmd.oid), le16_to_cpu(cmd.bufsize), val);
398
399 ret = lbs_cmd_with_response(priv, CMD_802_11_SNMP_MIB, &cmd);
400
401out:
402 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
403 return ret;
404}
405
406/**
407 * @brief Get an SNMP MIB value
408 *
409 * @param priv A pointer to struct lbs_private structure
410 * @param oid The OID to retrieve from the firmware
411 * @param out_val Location for the returned value
412 *
413 * @return 0 on success, error on failure
414 */
415int lbs_get_snmp_mib(struct lbs_private *priv, u32 oid, u16 *out_val)
416{
417 struct cmd_ds_802_11_snmp_mib cmd;
418 int ret;
419
420 lbs_deb_enter(LBS_DEB_CMD);
421
422 memset(&cmd, 0, sizeof (cmd));
423 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
424 cmd.action = cpu_to_le16(CMD_ACT_GET);
425 cmd.oid = cpu_to_le16(oid);
426
427 ret = lbs_cmd_with_response(priv, CMD_802_11_SNMP_MIB, &cmd);
428 if (ret)
429 goto out;
430
431 switch (le16_to_cpu(cmd.bufsize)) {
432 case sizeof(u8):
Holger Schurigfef06402009-10-22 15:30:59 +0200433 *out_val = cmd.value[0];
Dan Williams39fcf7a2008-09-10 12:49:00 -0400434 break;
435 case sizeof(u16):
436 *out_val = le16_to_cpu(*((__le16 *)(&cmd.value)));
437 break;
438 default:
439 lbs_deb_cmd("SNMP_CMD: (get) unhandled OID 0x%x size %d\n",
440 oid, le16_to_cpu(cmd.bufsize));
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200441 break;
442 }
443
Dan Williams39fcf7a2008-09-10 12:49:00 -0400444out:
445 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
446 return ret;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200447}
448
Dan Williams87c8c722008-08-19 15:15:35 -0400449/**
450 * @brief Get the min, max, and current TX power
451 *
452 * @param priv A pointer to struct lbs_private structure
453 * @param curlevel Current power level in dBm
454 * @param minlevel Minimum supported power level in dBm (optional)
455 * @param maxlevel Maximum supported power level in dBm (optional)
456 *
457 * @return 0 on success, error on failure
458 */
459int lbs_get_tx_power(struct lbs_private *priv, s16 *curlevel, s16 *minlevel,
460 s16 *maxlevel)
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200461{
Dan Williams87c8c722008-08-19 15:15:35 -0400462 struct cmd_ds_802_11_rf_tx_power cmd;
463 int ret;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200464
Holger Schurig9012b282007-05-25 11:27:16 -0400465 lbs_deb_enter(LBS_DEB_CMD);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200466
Dan Williams87c8c722008-08-19 15:15:35 -0400467 memset(&cmd, 0, sizeof(cmd));
468 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
469 cmd.action = cpu_to_le16(CMD_ACT_GET);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200470
Dan Williams87c8c722008-08-19 15:15:35 -0400471 ret = lbs_cmd_with_response(priv, CMD_802_11_RF_TX_POWER, &cmd);
472 if (ret == 0) {
473 *curlevel = le16_to_cpu(cmd.curlevel);
474 if (minlevel)
Holger Schurig87bf24f2008-10-29 10:35:02 +0100475 *minlevel = cmd.minlevel;
Dan Williams87c8c722008-08-19 15:15:35 -0400476 if (maxlevel)
Holger Schurig87bf24f2008-10-29 10:35:02 +0100477 *maxlevel = cmd.maxlevel;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200478 }
Holger Schurig9012b282007-05-25 11:27:16 -0400479
480 lbs_deb_leave(LBS_DEB_CMD);
Dan Williams87c8c722008-08-19 15:15:35 -0400481 return ret;
482}
483
484/**
485 * @brief Set the TX power
486 *
487 * @param priv A pointer to struct lbs_private structure
488 * @param dbm The desired power level in dBm
489 *
490 * @return 0 on success, error on failure
491 */
492int lbs_set_tx_power(struct lbs_private *priv, s16 dbm)
493{
494 struct cmd_ds_802_11_rf_tx_power cmd;
495 int ret;
496
497 lbs_deb_enter(LBS_DEB_CMD);
498
499 memset(&cmd, 0, sizeof(cmd));
500 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
501 cmd.action = cpu_to_le16(CMD_ACT_SET);
502 cmd.curlevel = cpu_to_le16(dbm);
503
504 lbs_deb_cmd("SET_RF_TX_POWER: %d dBm\n", dbm);
505
506 ret = lbs_cmd_with_response(priv, CMD_802_11_RF_TX_POWER, &cmd);
507
508 lbs_deb_leave(LBS_DEB_CMD);
509 return ret;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200510}
511
Holger Schurige98a88d2008-03-19 14:25:58 +0100512static int lbs_cmd_802_11_monitor_mode(struct cmd_ds_command *cmd,
Luis Carlos Cobo965f8bbc2007-08-02 13:16:55 -0400513 u16 cmd_action, void *pdata_buf)
514{
515 struct cmd_ds_802_11_monitor_mode *monitor = &cmd->params.monitor;
516
517 cmd->command = cpu_to_le16(CMD_802_11_MONITOR_MODE);
518 cmd->size =
519 cpu_to_le16(sizeof(struct cmd_ds_802_11_monitor_mode) +
Holger Schurig8ec97cc2009-10-22 15:30:55 +0200520 sizeof(struct cmd_header));
Luis Carlos Cobo965f8bbc2007-08-02 13:16:55 -0400521
522 monitor->action = cpu_to_le16(cmd_action);
523 if (cmd_action == CMD_ACT_SET) {
524 monitor->mode =
525 cpu_to_le16((u16) (*(u32 *) pdata_buf));
526 }
527
528 return 0;
529}
530
Dan Williams2dd4b262007-12-11 16:54:15 -0500531/**
532 * @brief Get the radio channel
533 *
534 * @param priv A pointer to struct lbs_private structure
535 *
536 * @return The channel on success, error on failure
537 */
Holger Schuriga3cbfb02009-10-16 17:33:56 +0200538static int lbs_get_channel(struct lbs_private *priv)
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200539{
Dan Williams2dd4b262007-12-11 16:54:15 -0500540 struct cmd_ds_802_11_rf_channel cmd;
541 int ret = 0;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200542
Holger Schurig8ff12da2007-08-02 11:54:31 -0400543 lbs_deb_enter(LBS_DEB_CMD);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200544
Holger Schurig8d0c7fa2008-04-09 10:23:31 +0200545 memset(&cmd, 0, sizeof(cmd));
Dan Williams2dd4b262007-12-11 16:54:15 -0500546 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
547 cmd.action = cpu_to_le16(CMD_OPT_802_11_RF_CHANNEL_GET);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200548
David Woodhouse689442d2007-12-12 16:00:42 -0500549 ret = lbs_cmd_with_response(priv, CMD_802_11_RF_CHANNEL, &cmd);
Dan Williams2dd4b262007-12-11 16:54:15 -0500550 if (ret)
551 goto out;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200552
Dan Williamscb182a62007-12-11 17:35:51 -0500553 ret = le16_to_cpu(cmd.channel);
554 lbs_deb_cmd("current radio channel is %d\n", ret);
Dan Williams2dd4b262007-12-11 16:54:15 -0500555
556out:
557 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
558 return ret;
559}
560
Holger Schurig73ab1f22008-04-02 16:52:19 +0200561int lbs_update_channel(struct lbs_private *priv)
562{
563 int ret;
564
565 /* the channel in f/w could be out of sync; get the current channel */
566 lbs_deb_enter(LBS_DEB_ASSOC);
567
568 ret = lbs_get_channel(priv);
569 if (ret > 0) {
Holger Schurigc14951f2009-10-22 15:30:50 +0200570 priv->channel = ret;
Holger Schurig73ab1f22008-04-02 16:52:19 +0200571 ret = 0;
572 }
573 lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
574 return ret;
575}
576
Dan Williams2dd4b262007-12-11 16:54:15 -0500577/**
578 * @brief Set the radio channel
579 *
580 * @param priv A pointer to struct lbs_private structure
581 * @param channel The desired channel, or 0 to clear a locked channel
582 *
583 * @return 0 on success, error on failure
584 */
585int lbs_set_channel(struct lbs_private *priv, u8 channel)
586{
587 struct cmd_ds_802_11_rf_channel cmd;
Manish Katiyar96d46d52008-10-13 16:22:42 +0530588#ifdef DEBUG
Holger Schurigc14951f2009-10-22 15:30:50 +0200589 u8 old_channel = priv->channel;
Manish Katiyar96d46d52008-10-13 16:22:42 +0530590#endif
Dan Williams2dd4b262007-12-11 16:54:15 -0500591 int ret = 0;
592
593 lbs_deb_enter(LBS_DEB_CMD);
594
Holger Schurig8d0c7fa2008-04-09 10:23:31 +0200595 memset(&cmd, 0, sizeof(cmd));
Dan Williams2dd4b262007-12-11 16:54:15 -0500596 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
597 cmd.action = cpu_to_le16(CMD_OPT_802_11_RF_CHANNEL_SET);
598 cmd.channel = cpu_to_le16(channel);
599
David Woodhouse689442d2007-12-12 16:00:42 -0500600 ret = lbs_cmd_with_response(priv, CMD_802_11_RF_CHANNEL, &cmd);
Dan Williams2dd4b262007-12-11 16:54:15 -0500601 if (ret)
602 goto out;
603
Holger Schurigc14951f2009-10-22 15:30:50 +0200604 priv->channel = (uint8_t) le16_to_cpu(cmd.channel);
Dan Williamscb182a62007-12-11 17:35:51 -0500605 lbs_deb_cmd("channel switch from %d to %d\n", old_channel,
Holger Schurigc14951f2009-10-22 15:30:50 +0200606 priv->channel);
Dan Williams2dd4b262007-12-11 16:54:15 -0500607
608out:
609 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
610 return ret;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200611}
612
Holger Schurige98a88d2008-03-19 14:25:58 +0100613static int lbs_cmd_reg_access(struct cmd_ds_command *cmdptr,
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200614 u8 cmd_action, void *pdata_buf)
615{
Holger Schurig10078322007-11-15 18:05:47 -0500616 struct lbs_offset_value *offval;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200617
Holger Schurig9012b282007-05-25 11:27:16 -0400618 lbs_deb_enter(LBS_DEB_CMD);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200619
Holger Schurig10078322007-11-15 18:05:47 -0500620 offval = (struct lbs_offset_value *)pdata_buf;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200621
Holger Schurigc2df2ef2007-12-07 15:30:44 +0000622 switch (le16_to_cpu(cmdptr->command)) {
Dan Williams0aef64d2007-08-02 11:31:18 -0400623 case CMD_MAC_REG_ACCESS:
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200624 {
625 struct cmd_ds_mac_reg_access *macreg;
626
627 cmdptr->size =
David Woodhouse981f1872007-05-25 23:36:54 -0400628 cpu_to_le16(sizeof (struct cmd_ds_mac_reg_access)
Holger Schurig8ec97cc2009-10-22 15:30:55 +0200629 + sizeof(struct cmd_header));
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200630 macreg =
631 (struct cmd_ds_mac_reg_access *)&cmdptr->params.
632 macreg;
633
634 macreg->action = cpu_to_le16(cmd_action);
635 macreg->offset = cpu_to_le16((u16) offval->offset);
636 macreg->value = cpu_to_le32(offval->value);
637
638 break;
639 }
640
Dan Williams0aef64d2007-08-02 11:31:18 -0400641 case CMD_BBP_REG_ACCESS:
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200642 {
643 struct cmd_ds_bbp_reg_access *bbpreg;
644
645 cmdptr->size =
646 cpu_to_le16(sizeof
647 (struct cmd_ds_bbp_reg_access)
Holger Schurig8ec97cc2009-10-22 15:30:55 +0200648 + sizeof(struct cmd_header));
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200649 bbpreg =
650 (struct cmd_ds_bbp_reg_access *)&cmdptr->params.
651 bbpreg;
652
653 bbpreg->action = cpu_to_le16(cmd_action);
654 bbpreg->offset = cpu_to_le16((u16) offval->offset);
655 bbpreg->value = (u8) offval->value;
656
657 break;
658 }
659
Dan Williams0aef64d2007-08-02 11:31:18 -0400660 case CMD_RF_REG_ACCESS:
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200661 {
662 struct cmd_ds_rf_reg_access *rfreg;
663
664 cmdptr->size =
665 cpu_to_le16(sizeof
666 (struct cmd_ds_rf_reg_access) +
Holger Schurig8ec97cc2009-10-22 15:30:55 +0200667 sizeof(struct cmd_header));
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200668 rfreg =
669 (struct cmd_ds_rf_reg_access *)&cmdptr->params.
670 rfreg;
671
672 rfreg->action = cpu_to_le16(cmd_action);
673 rfreg->offset = cpu_to_le16((u16) offval->offset);
674 rfreg->value = (u8) offval->value;
675
676 break;
677 }
678
679 default:
680 break;
681 }
682
Holger Schurig9012b282007-05-25 11:27:16 -0400683 lbs_deb_leave(LBS_DEB_CMD);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200684 return 0;
685}
686
David Woodhouse681ffbb2007-12-15 20:04:54 -0500687static void lbs_queue_cmd(struct lbs_private *priv,
688 struct cmd_ctrl_node *cmdnode)
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200689{
690 unsigned long flags;
David Woodhouse681ffbb2007-12-15 20:04:54 -0500691 int addtail = 1;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200692
Holger Schurig8ff12da2007-08-02 11:54:31 -0400693 lbs_deb_enter(LBS_DEB_HOST);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200694
David Woodhousec4ab4122007-12-15 00:41:51 -0500695 if (!cmdnode) {
696 lbs_deb_host("QUEUE_CMD: cmdnode is NULL\n");
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200697 goto done;
698 }
David Woodhoused9896ee2007-12-15 00:09:25 -0500699 if (!cmdnode->cmdbuf->size) {
700 lbs_deb_host("DNLD_CMD: cmd size is zero\n");
701 goto done;
702 }
David Woodhouseae125bf2007-12-15 04:22:52 -0500703 cmdnode->result = 0;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200704
705 /* Exit_PS command needs to be queued in the header always. */
Dan Williamsddac4522007-12-11 13:49:39 -0500706 if (le16_to_cpu(cmdnode->cmdbuf->command) == CMD_802_11_PS_MODE) {
David Woodhouse38bfab12007-12-16 23:26:54 -0500707 struct cmd_ds_802_11_ps_mode *psm = (void *) &cmdnode->cmdbuf[1];
Dan Williamsddac4522007-12-11 13:49:39 -0500708
Dan Williams0aef64d2007-08-02 11:31:18 -0400709 if (psm->action == cpu_to_le16(CMD_SUBCMD_EXIT_PS)) {
David Woodhouseaa21c002007-12-08 20:04:36 +0000710 if (priv->psstate != PS_STATE_FULL_POWER)
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200711 addtail = 0;
712 }
713 }
714
David Woodhouseaa21c002007-12-08 20:04:36 +0000715 spin_lock_irqsave(&priv->driver_lock, flags);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200716
David Woodhouseac472462007-12-08 00:35:00 +0000717 if (addtail)
David Woodhouseaa21c002007-12-08 20:04:36 +0000718 list_add_tail(&cmdnode->list, &priv->cmdpendingq);
David Woodhouseac472462007-12-08 00:35:00 +0000719 else
David Woodhouseaa21c002007-12-08 20:04:36 +0000720 list_add(&cmdnode->list, &priv->cmdpendingq);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200721
David Woodhouseaa21c002007-12-08 20:04:36 +0000722 spin_unlock_irqrestore(&priv->driver_lock, flags);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200723
Holger Schurig8ff12da2007-08-02 11:54:31 -0400724 lbs_deb_host("QUEUE_CMD: inserted command 0x%04x into cmdpendingq\n",
David Woodhousec4ab4122007-12-15 00:41:51 -0500725 le16_to_cpu(cmdnode->cmdbuf->command));
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200726
727done:
Holger Schurig8ff12da2007-08-02 11:54:31 -0400728 lbs_deb_leave(LBS_DEB_HOST);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200729}
730
David Woodhouse18c52e72007-12-17 16:03:58 -0500731static void lbs_submit_command(struct lbs_private *priv,
732 struct cmd_ctrl_node *cmdnode)
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200733{
734 unsigned long flags;
Dan Williamsddac4522007-12-11 13:49:39 -0500735 struct cmd_header *cmd;
David Woodhouse18c52e72007-12-17 16:03:58 -0500736 uint16_t cmdsize;
737 uint16_t command;
Holger Schurig57962f02008-05-14 16:30:28 +0200738 int timeo = 3 * HZ;
David Woodhouse18c52e72007-12-17 16:03:58 -0500739 int ret;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200740
Holger Schurig8ff12da2007-08-02 11:54:31 -0400741 lbs_deb_enter(LBS_DEB_HOST);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200742
Dan Williamsddac4522007-12-11 13:49:39 -0500743 cmd = cmdnode->cmdbuf;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200744
David Woodhouseaa21c002007-12-08 20:04:36 +0000745 spin_lock_irqsave(&priv->driver_lock, flags);
David Woodhouseaa21c002007-12-08 20:04:36 +0000746 priv->cur_cmd = cmdnode;
747 priv->cur_cmd_retcode = 0;
748 spin_unlock_irqrestore(&priv->driver_lock, flags);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200749
Dan Williamsddac4522007-12-11 13:49:39 -0500750 cmdsize = le16_to_cpu(cmd->size);
751 command = le16_to_cpu(cmd->command);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200752
David Woodhouse18c52e72007-12-17 16:03:58 -0500753 /* These commands take longer */
Dan Williamsbe0d76e2009-05-22 20:05:25 -0400754 if (command == CMD_802_11_SCAN || command == CMD_802_11_ASSOCIATE)
Holger Schurig57962f02008-05-14 16:30:28 +0200755 timeo = 5 * HZ;
David Woodhouse18c52e72007-12-17 16:03:58 -0500756
Holger Schurige5225b32008-03-26 10:04:44 +0100757 lbs_deb_cmd("DNLD_CMD: command 0x%04x, seq %d, size %d\n",
758 command, le16_to_cpu(cmd->seqnum), cmdsize);
Holger Schurig1afc09ab2008-01-29 09:14:40 +0100759 lbs_deb_hex(LBS_DEB_CMD, "DNLD_CMD", (void *) cmdnode->cmdbuf, cmdsize);
Holger Schurig8ff12da2007-08-02 11:54:31 -0400760
Dan Williamsddac4522007-12-11 13:49:39 -0500761 ret = priv->hw_host_to_card(priv, MVMS_CMD, (u8 *) cmd, cmdsize);
David Woodhouse18c52e72007-12-17 16:03:58 -0500762
David Woodhoused9896ee2007-12-15 00:09:25 -0500763 if (ret) {
764 lbs_pr_info("DNLD_CMD: hw_host_to_card failed: %d\n", ret);
David Woodhouse18c52e72007-12-17 16:03:58 -0500765 /* Let the timer kick in and retry, and potentially reset
766 the whole thing if the condition persists */
Holger Schurig57962f02008-05-14 16:30:28 +0200767 timeo = HZ/4;
Holger Schurig1afc09ab2008-01-29 09:14:40 +0100768 }
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200769
Amitkumar Karwar49125452009-09-30 20:04:38 -0700770 if (command == CMD_802_11_DEEP_SLEEP) {
771 if (priv->is_auto_deep_sleep_enabled) {
772 priv->wakeup_dev_required = 1;
773 priv->dnld_sent = 0;
774 }
775 priv->is_deep_sleep = 1;
776 lbs_complete_command(priv, cmdnode, 0);
777 } else {
778 /* Setup the timer after transmit command */
779 mod_timer(&priv->command_timer, jiffies + timeo);
780 }
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200781
David Woodhouse18c52e72007-12-17 16:03:58 -0500782 lbs_deb_leave(LBS_DEB_HOST);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200783}
784
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200785/**
786 * This function inserts command node to cmdfreeq
David Woodhouseaa21c002007-12-08 20:04:36 +0000787 * after cleans it. Requires priv->driver_lock held.
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200788 */
David Woodhouse183aeac2007-12-15 01:52:54 -0500789static void __lbs_cleanup_and_insert_cmd(struct lbs_private *priv,
David Woodhouse5ba2f8a2007-12-15 02:02:56 -0500790 struct cmd_ctrl_node *cmdnode)
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200791{
David Woodhouse5ba2f8a2007-12-15 02:02:56 -0500792 lbs_deb_enter(LBS_DEB_HOST);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200793
David Woodhouse5ba2f8a2007-12-15 02:02:56 -0500794 if (!cmdnode)
795 goto out;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200796
David Woodhouse5ba2f8a2007-12-15 02:02:56 -0500797 cmdnode->callback = NULL;
798 cmdnode->callback_arg = 0;
799
800 memset(cmdnode->cmdbuf, 0, LBS_CMD_BUFFER_SIZE);
801
802 list_add_tail(&cmdnode->list, &priv->cmdfreeq);
803 out:
804 lbs_deb_leave(LBS_DEB_HOST);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200805}
806
Holger Schurig69f90322007-11-23 15:43:44 +0100807static void lbs_cleanup_and_insert_cmd(struct lbs_private *priv,
808 struct cmd_ctrl_node *ptempcmd)
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200809{
810 unsigned long flags;
811
David Woodhouseaa21c002007-12-08 20:04:36 +0000812 spin_lock_irqsave(&priv->driver_lock, flags);
Holger Schurig10078322007-11-15 18:05:47 -0500813 __lbs_cleanup_and_insert_cmd(priv, ptempcmd);
David Woodhouseaa21c002007-12-08 20:04:36 +0000814 spin_unlock_irqrestore(&priv->driver_lock, flags);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200815}
816
David Woodhouse183aeac2007-12-15 01:52:54 -0500817void lbs_complete_command(struct lbs_private *priv, struct cmd_ctrl_node *cmd,
818 int result)
819{
820 if (cmd == priv->cur_cmd)
821 priv->cur_cmd_retcode = result;
David Woodhouse5ba2f8a2007-12-15 02:02:56 -0500822
David Woodhouseae125bf2007-12-15 04:22:52 -0500823 cmd->result = result;
David Woodhouse5ba2f8a2007-12-15 02:02:56 -0500824 cmd->cmdwaitqwoken = 1;
825 wake_up_interruptible(&cmd->cmdwait_q);
826
Holger Schurig8db4a2b2008-03-19 10:11:00 +0100827 if (!cmd->callback || cmd->callback == lbs_cmd_async_callback)
David Woodhousead12d0f2007-12-15 02:06:16 -0500828 __lbs_cleanup_and_insert_cmd(priv, cmd);
David Woodhouse183aeac2007-12-15 01:52:54 -0500829 priv->cur_cmd = NULL;
830}
831
Dan Williamsd5db2df2008-08-21 17:51:07 -0400832int lbs_set_radio(struct lbs_private *priv, u8 preamble, u8 radio_on)
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200833{
David Woodhousea7c45892007-12-17 22:43:48 -0500834 struct cmd_ds_802_11_radio_control cmd;
Dan Williamsd5db2df2008-08-21 17:51:07 -0400835 int ret = -EINVAL;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200836
Holger Schurig9012b282007-05-25 11:27:16 -0400837 lbs_deb_enter(LBS_DEB_CMD);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200838
David Woodhousea7c45892007-12-17 22:43:48 -0500839 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
840 cmd.action = cpu_to_le16(CMD_ACT_SET);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200841
Dan Williamsd5db2df2008-08-21 17:51:07 -0400842 /* Only v8 and below support setting the preamble */
843 if (priv->fwrelease < 0x09000000) {
844 switch (preamble) {
845 case RADIO_PREAMBLE_SHORT:
Dan Williamsd5db2df2008-08-21 17:51:07 -0400846 case RADIO_PREAMBLE_AUTO:
847 case RADIO_PREAMBLE_LONG:
848 cmd.control = cpu_to_le16(preamble);
849 break;
850 default:
851 goto out;
852 }
David Woodhousea7c45892007-12-17 22:43:48 -0500853 }
854
Dan Williamsd5db2df2008-08-21 17:51:07 -0400855 if (radio_on)
856 cmd.control |= cpu_to_le16(0x1);
857 else {
858 cmd.control &= cpu_to_le16(~0x1);
859 priv->txpower_cur = 0;
860 }
David Woodhousea7c45892007-12-17 22:43:48 -0500861
Dan Williamsd5db2df2008-08-21 17:51:07 -0400862 lbs_deb_cmd("RADIO_CONTROL: radio %s, preamble %d\n",
863 radio_on ? "ON" : "OFF", preamble);
864
865 priv->radio_on = radio_on;
David Woodhousea7c45892007-12-17 22:43:48 -0500866
867 ret = lbs_cmd_with_response(priv, CMD_802_11_RADIO_CONTROL, &cmd);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200868
Dan Williamsd5db2df2008-08-21 17:51:07 -0400869out:
Holger Schurig9012b282007-05-25 11:27:16 -0400870 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200871 return ret;
872}
873
Holger Schurigc97329e2008-03-18 11:20:21 +0100874void lbs_set_mac_control(struct lbs_private *priv)
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200875{
Holger Schurig835d3ac2008-03-12 16:05:40 +0100876 struct cmd_ds_mac_control cmd;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200877
Holger Schurig9012b282007-05-25 11:27:16 -0400878 lbs_deb_enter(LBS_DEB_CMD);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200879
Holger Schurig835d3ac2008-03-12 16:05:40 +0100880 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
Holger Schurigd9e97782008-03-12 16:06:43 +0100881 cmd.action = cpu_to_le16(priv->mac_control);
Holger Schurig835d3ac2008-03-12 16:05:40 +0100882 cmd.reserved = 0;
883
David Woodhouse75bf45a2008-05-20 13:32:45 +0100884 lbs_cmd_async(priv, CMD_MAC_CONTROL, &cmd.hdr, sizeof(cmd));
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200885
Holger Schurigc97329e2008-03-18 11:20:21 +0100886 lbs_deb_leave(LBS_DEB_CMD);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200887}
888
889/**
890 * @brief This function prepare the command before send to firmware.
891 *
Holger Schurig69f90322007-11-23 15:43:44 +0100892 * @param priv A pointer to struct lbs_private structure
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200893 * @param cmd_no command number
894 * @param cmd_action command action: GET or SET
895 * @param wait_option wait option: wait response or not
896 * @param cmd_oid cmd oid: treated as sub command
897 * @param pdata_buf A pointer to informaion buffer
898 * @return 0 or -1
899 */
Holger Schurig69f90322007-11-23 15:43:44 +0100900int lbs_prepare_and_send_command(struct lbs_private *priv,
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200901 u16 cmd_no,
902 u16 cmd_action,
903 u16 wait_option, u32 cmd_oid, void *pdata_buf)
904{
905 int ret = 0;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200906 struct cmd_ctrl_node *cmdnode;
907 struct cmd_ds_command *cmdptr;
908 unsigned long flags;
909
Holger Schurig8ff12da2007-08-02 11:54:31 -0400910 lbs_deb_enter(LBS_DEB_HOST);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200911
David Woodhouseaa21c002007-12-08 20:04:36 +0000912 if (!priv) {
913 lbs_deb_host("PREP_CMD: priv is NULL\n");
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200914 ret = -1;
915 goto done;
916 }
917
David Woodhouseaa21c002007-12-08 20:04:36 +0000918 if (priv->surpriseremoved) {
Holger Schurig8ff12da2007-08-02 11:54:31 -0400919 lbs_deb_host("PREP_CMD: card removed\n");
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200920 ret = -1;
921 goto done;
922 }
923
Amitkumar Karwar63f275d2009-10-06 19:20:28 -0700924 if (!lbs_is_cmd_allowed(priv)) {
925 ret = -EBUSY;
926 goto done;
927 }
928
Holger Schurig0d61d042007-12-05 17:58:06 +0100929 cmdnode = lbs_get_cmd_ctrl_node(priv);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200930
931 if (cmdnode == NULL) {
Holger Schurig8ff12da2007-08-02 11:54:31 -0400932 lbs_deb_host("PREP_CMD: cmdnode is NULL\n");
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200933
934 /* Wake up main thread to execute next command */
Dan Williamsfe336152007-08-02 11:32:25 -0400935 wake_up_interruptible(&priv->waitq);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200936 ret = -1;
937 goto done;
938 }
939
Holger Schurige98a88d2008-03-19 14:25:58 +0100940 cmdnode->callback = NULL;
941 cmdnode->callback_arg = (unsigned long)pdata_buf;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200942
Dan Williamsddac4522007-12-11 13:49:39 -0500943 cmdptr = (struct cmd_ds_command *)cmdnode->cmdbuf;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200944
Holger Schurig8ff12da2007-08-02 11:54:31 -0400945 lbs_deb_host("PREP_CMD: command 0x%04x\n", cmd_no);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200946
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200947 /* Set sequence number, command and INT option */
David Woodhouseaa21c002007-12-08 20:04:36 +0000948 priv->seqnum++;
949 cmdptr->seqnum = cpu_to_le16(priv->seqnum);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200950
David Woodhouse981f1872007-05-25 23:36:54 -0400951 cmdptr->command = cpu_to_le16(cmd_no);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200952 cmdptr->result = 0;
953
954 switch (cmd_no) {
Dan Williams0aef64d2007-08-02 11:31:18 -0400955 case CMD_802_11_PS_MODE:
Holger Schurige98a88d2008-03-19 14:25:58 +0100956 ret = lbs_cmd_802_11_ps_mode(cmdptr, cmd_action);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200957 break;
958
Dan Williams0aef64d2007-08-02 11:31:18 -0400959 case CMD_MAC_REG_ACCESS:
960 case CMD_BBP_REG_ACCESS:
961 case CMD_RF_REG_ACCESS:
Holger Schurige98a88d2008-03-19 14:25:58 +0100962 ret = lbs_cmd_reg_access(cmdptr, cmd_action, pdata_buf);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200963 break;
964
Luis Carlos Cobo965f8bbc2007-08-02 13:16:55 -0400965 case CMD_802_11_MONITOR_MODE:
Holger Schurige98a88d2008-03-19 14:25:58 +0100966 ret = lbs_cmd_802_11_monitor_mode(cmdptr,
Luis Carlos Cobo965f8bbc2007-08-02 13:16:55 -0400967 cmd_action, pdata_buf);
968 break;
969
Dan Williams0aef64d2007-08-02 11:31:18 -0400970 case CMD_802_11_RSSI:
Holger Schurig10078322007-11-15 18:05:47 -0500971 ret = lbs_cmd_802_11_rssi(priv, cmdptr);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200972 break;
973
Dan Williams0aef64d2007-08-02 11:31:18 -0400974 case CMD_802_11_SET_AFC:
975 case CMD_802_11_GET_AFC:
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200976
977 cmdptr->command = cpu_to_le16(cmd_no);
David Woodhouse981f1872007-05-25 23:36:54 -0400978 cmdptr->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_afc) +
Holger Schurig8ec97cc2009-10-22 15:30:55 +0200979 sizeof(struct cmd_header));
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200980
981 memmove(&cmdptr->params.afc,
982 pdata_buf, sizeof(struct cmd_ds_802_11_afc));
983
984 ret = 0;
985 goto done;
986
Dan Williams0aef64d2007-08-02 11:31:18 -0400987 case CMD_802_11_TPC_CFG:
988 cmdptr->command = cpu_to_le16(CMD_802_11_TPC_CFG);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200989 cmdptr->size =
990 cpu_to_le16(sizeof(struct cmd_ds_802_11_tpc_cfg) +
Holger Schurig8ec97cc2009-10-22 15:30:55 +0200991 sizeof(struct cmd_header));
Marcelo Tosatti876c9d32007-02-10 12:25:27 -0200992
993 memmove(&cmdptr->params.tpccfg,
994 pdata_buf, sizeof(struct cmd_ds_802_11_tpc_cfg));
995
996 ret = 0;
997 break;
David Woodhouse5844d122007-12-18 02:01:37 -0500998
Holger Schurig4143a232009-12-02 15:26:02 +0100999#ifdef CONFIG_LIBERTAS_MESH
1000
Dan Williams0aef64d2007-08-02 11:31:18 -04001001 case CMD_BT_ACCESS:
Holger Schurige98a88d2008-03-19 14:25:58 +01001002 ret = lbs_cmd_bt_access(cmdptr, cmd_action, pdata_buf);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001003 break;
1004
Dan Williams0aef64d2007-08-02 11:31:18 -04001005 case CMD_FWT_ACCESS:
Holger Schurige98a88d2008-03-19 14:25:58 +01001006 ret = lbs_cmd_fwt_access(cmdptr, cmd_action, pdata_buf);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001007 break;
1008
Holger Schurig4143a232009-12-02 15:26:02 +01001009#endif
1010
Brajesh Dave96287ac2007-11-20 17:44:28 -05001011 case CMD_802_11_BEACON_CTRL:
1012 ret = lbs_cmd_bcn_ctrl(priv, cmdptr, cmd_action);
1013 break;
Amitkumar Karwar49125452009-09-30 20:04:38 -07001014 case CMD_802_11_DEEP_SLEEP:
1015 cmdptr->command = cpu_to_le16(CMD_802_11_DEEP_SLEEP);
Holger Schurig8ec97cc2009-10-22 15:30:55 +02001016 cmdptr->size = cpu_to_le16(sizeof(struct cmd_header));
Amitkumar Karwar49125452009-09-30 20:04:38 -07001017 break;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001018 default:
David Woodhousee37fc6e2008-05-20 11:47:16 +01001019 lbs_pr_err("PREP_CMD: unknown command 0x%04x\n", cmd_no);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001020 ret = -1;
1021 break;
1022 }
1023
1024 /* return error, since the command preparation failed */
1025 if (ret != 0) {
Holger Schurig8ff12da2007-08-02 11:54:31 -04001026 lbs_deb_host("PREP_CMD: command preparation failed\n");
Holger Schurig10078322007-11-15 18:05:47 -05001027 lbs_cleanup_and_insert_cmd(priv, cmdnode);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001028 ret = -1;
1029 goto done;
1030 }
1031
1032 cmdnode->cmdwaitqwoken = 0;
1033
David Woodhouse681ffbb2007-12-15 20:04:54 -05001034 lbs_queue_cmd(priv, cmdnode);
Dan Williamsfe336152007-08-02 11:32:25 -04001035 wake_up_interruptible(&priv->waitq);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001036
Dan Williams0aef64d2007-08-02 11:31:18 -04001037 if (wait_option & CMD_OPTION_WAITFORRSP) {
Holger Schurig8ff12da2007-08-02 11:54:31 -04001038 lbs_deb_host("PREP_CMD: wait for response\n");
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001039 might_sleep();
1040 wait_event_interruptible(cmdnode->cmdwait_q,
1041 cmdnode->cmdwaitqwoken);
1042 }
1043
David Woodhouseaa21c002007-12-08 20:04:36 +00001044 spin_lock_irqsave(&priv->driver_lock, flags);
1045 if (priv->cur_cmd_retcode) {
Holger Schurig8ff12da2007-08-02 11:54:31 -04001046 lbs_deb_host("PREP_CMD: command failed with return code %d\n",
David Woodhouseaa21c002007-12-08 20:04:36 +00001047 priv->cur_cmd_retcode);
1048 priv->cur_cmd_retcode = 0;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001049 ret = -1;
1050 }
David Woodhouseaa21c002007-12-08 20:04:36 +00001051 spin_unlock_irqrestore(&priv->driver_lock, flags);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001052
1053done:
Holger Schurig8ff12da2007-08-02 11:54:31 -04001054 lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001055 return ret;
1056}
1057
1058/**
1059 * @brief This function allocates the command buffer and link
1060 * it to command free queue.
1061 *
Holger Schurig69f90322007-11-23 15:43:44 +01001062 * @param priv A pointer to struct lbs_private structure
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001063 * @return 0 or -1
1064 */
Holger Schurig69f90322007-11-23 15:43:44 +01001065int lbs_allocate_cmd_buffer(struct lbs_private *priv)
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001066{
1067 int ret = 0;
Dan Williamsddac4522007-12-11 13:49:39 -05001068 u32 bufsize;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001069 u32 i;
Dan Williamsddac4522007-12-11 13:49:39 -05001070 struct cmd_ctrl_node *cmdarray;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001071
Holger Schurig8ff12da2007-08-02 11:54:31 -04001072 lbs_deb_enter(LBS_DEB_HOST);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001073
Dan Williamsddac4522007-12-11 13:49:39 -05001074 /* Allocate and initialize the command array */
1075 bufsize = sizeof(struct cmd_ctrl_node) * LBS_NUM_CMD_BUFFERS;
1076 if (!(cmdarray = kzalloc(bufsize, GFP_KERNEL))) {
Holger Schurig8ff12da2007-08-02 11:54:31 -04001077 lbs_deb_host("ALLOC_CMD_BUF: tempcmd_array is NULL\n");
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001078 ret = -1;
1079 goto done;
1080 }
Dan Williamsddac4522007-12-11 13:49:39 -05001081 priv->cmd_array = cmdarray;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001082
Dan Williamsddac4522007-12-11 13:49:39 -05001083 /* Allocate and initialize each command buffer in the command array */
1084 for (i = 0; i < LBS_NUM_CMD_BUFFERS; i++) {
1085 cmdarray[i].cmdbuf = kzalloc(LBS_CMD_BUFFER_SIZE, GFP_KERNEL);
1086 if (!cmdarray[i].cmdbuf) {
Holger Schurig8ff12da2007-08-02 11:54:31 -04001087 lbs_deb_host("ALLOC_CMD_BUF: ptempvirtualaddr is NULL\n");
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001088 ret = -1;
1089 goto done;
1090 }
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001091 }
1092
Dan Williamsddac4522007-12-11 13:49:39 -05001093 for (i = 0; i < LBS_NUM_CMD_BUFFERS; i++) {
1094 init_waitqueue_head(&cmdarray[i].cmdwait_q);
1095 lbs_cleanup_and_insert_cmd(priv, &cmdarray[i]);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001096 }
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001097 ret = 0;
Holger Schurig9012b282007-05-25 11:27:16 -04001098
1099done:
Holger Schurig8ff12da2007-08-02 11:54:31 -04001100 lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001101 return ret;
1102}
1103
1104/**
1105 * @brief This function frees the command buffer.
1106 *
Holger Schurig69f90322007-11-23 15:43:44 +01001107 * @param priv A pointer to struct lbs_private structure
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001108 * @return 0 or -1
1109 */
Holger Schurig69f90322007-11-23 15:43:44 +01001110int lbs_free_cmd_buffer(struct lbs_private *priv)
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001111{
Dan Williamsddac4522007-12-11 13:49:39 -05001112 struct cmd_ctrl_node *cmdarray;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001113 unsigned int i;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001114
Holger Schurig8ff12da2007-08-02 11:54:31 -04001115 lbs_deb_enter(LBS_DEB_HOST);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001116
1117 /* need to check if cmd array is allocated or not */
David Woodhouseaa21c002007-12-08 20:04:36 +00001118 if (priv->cmd_array == NULL) {
Holger Schurig8ff12da2007-08-02 11:54:31 -04001119 lbs_deb_host("FREE_CMD_BUF: cmd_array is NULL\n");
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001120 goto done;
1121 }
1122
Dan Williamsddac4522007-12-11 13:49:39 -05001123 cmdarray = priv->cmd_array;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001124
1125 /* Release shared memory buffers */
Dan Williamsddac4522007-12-11 13:49:39 -05001126 for (i = 0; i < LBS_NUM_CMD_BUFFERS; i++) {
1127 if (cmdarray[i].cmdbuf) {
1128 kfree(cmdarray[i].cmdbuf);
1129 cmdarray[i].cmdbuf = NULL;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001130 }
1131 }
1132
1133 /* Release cmd_ctrl_node */
David Woodhouseaa21c002007-12-08 20:04:36 +00001134 if (priv->cmd_array) {
1135 kfree(priv->cmd_array);
1136 priv->cmd_array = NULL;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001137 }
1138
1139done:
Holger Schurig8ff12da2007-08-02 11:54:31 -04001140 lbs_deb_leave(LBS_DEB_HOST);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001141 return 0;
1142}
1143
1144/**
1145 * @brief This function gets a free command node if available in
1146 * command free queue.
1147 *
Holger Schurig69f90322007-11-23 15:43:44 +01001148 * @param priv A pointer to struct lbs_private structure
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001149 * @return cmd_ctrl_node A pointer to cmd_ctrl_node structure or NULL
1150 */
David Woodhouse2fd6cfe2007-12-11 17:44:10 -05001151static struct cmd_ctrl_node *lbs_get_cmd_ctrl_node(struct lbs_private *priv)
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001152{
1153 struct cmd_ctrl_node *tempnode;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001154 unsigned long flags;
1155
Holger Schurig8ff12da2007-08-02 11:54:31 -04001156 lbs_deb_enter(LBS_DEB_HOST);
1157
David Woodhouseaa21c002007-12-08 20:04:36 +00001158 if (!priv)
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001159 return NULL;
1160
David Woodhouseaa21c002007-12-08 20:04:36 +00001161 spin_lock_irqsave(&priv->driver_lock, flags);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001162
David Woodhouseaa21c002007-12-08 20:04:36 +00001163 if (!list_empty(&priv->cmdfreeq)) {
1164 tempnode = list_first_entry(&priv->cmdfreeq,
Li Zefanabe3ed12007-12-06 13:01:21 +01001165 struct cmd_ctrl_node, list);
1166 list_del(&tempnode->list);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001167 } else {
Holger Schurig8ff12da2007-08-02 11:54:31 -04001168 lbs_deb_host("GET_CMD_NODE: cmd_ctrl_node is not available\n");
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001169 tempnode = NULL;
1170 }
1171
David Woodhouseaa21c002007-12-08 20:04:36 +00001172 spin_unlock_irqrestore(&priv->driver_lock, flags);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001173
Holger Schurig8ff12da2007-08-02 11:54:31 -04001174 lbs_deb_leave(LBS_DEB_HOST);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001175 return tempnode;
1176}
1177
1178/**
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001179 * @brief This function executes next command in command
Nick Andrew877d0312009-01-26 11:06:57 +01001180 * pending queue. It will put firmware back to PS mode
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001181 * if applicable.
1182 *
Holger Schurig69f90322007-11-23 15:43:44 +01001183 * @param priv A pointer to struct lbs_private structure
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001184 * @return 0 or -1
1185 */
Holger Schurig69f90322007-11-23 15:43:44 +01001186int lbs_execute_next_command(struct lbs_private *priv)
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001187{
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001188 struct cmd_ctrl_node *cmdnode = NULL;
Dan Williamsddac4522007-12-11 13:49:39 -05001189 struct cmd_header *cmd;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001190 unsigned long flags;
1191 int ret = 0;
1192
Holger Schurig1afc09ab2008-01-29 09:14:40 +01001193 /* Debug group is LBS_DEB_THREAD and not LBS_DEB_HOST, because the
1194 * only caller to us is lbs_thread() and we get even when a
1195 * data packet is received */
Holger Schurig8ff12da2007-08-02 11:54:31 -04001196 lbs_deb_enter(LBS_DEB_THREAD);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001197
David Woodhouseaa21c002007-12-08 20:04:36 +00001198 spin_lock_irqsave(&priv->driver_lock, flags);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001199
David Woodhouseaa21c002007-12-08 20:04:36 +00001200 if (priv->cur_cmd) {
Holger Schurig8ff12da2007-08-02 11:54:31 -04001201 lbs_pr_alert( "EXEC_NEXT_CMD: already processing command!\n");
David Woodhouseaa21c002007-12-08 20:04:36 +00001202 spin_unlock_irqrestore(&priv->driver_lock, flags);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001203 ret = -1;
1204 goto done;
1205 }
1206
David Woodhouseaa21c002007-12-08 20:04:36 +00001207 if (!list_empty(&priv->cmdpendingq)) {
1208 cmdnode = list_first_entry(&priv->cmdpendingq,
Li Zefanabe3ed12007-12-06 13:01:21 +01001209 struct cmd_ctrl_node, list);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001210 }
1211
David Woodhouseaa21c002007-12-08 20:04:36 +00001212 spin_unlock_irqrestore(&priv->driver_lock, flags);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001213
1214 if (cmdnode) {
Dan Williamsddac4522007-12-11 13:49:39 -05001215 cmd = cmdnode->cmdbuf;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001216
Dan Williamsddac4522007-12-11 13:49:39 -05001217 if (is_command_allowed_in_ps(le16_to_cpu(cmd->command))) {
David Woodhouseaa21c002007-12-08 20:04:36 +00001218 if ((priv->psstate == PS_STATE_SLEEP) ||
1219 (priv->psstate == PS_STATE_PRE_SLEEP)) {
Holger Schurig8ff12da2007-08-02 11:54:31 -04001220 lbs_deb_host(
1221 "EXEC_NEXT_CMD: cannot send cmd 0x%04x in psstate %d\n",
Dan Williamsddac4522007-12-11 13:49:39 -05001222 le16_to_cpu(cmd->command),
David Woodhouseaa21c002007-12-08 20:04:36 +00001223 priv->psstate);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001224 ret = -1;
1225 goto done;
1226 }
Holger Schurig8ff12da2007-08-02 11:54:31 -04001227 lbs_deb_host("EXEC_NEXT_CMD: OK to send command "
Dan Williamsddac4522007-12-11 13:49:39 -05001228 "0x%04x in psstate %d\n",
1229 le16_to_cpu(cmd->command), priv->psstate);
David Woodhouseaa21c002007-12-08 20:04:36 +00001230 } else if (priv->psstate != PS_STATE_FULL_POWER) {
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001231 /*
1232 * 1. Non-PS command:
1233 * Queue it. set needtowakeup to TRUE if current state
Holger Schurig10078322007-11-15 18:05:47 -05001234 * is SLEEP, otherwise call lbs_ps_wakeup to send Exit_PS.
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001235 * 2. PS command but not Exit_PS:
1236 * Ignore it.
1237 * 3. PS command Exit_PS:
1238 * Set needtowakeup to TRUE if current state is SLEEP,
1239 * otherwise send this command down to firmware
1240 * immediately.
1241 */
Dan Williamsddac4522007-12-11 13:49:39 -05001242 if (cmd->command != cpu_to_le16(CMD_802_11_PS_MODE)) {
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001243 /* Prepare to send Exit PS,
1244 * this non PS command will be sent later */
David Woodhouseaa21c002007-12-08 20:04:36 +00001245 if ((priv->psstate == PS_STATE_SLEEP)
1246 || (priv->psstate == PS_STATE_PRE_SLEEP)
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001247 ) {
1248 /* w/ new scheme, it will not reach here.
1249 since it is blocked in main_thread. */
David Woodhouseaa21c002007-12-08 20:04:36 +00001250 priv->needtowakeup = 1;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001251 } else
Holger Schurig10078322007-11-15 18:05:47 -05001252 lbs_ps_wakeup(priv, 0);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001253
1254 ret = 0;
1255 goto done;
1256 } else {
1257 /*
1258 * PS command. Ignore it if it is not Exit_PS.
1259 * otherwise send it down immediately.
1260 */
David Woodhouse38bfab12007-12-16 23:26:54 -05001261 struct cmd_ds_802_11_ps_mode *psm = (void *)&cmd[1];
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001262
Holger Schurig8ff12da2007-08-02 11:54:31 -04001263 lbs_deb_host(
1264 "EXEC_NEXT_CMD: PS cmd, action 0x%02x\n",
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001265 psm->action);
1266 if (psm->action !=
Dan Williams0aef64d2007-08-02 11:31:18 -04001267 cpu_to_le16(CMD_SUBCMD_EXIT_PS)) {
Holger Schurig8ff12da2007-08-02 11:54:31 -04001268 lbs_deb_host(
1269 "EXEC_NEXT_CMD: ignore ENTER_PS cmd\n");
Li Zefanabe3ed12007-12-06 13:01:21 +01001270 list_del(&cmdnode->list);
David Woodhouse183aeac2007-12-15 01:52:54 -05001271 spin_lock_irqsave(&priv->driver_lock, flags);
1272 lbs_complete_command(priv, cmdnode, 0);
1273 spin_unlock_irqrestore(&priv->driver_lock, flags);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001274
1275 ret = 0;
1276 goto done;
1277 }
1278
David Woodhouseaa21c002007-12-08 20:04:36 +00001279 if ((priv->psstate == PS_STATE_SLEEP) ||
1280 (priv->psstate == PS_STATE_PRE_SLEEP)) {
Holger Schurig8ff12da2007-08-02 11:54:31 -04001281 lbs_deb_host(
1282 "EXEC_NEXT_CMD: ignore EXIT_PS cmd in sleep\n");
Li Zefanabe3ed12007-12-06 13:01:21 +01001283 list_del(&cmdnode->list);
David Woodhouse183aeac2007-12-15 01:52:54 -05001284 spin_lock_irqsave(&priv->driver_lock, flags);
1285 lbs_complete_command(priv, cmdnode, 0);
1286 spin_unlock_irqrestore(&priv->driver_lock, flags);
David Woodhouseaa21c002007-12-08 20:04:36 +00001287 priv->needtowakeup = 1;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001288
1289 ret = 0;
1290 goto done;
1291 }
1292
Holger Schurig8ff12da2007-08-02 11:54:31 -04001293 lbs_deb_host(
1294 "EXEC_NEXT_CMD: sending EXIT_PS\n");
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001295 }
1296 }
Li Zefanabe3ed12007-12-06 13:01:21 +01001297 list_del(&cmdnode->list);
Holger Schurig8ff12da2007-08-02 11:54:31 -04001298 lbs_deb_host("EXEC_NEXT_CMD: sending command 0x%04x\n",
Dan Williamsddac4522007-12-11 13:49:39 -05001299 le16_to_cpu(cmd->command));
David Woodhoused9896ee2007-12-15 00:09:25 -05001300 lbs_submit_command(priv, cmdnode);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001301 } else {
1302 /*
1303 * check if in power save mode, if yes, put the device back
1304 * to PS mode
1305 */
David Woodhouseaa21c002007-12-08 20:04:36 +00001306 if ((priv->psmode != LBS802_11POWERMODECAM) &&
1307 (priv->psstate == PS_STATE_FULL_POWER) &&
1308 ((priv->connect_status == LBS_CONNECTED) ||
Holger Schurig602114a2009-12-02 15:26:01 +01001309 lbs_mesh_connected(priv))) {
David Woodhouseaa21c002007-12-08 20:04:36 +00001310 if (priv->secinfo.WPAenabled ||
1311 priv->secinfo.WPA2enabled) {
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001312 /* check for valid WPA group keys */
David Woodhouseaa21c002007-12-08 20:04:36 +00001313 if (priv->wpa_mcast_key.len ||
1314 priv->wpa_unicast_key.len) {
Holger Schurig8ff12da2007-08-02 11:54:31 -04001315 lbs_deb_host(
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001316 "EXEC_NEXT_CMD: WPA enabled and GTK_SET"
1317 " go back to PS_SLEEP");
Holger Schurig10078322007-11-15 18:05:47 -05001318 lbs_ps_sleep(priv, 0);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001319 }
1320 } else {
Holger Schurig8ff12da2007-08-02 11:54:31 -04001321 lbs_deb_host(
1322 "EXEC_NEXT_CMD: cmdpendingq empty, "
1323 "go back to PS_SLEEP");
Holger Schurig10078322007-11-15 18:05:47 -05001324 lbs_ps_sleep(priv, 0);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001325 }
1326 }
1327 }
1328
1329 ret = 0;
1330done:
Holger Schurig8ff12da2007-08-02 11:54:31 -04001331 lbs_deb_leave(LBS_DEB_THREAD);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001332 return ret;
1333}
1334
Holger Schurigf539f2e2008-03-26 13:22:11 +01001335static void lbs_send_confirmsleep(struct lbs_private *priv)
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001336{
1337 unsigned long flags;
Holger Schurigf539f2e2008-03-26 13:22:11 +01001338 int ret;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001339
Holger Schurig8ff12da2007-08-02 11:54:31 -04001340 lbs_deb_enter(LBS_DEB_HOST);
Holger Schurigf539f2e2008-03-26 13:22:11 +01001341 lbs_deb_hex(LBS_DEB_HOST, "sleep confirm", (u8 *) &confirm_sleep,
1342 sizeof(confirm_sleep));
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001343
Holger Schurigf539f2e2008-03-26 13:22:11 +01001344 ret = priv->hw_host_to_card(priv, MVMS_CMD, (u8 *) &confirm_sleep,
1345 sizeof(confirm_sleep));
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001346 if (ret) {
Holger Schurigf539f2e2008-03-26 13:22:11 +01001347 lbs_pr_alert("confirm_sleep failed\n");
Holger Schurig7919b892008-04-01 14:50:43 +02001348 goto out;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001349 }
Holger Schurig7919b892008-04-01 14:50:43 +02001350
1351 spin_lock_irqsave(&priv->driver_lock, flags);
1352
Holger Schuriga01f5452008-06-04 11:10:40 +02001353 /* We don't get a response on the sleep-confirmation */
1354 priv->dnld_sent = DNLD_RES_RECEIVED;
1355
Holger Schurig7919b892008-04-01 14:50:43 +02001356 /* If nothing to do, go back to sleep (?) */
Stefani Seibolde64c0262009-12-21 14:37:28 -08001357 if (!kfifo_len(&priv->event_fifo) && !priv->resp_len[priv->resp_idx])
Holger Schurig7919b892008-04-01 14:50:43 +02001358 priv->psstate = PS_STATE_SLEEP;
1359
1360 spin_unlock_irqrestore(&priv->driver_lock, flags);
1361
1362out:
Holger Schurigf539f2e2008-03-26 13:22:11 +01001363 lbs_deb_leave(LBS_DEB_HOST);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001364}
1365
Holger Schurig69f90322007-11-23 15:43:44 +01001366void lbs_ps_sleep(struct lbs_private *priv, int wait_option)
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001367{
Holger Schurig8ff12da2007-08-02 11:54:31 -04001368 lbs_deb_enter(LBS_DEB_HOST);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001369
1370 /*
1371 * PS is currently supported only in Infrastructure mode
1372 * Remove this check if it is to be supported in IBSS mode also
1373 */
1374
Holger Schurig10078322007-11-15 18:05:47 -05001375 lbs_prepare_and_send_command(priv, CMD_802_11_PS_MODE,
Dan Williams0aef64d2007-08-02 11:31:18 -04001376 CMD_SUBCMD_ENTER_PS, wait_option, 0, NULL);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001377
Holger Schurig8ff12da2007-08-02 11:54:31 -04001378 lbs_deb_leave(LBS_DEB_HOST);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001379}
1380
1381/**
Holger Schurig8ff12da2007-08-02 11:54:31 -04001382 * @brief This function sends Exit_PS command to firmware.
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001383 *
Holger Schurig69f90322007-11-23 15:43:44 +01001384 * @param priv A pointer to struct lbs_private structure
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001385 * @param wait_option wait response or not
1386 * @return n/a
1387 */
Holger Schurig69f90322007-11-23 15:43:44 +01001388void lbs_ps_wakeup(struct lbs_private *priv, int wait_option)
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001389{
David Woodhouse981f1872007-05-25 23:36:54 -04001390 __le32 Localpsmode;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001391
Holger Schurig8ff12da2007-08-02 11:54:31 -04001392 lbs_deb_enter(LBS_DEB_HOST);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001393
Holger Schurig10078322007-11-15 18:05:47 -05001394 Localpsmode = cpu_to_le32(LBS802_11POWERMODECAM);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001395
Holger Schurig10078322007-11-15 18:05:47 -05001396 lbs_prepare_and_send_command(priv, CMD_802_11_PS_MODE,
Dan Williams0aef64d2007-08-02 11:31:18 -04001397 CMD_SUBCMD_EXIT_PS,
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001398 wait_option, 0, &Localpsmode);
1399
Holger Schurig8ff12da2007-08-02 11:54:31 -04001400 lbs_deb_leave(LBS_DEB_HOST);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001401}
1402
1403/**
1404 * @brief This function checks condition and prepares to
1405 * send sleep confirm command to firmware if ok.
1406 *
Holger Schurig69f90322007-11-23 15:43:44 +01001407 * @param priv A pointer to struct lbs_private structure
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001408 * @param psmode Power Saving mode
1409 * @return n/a
1410 */
Holger Schurigd4ff0ef2008-03-19 14:25:18 +01001411void lbs_ps_confirm_sleep(struct lbs_private *priv)
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001412{
1413 unsigned long flags =0;
Holger Schurigd4ff0ef2008-03-19 14:25:18 +01001414 int allowed = 1;
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001415
Holger Schurig8ff12da2007-08-02 11:54:31 -04001416 lbs_deb_enter(LBS_DEB_HOST);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001417
Holger Schuriga01f5452008-06-04 11:10:40 +02001418 spin_lock_irqsave(&priv->driver_lock, flags);
Holger Schurig634b8f42007-05-25 13:05:16 -04001419 if (priv->dnld_sent) {
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001420 allowed = 0;
David Woodhouse23d36ee2007-12-12 00:14:21 -05001421 lbs_deb_host("dnld_sent was set\n");
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001422 }
1423
Holger Schurig7919b892008-04-01 14:50:43 +02001424 /* In-progress command? */
David Woodhouseaa21c002007-12-08 20:04:36 +00001425 if (priv->cur_cmd) {
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001426 allowed = 0;
David Woodhouse23d36ee2007-12-12 00:14:21 -05001427 lbs_deb_host("cur_cmd was set\n");
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001428 }
Holger Schurig7919b892008-04-01 14:50:43 +02001429
1430 /* Pending events or command responses? */
Stefani Seibolde64c0262009-12-21 14:37:28 -08001431 if (kfifo_len(&priv->event_fifo) || priv->resp_len[priv->resp_idx]) {
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001432 allowed = 0;
Holger Schurig7919b892008-04-01 14:50:43 +02001433 lbs_deb_host("pending events or command responses\n");
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001434 }
David Woodhouseaa21c002007-12-08 20:04:36 +00001435 spin_unlock_irqrestore(&priv->driver_lock, flags);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001436
1437 if (allowed) {
Holger Schurig10078322007-11-15 18:05:47 -05001438 lbs_deb_host("sending lbs_ps_confirm_sleep\n");
Holger Schurigf539f2e2008-03-26 13:22:11 +01001439 lbs_send_confirmsleep(priv);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001440 } else {
Holger Schurig8ff12da2007-08-02 11:54:31 -04001441 lbs_deb_host("sleep confirm has been delayed\n");
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001442 }
1443
Holger Schurig8ff12da2007-08-02 11:54:31 -04001444 lbs_deb_leave(LBS_DEB_HOST);
Marcelo Tosatti876c9d32007-02-10 12:25:27 -02001445}
Holger Schurig675787e2007-12-05 17:58:11 +01001446
1447
Anna Neal0112c9e2008-09-11 11:17:25 -07001448/**
1449 * @brief Configures the transmission power control functionality.
1450 *
1451 * @param priv A pointer to struct lbs_private structure
1452 * @param enable Transmission power control enable
1453 * @param p0 Power level when link quality is good (dBm).
1454 * @param p1 Power level when link quality is fair (dBm).
1455 * @param p2 Power level when link quality is poor (dBm).
1456 * @param usesnr Use Signal to Noise Ratio in TPC
1457 *
1458 * @return 0 on success
1459 */
1460int lbs_set_tpc_cfg(struct lbs_private *priv, int enable, int8_t p0, int8_t p1,
1461 int8_t p2, int usesnr)
1462{
1463 struct cmd_ds_802_11_tpc_cfg cmd;
1464 int ret;
1465
1466 memset(&cmd, 0, sizeof(cmd));
1467 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
1468 cmd.action = cpu_to_le16(CMD_ACT_SET);
1469 cmd.enable = !!enable;
Anna Neal3ed6e082008-09-26 11:34:35 -04001470 cmd.usesnr = !!usesnr;
Anna Neal0112c9e2008-09-11 11:17:25 -07001471 cmd.P0 = p0;
1472 cmd.P1 = p1;
1473 cmd.P2 = p2;
1474
1475 ret = lbs_cmd_with_response(priv, CMD_802_11_TPC_CFG, &cmd);
1476
1477 return ret;
1478}
1479
1480/**
1481 * @brief Configures the power adaptation settings.
1482 *
1483 * @param priv A pointer to struct lbs_private structure
1484 * @param enable Power adaptation enable
1485 * @param p0 Power level for 1, 2, 5.5 and 11 Mbps (dBm).
1486 * @param p1 Power level for 6, 9, 12, 18, 22, 24 and 36 Mbps (dBm).
1487 * @param p2 Power level for 48 and 54 Mbps (dBm).
1488 *
1489 * @return 0 on Success
1490 */
1491
1492int lbs_set_power_adapt_cfg(struct lbs_private *priv, int enable, int8_t p0,
1493 int8_t p1, int8_t p2)
1494{
1495 struct cmd_ds_802_11_pa_cfg cmd;
1496 int ret;
1497
1498 memset(&cmd, 0, sizeof(cmd));
1499 cmd.hdr.size = cpu_to_le16(sizeof(cmd));
1500 cmd.action = cpu_to_le16(CMD_ACT_SET);
1501 cmd.enable = !!enable;
1502 cmd.P0 = p0;
1503 cmd.P1 = p1;
1504 cmd.P2 = p2;
1505
1506 ret = lbs_cmd_with_response(priv, CMD_802_11_PA_CFG , &cmd);
1507
1508 return ret;
1509}
1510
1511
Holger Schurig6d898b12009-10-14 16:49:53 +02001512struct cmd_ctrl_node *__lbs_cmd_async(struct lbs_private *priv,
Holger Schurig8db4a2b2008-03-19 10:11:00 +01001513 uint16_t command, struct cmd_header *in_cmd, int in_cmd_size,
1514 int (*callback)(struct lbs_private *, unsigned long, struct cmd_header *),
1515 unsigned long callback_arg)
Holger Schurig675787e2007-12-05 17:58:11 +01001516{
Holger Schurig675787e2007-12-05 17:58:11 +01001517 struct cmd_ctrl_node *cmdnode;
Holger Schurig675787e2007-12-05 17:58:11 +01001518
1519 lbs_deb_enter(LBS_DEB_HOST);
Holger Schurig675787e2007-12-05 17:58:11 +01001520
David Woodhouseaa21c002007-12-08 20:04:36 +00001521 if (priv->surpriseremoved) {
Holger Schurig675787e2007-12-05 17:58:11 +01001522 lbs_deb_host("PREP_CMD: card removed\n");
David Woodhouse3399ea52007-12-15 03:09:33 -05001523 cmdnode = ERR_PTR(-ENOENT);
Holger Schurig675787e2007-12-05 17:58:11 +01001524 goto done;
1525 }
1526
Amitkumar Karwar63f275d2009-10-06 19:20:28 -07001527 if (!lbs_is_cmd_allowed(priv)) {
1528 cmdnode = ERR_PTR(-EBUSY);
1529 goto done;
1530 }
1531
Holger Schurig675787e2007-12-05 17:58:11 +01001532 cmdnode = lbs_get_cmd_ctrl_node(priv);
Holger Schurig675787e2007-12-05 17:58:11 +01001533 if (cmdnode == NULL) {
1534 lbs_deb_host("PREP_CMD: cmdnode is NULL\n");
1535
1536 /* Wake up main thread to execute next command */
1537 wake_up_interruptible(&priv->waitq);
David Woodhouse3399ea52007-12-15 03:09:33 -05001538 cmdnode = ERR_PTR(-ENOBUFS);
Holger Schurig675787e2007-12-05 17:58:11 +01001539 goto done;
1540 }
1541
David Woodhouse448a51a2007-12-08 00:59:54 +00001542 cmdnode->callback = callback;
David Woodhouse1309b552007-12-10 13:36:10 -05001543 cmdnode->callback_arg = callback_arg;
Holger Schurig675787e2007-12-05 17:58:11 +01001544
Dan Williams7ad994d2007-12-11 12:33:30 -05001545 /* Copy the incoming command to the buffer */
Dan Williamsddac4522007-12-11 13:49:39 -05001546 memcpy(cmdnode->cmdbuf, in_cmd, in_cmd_size);
Dan Williams7ad994d2007-12-11 12:33:30 -05001547
Holger Schurig675787e2007-12-05 17:58:11 +01001548 /* Set sequence number, clean result, move to buffer */
David Woodhouseaa21c002007-12-08 20:04:36 +00001549 priv->seqnum++;
Dan Williamsddac4522007-12-11 13:49:39 -05001550 cmdnode->cmdbuf->command = cpu_to_le16(command);
1551 cmdnode->cmdbuf->size = cpu_to_le16(in_cmd_size);
1552 cmdnode->cmdbuf->seqnum = cpu_to_le16(priv->seqnum);
1553 cmdnode->cmdbuf->result = 0;
Holger Schurig675787e2007-12-05 17:58:11 +01001554
1555 lbs_deb_host("PREP_CMD: command 0x%04x\n", command);
1556
Holger Schurig675787e2007-12-05 17:58:11 +01001557 cmdnode->cmdwaitqwoken = 0;
David Woodhouse681ffbb2007-12-15 20:04:54 -05001558 lbs_queue_cmd(priv, cmdnode);
Holger Schurig675787e2007-12-05 17:58:11 +01001559 wake_up_interruptible(&priv->waitq);
1560
David Woodhouse3399ea52007-12-15 03:09:33 -05001561 done:
1562 lbs_deb_leave_args(LBS_DEB_HOST, "ret %p", cmdnode);
1563 return cmdnode;
1564}
1565
Holger Schurig8db4a2b2008-03-19 10:11:00 +01001566void lbs_cmd_async(struct lbs_private *priv, uint16_t command,
1567 struct cmd_header *in_cmd, int in_cmd_size)
1568{
1569 lbs_deb_enter(LBS_DEB_CMD);
1570 __lbs_cmd_async(priv, command, in_cmd, in_cmd_size,
1571 lbs_cmd_async_callback, 0);
1572 lbs_deb_leave(LBS_DEB_CMD);
1573}
1574
David Woodhouse3399ea52007-12-15 03:09:33 -05001575int __lbs_cmd(struct lbs_private *priv, uint16_t command,
1576 struct cmd_header *in_cmd, int in_cmd_size,
1577 int (*callback)(struct lbs_private *, unsigned long, struct cmd_header *),
1578 unsigned long callback_arg)
1579{
1580 struct cmd_ctrl_node *cmdnode;
1581 unsigned long flags;
1582 int ret = 0;
1583
1584 lbs_deb_enter(LBS_DEB_HOST);
1585
1586 cmdnode = __lbs_cmd_async(priv, command, in_cmd, in_cmd_size,
1587 callback, callback_arg);
1588 if (IS_ERR(cmdnode)) {
1589 ret = PTR_ERR(cmdnode);
1590 goto done;
1591 }
1592
Holger Schurig675787e2007-12-05 17:58:11 +01001593 might_sleep();
1594 wait_event_interruptible(cmdnode->cmdwait_q, cmdnode->cmdwaitqwoken);
1595
David Woodhouseaa21c002007-12-08 20:04:36 +00001596 spin_lock_irqsave(&priv->driver_lock, flags);
David Woodhouseae125bf2007-12-15 04:22:52 -05001597 ret = cmdnode->result;
1598 if (ret)
1599 lbs_pr_info("PREP_CMD: command 0x%04x failed: %d\n",
1600 command, ret);
David Woodhouse3399ea52007-12-15 03:09:33 -05001601
David Woodhousead12d0f2007-12-15 02:06:16 -05001602 __lbs_cleanup_and_insert_cmd(priv, cmdnode);
David Woodhouseaa21c002007-12-08 20:04:36 +00001603 spin_unlock_irqrestore(&priv->driver_lock, flags);
Holger Schurig675787e2007-12-05 17:58:11 +01001604
1605done:
1606 lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
1607 return ret;
1608}
Dan Williams14e865b2007-12-10 15:11:23 -05001609EXPORT_SYMBOL_GPL(__lbs_cmd);