]>
Commit | Line | Data |
---|---|---|
9bc6772e | 1 | #include "cmd.h" |
2f01a1f5 KV |
2 | |
3 | #include <linux/module.h> | |
5a0e3ad6 | 4 | #include <linux/slab.h> |
2f01a1f5 | 5 | #include <linux/crc7.h> |
2f01a1f5 | 6 | |
13674118 | 7 | #include "wl1251.h" |
9bc6772e KV |
8 | #include "reg.h" |
9 | #include "io.h" | |
10 | #include "ps.h" | |
11 | #include "acx.h" | |
ff25839b KV |
12 | |
13 | /** | |
14 | * send command to firmware | |
15 | * | |
16 | * @wl: wl struct | |
17 | * @id: command id | |
18 | * @buf: buffer containing the command, must work with dma | |
19 | * @len: length of the buffer | |
20 | */ | |
80301cdc | 21 | int wl1251_cmd_send(struct wl1251 *wl, u16 id, void *buf, size_t len) |
2f01a1f5 | 22 | { |
80301cdc | 23 | struct wl1251_cmd_header *cmd; |
2f01a1f5 | 24 | unsigned long timeout; |
2f01a1f5 KV |
25 | u32 intr; |
26 | int ret = 0; | |
27 | ||
ff25839b KV |
28 | cmd = buf; |
29 | cmd->id = id; | |
30 | cmd->status = 0; | |
31 | ||
32 | WARN_ON(len % 4 != 0); | |
2f01a1f5 | 33 | |
0764de64 | 34 | wl1251_mem_write(wl, wl->cmd_box_addr, buf, len); |
2f01a1f5 | 35 | |
80301cdc | 36 | wl1251_reg_write32(wl, ACX_REG_INTERRUPT_TRIG, INTR_TRIG_CMD); |
2f01a1f5 | 37 | |
80301cdc | 38 | timeout = jiffies + msecs_to_jiffies(WL1251_COMMAND_TIMEOUT); |
2f01a1f5 | 39 | |
80301cdc | 40 | intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_NO_CLEAR); |
0e71bb08 | 41 | while (!(intr & WL1251_ACX_INTR_CMD_COMPLETE)) { |
2f01a1f5 | 42 | if (time_after(jiffies, timeout)) { |
80301cdc | 43 | wl1251_error("command complete timeout"); |
2f01a1f5 KV |
44 | ret = -ETIMEDOUT; |
45 | goto out; | |
46 | } | |
47 | ||
48 | msleep(1); | |
49 | ||
80301cdc | 50 | intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_NO_CLEAR); |
2f01a1f5 KV |
51 | } |
52 | ||
80301cdc | 53 | wl1251_reg_write32(wl, ACX_REG_INTERRUPT_ACK, |
0e71bb08 | 54 | WL1251_ACX_INTR_CMD_COMPLETE); |
2f01a1f5 KV |
55 | |
56 | out: | |
2f01a1f5 KV |
57 | return ret; |
58 | } | |
59 | ||
ff25839b KV |
60 | /** |
61 | * send test command to firmware | |
62 | * | |
63 | * @wl: wl struct | |
6021b289 | 64 | * @buf: buffer containing the command, with all headers, must work with dma |
ff25839b KV |
65 | * @len: length of the buffer |
66 | * @answer: is answer needed | |
ff25839b | 67 | */ |
80301cdc | 68 | int wl1251_cmd_test(struct wl1251 *wl, void *buf, size_t buf_len, u8 answer) |
2f01a1f5 KV |
69 | { |
70 | int ret; | |
71 | ||
80301cdc | 72 | wl1251_debug(DEBUG_CMD, "cmd test"); |
2f01a1f5 | 73 | |
80301cdc | 74 | ret = wl1251_cmd_send(wl, CMD_TEST, buf, buf_len); |
ff25839b | 75 | |
2f01a1f5 | 76 | if (ret < 0) { |
80301cdc | 77 | wl1251_warning("TEST command failed"); |
6021b289 | 78 | return ret; |
2f01a1f5 KV |
79 | } |
80 | ||
81 | if (answer) { | |
80301cdc | 82 | struct wl1251_command *cmd_answer; |
6021b289 | 83 | |
2f01a1f5 KV |
84 | /* |
85 | * The test command got in, we can read the answer. | |
80301cdc | 86 | * The answer would be a wl1251_command, where the |
2f01a1f5 KV |
87 | * parameter array contains the actual answer. |
88 | */ | |
0764de64 | 89 | wl1251_mem_read(wl, wl->cmd_box_addr, buf, buf_len); |
2f01a1f5 | 90 | |
6021b289 AK |
91 | cmd_answer = buf; |
92 | ||
93 | if (cmd_answer->header.status != CMD_STATUS_SUCCESS) | |
80301cdc | 94 | wl1251_error("TEST command answer error: %d", |
6021b289 | 95 | cmd_answer->header.status); |
2f01a1f5 KV |
96 | } |
97 | ||
6021b289 | 98 | return 0; |
2f01a1f5 KV |
99 | } |
100 | ||
ff25839b KV |
101 | /** |
102 | * read acx from firmware | |
103 | * | |
104 | * @wl: wl struct | |
105 | * @id: acx id | |
106 | * @buf: buffer for the response, including all headers, must work with dma | |
25985edc | 107 | * @len: length of buf |
ff25839b | 108 | */ |
80301cdc | 109 | int wl1251_cmd_interrogate(struct wl1251 *wl, u16 id, void *buf, size_t len) |
2f01a1f5 | 110 | { |
ff25839b | 111 | struct acx_header *acx = buf; |
2f01a1f5 KV |
112 | int ret; |
113 | ||
80301cdc | 114 | wl1251_debug(DEBUG_CMD, "cmd interrogate"); |
2f01a1f5 | 115 | |
ff25839b | 116 | acx->id = id; |
2f01a1f5 | 117 | |
ff25839b KV |
118 | /* payload length, does not include any headers */ |
119 | acx->len = len - sizeof(*acx); | |
120 | ||
80301cdc | 121 | ret = wl1251_cmd_send(wl, CMD_INTERROGATE, acx, sizeof(*acx)); |
2f01a1f5 | 122 | if (ret < 0) { |
80301cdc | 123 | wl1251_error("INTERROGATE command failed"); |
ff25839b | 124 | goto out; |
2f01a1f5 KV |
125 | } |
126 | ||
2f01a1f5 | 127 | /* the interrogate command got in, we can read the answer */ |
0764de64 | 128 | wl1251_mem_read(wl, wl->cmd_box_addr, buf, len); |
2f01a1f5 | 129 | |
ff25839b KV |
130 | acx = buf; |
131 | if (acx->cmd.status != CMD_STATUS_SUCCESS) | |
80301cdc | 132 | wl1251_error("INTERROGATE command error: %d", |
ff25839b | 133 | acx->cmd.status); |
2f01a1f5 | 134 | |
ff25839b KV |
135 | out: |
136 | return ret; | |
2f01a1f5 KV |
137 | } |
138 | ||
ff25839b KV |
139 | /** |
140 | * write acx value to firmware | |
141 | * | |
142 | * @wl: wl struct | |
143 | * @id: acx id | |
144 | * @buf: buffer containing acx, including all headers, must work with dma | |
145 | * @len: length of buf | |
146 | */ | |
80301cdc | 147 | int wl1251_cmd_configure(struct wl1251 *wl, u16 id, void *buf, size_t len) |
2f01a1f5 | 148 | { |
ff25839b | 149 | struct acx_header *acx = buf; |
2f01a1f5 KV |
150 | int ret; |
151 | ||
80301cdc | 152 | wl1251_debug(DEBUG_CMD, "cmd configure"); |
2f01a1f5 | 153 | |
ff25839b KV |
154 | acx->id = id; |
155 | ||
156 | /* payload length, does not include any headers */ | |
157 | acx->len = len - sizeof(*acx); | |
158 | ||
80301cdc | 159 | ret = wl1251_cmd_send(wl, CMD_CONFIGURE, acx, len); |
2f01a1f5 | 160 | if (ret < 0) { |
80301cdc | 161 | wl1251_warning("CONFIGURE command NOK"); |
2f01a1f5 KV |
162 | return ret; |
163 | } | |
164 | ||
165 | return 0; | |
2f01a1f5 KV |
166 | } |
167 | ||
80301cdc | 168 | int wl1251_cmd_vbm(struct wl1251 *wl, u8 identity, |
2f01a1f5 KV |
169 | void *bitmap, u16 bitmap_len, u8 bitmap_control) |
170 | { | |
80301cdc | 171 | struct wl1251_cmd_vbm_update *vbm; |
2f01a1f5 KV |
172 | int ret; |
173 | ||
80301cdc | 174 | wl1251_debug(DEBUG_CMD, "cmd vbm"); |
2f01a1f5 | 175 | |
ff25839b KV |
176 | vbm = kzalloc(sizeof(*vbm), GFP_KERNEL); |
177 | if (!vbm) { | |
178 | ret = -ENOMEM; | |
179 | goto out; | |
180 | } | |
181 | ||
2f01a1f5 | 182 | /* Count and period will be filled by the target */ |
ff25839b | 183 | vbm->tim.bitmap_ctrl = bitmap_control; |
2f01a1f5 | 184 | if (bitmap_len > PARTIAL_VBM_MAX) { |
80301cdc | 185 | wl1251_warning("cmd vbm len is %d B, truncating to %d", |
2f01a1f5 KV |
186 | bitmap_len, PARTIAL_VBM_MAX); |
187 | bitmap_len = PARTIAL_VBM_MAX; | |
188 | } | |
ff25839b KV |
189 | memcpy(vbm->tim.pvb_field, bitmap, bitmap_len); |
190 | vbm->tim.identity = identity; | |
191 | vbm->tim.length = bitmap_len + 3; | |
2f01a1f5 | 192 | |
ff25839b | 193 | vbm->len = cpu_to_le16(bitmap_len + 5); |
2f01a1f5 | 194 | |
80301cdc | 195 | ret = wl1251_cmd_send(wl, CMD_VBM, vbm, sizeof(*vbm)); |
2f01a1f5 | 196 | if (ret < 0) { |
80301cdc | 197 | wl1251_error("VBM command failed"); |
ff25839b | 198 | goto out; |
2f01a1f5 KV |
199 | } |
200 | ||
ff25839b KV |
201 | out: |
202 | kfree(vbm); | |
9f19fa62 | 203 | return ret; |
2f01a1f5 KV |
204 | } |
205 | ||
80301cdc | 206 | int wl1251_cmd_data_path(struct wl1251 *wl, u8 channel, bool enable) |
2f01a1f5 | 207 | { |
ff25839b | 208 | struct cmd_enabledisable_path *cmd; |
2f01a1f5 KV |
209 | int ret; |
210 | u16 cmd_rx, cmd_tx; | |
211 | ||
80301cdc | 212 | wl1251_debug(DEBUG_CMD, "cmd data path"); |
2f01a1f5 | 213 | |
ff25839b KV |
214 | cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); |
215 | if (!cmd) { | |
216 | ret = -ENOMEM; | |
217 | goto out; | |
218 | } | |
219 | ||
220 | cmd->channel = channel; | |
221 | ||
2f01a1f5 KV |
222 | if (enable) { |
223 | cmd_rx = CMD_ENABLE_RX; | |
224 | cmd_tx = CMD_ENABLE_TX; | |
225 | } else { | |
226 | cmd_rx = CMD_DISABLE_RX; | |
227 | cmd_tx = CMD_DISABLE_TX; | |
228 | } | |
229 | ||
80301cdc | 230 | ret = wl1251_cmd_send(wl, cmd_rx, cmd, sizeof(*cmd)); |
2f01a1f5 | 231 | if (ret < 0) { |
80301cdc | 232 | wl1251_error("rx %s cmd for channel %d failed", |
2f01a1f5 | 233 | enable ? "start" : "stop", channel); |
ff25839b | 234 | goto out; |
2f01a1f5 KV |
235 | } |
236 | ||
80301cdc | 237 | wl1251_debug(DEBUG_BOOT, "rx %s cmd channel %d", |
2f01a1f5 KV |
238 | enable ? "start" : "stop", channel); |
239 | ||
80301cdc | 240 | ret = wl1251_cmd_send(wl, cmd_tx, cmd, sizeof(*cmd)); |
2f01a1f5 | 241 | if (ret < 0) { |
80301cdc | 242 | wl1251_error("tx %s cmd for channel %d failed", |
2f01a1f5 KV |
243 | enable ? "start" : "stop", channel); |
244 | return ret; | |
245 | } | |
246 | ||
80301cdc | 247 | wl1251_debug(DEBUG_BOOT, "tx %s cmd channel %d", |
2f01a1f5 KV |
248 | enable ? "start" : "stop", channel); |
249 | ||
ff25839b KV |
250 | out: |
251 | kfree(cmd); | |
252 | return ret; | |
2f01a1f5 KV |
253 | } |
254 | ||
c88f8754 KV |
255 | int wl1251_cmd_join(struct wl1251 *wl, u8 bss_type, u8 channel, |
256 | u16 beacon_interval, u8 dtim_interval) | |
2f01a1f5 | 257 | { |
ff25839b | 258 | struct cmd_join *join; |
2f01a1f5 KV |
259 | int ret, i; |
260 | u8 *bssid; | |
261 | ||
ff25839b KV |
262 | join = kzalloc(sizeof(*join), GFP_KERNEL); |
263 | if (!join) { | |
264 | ret = -ENOMEM; | |
265 | goto out; | |
266 | } | |
267 | ||
c88f8754 | 268 | wl1251_debug(DEBUG_CMD, "cmd join%s ch %d %d/%d", |
e2fd4611 | 269 | bss_type == BSS_TYPE_IBSS ? " ibss" : "", |
c88f8754 | 270 | channel, beacon_interval, dtim_interval); |
2f01a1f5 KV |
271 | |
272 | /* Reverse order BSSID */ | |
ff25839b | 273 | bssid = (u8 *) &join->bssid_lsb; |
2f01a1f5 KV |
274 | for (i = 0; i < ETH_ALEN; i++) |
275 | bssid[i] = wl->bssid[ETH_ALEN - i - 1]; | |
276 | ||
ff25839b KV |
277 | join->rx_config_options = wl->rx_config; |
278 | join->rx_filter_options = wl->rx_filter; | |
2f01a1f5 | 279 | |
f26b32ed KV |
280 | /* |
281 | * FIXME: disable temporarily all filters because after commit | |
282 | * 9cef8737 "mac80211: fix managed mode BSSID handling" broke | |
283 | * association. The filter logic needs to be implemented properly | |
284 | * and once that is done, this hack can be removed. | |
285 | */ | |
286 | join->rx_config_options = 0; | |
287 | join->rx_filter_options = WL1251_DEFAULT_RX_FILTER; | |
288 | ||
ff25839b | 289 | join->basic_rate_set = RATE_MASK_1MBPS | RATE_MASK_2MBPS | |
2f01a1f5 KV |
290 | RATE_MASK_5_5MBPS | RATE_MASK_11MBPS; |
291 | ||
ff25839b KV |
292 | join->beacon_interval = beacon_interval; |
293 | join->dtim_interval = dtim_interval; | |
294 | join->bss_type = bss_type; | |
c88f8754 | 295 | join->channel = channel; |
ff25839b | 296 | join->ctrl = JOIN_CMD_CTRL_TX_FLUSH; |
2f01a1f5 | 297 | |
80301cdc | 298 | ret = wl1251_cmd_send(wl, CMD_START_JOIN, join, sizeof(*join)); |
2f01a1f5 | 299 | if (ret < 0) { |
80301cdc | 300 | wl1251_error("failed to initiate cmd join"); |
ff25839b | 301 | goto out; |
2f01a1f5 KV |
302 | } |
303 | ||
ff25839b KV |
304 | out: |
305 | kfree(join); | |
306 | return ret; | |
2f01a1f5 KV |
307 | } |
308 | ||
80301cdc | 309 | int wl1251_cmd_ps_mode(struct wl1251 *wl, u8 ps_mode) |
2f01a1f5 | 310 | { |
80301cdc | 311 | struct wl1251_cmd_ps_params *ps_params = NULL; |
ff25839b | 312 | int ret = 0; |
2f01a1f5 | 313 | |
80301cdc | 314 | wl1251_debug(DEBUG_CMD, "cmd set ps mode"); |
2f01a1f5 | 315 | |
ff25839b KV |
316 | ps_params = kzalloc(sizeof(*ps_params), GFP_KERNEL); |
317 | if (!ps_params) { | |
318 | ret = -ENOMEM; | |
319 | goto out; | |
320 | } | |
321 | ||
322 | ps_params->ps_mode = ps_mode; | |
323 | ps_params->send_null_data = 1; | |
324 | ps_params->retries = 5; | |
325 | ps_params->hang_over_period = 128; | |
326 | ps_params->null_data_rate = 1; /* 1 Mbps */ | |
2f01a1f5 | 327 | |
80301cdc | 328 | ret = wl1251_cmd_send(wl, CMD_SET_PS_MODE, ps_params, |
ff25839b | 329 | sizeof(*ps_params)); |
2f01a1f5 | 330 | if (ret < 0) { |
80301cdc | 331 | wl1251_error("cmd set_ps_mode failed"); |
ff25839b | 332 | goto out; |
2f01a1f5 KV |
333 | } |
334 | ||
ff25839b KV |
335 | out: |
336 | kfree(ps_params); | |
337 | return ret; | |
2f01a1f5 KV |
338 | } |
339 | ||
80301cdc | 340 | int wl1251_cmd_read_memory(struct wl1251 *wl, u32 addr, void *answer, |
ff25839b | 341 | size_t len) |
2f01a1f5 | 342 | { |
ff25839b KV |
343 | struct cmd_read_write_memory *cmd; |
344 | int ret = 0; | |
2f01a1f5 | 345 | |
80301cdc | 346 | wl1251_debug(DEBUG_CMD, "cmd read memory"); |
2f01a1f5 | 347 | |
ff25839b KV |
348 | cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); |
349 | if (!cmd) { | |
350 | ret = -ENOMEM; | |
351 | goto out; | |
352 | } | |
353 | ||
354 | WARN_ON(len > MAX_READ_SIZE); | |
355 | len = min_t(size_t, len, MAX_READ_SIZE); | |
356 | ||
357 | cmd->addr = addr; | |
358 | cmd->size = len; | |
2f01a1f5 | 359 | |
80301cdc | 360 | ret = wl1251_cmd_send(wl, CMD_READ_MEMORY, cmd, sizeof(*cmd)); |
2f01a1f5 | 361 | if (ret < 0) { |
80301cdc | 362 | wl1251_error("read memory command failed: %d", ret); |
ff25839b | 363 | goto out; |
2f01a1f5 KV |
364 | } |
365 | ||
366 | /* the read command got in, we can now read the answer */ | |
0764de64 | 367 | wl1251_mem_read(wl, wl->cmd_box_addr, cmd, sizeof(*cmd)); |
2f01a1f5 | 368 | |
ff25839b | 369 | if (cmd->header.status != CMD_STATUS_SUCCESS) |
80301cdc | 370 | wl1251_error("error in read command result: %d", |
ff25839b | 371 | cmd->header.status); |
2f01a1f5 | 372 | |
ff25839b | 373 | memcpy(answer, cmd->value, len); |
2f01a1f5 | 374 | |
ff25839b KV |
375 | out: |
376 | kfree(cmd); | |
377 | return ret; | |
2f01a1f5 KV |
378 | } |
379 | ||
80301cdc | 380 | int wl1251_cmd_template_set(struct wl1251 *wl, u16 cmd_id, |
2f01a1f5 KV |
381 | void *buf, size_t buf_len) |
382 | { | |
80301cdc | 383 | struct wl1251_cmd_packet_template *cmd; |
ff25839b KV |
384 | size_t cmd_len; |
385 | int ret = 0; | |
2f01a1f5 | 386 | |
80301cdc | 387 | wl1251_debug(DEBUG_CMD, "cmd template %d", cmd_id); |
2f01a1f5 | 388 | |
80301cdc KV |
389 | WARN_ON(buf_len > WL1251_MAX_TEMPLATE_SIZE); |
390 | buf_len = min_t(size_t, buf_len, WL1251_MAX_TEMPLATE_SIZE); | |
ff25839b KV |
391 | cmd_len = ALIGN(sizeof(*cmd) + buf_len, 4); |
392 | ||
393 | cmd = kzalloc(cmd_len, GFP_KERNEL); | |
394 | if (!cmd) { | |
395 | ret = -ENOMEM; | |
396 | goto out; | |
397 | } | |
398 | ||
399 | cmd->size = cpu_to_le16(buf_len); | |
2f01a1f5 KV |
400 | |
401 | if (buf) | |
ff25839b | 402 | memcpy(cmd->data, buf, buf_len); |
2f01a1f5 | 403 | |
80301cdc | 404 | ret = wl1251_cmd_send(wl, cmd_id, cmd, cmd_len); |
2f01a1f5 | 405 | if (ret < 0) { |
80301cdc | 406 | wl1251_warning("cmd set_template failed: %d", ret); |
ff25839b | 407 | goto out; |
2f01a1f5 KV |
408 | } |
409 | ||
ff25839b KV |
410 | out: |
411 | kfree(cmd); | |
412 | return ret; | |
2f01a1f5 | 413 | } |
3a98c30f KV |
414 | |
415 | int wl1251_cmd_scan(struct wl1251 *wl, u8 *ssid, size_t ssid_len, | |
dc52f0a8 | 416 | struct ieee80211_channel *channels[], |
3a98c30f KV |
417 | unsigned int n_channels, unsigned int n_probes) |
418 | { | |
419 | struct wl1251_cmd_scan *cmd; | |
420 | int i, ret = 0; | |
421 | ||
422 | wl1251_debug(DEBUG_CMD, "cmd scan"); | |
423 | ||
424 | cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); | |
425 | if (!cmd) | |
426 | return -ENOMEM; | |
427 | ||
428 | cmd->params.rx_config_options = cpu_to_le32(CFG_RX_ALL_GOOD); | |
429 | cmd->params.rx_filter_options = cpu_to_le32(CFG_RX_PRSP_EN | | |
430 | CFG_RX_MGMT_EN | | |
431 | CFG_RX_BCN_EN); | |
432 | cmd->params.scan_options = 0; | |
433 | cmd->params.num_channels = n_channels; | |
434 | cmd->params.num_probe_requests = n_probes; | |
435 | cmd->params.tx_rate = cpu_to_le16(1 << 1); /* 2 Mbps */ | |
436 | cmd->params.tid_trigger = 0; | |
437 | ||
438 | for (i = 0; i < n_channels; i++) { | |
439 | cmd->channels[i].min_duration = | |
440 | cpu_to_le32(WL1251_SCAN_MIN_DURATION); | |
441 | cmd->channels[i].max_duration = | |
442 | cpu_to_le32(WL1251_SCAN_MAX_DURATION); | |
443 | memset(&cmd->channels[i].bssid_lsb, 0xff, 4); | |
444 | memset(&cmd->channels[i].bssid_msb, 0xff, 2); | |
445 | cmd->channels[i].early_termination = 0; | |
446 | cmd->channels[i].tx_power_att = 0; | |
dc52f0a8 | 447 | cmd->channels[i].channel = channels[i]->hw_value; |
3a98c30f KV |
448 | } |
449 | ||
450 | cmd->params.ssid_len = ssid_len; | |
451 | if (ssid) | |
452 | memcpy(cmd->params.ssid, ssid, ssid_len); | |
453 | ||
454 | ret = wl1251_cmd_send(wl, CMD_SCAN, cmd, sizeof(*cmd)); | |
455 | if (ret < 0) { | |
456 | wl1251_error("cmd scan failed: %d", ret); | |
457 | goto out; | |
458 | } | |
459 | ||
460 | wl1251_mem_read(wl, wl->cmd_box_addr, cmd, sizeof(*cmd)); | |
461 | ||
462 | if (cmd->header.status != CMD_STATUS_SUCCESS) { | |
463 | wl1251_error("cmd scan status wasn't success: %d", | |
464 | cmd->header.status); | |
465 | ret = -EIO; | |
466 | goto out; | |
467 | } | |
468 | ||
469 | out: | |
470 | kfree(cmd); | |
471 | return ret; | |
472 | } | |
473 | ||
474 | int wl1251_cmd_trigger_scan_to(struct wl1251 *wl, u32 timeout) | |
475 | { | |
476 | struct wl1251_cmd_trigger_scan_to *cmd; | |
477 | int ret; | |
478 | ||
479 | wl1251_debug(DEBUG_CMD, "cmd trigger scan to"); | |
480 | ||
481 | cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); | |
482 | if (!cmd) | |
483 | return -ENOMEM; | |
484 | ||
485 | cmd->timeout = timeout; | |
486 | ||
fe0dbcc9 | 487 | ret = wl1251_cmd_send(wl, CMD_TRIGGER_SCAN_TO, cmd, sizeof(*cmd)); |
3a98c30f KV |
488 | if (ret < 0) { |
489 | wl1251_error("cmd trigger scan to failed: %d", ret); | |
490 | goto out; | |
491 | } | |
492 | ||
493 | out: | |
494 | kfree(cmd); | |
495 | return ret; | |
496 | } |