a712a0f7b370d6b3ab3b6c350f22d31b3c95c538
[linux-2.6.git] / drivers / net / wireless / wl12xx / cmd.c
1 /*
2  * This file is part of wl1271
3  *
4  * Copyright (C) 2009-2010 Nokia Corporation
5  *
6  * Contact: Luciano Coelho <luciano.coelho@nokia.com>
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * version 2 as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20  * 02110-1301 USA
21  *
22  */
23
24 #include <linux/module.h>
25 #include <linux/platform_device.h>
26 #include <linux/spi/spi.h>
27 #include <linux/etherdevice.h>
28 #include <linux/ieee80211.h>
29 #include <linux/slab.h>
30
31 #include "wl12xx.h"
32 #include "reg.h"
33 #include "io.h"
34 #include "acx.h"
35 #include "wl12xx_80211.h"
36 #include "cmd.h"
37 #include "event.h"
38 #include "tx.h"
39
40 #define WL1271_CMD_FAST_POLL_COUNT       50
41
42 /*
43  * send command to firmware
44  *
45  * @wl: wl struct
46  * @id: command id
47  * @buf: buffer containing the command, must work with dma
48  * @len: length of the buffer
49  */
50 int wl1271_cmd_send(struct wl1271 *wl, u16 id, void *buf, size_t len,
51                     size_t res_len)
52 {
53         struct wl1271_cmd_header *cmd;
54         unsigned long timeout;
55         u32 intr;
56         int ret = 0;
57         u16 status;
58         u16 poll_count = 0;
59
60         cmd = buf;
61         cmd->id = cpu_to_le16(id);
62         cmd->status = 0;
63
64         WARN_ON(len % 4 != 0);
65         WARN_ON(test_bit(WL1271_FLAG_IN_ELP, &wl->flags));
66
67         wl1271_write(wl, wl->cmd_box_addr, buf, len, false);
68
69         wl1271_write32(wl, ACX_REG_INTERRUPT_TRIG, INTR_TRIG_CMD);
70
71         timeout = jiffies + msecs_to_jiffies(WL1271_COMMAND_TIMEOUT);
72
73         intr = wl1271_read32(wl, ACX_REG_INTERRUPT_NO_CLEAR);
74         while (!(intr & WL1271_ACX_INTR_CMD_COMPLETE)) {
75                 if (time_after(jiffies, timeout)) {
76                         wl1271_error("command complete timeout");
77                         ret = -ETIMEDOUT;
78                         goto fail;
79                 }
80
81                 poll_count++;
82                 if (poll_count < WL1271_CMD_FAST_POLL_COUNT)
83                         udelay(10);
84                 else
85                         msleep(1);
86
87                 intr = wl1271_read32(wl, ACX_REG_INTERRUPT_NO_CLEAR);
88         }
89
90         /* read back the status code of the command */
91         if (res_len == 0)
92                 res_len = sizeof(struct wl1271_cmd_header);
93         wl1271_read(wl, wl->cmd_box_addr, cmd, res_len, false);
94
95         status = le16_to_cpu(cmd->status);
96         if (status != CMD_STATUS_SUCCESS) {
97                 wl1271_error("command execute failure %d", status);
98                 ret = -EIO;
99                 goto fail;
100         }
101
102         wl1271_write32(wl, ACX_REG_INTERRUPT_ACK,
103                        WL1271_ACX_INTR_CMD_COMPLETE);
104         return 0;
105
106 fail:
107         WARN_ON(1);
108         wl12xx_queue_recovery_work(wl);
109         return ret;
110 }
111
112 int wl1271_cmd_general_parms(struct wl1271 *wl)
113 {
114         struct wl1271_general_parms_cmd *gen_parms;
115         struct wl1271_ini_general_params *gp =
116                 &((struct wl1271_nvs_file *)wl->nvs)->general_params;
117         bool answer = false;
118         int ret;
119
120         if (!wl->nvs)
121                 return -ENODEV;
122
123         gen_parms = kzalloc(sizeof(*gen_parms), GFP_KERNEL);
124         if (!gen_parms)
125                 return -ENOMEM;
126
127         gen_parms->test.id = TEST_CMD_INI_FILE_GENERAL_PARAM;
128
129         memcpy(&gen_parms->general_params, gp, sizeof(*gp));
130
131         if (gp->tx_bip_fem_auto_detect)
132                 answer = true;
133
134         /* Override the REF CLK from the NVS with the one from platform data */
135         gen_parms->general_params.ref_clock = wl->ref_clock;
136
137         /* LPD mode enable (bits 6-7) in WL1271 AP mode only */
138         if (wl->quirks & WL12XX_QUIRK_LPD_MODE)
139                 gen_parms->general_params.general_settings |=
140                         GENERAL_SETTINGS_DRPW_LPD;
141
142         ret = wl1271_cmd_test(wl, gen_parms, sizeof(*gen_parms), answer);
143         if (ret < 0) {
144                 wl1271_warning("CMD_INI_FILE_GENERAL_PARAM failed");
145                 goto out;
146         }
147
148         gp->tx_bip_fem_manufacturer =
149                 gen_parms->general_params.tx_bip_fem_manufacturer;
150
151         wl1271_debug(DEBUG_CMD, "FEM autodetect: %s, manufacturer: %d\n",
152                      answer ? "auto" : "manual", gp->tx_bip_fem_manufacturer);
153
154 out:
155         kfree(gen_parms);
156         return ret;
157 }
158
159 int wl128x_cmd_general_parms(struct wl1271 *wl)
160 {
161         struct wl128x_general_parms_cmd *gen_parms;
162         struct wl128x_ini_general_params *gp =
163                 &((struct wl128x_nvs_file *)wl->nvs)->general_params;
164         bool answer = false;
165         int ret;
166
167         if (!wl->nvs)
168                 return -ENODEV;
169
170         gen_parms = kzalloc(sizeof(*gen_parms), GFP_KERNEL);
171         if (!gen_parms)
172                 return -ENOMEM;
173
174         gen_parms->test.id = TEST_CMD_INI_FILE_GENERAL_PARAM;
175
176         memcpy(&gen_parms->general_params, gp, sizeof(*gp));
177
178         if (gp->tx_bip_fem_auto_detect)
179                 answer = true;
180
181         /* Replace REF and TCXO CLKs with the ones from platform data */
182         gen_parms->general_params.ref_clock = wl->ref_clock;
183         gen_parms->general_params.tcxo_ref_clock = wl->tcxo_clock;
184
185         ret = wl1271_cmd_test(wl, gen_parms, sizeof(*gen_parms), answer);
186         if (ret < 0) {
187                 wl1271_warning("CMD_INI_FILE_GENERAL_PARAM failed");
188                 goto out;
189         }
190
191         gp->tx_bip_fem_manufacturer =
192                 gen_parms->general_params.tx_bip_fem_manufacturer;
193
194         wl1271_debug(DEBUG_CMD, "FEM autodetect: %s, manufacturer: %d\n",
195                      answer ? "auto" : "manual", gp->tx_bip_fem_manufacturer);
196
197 out:
198         kfree(gen_parms);
199         return ret;
200 }
201
202 int wl1271_cmd_radio_parms(struct wl1271 *wl)
203 {
204         struct wl1271_nvs_file *nvs = (struct wl1271_nvs_file *)wl->nvs;
205         struct wl1271_radio_parms_cmd *radio_parms;
206         struct wl1271_ini_general_params *gp = &nvs->general_params;
207         int ret;
208
209         if (!wl->nvs)
210                 return -ENODEV;
211
212         radio_parms = kzalloc(sizeof(*radio_parms), GFP_KERNEL);
213         if (!radio_parms)
214                 return -ENOMEM;
215
216         radio_parms->test.id = TEST_CMD_INI_FILE_RADIO_PARAM;
217
218         /* 2.4GHz parameters */
219         memcpy(&radio_parms->static_params_2, &nvs->stat_radio_params_2,
220                sizeof(struct wl1271_ini_band_params_2));
221         memcpy(&radio_parms->dyn_params_2,
222                &nvs->dyn_radio_params_2[gp->tx_bip_fem_manufacturer].params,
223                sizeof(struct wl1271_ini_fem_params_2));
224
225         /* 5GHz parameters */
226         memcpy(&radio_parms->static_params_5,
227                &nvs->stat_radio_params_5,
228                sizeof(struct wl1271_ini_band_params_5));
229         memcpy(&radio_parms->dyn_params_5,
230                &nvs->dyn_radio_params_5[gp->tx_bip_fem_manufacturer].params,
231                sizeof(struct wl1271_ini_fem_params_5));
232
233         wl1271_dump(DEBUG_CMD, "TEST_CMD_INI_FILE_RADIO_PARAM: ",
234                     radio_parms, sizeof(*radio_parms));
235
236         ret = wl1271_cmd_test(wl, radio_parms, sizeof(*radio_parms), 0);
237         if (ret < 0)
238                 wl1271_warning("CMD_INI_FILE_RADIO_PARAM failed");
239
240         kfree(radio_parms);
241         return ret;
242 }
243
244 int wl128x_cmd_radio_parms(struct wl1271 *wl)
245 {
246         struct wl128x_nvs_file *nvs = (struct wl128x_nvs_file *)wl->nvs;
247         struct wl128x_radio_parms_cmd *radio_parms;
248         struct wl128x_ini_general_params *gp = &nvs->general_params;
249         int ret;
250
251         if (!wl->nvs)
252                 return -ENODEV;
253
254         radio_parms = kzalloc(sizeof(*radio_parms), GFP_KERNEL);
255         if (!radio_parms)
256                 return -ENOMEM;
257
258         radio_parms->test.id = TEST_CMD_INI_FILE_RADIO_PARAM;
259
260         /* 2.4GHz parameters */
261         memcpy(&radio_parms->static_params_2, &nvs->stat_radio_params_2,
262                sizeof(struct wl128x_ini_band_params_2));
263         memcpy(&radio_parms->dyn_params_2,
264                &nvs->dyn_radio_params_2[gp->tx_bip_fem_manufacturer].params,
265                sizeof(struct wl128x_ini_fem_params_2));
266
267         /* 5GHz parameters */
268         memcpy(&radio_parms->static_params_5,
269                &nvs->stat_radio_params_5,
270                sizeof(struct wl128x_ini_band_params_5));
271         memcpy(&radio_parms->dyn_params_5,
272                &nvs->dyn_radio_params_5[gp->tx_bip_fem_manufacturer].params,
273                sizeof(struct wl128x_ini_fem_params_5));
274
275         radio_parms->fem_vendor_and_options = nvs->fem_vendor_and_options;
276
277         wl1271_dump(DEBUG_CMD, "TEST_CMD_INI_FILE_RADIO_PARAM: ",
278                     radio_parms, sizeof(*radio_parms));
279
280         ret = wl1271_cmd_test(wl, radio_parms, sizeof(*radio_parms), 0);
281         if (ret < 0)
282                 wl1271_warning("CMD_INI_FILE_RADIO_PARAM failed");
283
284         kfree(radio_parms);
285         return ret;
286 }
287
288 int wl1271_cmd_ext_radio_parms(struct wl1271 *wl)
289 {
290         struct wl1271_ext_radio_parms_cmd *ext_radio_parms;
291         struct conf_rf_settings *rf = &wl->conf.rf;
292         int ret;
293
294         if (!wl->nvs)
295                 return -ENODEV;
296
297         ext_radio_parms = kzalloc(sizeof(*ext_radio_parms), GFP_KERNEL);
298         if (!ext_radio_parms)
299                 return -ENOMEM;
300
301         ext_radio_parms->test.id = TEST_CMD_INI_FILE_RF_EXTENDED_PARAM;
302
303         memcpy(ext_radio_parms->tx_per_channel_power_compensation_2,
304                rf->tx_per_channel_power_compensation_2,
305                CONF_TX_PWR_COMPENSATION_LEN_2);
306         memcpy(ext_radio_parms->tx_per_channel_power_compensation_5,
307                rf->tx_per_channel_power_compensation_5,
308                CONF_TX_PWR_COMPENSATION_LEN_5);
309
310         wl1271_dump(DEBUG_CMD, "TEST_CMD_INI_FILE_EXT_RADIO_PARAM: ",
311                     ext_radio_parms, sizeof(*ext_radio_parms));
312
313         ret = wl1271_cmd_test(wl, ext_radio_parms, sizeof(*ext_radio_parms), 0);
314         if (ret < 0)
315                 wl1271_warning("TEST_CMD_INI_FILE_RF_EXTENDED_PARAM failed");
316
317         kfree(ext_radio_parms);
318         return ret;
319 }
320
321 /*
322  * Poll the mailbox event field until any of the bits in the mask is set or a
323  * timeout occurs (WL1271_EVENT_TIMEOUT in msecs)
324  */
325 static int wl1271_cmd_wait_for_event_or_timeout(struct wl1271 *wl, u32 mask)
326 {
327         u32 events_vector, event;
328         unsigned long timeout;
329
330         timeout = jiffies + msecs_to_jiffies(WL1271_EVENT_TIMEOUT);
331
332         do {
333                 if (time_after(jiffies, timeout)) {
334                         wl1271_debug(DEBUG_CMD, "timeout waiting for event %d",
335                                      (int)mask);
336                         return -ETIMEDOUT;
337                 }
338
339                 msleep(1);
340
341                 /* read from both event fields */
342                 wl1271_read(wl, wl->mbox_ptr[0], &events_vector,
343                             sizeof(events_vector), false);
344                 event = events_vector & mask;
345                 wl1271_read(wl, wl->mbox_ptr[1], &events_vector,
346                             sizeof(events_vector), false);
347                 event |= events_vector & mask;
348         } while (!event);
349
350         return 0;
351 }
352
353 static int wl1271_cmd_wait_for_event(struct wl1271 *wl, u32 mask)
354 {
355         int ret;
356
357         ret = wl1271_cmd_wait_for_event_or_timeout(wl, mask);
358         if (ret != 0) {
359                 wl12xx_queue_recovery_work(wl);
360                 return ret;
361         }
362
363         return 0;
364 }
365
366 int wl1271_cmd_join(struct wl1271 *wl, u8 bss_type)
367 {
368         struct wl1271_cmd_join *join;
369         int ret, i;
370         u8 *bssid;
371
372         join = kzalloc(sizeof(*join), GFP_KERNEL);
373         if (!join) {
374                 ret = -ENOMEM;
375                 goto out;
376         }
377
378         wl1271_debug(DEBUG_CMD, "cmd join");
379
380         /* Reverse order BSSID */
381         bssid = (u8 *) &join->bssid_lsb;
382         for (i = 0; i < ETH_ALEN; i++)
383                 bssid[i] = wl->bssid[ETH_ALEN - i - 1];
384
385         join->rx_config_options = cpu_to_le32(wl->rx_config);
386         join->rx_filter_options = cpu_to_le32(wl->rx_filter);
387         join->bss_type = bss_type;
388         join->basic_rate_set = cpu_to_le32(wl->basic_rate_set);
389         join->supported_rate_set = cpu_to_le32(wl->rate_set);
390
391         if (wl->band == IEEE80211_BAND_5GHZ)
392                 join->bss_type |= WL1271_JOIN_CMD_BSS_TYPE_5GHZ;
393
394         join->beacon_interval = cpu_to_le16(wl->beacon_int);
395         join->dtim_interval = WL1271_DEFAULT_DTIM_PERIOD;
396
397         join->channel = wl->channel;
398         join->ssid_len = wl->ssid_len;
399         memcpy(join->ssid, wl->ssid, wl->ssid_len);
400
401         join->ctrl |= wl->session_counter << WL1271_JOIN_CMD_TX_SESSION_OFFSET;
402
403         wl1271_debug(DEBUG_CMD, "cmd join: basic_rate_set=0x%x, rate_set=0x%x",
404                 join->basic_rate_set, join->supported_rate_set);
405
406         ret = wl1271_cmd_send(wl, CMD_START_JOIN, join, sizeof(*join), 0);
407         if (ret < 0) {
408                 wl1271_error("failed to initiate cmd join");
409                 goto out_free;
410         }
411
412         ret = wl1271_cmd_wait_for_event(wl, JOIN_EVENT_COMPLETE_ID);
413         if (ret < 0)
414                 wl1271_error("cmd join event completion error");
415
416 out_free:
417         kfree(join);
418
419 out:
420         return ret;
421 }
422
423 /**
424  * send test command to firmware
425  *
426  * @wl: wl struct
427  * @buf: buffer containing the command, with all headers, must work with dma
428  * @len: length of the buffer
429  * @answer: is answer needed
430  */
431 int wl1271_cmd_test(struct wl1271 *wl, void *buf, size_t buf_len, u8 answer)
432 {
433         int ret;
434         size_t res_len = 0;
435
436         wl1271_debug(DEBUG_CMD, "cmd test");
437
438         if (answer)
439                 res_len = buf_len;
440
441         ret = wl1271_cmd_send(wl, CMD_TEST, buf, buf_len, res_len);
442
443         if (ret < 0) {
444                 wl1271_warning("TEST command failed");
445                 return ret;
446         }
447
448         return ret;
449 }
450
451 /**
452  * read acx from firmware
453  *
454  * @wl: wl struct
455  * @id: acx id
456  * @buf: buffer for the response, including all headers, must work with dma
457  * @len: length of buf
458  */
459 int wl1271_cmd_interrogate(struct wl1271 *wl, u16 id, void *buf, size_t len)
460 {
461         struct acx_header *acx = buf;
462         int ret;
463
464         wl1271_debug(DEBUG_CMD, "cmd interrogate");
465
466         acx->id = cpu_to_le16(id);
467
468         /* payload length, does not include any headers */
469         acx->len = cpu_to_le16(len - sizeof(*acx));
470
471         ret = wl1271_cmd_send(wl, CMD_INTERROGATE, acx, sizeof(*acx), len);
472         if (ret < 0)
473                 wl1271_error("INTERROGATE command failed");
474
475         return ret;
476 }
477
478 /**
479  * write acx value to firmware
480  *
481  * @wl: wl struct
482  * @id: acx id
483  * @buf: buffer containing acx, including all headers, must work with dma
484  * @len: length of buf
485  */
486 int wl1271_cmd_configure(struct wl1271 *wl, u16 id, void *buf, size_t len)
487 {
488         struct acx_header *acx = buf;
489         int ret;
490
491         wl1271_debug(DEBUG_CMD, "cmd configure");
492
493         acx->id = cpu_to_le16(id);
494
495         /* payload length, does not include any headers */
496         acx->len = cpu_to_le16(len - sizeof(*acx));
497
498         ret = wl1271_cmd_send(wl, CMD_CONFIGURE, acx, len, 0);
499         if (ret < 0) {
500                 wl1271_warning("CONFIGURE command NOK");
501                 return ret;
502         }
503
504         return 0;
505 }
506
507 int wl1271_cmd_data_path(struct wl1271 *wl, bool enable)
508 {
509         struct cmd_enabledisable_path *cmd;
510         int ret;
511         u16 cmd_rx, cmd_tx;
512
513         wl1271_debug(DEBUG_CMD, "cmd data path");
514
515         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
516         if (!cmd) {
517                 ret = -ENOMEM;
518                 goto out;
519         }
520
521         /* the channel here is only used for calibration, so hardcoded to 1 */
522         cmd->channel = 1;
523
524         if (enable) {
525                 cmd_rx = CMD_ENABLE_RX;
526                 cmd_tx = CMD_ENABLE_TX;
527         } else {
528                 cmd_rx = CMD_DISABLE_RX;
529                 cmd_tx = CMD_DISABLE_TX;
530         }
531
532         ret = wl1271_cmd_send(wl, cmd_rx, cmd, sizeof(*cmd), 0);
533         if (ret < 0) {
534                 wl1271_error("rx %s cmd for channel %d failed",
535                              enable ? "start" : "stop", cmd->channel);
536                 goto out;
537         }
538
539         wl1271_debug(DEBUG_BOOT, "rx %s cmd channel %d",
540                      enable ? "start" : "stop", cmd->channel);
541
542         ret = wl1271_cmd_send(wl, cmd_tx, cmd, sizeof(*cmd), 0);
543         if (ret < 0) {
544                 wl1271_error("tx %s cmd for channel %d failed",
545                              enable ? "start" : "stop", cmd->channel);
546                 goto out;
547         }
548
549         wl1271_debug(DEBUG_BOOT, "tx %s cmd channel %d",
550                      enable ? "start" : "stop", cmd->channel);
551
552 out:
553         kfree(cmd);
554         return ret;
555 }
556
557 int wl1271_cmd_ps_mode(struct wl1271 *wl, u8 ps_mode)
558 {
559         struct wl1271_cmd_ps_params *ps_params = NULL;
560         int ret = 0;
561
562         wl1271_debug(DEBUG_CMD, "cmd set ps mode");
563
564         ps_params = kzalloc(sizeof(*ps_params), GFP_KERNEL);
565         if (!ps_params) {
566                 ret = -ENOMEM;
567                 goto out;
568         }
569
570         ps_params->ps_mode = ps_mode;
571
572         ret = wl1271_cmd_send(wl, CMD_SET_PS_MODE, ps_params,
573                               sizeof(*ps_params), 0);
574         if (ret < 0) {
575                 wl1271_error("cmd set_ps_mode failed");
576                 goto out;
577         }
578
579 out:
580         kfree(ps_params);
581         return ret;
582 }
583
584 int wl1271_cmd_template_set(struct wl1271 *wl, u16 template_id,
585                             void *buf, size_t buf_len, int index, u32 rates)
586 {
587         struct wl1271_cmd_template_set *cmd;
588         int ret = 0;
589
590         wl1271_debug(DEBUG_CMD, "cmd template_set %d", template_id);
591
592         WARN_ON(buf_len > WL1271_CMD_TEMPL_MAX_SIZE);
593         buf_len = min_t(size_t, buf_len, WL1271_CMD_TEMPL_MAX_SIZE);
594
595         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
596         if (!cmd) {
597                 ret = -ENOMEM;
598                 goto out;
599         }
600
601         cmd->len = cpu_to_le16(buf_len);
602         cmd->template_type = template_id;
603         cmd->enabled_rates = cpu_to_le32(rates);
604         cmd->short_retry_limit = wl->conf.tx.tmpl_short_retry_limit;
605         cmd->long_retry_limit = wl->conf.tx.tmpl_long_retry_limit;
606         cmd->index = index;
607
608         if (buf)
609                 memcpy(cmd->template_data, buf, buf_len);
610
611         ret = wl1271_cmd_send(wl, CMD_SET_TEMPLATE, cmd, sizeof(*cmd), 0);
612         if (ret < 0) {
613                 wl1271_warning("cmd set_template failed: %d", ret);
614                 goto out_free;
615         }
616
617 out_free:
618         kfree(cmd);
619
620 out:
621         return ret;
622 }
623
624 int wl1271_cmd_build_null_data(struct wl1271 *wl)
625 {
626         struct sk_buff *skb = NULL;
627         int size;
628         void *ptr;
629         int ret = -ENOMEM;
630
631
632         if (wl->bss_type == BSS_TYPE_IBSS) {
633                 size = sizeof(struct wl12xx_null_data_template);
634                 ptr = NULL;
635         } else {
636                 skb = ieee80211_nullfunc_get(wl->hw, wl->vif);
637                 if (!skb)
638                         goto out;
639                 size = skb->len;
640                 ptr = skb->data;
641         }
642
643         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_NULL_DATA, ptr, size, 0,
644                                       wl->basic_rate);
645
646 out:
647         dev_kfree_skb(skb);
648         if (ret)
649                 wl1271_warning("cmd buld null data failed %d", ret);
650
651         return ret;
652
653 }
654
655 int wl1271_cmd_build_klv_null_data(struct wl1271 *wl)
656 {
657         struct sk_buff *skb = NULL;
658         int ret = -ENOMEM;
659
660         skb = ieee80211_nullfunc_get(wl->hw, wl->vif);
661         if (!skb)
662                 goto out;
663
664         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_KLV,
665                                       skb->data, skb->len,
666                                       CMD_TEMPL_KLV_IDX_NULL_DATA,
667                                       wl->basic_rate);
668
669 out:
670         dev_kfree_skb(skb);
671         if (ret)
672                 wl1271_warning("cmd build klv null data failed %d", ret);
673
674         return ret;
675
676 }
677
678 int wl1271_cmd_build_ps_poll(struct wl1271 *wl, u16 aid)
679 {
680         struct sk_buff *skb;
681         int ret = 0;
682
683         skb = ieee80211_pspoll_get(wl->hw, wl->vif);
684         if (!skb)
685                 goto out;
686
687         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_PS_POLL, skb->data,
688                                       skb->len, 0, wl->basic_rate_set);
689
690 out:
691         dev_kfree_skb(skb);
692         return ret;
693 }
694
695 int wl1271_cmd_build_probe_req(struct wl1271 *wl,
696                                const u8 *ssid, size_t ssid_len,
697                                const u8 *ie, size_t ie_len, u8 band)
698 {
699         struct sk_buff *skb;
700         int ret;
701
702         skb = ieee80211_probereq_get(wl->hw, wl->vif, ssid, ssid_len,
703                                      ie, ie_len);
704         if (!skb) {
705                 ret = -ENOMEM;
706                 goto out;
707         }
708
709         wl1271_dump(DEBUG_SCAN, "PROBE REQ: ", skb->data, skb->len);
710
711         if (band == IEEE80211_BAND_2GHZ)
712                 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_CFG_PROBE_REQ_2_4,
713                                               skb->data, skb->len, 0,
714                                               wl->conf.tx.basic_rate);
715         else
716                 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_CFG_PROBE_REQ_5,
717                                               skb->data, skb->len, 0,
718                                               wl->conf.tx.basic_rate_5);
719
720 out:
721         dev_kfree_skb(skb);
722         return ret;
723 }
724
725 struct sk_buff *wl1271_cmd_build_ap_probe_req(struct wl1271 *wl,
726                                               struct sk_buff *skb)
727 {
728         int ret;
729
730         if (!skb)
731                 skb = ieee80211_ap_probereq_get(wl->hw, wl->vif);
732         if (!skb)
733                 goto out;
734
735         wl1271_dump(DEBUG_SCAN, "AP PROBE REQ: ", skb->data, skb->len);
736
737         if (wl->band == IEEE80211_BAND_2GHZ)
738                 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_CFG_PROBE_REQ_2_4,
739                                               skb->data, skb->len, 0,
740                                               wl->conf.tx.basic_rate);
741         else
742                 ret = wl1271_cmd_template_set(wl, CMD_TEMPL_CFG_PROBE_REQ_5,
743                                               skb->data, skb->len, 0,
744                                               wl->conf.tx.basic_rate_5);
745
746         if (ret < 0)
747                 wl1271_error("Unable to set ap probe request template.");
748
749 out:
750         return skb;
751 }
752
753 int wl1271_cmd_build_arp_rsp(struct wl1271 *wl, __be32 ip_addr)
754 {
755         int ret;
756         struct wl12xx_arp_rsp_template tmpl;
757         struct ieee80211_hdr_3addr *hdr;
758         struct arphdr *arp_hdr;
759
760         memset(&tmpl, 0, sizeof(tmpl));
761
762         /* mac80211 header */
763         hdr = &tmpl.hdr;
764         hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
765                                          IEEE80211_STYPE_DATA |
766                                          IEEE80211_FCTL_TODS);
767         memcpy(hdr->addr1, wl->vif->bss_conf.bssid, ETH_ALEN);
768         memcpy(hdr->addr2, wl->vif->addr, ETH_ALEN);
769         memset(hdr->addr3, 0xff, ETH_ALEN);
770
771         /* llc layer */
772         memcpy(tmpl.llc_hdr, rfc1042_header, sizeof(rfc1042_header));
773         tmpl.llc_type = cpu_to_be16(ETH_P_ARP);
774
775         /* arp header */
776         arp_hdr = &tmpl.arp_hdr;
777         arp_hdr->ar_hrd = cpu_to_be16(ARPHRD_ETHER);
778         arp_hdr->ar_pro = cpu_to_be16(ETH_P_IP);
779         arp_hdr->ar_hln = ETH_ALEN;
780         arp_hdr->ar_pln = 4;
781         arp_hdr->ar_op = cpu_to_be16(ARPOP_REPLY);
782
783         /* arp payload */
784         memcpy(tmpl.sender_hw, wl->vif->addr, ETH_ALEN);
785         tmpl.sender_ip = ip_addr;
786
787         ret = wl1271_cmd_template_set(wl, CMD_TEMPL_ARP_RSP,
788                                       &tmpl, sizeof(tmpl), 0,
789                                       wl->basic_rate);
790
791         return ret;
792 }
793
794 int wl1271_build_qos_null_data(struct wl1271 *wl)
795 {
796         struct ieee80211_qos_hdr template;
797
798         memset(&template, 0, sizeof(template));
799
800         memcpy(template.addr1, wl->bssid, ETH_ALEN);
801         memcpy(template.addr2, wl->mac_addr, ETH_ALEN);
802         memcpy(template.addr3, wl->bssid, ETH_ALEN);
803
804         template.frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
805                                              IEEE80211_STYPE_QOS_NULLFUNC |
806                                              IEEE80211_FCTL_TODS);
807
808         /* FIXME: not sure what priority to use here */
809         template.qos_ctrl = cpu_to_le16(0);
810
811         return wl1271_cmd_template_set(wl, CMD_TEMPL_QOS_NULL_DATA, &template,
812                                        sizeof(template), 0,
813                                        wl->basic_rate);
814 }
815
816 int wl1271_cmd_set_sta_default_wep_key(struct wl1271 *wl, u8 id)
817 {
818         struct wl1271_cmd_set_sta_keys *cmd;
819         int ret = 0;
820
821         wl1271_debug(DEBUG_CMD, "cmd set_default_wep_key %d", id);
822
823         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
824         if (!cmd) {
825                 ret = -ENOMEM;
826                 goto out;
827         }
828
829         cmd->id = id;
830         cmd->key_action = cpu_to_le16(KEY_SET_ID);
831         cmd->key_type = KEY_WEP;
832
833         ret = wl1271_cmd_send(wl, CMD_SET_KEYS, cmd, sizeof(*cmd), 0);
834         if (ret < 0) {
835                 wl1271_warning("cmd set_default_wep_key failed: %d", ret);
836                 goto out;
837         }
838
839 out:
840         kfree(cmd);
841
842         return ret;
843 }
844
845 int wl1271_cmd_set_ap_default_wep_key(struct wl1271 *wl, u8 id)
846 {
847         struct wl1271_cmd_set_ap_keys *cmd;
848         int ret = 0;
849
850         wl1271_debug(DEBUG_CMD, "cmd set_ap_default_wep_key %d", id);
851
852         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
853         if (!cmd) {
854                 ret = -ENOMEM;
855                 goto out;
856         }
857
858         cmd->hlid = WL1271_AP_BROADCAST_HLID;
859         cmd->key_id = id;
860         cmd->lid_key_type = WEP_DEFAULT_LID_TYPE;
861         cmd->key_action = cpu_to_le16(KEY_SET_ID);
862         cmd->key_type = KEY_WEP;
863
864         ret = wl1271_cmd_send(wl, CMD_SET_KEYS, cmd, sizeof(*cmd), 0);
865         if (ret < 0) {
866                 wl1271_warning("cmd set_ap_default_wep_key failed: %d", ret);
867                 goto out;
868         }
869
870 out:
871         kfree(cmd);
872
873         return ret;
874 }
875
876 int wl1271_cmd_set_sta_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
877                        u8 key_size, const u8 *key, const u8 *addr,
878                        u32 tx_seq_32, u16 tx_seq_16)
879 {
880         struct wl1271_cmd_set_sta_keys *cmd;
881         int ret = 0;
882
883         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
884         if (!cmd) {
885                 ret = -ENOMEM;
886                 goto out;
887         }
888
889         if (key_type != KEY_WEP)
890                 memcpy(cmd->addr, addr, ETH_ALEN);
891
892         cmd->key_action = cpu_to_le16(action);
893         cmd->key_size = key_size;
894         cmd->key_type = key_type;
895
896         cmd->ac_seq_num16[0] = cpu_to_le16(tx_seq_16);
897         cmd->ac_seq_num32[0] = cpu_to_le32(tx_seq_32);
898
899         /* we have only one SSID profile */
900         cmd->ssid_profile = 0;
901
902         cmd->id = id;
903
904         if (key_type == KEY_TKIP) {
905                 /*
906                  * We get the key in the following form:
907                  * TKIP (16 bytes) - TX MIC (8 bytes) - RX MIC (8 bytes)
908                  * but the target is expecting:
909                  * TKIP - RX MIC - TX MIC
910                  */
911                 memcpy(cmd->key, key, 16);
912                 memcpy(cmd->key + 16, key + 24, 8);
913                 memcpy(cmd->key + 24, key + 16, 8);
914
915         } else {
916                 memcpy(cmd->key, key, key_size);
917         }
918
919         wl1271_dump(DEBUG_CRYPT, "TARGET KEY: ", cmd, sizeof(*cmd));
920
921         ret = wl1271_cmd_send(wl, CMD_SET_KEYS, cmd, sizeof(*cmd), 0);
922         if (ret < 0) {
923                 wl1271_warning("could not set keys");
924         goto out;
925         }
926
927 out:
928         kfree(cmd);
929
930         return ret;
931 }
932
933 int wl1271_cmd_set_ap_key(struct wl1271 *wl, u16 action, u8 id, u8 key_type,
934                         u8 key_size, const u8 *key, u8 hlid, u32 tx_seq_32,
935                         u16 tx_seq_16)
936 {
937         struct wl1271_cmd_set_ap_keys *cmd;
938         int ret = 0;
939         u8 lid_type;
940
941         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
942         if (!cmd)
943                 return -ENOMEM;
944
945         if (hlid == WL1271_AP_BROADCAST_HLID) {
946                 if (key_type == KEY_WEP)
947                         lid_type = WEP_DEFAULT_LID_TYPE;
948                 else
949                         lid_type = BROADCAST_LID_TYPE;
950         } else {
951                 lid_type = UNICAST_LID_TYPE;
952         }
953
954         wl1271_debug(DEBUG_CRYPT, "ap key action: %d id: %d lid: %d type: %d"
955                      " hlid: %d", (int)action, (int)id, (int)lid_type,
956                      (int)key_type, (int)hlid);
957
958         cmd->lid_key_type = lid_type;
959         cmd->hlid = hlid;
960         cmd->key_action = cpu_to_le16(action);
961         cmd->key_size = key_size;
962         cmd->key_type = key_type;
963         cmd->key_id = id;
964         cmd->ac_seq_num16[0] = cpu_to_le16(tx_seq_16);
965         cmd->ac_seq_num32[0] = cpu_to_le32(tx_seq_32);
966
967         if (key_type == KEY_TKIP) {
968                 /*
969                  * We get the key in the following form:
970                  * TKIP (16 bytes) - TX MIC (8 bytes) - RX MIC (8 bytes)
971                  * but the target is expecting:
972                  * TKIP - RX MIC - TX MIC
973                  */
974                 memcpy(cmd->key, key, 16);
975                 memcpy(cmd->key + 16, key + 24, 8);
976                 memcpy(cmd->key + 24, key + 16, 8);
977         } else {
978                 memcpy(cmd->key, key, key_size);
979         }
980
981         wl1271_dump(DEBUG_CRYPT, "TARGET AP KEY: ", cmd, sizeof(*cmd));
982
983         ret = wl1271_cmd_send(wl, CMD_SET_KEYS, cmd, sizeof(*cmd), 0);
984         if (ret < 0) {
985                 wl1271_warning("could not set ap keys");
986                 goto out;
987         }
988
989 out:
990         kfree(cmd);
991         return ret;
992 }
993
994 int wl1271_cmd_disconnect(struct wl1271 *wl)
995 {
996         struct wl1271_cmd_disconnect *cmd;
997         int ret = 0;
998
999         wl1271_debug(DEBUG_CMD, "cmd disconnect");
1000
1001         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1002         if (!cmd) {
1003                 ret = -ENOMEM;
1004                 goto out;
1005         }
1006
1007         cmd->rx_config_options = cpu_to_le32(wl->rx_config);
1008         cmd->rx_filter_options = cpu_to_le32(wl->rx_filter);
1009         /* disconnect reason is not used in immediate disconnections */
1010         cmd->type = DISCONNECT_IMMEDIATE;
1011
1012         ret = wl1271_cmd_send(wl, CMD_DISCONNECT, cmd, sizeof(*cmd), 0);
1013         if (ret < 0) {
1014                 wl1271_error("failed to send disconnect command");
1015                 goto out_free;
1016         }
1017
1018         ret = wl1271_cmd_wait_for_event(wl, DISCONNECT_EVENT_COMPLETE_ID);
1019         if (ret < 0)
1020                 wl1271_error("cmd disconnect event completion error");
1021
1022 out_free:
1023         kfree(cmd);
1024
1025 out:
1026         return ret;
1027 }
1028
1029 int wl1271_cmd_set_sta_state(struct wl1271 *wl)
1030 {
1031         struct wl1271_cmd_set_sta_state *cmd;
1032         int ret = 0;
1033
1034         wl1271_debug(DEBUG_CMD, "cmd set sta state");
1035
1036         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1037         if (!cmd) {
1038                 ret = -ENOMEM;
1039                 goto out;
1040         }
1041
1042         cmd->state = WL1271_CMD_STA_STATE_CONNECTED;
1043
1044         ret = wl1271_cmd_send(wl, CMD_SET_STA_STATE, cmd, sizeof(*cmd), 0);
1045         if (ret < 0) {
1046                 wl1271_error("failed to send set STA state command");
1047                 goto out_free;
1048         }
1049
1050 out_free:
1051         kfree(cmd);
1052
1053 out:
1054         return ret;
1055 }
1056
1057 int wl1271_cmd_start_bss(struct wl1271 *wl)
1058 {
1059         struct wl1271_cmd_bss_start *cmd;
1060         struct ieee80211_bss_conf *bss_conf = &wl->vif->bss_conf;
1061         int ret;
1062
1063         wl1271_debug(DEBUG_CMD, "cmd start bss");
1064
1065         /*
1066          * FIXME: We currently do not support hidden SSID. The real SSID
1067          * should be fetched from mac80211 first.
1068          */
1069         if (wl->ssid_len == 0) {
1070                 wl1271_warning("Hidden SSID currently not supported for AP");
1071                 ret = -EINVAL;
1072                 goto out;
1073         }
1074
1075         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1076         if (!cmd) {
1077                 ret = -ENOMEM;
1078                 goto out;
1079         }
1080
1081         memcpy(cmd->bssid, bss_conf->bssid, ETH_ALEN);
1082
1083         cmd->aging_period = cpu_to_le16(WL1271_AP_DEF_INACTIV_SEC);
1084         cmd->bss_index = WL1271_AP_BSS_INDEX;
1085         cmd->global_hlid = WL1271_AP_GLOBAL_HLID;
1086         cmd->broadcast_hlid = WL1271_AP_BROADCAST_HLID;
1087         cmd->basic_rate_set = cpu_to_le32(wl->basic_rate_set);
1088         cmd->beacon_interval = cpu_to_le16(wl->beacon_int);
1089         cmd->dtim_interval = bss_conf->dtim_period;
1090         cmd->beacon_expiry = WL1271_AP_DEF_BEACON_EXP;
1091         cmd->channel = wl->channel;
1092         cmd->ssid_len = wl->ssid_len;
1093         cmd->ssid_type = SSID_TYPE_PUBLIC;
1094         memcpy(cmd->ssid, wl->ssid, wl->ssid_len);
1095
1096         switch (wl->band) {
1097         case IEEE80211_BAND_2GHZ:
1098                 cmd->band = RADIO_BAND_2_4GHZ;
1099                 break;
1100         case IEEE80211_BAND_5GHZ:
1101                 cmd->band = RADIO_BAND_5GHZ;
1102                 break;
1103         default:
1104                 wl1271_warning("bss start - unknown band: %d", (int)wl->band);
1105                 cmd->band = RADIO_BAND_2_4GHZ;
1106                 break;
1107         }
1108
1109         ret = wl1271_cmd_send(wl, CMD_BSS_START, cmd, sizeof(*cmd), 0);
1110         if (ret < 0) {
1111                 wl1271_error("failed to initiate cmd start bss");
1112                 goto out_free;
1113         }
1114
1115 out_free:
1116         kfree(cmd);
1117
1118 out:
1119         return ret;
1120 }
1121
1122 int wl1271_cmd_stop_bss(struct wl1271 *wl)
1123 {
1124         struct wl1271_cmd_bss_start *cmd;
1125         int ret;
1126
1127         wl1271_debug(DEBUG_CMD, "cmd stop bss");
1128
1129         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1130         if (!cmd) {
1131                 ret = -ENOMEM;
1132                 goto out;
1133         }
1134
1135         cmd->bss_index = WL1271_AP_BSS_INDEX;
1136
1137         ret = wl1271_cmd_send(wl, CMD_BSS_STOP, cmd, sizeof(*cmd), 0);
1138         if (ret < 0) {
1139                 wl1271_error("failed to initiate cmd stop bss");
1140                 goto out_free;
1141         }
1142
1143 out_free:
1144         kfree(cmd);
1145
1146 out:
1147         return ret;
1148 }
1149
1150 int wl1271_cmd_add_sta(struct wl1271 *wl, struct ieee80211_sta *sta, u8 hlid)
1151 {
1152         struct wl1271_cmd_add_sta *cmd;
1153         int ret;
1154
1155         wl1271_debug(DEBUG_CMD, "cmd add sta %d", (int)hlid);
1156
1157         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1158         if (!cmd) {
1159                 ret = -ENOMEM;
1160                 goto out;
1161         }
1162
1163         /* currently we don't support UAPSD */
1164         cmd->sp_len = 0;
1165
1166         memcpy(cmd->addr, sta->addr, ETH_ALEN);
1167         cmd->bss_index = WL1271_AP_BSS_INDEX;
1168         cmd->aid = sta->aid;
1169         cmd->hlid = hlid;
1170
1171         /*
1172          * FIXME: Does STA support QOS? We need to propagate this info from
1173          * hostapd. Currently not that important since this is only used for
1174          * sending the correct flavor of null-data packet in response to a
1175          * trigger.
1176          */
1177         cmd->wmm = 0;
1178
1179         cmd->supported_rates = cpu_to_le32(wl1271_tx_enabled_rates_get(wl,
1180                                                 sta->supp_rates[wl->band]));
1181
1182         wl1271_debug(DEBUG_CMD, "new sta rates: 0x%x", cmd->supported_rates);
1183
1184         ret = wl1271_cmd_send(wl, CMD_ADD_STA, cmd, sizeof(*cmd), 0);
1185         if (ret < 0) {
1186                 wl1271_error("failed to initiate cmd add sta");
1187                 goto out_free;
1188         }
1189
1190 out_free:
1191         kfree(cmd);
1192
1193 out:
1194         return ret;
1195 }
1196
1197 int wl1271_cmd_remove_sta(struct wl1271 *wl, u8 hlid)
1198 {
1199         struct wl1271_cmd_remove_sta *cmd;
1200         int ret;
1201
1202         wl1271_debug(DEBUG_CMD, "cmd remove sta %d", (int)hlid);
1203
1204         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1205         if (!cmd) {
1206                 ret = -ENOMEM;
1207                 goto out;
1208         }
1209
1210         cmd->hlid = hlid;
1211         /* We never send a deauth, mac80211 is in charge of this */
1212         cmd->reason_opcode = 0;
1213         cmd->send_deauth_flag = 0;
1214
1215         ret = wl1271_cmd_send(wl, CMD_REMOVE_STA, cmd, sizeof(*cmd), 0);
1216         if (ret < 0) {
1217                 wl1271_error("failed to initiate cmd remove sta");
1218                 goto out_free;
1219         }
1220
1221         /*
1222          * We are ok with a timeout here. The event is sometimes not sent
1223          * due to a firmware bug.
1224          */
1225         wl1271_cmd_wait_for_event_or_timeout(wl, STA_REMOVE_COMPLETE_EVENT_ID);
1226
1227 out_free:
1228         kfree(cmd);
1229
1230 out:
1231         return ret;
1232 }
1233
1234 int wl12xx_cmd_config_fwlog(struct wl1271 *wl)
1235 {
1236         struct wl12xx_cmd_config_fwlog *cmd;
1237         int ret = 0;
1238
1239         wl1271_debug(DEBUG_CMD, "cmd config firmware logger");
1240
1241         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1242         if (!cmd) {
1243                 ret = -ENOMEM;
1244                 goto out;
1245         }
1246
1247         cmd->logger_mode = wl->conf.fwlog.mode;
1248         cmd->log_severity = wl->conf.fwlog.severity;
1249         cmd->timestamp = wl->conf.fwlog.timestamp;
1250         cmd->output = wl->conf.fwlog.output;
1251         cmd->threshold = wl->conf.fwlog.threshold;
1252
1253         ret = wl1271_cmd_send(wl, CMD_CONFIG_FWLOGGER, cmd, sizeof(*cmd), 0);
1254         if (ret < 0) {
1255                 wl1271_error("failed to send config firmware logger command");
1256                 goto out_free;
1257         }
1258
1259 out_free:
1260         kfree(cmd);
1261
1262 out:
1263         return ret;
1264 }
1265
1266 int wl12xx_cmd_start_fwlog(struct wl1271 *wl)
1267 {
1268         struct wl12xx_cmd_start_fwlog *cmd;
1269         int ret = 0;
1270
1271         wl1271_debug(DEBUG_CMD, "cmd start firmware logger");
1272
1273         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1274         if (!cmd) {
1275                 ret = -ENOMEM;
1276                 goto out;
1277         }
1278
1279         ret = wl1271_cmd_send(wl, CMD_START_FWLOGGER, cmd, sizeof(*cmd), 0);
1280         if (ret < 0) {
1281                 wl1271_error("failed to send start firmware logger command");
1282                 goto out_free;
1283         }
1284
1285 out_free:
1286         kfree(cmd);
1287
1288 out:
1289         return ret;
1290 }
1291
1292 int wl12xx_cmd_stop_fwlog(struct wl1271 *wl)
1293 {
1294         struct wl12xx_cmd_stop_fwlog *cmd;
1295         int ret = 0;
1296
1297         wl1271_debug(DEBUG_CMD, "cmd stop firmware logger");
1298
1299         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
1300         if (!cmd) {
1301                 ret = -ENOMEM;
1302                 goto out;
1303         }
1304
1305         ret = wl1271_cmd_send(wl, CMD_STOP_FWLOGGER, cmd, sizeof(*cmd), 0);
1306         if (ret < 0) {
1307                 wl1271_error("failed to send stop firmware logger command");
1308                 goto out_free;
1309         }
1310
1311 out_free:
1312         kfree(cmd);
1313
1314 out:
1315         return ret;
1316 }