1d2912cb1SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
2560424e9SKalle Valo /*
3560424e9SKalle Valo * WSM host interface (HI) implementation for
4560424e9SKalle Valo * ST-Ericsson CW1200 mac80211 drivers.
5560424e9SKalle Valo *
6560424e9SKalle Valo * Copyright (c) 2010, ST-Ericsson
7560424e9SKalle Valo * Author: Dmitry Tarnyagin <dmitry.tarnyagin@lockless.no>
8560424e9SKalle Valo */
9560424e9SKalle Valo
10560424e9SKalle Valo #include <linux/skbuff.h>
11560424e9SKalle Valo #include <linux/wait.h>
12560424e9SKalle Valo #include <linux/delay.h>
13560424e9SKalle Valo #include <linux/sched.h>
14560424e9SKalle Valo #include <linux/random.h>
15560424e9SKalle Valo
16560424e9SKalle Valo #include "cw1200.h"
17560424e9SKalle Valo #include "wsm.h"
18560424e9SKalle Valo #include "bh.h"
19560424e9SKalle Valo #include "sta.h"
20560424e9SKalle Valo #include "debug.h"
21560424e9SKalle Valo
22560424e9SKalle Valo #define WSM_CMD_TIMEOUT (2 * HZ) /* With respect to interrupt loss */
23560424e9SKalle Valo #define WSM_CMD_START_TIMEOUT (7 * HZ)
24560424e9SKalle Valo #define WSM_CMD_RESET_TIMEOUT (3 * HZ) /* 2 sec. timeout was observed. */
25560424e9SKalle Valo #define WSM_CMD_MAX_TIMEOUT (3 * HZ)
26560424e9SKalle Valo
27560424e9SKalle Valo #define WSM_SKIP(buf, size) \
28560424e9SKalle Valo do { \
29560424e9SKalle Valo if ((buf)->data + size > (buf)->end) \
30560424e9SKalle Valo goto underflow; \
31560424e9SKalle Valo (buf)->data += size; \
32560424e9SKalle Valo } while (0)
33560424e9SKalle Valo
34560424e9SKalle Valo #define WSM_GET(buf, ptr, size) \
35560424e9SKalle Valo do { \
36560424e9SKalle Valo if ((buf)->data + size > (buf)->end) \
37560424e9SKalle Valo goto underflow; \
38560424e9SKalle Valo memcpy(ptr, (buf)->data, size); \
39560424e9SKalle Valo (buf)->data += size; \
40560424e9SKalle Valo } while (0)
41560424e9SKalle Valo
42560424e9SKalle Valo #define __WSM_GET(buf, type, type2, cvt) \
43560424e9SKalle Valo ({ \
44560424e9SKalle Valo type val; \
45560424e9SKalle Valo if ((buf)->data + sizeof(type) > (buf)->end) \
46560424e9SKalle Valo goto underflow; \
47560424e9SKalle Valo val = cvt(*(type2 *)(buf)->data); \
48560424e9SKalle Valo (buf)->data += sizeof(type); \
49560424e9SKalle Valo val; \
50560424e9SKalle Valo })
51560424e9SKalle Valo
52560424e9SKalle Valo #define WSM_GET8(buf) __WSM_GET(buf, u8, u8, (u8))
53560424e9SKalle Valo #define WSM_GET16(buf) __WSM_GET(buf, u16, __le16, __le16_to_cpu)
54560424e9SKalle Valo #define WSM_GET32(buf) __WSM_GET(buf, u32, __le32, __le32_to_cpu)
55560424e9SKalle Valo
56560424e9SKalle Valo #define WSM_PUT(buf, ptr, size) \
57560424e9SKalle Valo do { \
58560424e9SKalle Valo if ((buf)->data + size > (buf)->end) \
59560424e9SKalle Valo if (wsm_buf_reserve((buf), size)) \
60560424e9SKalle Valo goto nomem; \
61560424e9SKalle Valo memcpy((buf)->data, ptr, size); \
62560424e9SKalle Valo (buf)->data += size; \
63560424e9SKalle Valo } while (0)
64560424e9SKalle Valo
65560424e9SKalle Valo #define __WSM_PUT(buf, val, type, type2, cvt) \
66560424e9SKalle Valo do { \
67560424e9SKalle Valo if ((buf)->data + sizeof(type) > (buf)->end) \
68560424e9SKalle Valo if (wsm_buf_reserve((buf), sizeof(type))) \
69560424e9SKalle Valo goto nomem; \
70560424e9SKalle Valo *(type2 *)(buf)->data = cvt(val); \
71560424e9SKalle Valo (buf)->data += sizeof(type); \
72560424e9SKalle Valo } while (0)
73560424e9SKalle Valo
74560424e9SKalle Valo #define WSM_PUT8(buf, val) __WSM_PUT(buf, val, u8, u8, (u8))
75560424e9SKalle Valo #define WSM_PUT16(buf, val) __WSM_PUT(buf, val, u16, __le16, __cpu_to_le16)
76560424e9SKalle Valo #define WSM_PUT32(buf, val) __WSM_PUT(buf, val, u32, __le32, __cpu_to_le32)
77560424e9SKalle Valo
78560424e9SKalle Valo static void wsm_buf_reset(struct wsm_buf *buf);
79560424e9SKalle Valo static int wsm_buf_reserve(struct wsm_buf *buf, size_t extra_size);
80560424e9SKalle Valo
81560424e9SKalle Valo static int wsm_cmd_send(struct cw1200_common *priv,
82560424e9SKalle Valo struct wsm_buf *buf,
83560424e9SKalle Valo void *arg, u16 cmd, long tmo);
84560424e9SKalle Valo
85560424e9SKalle Valo #define wsm_cmd_lock(__priv) mutex_lock(&((__priv)->wsm_cmd_mux))
86560424e9SKalle Valo #define wsm_cmd_unlock(__priv) mutex_unlock(&((__priv)->wsm_cmd_mux))
87560424e9SKalle Valo
88560424e9SKalle Valo /* ******************************************************************** */
89560424e9SKalle Valo /* WSM API implementation */
90560424e9SKalle Valo
wsm_generic_confirm(struct cw1200_common * priv,void * arg,struct wsm_buf * buf)91560424e9SKalle Valo static int wsm_generic_confirm(struct cw1200_common *priv,
92560424e9SKalle Valo void *arg,
93560424e9SKalle Valo struct wsm_buf *buf)
94560424e9SKalle Valo {
95560424e9SKalle Valo u32 status = WSM_GET32(buf);
96560424e9SKalle Valo if (status != WSM_STATUS_SUCCESS)
97560424e9SKalle Valo return -EINVAL;
98560424e9SKalle Valo return 0;
99560424e9SKalle Valo
100560424e9SKalle Valo underflow:
101560424e9SKalle Valo WARN_ON(1);
102560424e9SKalle Valo return -EINVAL;
103560424e9SKalle Valo }
104560424e9SKalle Valo
wsm_configuration(struct cw1200_common * priv,struct wsm_configuration * arg)105560424e9SKalle Valo int wsm_configuration(struct cw1200_common *priv, struct wsm_configuration *arg)
106560424e9SKalle Valo {
107560424e9SKalle Valo int ret;
108560424e9SKalle Valo struct wsm_buf *buf = &priv->wsm_cmd_buf;
109560424e9SKalle Valo
110560424e9SKalle Valo wsm_cmd_lock(priv);
111560424e9SKalle Valo
112560424e9SKalle Valo WSM_PUT32(buf, arg->dot11MaxTransmitMsduLifeTime);
113560424e9SKalle Valo WSM_PUT32(buf, arg->dot11MaxReceiveLifeTime);
114560424e9SKalle Valo WSM_PUT32(buf, arg->dot11RtsThreshold);
115560424e9SKalle Valo
116560424e9SKalle Valo /* DPD block. */
117560424e9SKalle Valo WSM_PUT16(buf, arg->dpdData_size + 12);
118560424e9SKalle Valo WSM_PUT16(buf, 1); /* DPD version */
119560424e9SKalle Valo WSM_PUT(buf, arg->dot11StationId, ETH_ALEN);
120560424e9SKalle Valo WSM_PUT16(buf, 5); /* DPD flags */
121560424e9SKalle Valo WSM_PUT(buf, arg->dpdData, arg->dpdData_size);
122560424e9SKalle Valo
123560424e9SKalle Valo ret = wsm_cmd_send(priv, buf, arg,
124560424e9SKalle Valo WSM_CONFIGURATION_REQ_ID, WSM_CMD_TIMEOUT);
125560424e9SKalle Valo
126560424e9SKalle Valo wsm_cmd_unlock(priv);
127560424e9SKalle Valo return ret;
128560424e9SKalle Valo
129560424e9SKalle Valo nomem:
130560424e9SKalle Valo wsm_cmd_unlock(priv);
131560424e9SKalle Valo return -ENOMEM;
132560424e9SKalle Valo }
133560424e9SKalle Valo
wsm_configuration_confirm(struct cw1200_common * priv,struct wsm_configuration * arg,struct wsm_buf * buf)134560424e9SKalle Valo static int wsm_configuration_confirm(struct cw1200_common *priv,
135560424e9SKalle Valo struct wsm_configuration *arg,
136560424e9SKalle Valo struct wsm_buf *buf)
137560424e9SKalle Valo {
138560424e9SKalle Valo int i;
139560424e9SKalle Valo int status;
140560424e9SKalle Valo
141560424e9SKalle Valo status = WSM_GET32(buf);
142560424e9SKalle Valo if (WARN_ON(status != WSM_STATUS_SUCCESS))
143560424e9SKalle Valo return -EINVAL;
144560424e9SKalle Valo
145560424e9SKalle Valo WSM_GET(buf, arg->dot11StationId, ETH_ALEN);
146560424e9SKalle Valo arg->dot11FrequencyBandsSupported = WSM_GET8(buf);
147560424e9SKalle Valo WSM_SKIP(buf, 1);
148560424e9SKalle Valo arg->supportedRateMask = WSM_GET32(buf);
149560424e9SKalle Valo for (i = 0; i < 2; ++i) {
150560424e9SKalle Valo arg->txPowerRange[i].min_power_level = WSM_GET32(buf);
151560424e9SKalle Valo arg->txPowerRange[i].max_power_level = WSM_GET32(buf);
152560424e9SKalle Valo arg->txPowerRange[i].stepping = WSM_GET32(buf);
153560424e9SKalle Valo }
154560424e9SKalle Valo return 0;
155560424e9SKalle Valo
156560424e9SKalle Valo underflow:
157560424e9SKalle Valo WARN_ON(1);
158560424e9SKalle Valo return -EINVAL;
159560424e9SKalle Valo }
160560424e9SKalle Valo
161560424e9SKalle Valo /* ******************************************************************** */
162560424e9SKalle Valo
wsm_reset(struct cw1200_common * priv,const struct wsm_reset * arg)163560424e9SKalle Valo int wsm_reset(struct cw1200_common *priv, const struct wsm_reset *arg)
164560424e9SKalle Valo {
165560424e9SKalle Valo int ret;
166560424e9SKalle Valo struct wsm_buf *buf = &priv->wsm_cmd_buf;
167560424e9SKalle Valo u16 cmd = WSM_RESET_REQ_ID | WSM_TX_LINK_ID(arg->link_id);
168560424e9SKalle Valo
169560424e9SKalle Valo wsm_cmd_lock(priv);
170560424e9SKalle Valo
171560424e9SKalle Valo WSM_PUT32(buf, arg->reset_statistics ? 0 : 1);
172560424e9SKalle Valo ret = wsm_cmd_send(priv, buf, NULL, cmd, WSM_CMD_RESET_TIMEOUT);
173560424e9SKalle Valo wsm_cmd_unlock(priv);
174560424e9SKalle Valo return ret;
175560424e9SKalle Valo
176560424e9SKalle Valo nomem:
177560424e9SKalle Valo wsm_cmd_unlock(priv);
178560424e9SKalle Valo return -ENOMEM;
179560424e9SKalle Valo }
180560424e9SKalle Valo
181560424e9SKalle Valo /* ******************************************************************** */
182560424e9SKalle Valo
183560424e9SKalle Valo struct wsm_mib {
184560424e9SKalle Valo u16 mib_id;
185560424e9SKalle Valo void *buf;
186560424e9SKalle Valo size_t buf_size;
187560424e9SKalle Valo };
188560424e9SKalle Valo
wsm_read_mib(struct cw1200_common * priv,u16 mib_id,void * _buf,size_t buf_size)189560424e9SKalle Valo int wsm_read_mib(struct cw1200_common *priv, u16 mib_id, void *_buf,
190560424e9SKalle Valo size_t buf_size)
191560424e9SKalle Valo {
192560424e9SKalle Valo int ret;
193560424e9SKalle Valo struct wsm_buf *buf = &priv->wsm_cmd_buf;
194560424e9SKalle Valo struct wsm_mib mib_buf = {
195560424e9SKalle Valo .mib_id = mib_id,
196560424e9SKalle Valo .buf = _buf,
197560424e9SKalle Valo .buf_size = buf_size,
198560424e9SKalle Valo };
199560424e9SKalle Valo wsm_cmd_lock(priv);
200560424e9SKalle Valo
201560424e9SKalle Valo WSM_PUT16(buf, mib_id);
202560424e9SKalle Valo WSM_PUT16(buf, 0);
203560424e9SKalle Valo
204560424e9SKalle Valo ret = wsm_cmd_send(priv, buf, &mib_buf,
205560424e9SKalle Valo WSM_READ_MIB_REQ_ID, WSM_CMD_TIMEOUT);
206560424e9SKalle Valo wsm_cmd_unlock(priv);
207560424e9SKalle Valo return ret;
208560424e9SKalle Valo
209560424e9SKalle Valo nomem:
210560424e9SKalle Valo wsm_cmd_unlock(priv);
211560424e9SKalle Valo return -ENOMEM;
212560424e9SKalle Valo }
213560424e9SKalle Valo
wsm_read_mib_confirm(struct cw1200_common * priv,struct wsm_mib * arg,struct wsm_buf * buf)214560424e9SKalle Valo static int wsm_read_mib_confirm(struct cw1200_common *priv,
215560424e9SKalle Valo struct wsm_mib *arg,
216560424e9SKalle Valo struct wsm_buf *buf)
217560424e9SKalle Valo {
218560424e9SKalle Valo u16 size;
219560424e9SKalle Valo if (WARN_ON(WSM_GET32(buf) != WSM_STATUS_SUCCESS))
220560424e9SKalle Valo return -EINVAL;
221560424e9SKalle Valo
222560424e9SKalle Valo if (WARN_ON(WSM_GET16(buf) != arg->mib_id))
223560424e9SKalle Valo return -EINVAL;
224560424e9SKalle Valo
225560424e9SKalle Valo size = WSM_GET16(buf);
226560424e9SKalle Valo if (size > arg->buf_size)
227560424e9SKalle Valo size = arg->buf_size;
228560424e9SKalle Valo
229560424e9SKalle Valo WSM_GET(buf, arg->buf, size);
230560424e9SKalle Valo arg->buf_size = size;
231560424e9SKalle Valo return 0;
232560424e9SKalle Valo
233560424e9SKalle Valo underflow:
234560424e9SKalle Valo WARN_ON(1);
235560424e9SKalle Valo return -EINVAL;
236560424e9SKalle Valo }
237560424e9SKalle Valo
238560424e9SKalle Valo /* ******************************************************************** */
239560424e9SKalle Valo
wsm_write_mib(struct cw1200_common * priv,u16 mib_id,void * _buf,size_t buf_size)240560424e9SKalle Valo int wsm_write_mib(struct cw1200_common *priv, u16 mib_id, void *_buf,
241560424e9SKalle Valo size_t buf_size)
242560424e9SKalle Valo {
243560424e9SKalle Valo int ret;
244560424e9SKalle Valo struct wsm_buf *buf = &priv->wsm_cmd_buf;
245560424e9SKalle Valo struct wsm_mib mib_buf = {
246560424e9SKalle Valo .mib_id = mib_id,
247560424e9SKalle Valo .buf = _buf,
248560424e9SKalle Valo .buf_size = buf_size,
249560424e9SKalle Valo };
250560424e9SKalle Valo
251560424e9SKalle Valo wsm_cmd_lock(priv);
252560424e9SKalle Valo
253560424e9SKalle Valo WSM_PUT16(buf, mib_id);
254560424e9SKalle Valo WSM_PUT16(buf, buf_size);
255560424e9SKalle Valo WSM_PUT(buf, _buf, buf_size);
256560424e9SKalle Valo
257560424e9SKalle Valo ret = wsm_cmd_send(priv, buf, &mib_buf,
258560424e9SKalle Valo WSM_WRITE_MIB_REQ_ID, WSM_CMD_TIMEOUT);
259560424e9SKalle Valo wsm_cmd_unlock(priv);
260560424e9SKalle Valo return ret;
261560424e9SKalle Valo
262560424e9SKalle Valo nomem:
263560424e9SKalle Valo wsm_cmd_unlock(priv);
264560424e9SKalle Valo return -ENOMEM;
265560424e9SKalle Valo }
266560424e9SKalle Valo
wsm_write_mib_confirm(struct cw1200_common * priv,struct wsm_mib * arg,struct wsm_buf * buf)267560424e9SKalle Valo static int wsm_write_mib_confirm(struct cw1200_common *priv,
268560424e9SKalle Valo struct wsm_mib *arg,
269560424e9SKalle Valo struct wsm_buf *buf)
270560424e9SKalle Valo {
271560424e9SKalle Valo int ret;
272560424e9SKalle Valo
273560424e9SKalle Valo ret = wsm_generic_confirm(priv, arg, buf);
274560424e9SKalle Valo if (ret)
275560424e9SKalle Valo return ret;
276560424e9SKalle Valo
277560424e9SKalle Valo if (arg->mib_id == WSM_MIB_ID_OPERATIONAL_POWER_MODE) {
278560424e9SKalle Valo /* OperationalMode: update PM status. */
279560424e9SKalle Valo const char *p = arg->buf;
280560424e9SKalle Valo cw1200_enable_powersave(priv, (p[0] & 0x0F) ? true : false);
281560424e9SKalle Valo }
282560424e9SKalle Valo return 0;
283560424e9SKalle Valo }
284560424e9SKalle Valo
285560424e9SKalle Valo /* ******************************************************************** */
286560424e9SKalle Valo
wsm_scan(struct cw1200_common * priv,const struct wsm_scan * arg)287560424e9SKalle Valo int wsm_scan(struct cw1200_common *priv, const struct wsm_scan *arg)
288560424e9SKalle Valo {
289560424e9SKalle Valo int i;
290560424e9SKalle Valo int ret;
291560424e9SKalle Valo struct wsm_buf *buf = &priv->wsm_cmd_buf;
292560424e9SKalle Valo
293560424e9SKalle Valo if (arg->num_channels > 48)
294560424e9SKalle Valo return -EINVAL;
295560424e9SKalle Valo
296560424e9SKalle Valo if (arg->num_ssids > 2)
297560424e9SKalle Valo return -EINVAL;
298560424e9SKalle Valo
299560424e9SKalle Valo if (arg->band > 1)
300560424e9SKalle Valo return -EINVAL;
301560424e9SKalle Valo
302560424e9SKalle Valo wsm_cmd_lock(priv);
303560424e9SKalle Valo
304560424e9SKalle Valo WSM_PUT8(buf, arg->band);
305560424e9SKalle Valo WSM_PUT8(buf, arg->type);
306560424e9SKalle Valo WSM_PUT8(buf, arg->flags);
307560424e9SKalle Valo WSM_PUT8(buf, arg->max_tx_rate);
308560424e9SKalle Valo WSM_PUT32(buf, arg->auto_scan_interval);
309560424e9SKalle Valo WSM_PUT8(buf, arg->num_probes);
310560424e9SKalle Valo WSM_PUT8(buf, arg->num_channels);
311560424e9SKalle Valo WSM_PUT8(buf, arg->num_ssids);
312560424e9SKalle Valo WSM_PUT8(buf, arg->probe_delay);
313560424e9SKalle Valo
314560424e9SKalle Valo for (i = 0; i < arg->num_channels; ++i) {
315560424e9SKalle Valo WSM_PUT16(buf, arg->ch[i].number);
316560424e9SKalle Valo WSM_PUT16(buf, 0);
317560424e9SKalle Valo WSM_PUT32(buf, arg->ch[i].min_chan_time);
318560424e9SKalle Valo WSM_PUT32(buf, arg->ch[i].max_chan_time);
319560424e9SKalle Valo WSM_PUT32(buf, 0);
320560424e9SKalle Valo }
321560424e9SKalle Valo
322560424e9SKalle Valo for (i = 0; i < arg->num_ssids; ++i) {
323560424e9SKalle Valo WSM_PUT32(buf, arg->ssids[i].length);
324560424e9SKalle Valo WSM_PUT(buf, &arg->ssids[i].ssid[0],
325560424e9SKalle Valo sizeof(arg->ssids[i].ssid));
326560424e9SKalle Valo }
327560424e9SKalle Valo
328560424e9SKalle Valo ret = wsm_cmd_send(priv, buf, NULL,
329560424e9SKalle Valo WSM_START_SCAN_REQ_ID, WSM_CMD_TIMEOUT);
330560424e9SKalle Valo wsm_cmd_unlock(priv);
331560424e9SKalle Valo return ret;
332560424e9SKalle Valo
333560424e9SKalle Valo nomem:
334560424e9SKalle Valo wsm_cmd_unlock(priv);
335560424e9SKalle Valo return -ENOMEM;
336560424e9SKalle Valo }
337560424e9SKalle Valo
338560424e9SKalle Valo /* ******************************************************************** */
339560424e9SKalle Valo
wsm_stop_scan(struct cw1200_common * priv)340560424e9SKalle Valo int wsm_stop_scan(struct cw1200_common *priv)
341560424e9SKalle Valo {
342560424e9SKalle Valo int ret;
343560424e9SKalle Valo struct wsm_buf *buf = &priv->wsm_cmd_buf;
344560424e9SKalle Valo wsm_cmd_lock(priv);
345560424e9SKalle Valo ret = wsm_cmd_send(priv, buf, NULL,
346560424e9SKalle Valo WSM_STOP_SCAN_REQ_ID, WSM_CMD_TIMEOUT);
347560424e9SKalle Valo wsm_cmd_unlock(priv);
348560424e9SKalle Valo return ret;
349560424e9SKalle Valo }
350560424e9SKalle Valo
351560424e9SKalle Valo
wsm_tx_confirm(struct cw1200_common * priv,struct wsm_buf * buf,int link_id)352560424e9SKalle Valo static int wsm_tx_confirm(struct cw1200_common *priv,
353560424e9SKalle Valo struct wsm_buf *buf,
354560424e9SKalle Valo int link_id)
355560424e9SKalle Valo {
356560424e9SKalle Valo struct wsm_tx_confirm tx_confirm;
357560424e9SKalle Valo
358560424e9SKalle Valo tx_confirm.packet_id = WSM_GET32(buf);
359560424e9SKalle Valo tx_confirm.status = WSM_GET32(buf);
360560424e9SKalle Valo tx_confirm.tx_rate = WSM_GET8(buf);
361560424e9SKalle Valo tx_confirm.ack_failures = WSM_GET8(buf);
362560424e9SKalle Valo tx_confirm.flags = WSM_GET16(buf);
363560424e9SKalle Valo tx_confirm.media_delay = WSM_GET32(buf);
364560424e9SKalle Valo tx_confirm.tx_queue_delay = WSM_GET32(buf);
365560424e9SKalle Valo
366560424e9SKalle Valo cw1200_tx_confirm_cb(priv, link_id, &tx_confirm);
367560424e9SKalle Valo return 0;
368560424e9SKalle Valo
369560424e9SKalle Valo underflow:
370560424e9SKalle Valo WARN_ON(1);
371560424e9SKalle Valo return -EINVAL;
372560424e9SKalle Valo }
373560424e9SKalle Valo
wsm_multi_tx_confirm(struct cw1200_common * priv,struct wsm_buf * buf,int link_id)374560424e9SKalle Valo static int wsm_multi_tx_confirm(struct cw1200_common *priv,
375560424e9SKalle Valo struct wsm_buf *buf, int link_id)
376560424e9SKalle Valo {
377560424e9SKalle Valo int ret;
378560424e9SKalle Valo int count;
379560424e9SKalle Valo
380560424e9SKalle Valo count = WSM_GET32(buf);
381560424e9SKalle Valo if (WARN_ON(count <= 0))
382560424e9SKalle Valo return -EINVAL;
383560424e9SKalle Valo
384560424e9SKalle Valo if (count > 1) {
385560424e9SKalle Valo /* We already released one buffer, now for the rest */
386560424e9SKalle Valo ret = wsm_release_tx_buffer(priv, count - 1);
387560424e9SKalle Valo if (ret < 0)
388560424e9SKalle Valo return ret;
389560424e9SKalle Valo else if (ret > 0)
390560424e9SKalle Valo cw1200_bh_wakeup(priv);
391560424e9SKalle Valo }
392560424e9SKalle Valo
393560424e9SKalle Valo cw1200_debug_txed_multi(priv, count);
3947fc1503cSArnd Bergmann do {
395560424e9SKalle Valo ret = wsm_tx_confirm(priv, buf, link_id);
3967fc1503cSArnd Bergmann } while (!ret && --count);
3977fc1503cSArnd Bergmann
398560424e9SKalle Valo return ret;
399560424e9SKalle Valo
400560424e9SKalle Valo underflow:
401560424e9SKalle Valo WARN_ON(1);
402560424e9SKalle Valo return -EINVAL;
403560424e9SKalle Valo }
404560424e9SKalle Valo
405560424e9SKalle Valo /* ******************************************************************** */
406560424e9SKalle Valo
wsm_join_confirm(struct cw1200_common * priv,struct wsm_join_cnf * arg,struct wsm_buf * buf)407560424e9SKalle Valo static int wsm_join_confirm(struct cw1200_common *priv,
408560424e9SKalle Valo struct wsm_join_cnf *arg,
409560424e9SKalle Valo struct wsm_buf *buf)
410560424e9SKalle Valo {
411560424e9SKalle Valo arg->status = WSM_GET32(buf);
412560424e9SKalle Valo if (WARN_ON(arg->status) != WSM_STATUS_SUCCESS)
413560424e9SKalle Valo return -EINVAL;
414560424e9SKalle Valo
415560424e9SKalle Valo arg->min_power_level = WSM_GET32(buf);
416560424e9SKalle Valo arg->max_power_level = WSM_GET32(buf);
417560424e9SKalle Valo
418560424e9SKalle Valo return 0;
419560424e9SKalle Valo
420560424e9SKalle Valo underflow:
421560424e9SKalle Valo WARN_ON(1);
422560424e9SKalle Valo return -EINVAL;
423560424e9SKalle Valo }
424560424e9SKalle Valo
wsm_join(struct cw1200_common * priv,struct wsm_join * arg)425560424e9SKalle Valo int wsm_join(struct cw1200_common *priv, struct wsm_join *arg)
426560424e9SKalle Valo {
427560424e9SKalle Valo int ret;
428560424e9SKalle Valo struct wsm_buf *buf = &priv->wsm_cmd_buf;
429560424e9SKalle Valo struct wsm_join_cnf resp;
430560424e9SKalle Valo wsm_cmd_lock(priv);
431560424e9SKalle Valo
432560424e9SKalle Valo WSM_PUT8(buf, arg->mode);
433560424e9SKalle Valo WSM_PUT8(buf, arg->band);
434560424e9SKalle Valo WSM_PUT16(buf, arg->channel_number);
435560424e9SKalle Valo WSM_PUT(buf, &arg->bssid[0], sizeof(arg->bssid));
436560424e9SKalle Valo WSM_PUT16(buf, arg->atim_window);
437560424e9SKalle Valo WSM_PUT8(buf, arg->preamble_type);
438560424e9SKalle Valo WSM_PUT8(buf, arg->probe_for_join);
439560424e9SKalle Valo WSM_PUT8(buf, arg->dtim_period);
440560424e9SKalle Valo WSM_PUT8(buf, arg->flags);
441560424e9SKalle Valo WSM_PUT32(buf, arg->ssid_len);
442560424e9SKalle Valo WSM_PUT(buf, &arg->ssid[0], sizeof(arg->ssid));
443560424e9SKalle Valo WSM_PUT32(buf, arg->beacon_interval);
444560424e9SKalle Valo WSM_PUT32(buf, arg->basic_rate_set);
445560424e9SKalle Valo
446560424e9SKalle Valo priv->tx_burst_idx = -1;
447560424e9SKalle Valo ret = wsm_cmd_send(priv, buf, &resp,
448560424e9SKalle Valo WSM_JOIN_REQ_ID, WSM_CMD_TIMEOUT);
449560424e9SKalle Valo /* TODO: Update state based on resp.min|max_power_level */
450560424e9SKalle Valo
451560424e9SKalle Valo priv->join_complete_status = resp.status;
452560424e9SKalle Valo
453560424e9SKalle Valo wsm_cmd_unlock(priv);
454560424e9SKalle Valo return ret;
455560424e9SKalle Valo
456560424e9SKalle Valo nomem:
457560424e9SKalle Valo wsm_cmd_unlock(priv);
458560424e9SKalle Valo return -ENOMEM;
459560424e9SKalle Valo }
460560424e9SKalle Valo
461560424e9SKalle Valo /* ******************************************************************** */
462560424e9SKalle Valo
wsm_set_bss_params(struct cw1200_common * priv,const struct wsm_set_bss_params * arg)463560424e9SKalle Valo int wsm_set_bss_params(struct cw1200_common *priv,
464560424e9SKalle Valo const struct wsm_set_bss_params *arg)
465560424e9SKalle Valo {
466560424e9SKalle Valo int ret;
467560424e9SKalle Valo struct wsm_buf *buf = &priv->wsm_cmd_buf;
468560424e9SKalle Valo
469560424e9SKalle Valo wsm_cmd_lock(priv);
470560424e9SKalle Valo
471560424e9SKalle Valo WSM_PUT8(buf, (arg->reset_beacon_loss ? 0x1 : 0));
472560424e9SKalle Valo WSM_PUT8(buf, arg->beacon_lost_count);
473560424e9SKalle Valo WSM_PUT16(buf, arg->aid);
474560424e9SKalle Valo WSM_PUT32(buf, arg->operational_rate_set);
475560424e9SKalle Valo
476560424e9SKalle Valo ret = wsm_cmd_send(priv, buf, NULL,
477560424e9SKalle Valo WSM_SET_BSS_PARAMS_REQ_ID, WSM_CMD_TIMEOUT);
478560424e9SKalle Valo
479560424e9SKalle Valo wsm_cmd_unlock(priv);
480560424e9SKalle Valo return ret;
481560424e9SKalle Valo
482560424e9SKalle Valo nomem:
483560424e9SKalle Valo wsm_cmd_unlock(priv);
484560424e9SKalle Valo return -ENOMEM;
485560424e9SKalle Valo }
486560424e9SKalle Valo
487560424e9SKalle Valo /* ******************************************************************** */
488560424e9SKalle Valo
wsm_add_key(struct cw1200_common * priv,const struct wsm_add_key * arg)489560424e9SKalle Valo int wsm_add_key(struct cw1200_common *priv, const struct wsm_add_key *arg)
490560424e9SKalle Valo {
491560424e9SKalle Valo int ret;
492560424e9SKalle Valo struct wsm_buf *buf = &priv->wsm_cmd_buf;
493560424e9SKalle Valo
494560424e9SKalle Valo wsm_cmd_lock(priv);
495560424e9SKalle Valo
496560424e9SKalle Valo WSM_PUT(buf, arg, sizeof(*arg));
497560424e9SKalle Valo
498560424e9SKalle Valo ret = wsm_cmd_send(priv, buf, NULL,
499560424e9SKalle Valo WSM_ADD_KEY_REQ_ID, WSM_CMD_TIMEOUT);
500560424e9SKalle Valo
501560424e9SKalle Valo wsm_cmd_unlock(priv);
502560424e9SKalle Valo return ret;
503560424e9SKalle Valo
504560424e9SKalle Valo nomem:
505560424e9SKalle Valo wsm_cmd_unlock(priv);
506560424e9SKalle Valo return -ENOMEM;
507560424e9SKalle Valo }
508560424e9SKalle Valo
509560424e9SKalle Valo /* ******************************************************************** */
510560424e9SKalle Valo
wsm_remove_key(struct cw1200_common * priv,const struct wsm_remove_key * arg)511560424e9SKalle Valo int wsm_remove_key(struct cw1200_common *priv, const struct wsm_remove_key *arg)
512560424e9SKalle Valo {
513560424e9SKalle Valo int ret;
514560424e9SKalle Valo struct wsm_buf *buf = &priv->wsm_cmd_buf;
515560424e9SKalle Valo
516560424e9SKalle Valo wsm_cmd_lock(priv);
517560424e9SKalle Valo
518560424e9SKalle Valo WSM_PUT8(buf, arg->index);
519560424e9SKalle Valo WSM_PUT8(buf, 0);
520560424e9SKalle Valo WSM_PUT16(buf, 0);
521560424e9SKalle Valo
522560424e9SKalle Valo ret = wsm_cmd_send(priv, buf, NULL,
523560424e9SKalle Valo WSM_REMOVE_KEY_REQ_ID, WSM_CMD_TIMEOUT);
524560424e9SKalle Valo
525560424e9SKalle Valo wsm_cmd_unlock(priv);
526560424e9SKalle Valo return ret;
527560424e9SKalle Valo
528560424e9SKalle Valo nomem:
529560424e9SKalle Valo wsm_cmd_unlock(priv);
530560424e9SKalle Valo return -ENOMEM;
531560424e9SKalle Valo }
532560424e9SKalle Valo
533560424e9SKalle Valo /* ******************************************************************** */
534560424e9SKalle Valo
wsm_set_tx_queue_params(struct cw1200_common * priv,const struct wsm_set_tx_queue_params * arg,u8 id)535560424e9SKalle Valo int wsm_set_tx_queue_params(struct cw1200_common *priv,
536560424e9SKalle Valo const struct wsm_set_tx_queue_params *arg, u8 id)
537560424e9SKalle Valo {
538560424e9SKalle Valo int ret;
539560424e9SKalle Valo struct wsm_buf *buf = &priv->wsm_cmd_buf;
540fe683faeSColin Ian King static const u8 queue_id_to_wmm_aci[] = { 3, 2, 0, 1 };
541560424e9SKalle Valo
542560424e9SKalle Valo wsm_cmd_lock(priv);
543560424e9SKalle Valo
544560424e9SKalle Valo WSM_PUT8(buf, queue_id_to_wmm_aci[id]);
545560424e9SKalle Valo WSM_PUT8(buf, 0);
546560424e9SKalle Valo WSM_PUT8(buf, arg->ackPolicy);
547560424e9SKalle Valo WSM_PUT8(buf, 0);
548560424e9SKalle Valo WSM_PUT32(buf, arg->maxTransmitLifetime);
549560424e9SKalle Valo WSM_PUT16(buf, arg->allowedMediumTime);
550560424e9SKalle Valo WSM_PUT16(buf, 0);
551560424e9SKalle Valo
552560424e9SKalle Valo ret = wsm_cmd_send(priv, buf, NULL, 0x0012, WSM_CMD_TIMEOUT);
553560424e9SKalle Valo
554560424e9SKalle Valo wsm_cmd_unlock(priv);
555560424e9SKalle Valo return ret;
556560424e9SKalle Valo
557560424e9SKalle Valo nomem:
558560424e9SKalle Valo wsm_cmd_unlock(priv);
559560424e9SKalle Valo return -ENOMEM;
560560424e9SKalle Valo }
561560424e9SKalle Valo
562560424e9SKalle Valo /* ******************************************************************** */
563560424e9SKalle Valo
wsm_set_edca_params(struct cw1200_common * priv,const struct wsm_edca_params * arg)564560424e9SKalle Valo int wsm_set_edca_params(struct cw1200_common *priv,
565560424e9SKalle Valo const struct wsm_edca_params *arg)
566560424e9SKalle Valo {
567560424e9SKalle Valo int ret;
568560424e9SKalle Valo struct wsm_buf *buf = &priv->wsm_cmd_buf;
569560424e9SKalle Valo
570560424e9SKalle Valo wsm_cmd_lock(priv);
571560424e9SKalle Valo
572560424e9SKalle Valo /* Implemented according to specification. */
573560424e9SKalle Valo
574560424e9SKalle Valo WSM_PUT16(buf, arg->params[3].cwmin);
575560424e9SKalle Valo WSM_PUT16(buf, arg->params[2].cwmin);
576560424e9SKalle Valo WSM_PUT16(buf, arg->params[1].cwmin);
577560424e9SKalle Valo WSM_PUT16(buf, arg->params[0].cwmin);
578560424e9SKalle Valo
579560424e9SKalle Valo WSM_PUT16(buf, arg->params[3].cwmax);
580560424e9SKalle Valo WSM_PUT16(buf, arg->params[2].cwmax);
581560424e9SKalle Valo WSM_PUT16(buf, arg->params[1].cwmax);
582560424e9SKalle Valo WSM_PUT16(buf, arg->params[0].cwmax);
583560424e9SKalle Valo
584560424e9SKalle Valo WSM_PUT8(buf, arg->params[3].aifns);
585560424e9SKalle Valo WSM_PUT8(buf, arg->params[2].aifns);
586560424e9SKalle Valo WSM_PUT8(buf, arg->params[1].aifns);
587560424e9SKalle Valo WSM_PUT8(buf, arg->params[0].aifns);
588560424e9SKalle Valo
589560424e9SKalle Valo WSM_PUT16(buf, arg->params[3].txop_limit);
590560424e9SKalle Valo WSM_PUT16(buf, arg->params[2].txop_limit);
591560424e9SKalle Valo WSM_PUT16(buf, arg->params[1].txop_limit);
592560424e9SKalle Valo WSM_PUT16(buf, arg->params[0].txop_limit);
593560424e9SKalle Valo
594560424e9SKalle Valo WSM_PUT32(buf, arg->params[3].max_rx_lifetime);
595560424e9SKalle Valo WSM_PUT32(buf, arg->params[2].max_rx_lifetime);
596560424e9SKalle Valo WSM_PUT32(buf, arg->params[1].max_rx_lifetime);
597560424e9SKalle Valo WSM_PUT32(buf, arg->params[0].max_rx_lifetime);
598560424e9SKalle Valo
599560424e9SKalle Valo ret = wsm_cmd_send(priv, buf, NULL,
600560424e9SKalle Valo WSM_EDCA_PARAMS_REQ_ID, WSM_CMD_TIMEOUT);
601560424e9SKalle Valo wsm_cmd_unlock(priv);
602560424e9SKalle Valo return ret;
603560424e9SKalle Valo
604560424e9SKalle Valo nomem:
605560424e9SKalle Valo wsm_cmd_unlock(priv);
606560424e9SKalle Valo return -ENOMEM;
607560424e9SKalle Valo }
608560424e9SKalle Valo
609560424e9SKalle Valo /* ******************************************************************** */
610560424e9SKalle Valo
wsm_switch_channel(struct cw1200_common * priv,const struct wsm_switch_channel * arg)611560424e9SKalle Valo int wsm_switch_channel(struct cw1200_common *priv,
612560424e9SKalle Valo const struct wsm_switch_channel *arg)
613560424e9SKalle Valo {
614560424e9SKalle Valo int ret;
615560424e9SKalle Valo struct wsm_buf *buf = &priv->wsm_cmd_buf;
616560424e9SKalle Valo
617560424e9SKalle Valo wsm_cmd_lock(priv);
618560424e9SKalle Valo
619560424e9SKalle Valo WSM_PUT8(buf, arg->mode);
620560424e9SKalle Valo WSM_PUT8(buf, arg->switch_count);
621560424e9SKalle Valo WSM_PUT16(buf, arg->channel_number);
622560424e9SKalle Valo
623560424e9SKalle Valo priv->channel_switch_in_progress = 1;
624560424e9SKalle Valo
625560424e9SKalle Valo ret = wsm_cmd_send(priv, buf, NULL,
626560424e9SKalle Valo WSM_SWITCH_CHANNEL_REQ_ID, WSM_CMD_TIMEOUT);
627560424e9SKalle Valo if (ret)
628560424e9SKalle Valo priv->channel_switch_in_progress = 0;
629560424e9SKalle Valo
630560424e9SKalle Valo wsm_cmd_unlock(priv);
631560424e9SKalle Valo return ret;
632560424e9SKalle Valo
633560424e9SKalle Valo nomem:
634560424e9SKalle Valo wsm_cmd_unlock(priv);
635560424e9SKalle Valo return -ENOMEM;
636560424e9SKalle Valo }
637560424e9SKalle Valo
638560424e9SKalle Valo /* ******************************************************************** */
639560424e9SKalle Valo
wsm_set_pm(struct cw1200_common * priv,const struct wsm_set_pm * arg)640560424e9SKalle Valo int wsm_set_pm(struct cw1200_common *priv, const struct wsm_set_pm *arg)
641560424e9SKalle Valo {
642560424e9SKalle Valo int ret;
643560424e9SKalle Valo struct wsm_buf *buf = &priv->wsm_cmd_buf;
644560424e9SKalle Valo priv->ps_mode_switch_in_progress = 1;
645560424e9SKalle Valo
646560424e9SKalle Valo wsm_cmd_lock(priv);
647560424e9SKalle Valo
648560424e9SKalle Valo WSM_PUT8(buf, arg->mode);
649560424e9SKalle Valo WSM_PUT8(buf, arg->fast_psm_idle_period);
650560424e9SKalle Valo WSM_PUT8(buf, arg->ap_psm_change_period);
651560424e9SKalle Valo WSM_PUT8(buf, arg->min_auto_pspoll_period);
652560424e9SKalle Valo
653560424e9SKalle Valo ret = wsm_cmd_send(priv, buf, NULL,
654560424e9SKalle Valo WSM_SET_PM_REQ_ID, WSM_CMD_TIMEOUT);
655560424e9SKalle Valo
656560424e9SKalle Valo wsm_cmd_unlock(priv);
657560424e9SKalle Valo return ret;
658560424e9SKalle Valo
659560424e9SKalle Valo nomem:
660560424e9SKalle Valo wsm_cmd_unlock(priv);
661560424e9SKalle Valo return -ENOMEM;
662560424e9SKalle Valo }
663560424e9SKalle Valo
664560424e9SKalle Valo /* ******************************************************************** */
665560424e9SKalle Valo
wsm_start(struct cw1200_common * priv,const struct wsm_start * arg)666560424e9SKalle Valo int wsm_start(struct cw1200_common *priv, const struct wsm_start *arg)
667560424e9SKalle Valo {
668560424e9SKalle Valo int ret;
669560424e9SKalle Valo struct wsm_buf *buf = &priv->wsm_cmd_buf;
670560424e9SKalle Valo
671560424e9SKalle Valo wsm_cmd_lock(priv);
672560424e9SKalle Valo
673560424e9SKalle Valo WSM_PUT8(buf, arg->mode);
674560424e9SKalle Valo WSM_PUT8(buf, arg->band);
675560424e9SKalle Valo WSM_PUT16(buf, arg->channel_number);
676560424e9SKalle Valo WSM_PUT32(buf, arg->ct_window);
677560424e9SKalle Valo WSM_PUT32(buf, arg->beacon_interval);
678560424e9SKalle Valo WSM_PUT8(buf, arg->dtim_period);
679560424e9SKalle Valo WSM_PUT8(buf, arg->preamble);
680560424e9SKalle Valo WSM_PUT8(buf, arg->probe_delay);
681560424e9SKalle Valo WSM_PUT8(buf, arg->ssid_len);
682560424e9SKalle Valo WSM_PUT(buf, arg->ssid, sizeof(arg->ssid));
683560424e9SKalle Valo WSM_PUT32(buf, arg->basic_rate_set);
684560424e9SKalle Valo
685560424e9SKalle Valo priv->tx_burst_idx = -1;
686560424e9SKalle Valo ret = wsm_cmd_send(priv, buf, NULL,
687560424e9SKalle Valo WSM_START_REQ_ID, WSM_CMD_START_TIMEOUT);
688560424e9SKalle Valo
689560424e9SKalle Valo wsm_cmd_unlock(priv);
690560424e9SKalle Valo return ret;
691560424e9SKalle Valo
692560424e9SKalle Valo nomem:
693560424e9SKalle Valo wsm_cmd_unlock(priv);
694560424e9SKalle Valo return -ENOMEM;
695560424e9SKalle Valo }
696560424e9SKalle Valo
697560424e9SKalle Valo /* ******************************************************************** */
698560424e9SKalle Valo
wsm_beacon_transmit(struct cw1200_common * priv,const struct wsm_beacon_transmit * arg)699560424e9SKalle Valo int wsm_beacon_transmit(struct cw1200_common *priv,
700560424e9SKalle Valo const struct wsm_beacon_transmit *arg)
701560424e9SKalle Valo {
702560424e9SKalle Valo int ret;
703560424e9SKalle Valo struct wsm_buf *buf = &priv->wsm_cmd_buf;
704560424e9SKalle Valo
705560424e9SKalle Valo wsm_cmd_lock(priv);
706560424e9SKalle Valo
707560424e9SKalle Valo WSM_PUT32(buf, arg->enable_beaconing ? 1 : 0);
708560424e9SKalle Valo
709560424e9SKalle Valo ret = wsm_cmd_send(priv, buf, NULL,
710560424e9SKalle Valo WSM_BEACON_TRANSMIT_REQ_ID, WSM_CMD_TIMEOUT);
711560424e9SKalle Valo
712560424e9SKalle Valo wsm_cmd_unlock(priv);
713560424e9SKalle Valo return ret;
714560424e9SKalle Valo
715560424e9SKalle Valo nomem:
716560424e9SKalle Valo wsm_cmd_unlock(priv);
717560424e9SKalle Valo return -ENOMEM;
718560424e9SKalle Valo }
719560424e9SKalle Valo
720560424e9SKalle Valo /* ******************************************************************** */
721560424e9SKalle Valo
wsm_start_find(struct cw1200_common * priv)722560424e9SKalle Valo int wsm_start_find(struct cw1200_common *priv)
723560424e9SKalle Valo {
724560424e9SKalle Valo int ret;
725560424e9SKalle Valo struct wsm_buf *buf = &priv->wsm_cmd_buf;
726560424e9SKalle Valo
727560424e9SKalle Valo wsm_cmd_lock(priv);
728560424e9SKalle Valo ret = wsm_cmd_send(priv, buf, NULL, 0x0019, WSM_CMD_TIMEOUT);
729560424e9SKalle Valo wsm_cmd_unlock(priv);
730560424e9SKalle Valo return ret;
731560424e9SKalle Valo }
732560424e9SKalle Valo
733560424e9SKalle Valo /* ******************************************************************** */
734560424e9SKalle Valo
wsm_stop_find(struct cw1200_common * priv)735560424e9SKalle Valo int wsm_stop_find(struct cw1200_common *priv)
736560424e9SKalle Valo {
737560424e9SKalle Valo int ret;
738560424e9SKalle Valo struct wsm_buf *buf = &priv->wsm_cmd_buf;
739560424e9SKalle Valo
740560424e9SKalle Valo wsm_cmd_lock(priv);
741560424e9SKalle Valo ret = wsm_cmd_send(priv, buf, NULL, 0x001A, WSM_CMD_TIMEOUT);
742560424e9SKalle Valo wsm_cmd_unlock(priv);
743560424e9SKalle Valo return ret;
744560424e9SKalle Valo }
745560424e9SKalle Valo
746560424e9SKalle Valo /* ******************************************************************** */
747560424e9SKalle Valo
wsm_map_link(struct cw1200_common * priv,const struct wsm_map_link * arg)748560424e9SKalle Valo int wsm_map_link(struct cw1200_common *priv, const struct wsm_map_link *arg)
749560424e9SKalle Valo {
750560424e9SKalle Valo int ret;
751560424e9SKalle Valo struct wsm_buf *buf = &priv->wsm_cmd_buf;
752560424e9SKalle Valo u16 cmd = 0x001C | WSM_TX_LINK_ID(arg->link_id);
753560424e9SKalle Valo
754560424e9SKalle Valo wsm_cmd_lock(priv);
755560424e9SKalle Valo
756560424e9SKalle Valo WSM_PUT(buf, &arg->mac_addr[0], sizeof(arg->mac_addr));
757560424e9SKalle Valo WSM_PUT16(buf, 0);
758560424e9SKalle Valo
759560424e9SKalle Valo ret = wsm_cmd_send(priv, buf, NULL, cmd, WSM_CMD_TIMEOUT);
760560424e9SKalle Valo
761560424e9SKalle Valo wsm_cmd_unlock(priv);
762560424e9SKalle Valo return ret;
763560424e9SKalle Valo
764560424e9SKalle Valo nomem:
765560424e9SKalle Valo wsm_cmd_unlock(priv);
766560424e9SKalle Valo return -ENOMEM;
767560424e9SKalle Valo }
768560424e9SKalle Valo
769560424e9SKalle Valo /* ******************************************************************** */
770560424e9SKalle Valo
wsm_update_ie(struct cw1200_common * priv,const struct wsm_update_ie * arg)771560424e9SKalle Valo int wsm_update_ie(struct cw1200_common *priv,
772560424e9SKalle Valo const struct wsm_update_ie *arg)
773560424e9SKalle Valo {
774560424e9SKalle Valo int ret;
775560424e9SKalle Valo struct wsm_buf *buf = &priv->wsm_cmd_buf;
776560424e9SKalle Valo
777560424e9SKalle Valo wsm_cmd_lock(priv);
778560424e9SKalle Valo
779560424e9SKalle Valo WSM_PUT16(buf, arg->what);
780560424e9SKalle Valo WSM_PUT16(buf, arg->count);
781560424e9SKalle Valo WSM_PUT(buf, arg->ies, arg->length);
782560424e9SKalle Valo
783560424e9SKalle Valo ret = wsm_cmd_send(priv, buf, NULL, 0x001B, WSM_CMD_TIMEOUT);
784560424e9SKalle Valo
785560424e9SKalle Valo wsm_cmd_unlock(priv);
786560424e9SKalle Valo return ret;
787560424e9SKalle Valo
788560424e9SKalle Valo nomem:
789560424e9SKalle Valo wsm_cmd_unlock(priv);
790560424e9SKalle Valo return -ENOMEM;
791560424e9SKalle Valo }
792560424e9SKalle Valo
793560424e9SKalle Valo /* ******************************************************************** */
wsm_set_probe_responder(struct cw1200_common * priv,bool enable)794560424e9SKalle Valo int wsm_set_probe_responder(struct cw1200_common *priv, bool enable)
795560424e9SKalle Valo {
796560424e9SKalle Valo priv->rx_filter.probeResponder = enable;
797560424e9SKalle Valo return wsm_set_rx_filter(priv, &priv->rx_filter);
798560424e9SKalle Valo }
799560424e9SKalle Valo
800560424e9SKalle Valo /* ******************************************************************** */
801560424e9SKalle Valo /* WSM indication events implementation */
802560424e9SKalle Valo const char * const cw1200_fw_types[] = {
803560424e9SKalle Valo "ETF",
804560424e9SKalle Valo "WFM",
805560424e9SKalle Valo "WSM",
806560424e9SKalle Valo "HI test",
807560424e9SKalle Valo "Platform test"
808560424e9SKalle Valo };
809560424e9SKalle Valo
wsm_startup_indication(struct cw1200_common * priv,struct wsm_buf * buf)810560424e9SKalle Valo static int wsm_startup_indication(struct cw1200_common *priv,
811560424e9SKalle Valo struct wsm_buf *buf)
812560424e9SKalle Valo {
813560424e9SKalle Valo priv->wsm_caps.input_buffers = WSM_GET16(buf);
814560424e9SKalle Valo priv->wsm_caps.input_buffer_size = WSM_GET16(buf);
815560424e9SKalle Valo priv->wsm_caps.hw_id = WSM_GET16(buf);
816560424e9SKalle Valo priv->wsm_caps.hw_subid = WSM_GET16(buf);
817560424e9SKalle Valo priv->wsm_caps.status = WSM_GET16(buf);
818560424e9SKalle Valo priv->wsm_caps.fw_cap = WSM_GET16(buf);
819560424e9SKalle Valo priv->wsm_caps.fw_type = WSM_GET16(buf);
820560424e9SKalle Valo priv->wsm_caps.fw_api = WSM_GET16(buf);
821560424e9SKalle Valo priv->wsm_caps.fw_build = WSM_GET16(buf);
822560424e9SKalle Valo priv->wsm_caps.fw_ver = WSM_GET16(buf);
823560424e9SKalle Valo WSM_GET(buf, priv->wsm_caps.fw_label, sizeof(priv->wsm_caps.fw_label));
824560424e9SKalle Valo priv->wsm_caps.fw_label[sizeof(priv->wsm_caps.fw_label) - 1] = 0; /* Do not trust FW too much... */
825560424e9SKalle Valo
826560424e9SKalle Valo if (WARN_ON(priv->wsm_caps.status))
827560424e9SKalle Valo return -EINVAL;
828560424e9SKalle Valo
829560424e9SKalle Valo if (WARN_ON(priv->wsm_caps.fw_type > 4))
830560424e9SKalle Valo return -EINVAL;
831560424e9SKalle Valo
832560424e9SKalle Valo pr_info("CW1200 WSM init done.\n"
833560424e9SKalle Valo " Input buffers: %d x %d bytes\n"
834560424e9SKalle Valo " Hardware: %d.%d\n"
835560424e9SKalle Valo " %s firmware [%s], ver: %d, build: %d,"
836560424e9SKalle Valo " api: %d, cap: 0x%.4X\n",
837560424e9SKalle Valo priv->wsm_caps.input_buffers,
838560424e9SKalle Valo priv->wsm_caps.input_buffer_size,
839560424e9SKalle Valo priv->wsm_caps.hw_id, priv->wsm_caps.hw_subid,
840560424e9SKalle Valo cw1200_fw_types[priv->wsm_caps.fw_type],
841560424e9SKalle Valo priv->wsm_caps.fw_label, priv->wsm_caps.fw_ver,
842560424e9SKalle Valo priv->wsm_caps.fw_build,
843560424e9SKalle Valo priv->wsm_caps.fw_api, priv->wsm_caps.fw_cap);
844560424e9SKalle Valo
845560424e9SKalle Valo /* Disable unsupported frequency bands */
846560424e9SKalle Valo if (!(priv->wsm_caps.fw_cap & 0x1))
84757fbcce3SJohannes Berg priv->hw->wiphy->bands[NL80211_BAND_2GHZ] = NULL;
848560424e9SKalle Valo if (!(priv->wsm_caps.fw_cap & 0x2))
84957fbcce3SJohannes Berg priv->hw->wiphy->bands[NL80211_BAND_5GHZ] = NULL;
850560424e9SKalle Valo
851560424e9SKalle Valo priv->firmware_ready = 1;
852560424e9SKalle Valo wake_up(&priv->wsm_startup_done);
853560424e9SKalle Valo return 0;
854560424e9SKalle Valo
855560424e9SKalle Valo underflow:
856560424e9SKalle Valo WARN_ON(1);
857560424e9SKalle Valo return -EINVAL;
858560424e9SKalle Valo }
859560424e9SKalle Valo
wsm_receive_indication(struct cw1200_common * priv,int link_id,struct wsm_buf * buf,struct sk_buff ** skb_p)860560424e9SKalle Valo static int wsm_receive_indication(struct cw1200_common *priv,
861560424e9SKalle Valo int link_id,
862560424e9SKalle Valo struct wsm_buf *buf,
863560424e9SKalle Valo struct sk_buff **skb_p)
864560424e9SKalle Valo {
865560424e9SKalle Valo struct wsm_rx rx;
866560424e9SKalle Valo struct ieee80211_hdr *hdr;
867560424e9SKalle Valo size_t hdr_len;
868560424e9SKalle Valo __le16 fctl;
869560424e9SKalle Valo
870560424e9SKalle Valo rx.status = WSM_GET32(buf);
871560424e9SKalle Valo rx.channel_number = WSM_GET16(buf);
872560424e9SKalle Valo rx.rx_rate = WSM_GET8(buf);
873560424e9SKalle Valo rx.rcpi_rssi = WSM_GET8(buf);
874560424e9SKalle Valo rx.flags = WSM_GET32(buf);
875560424e9SKalle Valo
876560424e9SKalle Valo /* FW Workaround: Drop probe resp or
877560424e9SKalle Valo beacon when RSSI is 0
878560424e9SKalle Valo */
879560424e9SKalle Valo hdr = (struct ieee80211_hdr *)(*skb_p)->data;
880560424e9SKalle Valo
881560424e9SKalle Valo if (!rx.rcpi_rssi &&
882560424e9SKalle Valo (ieee80211_is_probe_resp(hdr->frame_control) ||
883560424e9SKalle Valo ieee80211_is_beacon(hdr->frame_control)))
884560424e9SKalle Valo return 0;
885560424e9SKalle Valo
886560424e9SKalle Valo /* If no RSSI subscription has been made,
887560424e9SKalle Valo * convert RCPI to RSSI here
888560424e9SKalle Valo */
889560424e9SKalle Valo if (!priv->cqm_use_rssi)
890560424e9SKalle Valo rx.rcpi_rssi = rx.rcpi_rssi / 2 - 110;
891560424e9SKalle Valo
892560424e9SKalle Valo fctl = *(__le16 *)buf->data;
893560424e9SKalle Valo hdr_len = buf->data - buf->begin;
894560424e9SKalle Valo skb_pull(*skb_p, hdr_len);
895560424e9SKalle Valo if (!rx.status && ieee80211_is_deauth(fctl)) {
896560424e9SKalle Valo if (priv->join_status == CW1200_JOIN_STATUS_STA) {
897560424e9SKalle Valo /* Shedule unjoin work */
898560424e9SKalle Valo pr_debug("[WSM] Issue unjoin command (RX).\n");
899560424e9SKalle Valo wsm_lock_tx_async(priv);
900560424e9SKalle Valo if (queue_work(priv->workqueue,
901560424e9SKalle Valo &priv->unjoin_work) <= 0)
902560424e9SKalle Valo wsm_unlock_tx(priv);
903560424e9SKalle Valo }
904560424e9SKalle Valo }
905560424e9SKalle Valo cw1200_rx_cb(priv, &rx, link_id, skb_p);
906560424e9SKalle Valo if (*skb_p)
907560424e9SKalle Valo skb_push(*skb_p, hdr_len);
908560424e9SKalle Valo
909560424e9SKalle Valo return 0;
910560424e9SKalle Valo
911560424e9SKalle Valo underflow:
912560424e9SKalle Valo return -EINVAL;
913560424e9SKalle Valo }
914560424e9SKalle Valo
wsm_event_indication(struct cw1200_common * priv,struct wsm_buf * buf)915560424e9SKalle Valo static int wsm_event_indication(struct cw1200_common *priv, struct wsm_buf *buf)
916560424e9SKalle Valo {
917560424e9SKalle Valo int first;
918560424e9SKalle Valo struct cw1200_wsm_event *event;
919560424e9SKalle Valo
920560424e9SKalle Valo if (priv->mode == NL80211_IFTYPE_UNSPECIFIED) {
921560424e9SKalle Valo /* STA is stopped. */
922560424e9SKalle Valo return 0;
923560424e9SKalle Valo }
924560424e9SKalle Valo
925560424e9SKalle Valo event = kzalloc(sizeof(struct cw1200_wsm_event), GFP_KERNEL);
926560424e9SKalle Valo if (!event)
927560424e9SKalle Valo return -ENOMEM;
928560424e9SKalle Valo
929560424e9SKalle Valo event->evt.id = WSM_GET32(buf);
930560424e9SKalle Valo event->evt.data = WSM_GET32(buf);
931560424e9SKalle Valo
932560424e9SKalle Valo pr_debug("[WSM] Event: %d(%d)\n",
933560424e9SKalle Valo event->evt.id, event->evt.data);
934560424e9SKalle Valo
935560424e9SKalle Valo spin_lock(&priv->event_queue_lock);
936560424e9SKalle Valo first = list_empty(&priv->event_queue);
937560424e9SKalle Valo list_add_tail(&event->link, &priv->event_queue);
938560424e9SKalle Valo spin_unlock(&priv->event_queue_lock);
939560424e9SKalle Valo
940560424e9SKalle Valo if (first)
941560424e9SKalle Valo queue_work(priv->workqueue, &priv->event_handler);
942560424e9SKalle Valo
943560424e9SKalle Valo return 0;
944560424e9SKalle Valo
945560424e9SKalle Valo underflow:
946560424e9SKalle Valo kfree(event);
947560424e9SKalle Valo return -EINVAL;
948560424e9SKalle Valo }
949560424e9SKalle Valo
wsm_channel_switch_indication(struct cw1200_common * priv,struct wsm_buf * buf)950560424e9SKalle Valo static int wsm_channel_switch_indication(struct cw1200_common *priv,
951560424e9SKalle Valo struct wsm_buf *buf)
952560424e9SKalle Valo {
953560424e9SKalle Valo WARN_ON(WSM_GET32(buf));
954560424e9SKalle Valo
955560424e9SKalle Valo priv->channel_switch_in_progress = 0;
956560424e9SKalle Valo wake_up(&priv->channel_switch_done);
957560424e9SKalle Valo
958560424e9SKalle Valo wsm_unlock_tx(priv);
959560424e9SKalle Valo
960560424e9SKalle Valo return 0;
961560424e9SKalle Valo
962560424e9SKalle Valo underflow:
963560424e9SKalle Valo return -EINVAL;
964560424e9SKalle Valo }
965560424e9SKalle Valo
wsm_set_pm_indication(struct cw1200_common * priv,struct wsm_buf * buf)966560424e9SKalle Valo static int wsm_set_pm_indication(struct cw1200_common *priv,
967560424e9SKalle Valo struct wsm_buf *buf)
968560424e9SKalle Valo {
969560424e9SKalle Valo /* TODO: Check buf (struct wsm_set_pm_complete) for validity */
970560424e9SKalle Valo if (priv->ps_mode_switch_in_progress) {
971560424e9SKalle Valo priv->ps_mode_switch_in_progress = 0;
972560424e9SKalle Valo wake_up(&priv->ps_mode_switch_done);
973560424e9SKalle Valo }
974560424e9SKalle Valo return 0;
975560424e9SKalle Valo }
976560424e9SKalle Valo
wsm_scan_started(struct cw1200_common * priv,void * arg,struct wsm_buf * buf)977560424e9SKalle Valo static int wsm_scan_started(struct cw1200_common *priv, void *arg,
978560424e9SKalle Valo struct wsm_buf *buf)
979560424e9SKalle Valo {
980560424e9SKalle Valo u32 status = WSM_GET32(buf);
981560424e9SKalle Valo if (status != WSM_STATUS_SUCCESS) {
982560424e9SKalle Valo cw1200_scan_failed_cb(priv);
983560424e9SKalle Valo return -EINVAL;
984560424e9SKalle Valo }
985560424e9SKalle Valo return 0;
986560424e9SKalle Valo
987560424e9SKalle Valo underflow:
988560424e9SKalle Valo WARN_ON(1);
989560424e9SKalle Valo return -EINVAL;
990560424e9SKalle Valo }
991560424e9SKalle Valo
wsm_scan_complete_indication(struct cw1200_common * priv,struct wsm_buf * buf)992560424e9SKalle Valo static int wsm_scan_complete_indication(struct cw1200_common *priv,
993560424e9SKalle Valo struct wsm_buf *buf)
994560424e9SKalle Valo {
995560424e9SKalle Valo struct wsm_scan_complete arg;
996560424e9SKalle Valo arg.status = WSM_GET32(buf);
997560424e9SKalle Valo arg.psm = WSM_GET8(buf);
998560424e9SKalle Valo arg.num_channels = WSM_GET8(buf);
999560424e9SKalle Valo cw1200_scan_complete_cb(priv, &arg);
1000560424e9SKalle Valo
1001560424e9SKalle Valo return 0;
1002560424e9SKalle Valo
1003560424e9SKalle Valo underflow:
1004560424e9SKalle Valo return -EINVAL;
1005560424e9SKalle Valo }
1006560424e9SKalle Valo
wsm_join_complete_indication(struct cw1200_common * priv,struct wsm_buf * buf)1007560424e9SKalle Valo static int wsm_join_complete_indication(struct cw1200_common *priv,
1008560424e9SKalle Valo struct wsm_buf *buf)
1009560424e9SKalle Valo {
1010560424e9SKalle Valo struct wsm_join_complete arg;
1011560424e9SKalle Valo arg.status = WSM_GET32(buf);
1012560424e9SKalle Valo pr_debug("[WSM] Join complete indication, status: %d\n", arg.status);
1013560424e9SKalle Valo cw1200_join_complete_cb(priv, &arg);
1014560424e9SKalle Valo
1015560424e9SKalle Valo return 0;
1016560424e9SKalle Valo
1017560424e9SKalle Valo underflow:
1018560424e9SKalle Valo return -EINVAL;
1019560424e9SKalle Valo }
1020560424e9SKalle Valo
wsm_find_complete_indication(struct cw1200_common * priv,struct wsm_buf * buf)1021560424e9SKalle Valo static int wsm_find_complete_indication(struct cw1200_common *priv,
1022560424e9SKalle Valo struct wsm_buf *buf)
1023560424e9SKalle Valo {
1024560424e9SKalle Valo pr_warn("Implement find_complete_indication\n");
1025560424e9SKalle Valo return 0;
1026560424e9SKalle Valo }
1027560424e9SKalle Valo
wsm_ba_timeout_indication(struct cw1200_common * priv,struct wsm_buf * buf)1028560424e9SKalle Valo static int wsm_ba_timeout_indication(struct cw1200_common *priv,
1029560424e9SKalle Valo struct wsm_buf *buf)
1030560424e9SKalle Valo {
1031560424e9SKalle Valo u8 tid;
1032560424e9SKalle Valo u8 addr[ETH_ALEN];
1033560424e9SKalle Valo
1034e2eb189eSLee Jones WSM_GET32(buf);
1035560424e9SKalle Valo tid = WSM_GET8(buf);
1036e2eb189eSLee Jones WSM_GET8(buf);
1037560424e9SKalle Valo WSM_GET(buf, addr, ETH_ALEN);
1038560424e9SKalle Valo
1039560424e9SKalle Valo pr_info("BlockACK timeout, tid %d, addr %pM\n",
1040560424e9SKalle Valo tid, addr);
1041560424e9SKalle Valo
1042560424e9SKalle Valo return 0;
1043560424e9SKalle Valo
1044560424e9SKalle Valo underflow:
1045560424e9SKalle Valo return -EINVAL;
1046560424e9SKalle Valo }
1047560424e9SKalle Valo
wsm_suspend_resume_indication(struct cw1200_common * priv,int link_id,struct wsm_buf * buf)1048560424e9SKalle Valo static int wsm_suspend_resume_indication(struct cw1200_common *priv,
1049560424e9SKalle Valo int link_id, struct wsm_buf *buf)
1050560424e9SKalle Valo {
1051560424e9SKalle Valo u32 flags;
1052560424e9SKalle Valo struct wsm_suspend_resume arg;
1053560424e9SKalle Valo
1054560424e9SKalle Valo flags = WSM_GET32(buf);
1055560424e9SKalle Valo arg.link_id = link_id;
1056560424e9SKalle Valo arg.stop = !(flags & 1);
1057560424e9SKalle Valo arg.multicast = !!(flags & 8);
1058560424e9SKalle Valo arg.queue = (flags >> 1) & 3;
1059560424e9SKalle Valo
1060560424e9SKalle Valo cw1200_suspend_resume(priv, &arg);
1061560424e9SKalle Valo
1062560424e9SKalle Valo return 0;
1063560424e9SKalle Valo
1064560424e9SKalle Valo underflow:
1065560424e9SKalle Valo return -EINVAL;
1066560424e9SKalle Valo }
1067560424e9SKalle Valo
1068560424e9SKalle Valo
1069560424e9SKalle Valo /* ******************************************************************** */
1070560424e9SKalle Valo /* WSM TX */
1071560424e9SKalle Valo
wsm_cmd_send(struct cw1200_common * priv,struct wsm_buf * buf,void * arg,u16 cmd,long tmo)1072560424e9SKalle Valo static int wsm_cmd_send(struct cw1200_common *priv,
1073560424e9SKalle Valo struct wsm_buf *buf,
1074560424e9SKalle Valo void *arg, u16 cmd, long tmo)
1075560424e9SKalle Valo {
1076560424e9SKalle Valo size_t buf_len = buf->data - buf->begin;
1077560424e9SKalle Valo int ret;
1078560424e9SKalle Valo
1079560424e9SKalle Valo /* Don't bother if we're dead. */
1080560424e9SKalle Valo if (priv->bh_error) {
1081560424e9SKalle Valo ret = 0;
1082560424e9SKalle Valo goto done;
1083560424e9SKalle Valo }
1084560424e9SKalle Valo
1085560424e9SKalle Valo /* Block until the cmd buffer is completed. Tortuous. */
1086560424e9SKalle Valo spin_lock(&priv->wsm_cmd.lock);
1087560424e9SKalle Valo while (!priv->wsm_cmd.done) {
1088560424e9SKalle Valo spin_unlock(&priv->wsm_cmd.lock);
1089560424e9SKalle Valo spin_lock(&priv->wsm_cmd.lock);
1090560424e9SKalle Valo }
1091560424e9SKalle Valo priv->wsm_cmd.done = 0;
1092560424e9SKalle Valo spin_unlock(&priv->wsm_cmd.lock);
1093560424e9SKalle Valo
1094560424e9SKalle Valo if (cmd == WSM_WRITE_MIB_REQ_ID ||
1095560424e9SKalle Valo cmd == WSM_READ_MIB_REQ_ID)
1096560424e9SKalle Valo pr_debug("[WSM] >>> 0x%.4X [MIB: 0x%.4X] (%zu)\n",
1097560424e9SKalle Valo cmd, __le16_to_cpu(((__le16 *)buf->begin)[2]),
1098560424e9SKalle Valo buf_len);
1099560424e9SKalle Valo else
1100560424e9SKalle Valo pr_debug("[WSM] >>> 0x%.4X (%zu)\n", cmd, buf_len);
1101560424e9SKalle Valo
1102560424e9SKalle Valo /* Due to buggy SPI on CW1200, we need to
1103560424e9SKalle Valo * pad the message by a few bytes to ensure
1104560424e9SKalle Valo * that it's completely received.
1105560424e9SKalle Valo */
1106560424e9SKalle Valo buf_len += 4;
1107560424e9SKalle Valo
1108560424e9SKalle Valo /* Fill HI message header */
1109560424e9SKalle Valo /* BH will add sequence number */
1110560424e9SKalle Valo ((__le16 *)buf->begin)[0] = __cpu_to_le16(buf_len);
1111560424e9SKalle Valo ((__le16 *)buf->begin)[1] = __cpu_to_le16(cmd);
1112560424e9SKalle Valo
1113560424e9SKalle Valo spin_lock(&priv->wsm_cmd.lock);
1114560424e9SKalle Valo BUG_ON(priv->wsm_cmd.ptr);
1115560424e9SKalle Valo priv->wsm_cmd.ptr = buf->begin;
1116560424e9SKalle Valo priv->wsm_cmd.len = buf_len;
1117560424e9SKalle Valo priv->wsm_cmd.arg = arg;
1118560424e9SKalle Valo priv->wsm_cmd.cmd = cmd;
1119560424e9SKalle Valo spin_unlock(&priv->wsm_cmd.lock);
1120560424e9SKalle Valo
1121560424e9SKalle Valo cw1200_bh_wakeup(priv);
1122560424e9SKalle Valo
1123560424e9SKalle Valo /* Wait for command completion */
1124560424e9SKalle Valo ret = wait_event_timeout(priv->wsm_cmd_wq,
1125560424e9SKalle Valo priv->wsm_cmd.done, tmo);
1126560424e9SKalle Valo
1127560424e9SKalle Valo if (!ret && !priv->wsm_cmd.done) {
1128560424e9SKalle Valo spin_lock(&priv->wsm_cmd.lock);
1129560424e9SKalle Valo priv->wsm_cmd.done = 1;
1130560424e9SKalle Valo priv->wsm_cmd.ptr = NULL;
1131560424e9SKalle Valo spin_unlock(&priv->wsm_cmd.lock);
1132560424e9SKalle Valo if (priv->bh_error) {
1133560424e9SKalle Valo /* Return ok to help system cleanup */
1134560424e9SKalle Valo ret = 0;
1135560424e9SKalle Valo } else {
1136560424e9SKalle Valo pr_err("CMD req (0x%04x) stuck in firmware, killing BH\n", priv->wsm_cmd.cmd);
1137560424e9SKalle Valo print_hex_dump_bytes("REQDUMP: ", DUMP_PREFIX_NONE,
1138560424e9SKalle Valo buf->begin, buf_len);
1139560424e9SKalle Valo pr_err("Outstanding outgoing frames: %d\n", priv->hw_bufs_used);
1140560424e9SKalle Valo
1141560424e9SKalle Valo /* Kill BH thread to report the error to the top layer. */
114207f995caSYejune Deng atomic_inc(&priv->bh_term);
1143560424e9SKalle Valo wake_up(&priv->bh_wq);
1144560424e9SKalle Valo ret = -ETIMEDOUT;
1145560424e9SKalle Valo }
1146560424e9SKalle Valo } else {
1147560424e9SKalle Valo spin_lock(&priv->wsm_cmd.lock);
1148560424e9SKalle Valo BUG_ON(!priv->wsm_cmd.done);
1149560424e9SKalle Valo ret = priv->wsm_cmd.ret;
1150560424e9SKalle Valo spin_unlock(&priv->wsm_cmd.lock);
1151560424e9SKalle Valo }
1152560424e9SKalle Valo done:
1153560424e9SKalle Valo wsm_buf_reset(buf);
1154560424e9SKalle Valo return ret;
1155560424e9SKalle Valo }
1156560424e9SKalle Valo
1157560424e9SKalle Valo /* ******************************************************************** */
1158560424e9SKalle Valo /* WSM TX port control */
1159560424e9SKalle Valo
wsm_lock_tx(struct cw1200_common * priv)1160560424e9SKalle Valo void wsm_lock_tx(struct cw1200_common *priv)
1161560424e9SKalle Valo {
1162560424e9SKalle Valo wsm_cmd_lock(priv);
116307f995caSYejune Deng if (atomic_inc_return(&priv->tx_lock) == 1) {
1164560424e9SKalle Valo if (wsm_flush_tx(priv))
1165560424e9SKalle Valo pr_debug("[WSM] TX is locked.\n");
1166560424e9SKalle Valo }
1167560424e9SKalle Valo wsm_cmd_unlock(priv);
1168560424e9SKalle Valo }
1169560424e9SKalle Valo
wsm_lock_tx_async(struct cw1200_common * priv)1170560424e9SKalle Valo void wsm_lock_tx_async(struct cw1200_common *priv)
1171560424e9SKalle Valo {
117207f995caSYejune Deng if (atomic_inc_return(&priv->tx_lock) == 1)
1173560424e9SKalle Valo pr_debug("[WSM] TX is locked (async).\n");
1174560424e9SKalle Valo }
1175560424e9SKalle Valo
wsm_flush_tx(struct cw1200_common * priv)1176560424e9SKalle Valo bool wsm_flush_tx(struct cw1200_common *priv)
1177560424e9SKalle Valo {
1178560424e9SKalle Valo unsigned long timestamp = jiffies;
1179560424e9SKalle Valo bool pending = false;
1180560424e9SKalle Valo long timeout;
1181560424e9SKalle Valo int i;
1182560424e9SKalle Valo
1183560424e9SKalle Valo /* Flush must be called with TX lock held. */
1184560424e9SKalle Valo BUG_ON(!atomic_read(&priv->tx_lock));
1185560424e9SKalle Valo
1186560424e9SKalle Valo /* First check if we really need to do something.
1187560424e9SKalle Valo * It is safe to use unprotected access, as hw_bufs_used
1188560424e9SKalle Valo * can only decrements.
1189560424e9SKalle Valo */
1190560424e9SKalle Valo if (!priv->hw_bufs_used)
1191560424e9SKalle Valo return true;
1192560424e9SKalle Valo
1193560424e9SKalle Valo if (priv->bh_error) {
1194560424e9SKalle Valo /* In case of failure do not wait for magic. */
1195560424e9SKalle Valo pr_err("[WSM] Fatal error occurred, will not flush TX.\n");
1196560424e9SKalle Valo return false;
1197560424e9SKalle Valo } else {
1198560424e9SKalle Valo /* Get a timestamp of "oldest" frame */
1199560424e9SKalle Valo for (i = 0; i < 4; ++i)
1200560424e9SKalle Valo pending |= cw1200_queue_get_xmit_timestamp(
1201560424e9SKalle Valo &priv->tx_queue[i],
1202560424e9SKalle Valo ×tamp, 0xffffffff);
1203560424e9SKalle Valo /* If there's nothing pending, we're good */
1204560424e9SKalle Valo if (!pending)
1205560424e9SKalle Valo return true;
1206560424e9SKalle Valo
1207560424e9SKalle Valo timeout = timestamp + WSM_CMD_LAST_CHANCE_TIMEOUT - jiffies;
1208560424e9SKalle Valo if (timeout < 0 || wait_event_timeout(priv->bh_evt_wq,
1209560424e9SKalle Valo !priv->hw_bufs_used,
1210560424e9SKalle Valo timeout) <= 0) {
1211560424e9SKalle Valo /* Hmmm... Not good. Frame had stuck in firmware. */
1212560424e9SKalle Valo priv->bh_error = 1;
1213560424e9SKalle Valo wiphy_err(priv->hw->wiphy, "[WSM] TX Frames (%d) stuck in firmware, killing BH\n", priv->hw_bufs_used);
1214560424e9SKalle Valo wake_up(&priv->bh_wq);
1215560424e9SKalle Valo return false;
1216560424e9SKalle Valo }
1217560424e9SKalle Valo
1218560424e9SKalle Valo /* Ok, everything is flushed. */
1219560424e9SKalle Valo return true;
1220560424e9SKalle Valo }
1221560424e9SKalle Valo }
1222560424e9SKalle Valo
wsm_unlock_tx(struct cw1200_common * priv)1223560424e9SKalle Valo void wsm_unlock_tx(struct cw1200_common *priv)
1224560424e9SKalle Valo {
1225560424e9SKalle Valo int tx_lock;
122607f995caSYejune Deng tx_lock = atomic_dec_return(&priv->tx_lock);
1227560424e9SKalle Valo BUG_ON(tx_lock < 0);
1228560424e9SKalle Valo
1229560424e9SKalle Valo if (tx_lock == 0) {
1230560424e9SKalle Valo if (!priv->bh_error)
1231560424e9SKalle Valo cw1200_bh_wakeup(priv);
1232560424e9SKalle Valo pr_debug("[WSM] TX is unlocked.\n");
1233560424e9SKalle Valo }
1234560424e9SKalle Valo }
1235560424e9SKalle Valo
1236560424e9SKalle Valo /* ******************************************************************** */
1237560424e9SKalle Valo /* WSM RX */
1238560424e9SKalle Valo
wsm_handle_exception(struct cw1200_common * priv,u8 * data,size_t len)1239560424e9SKalle Valo int wsm_handle_exception(struct cw1200_common *priv, u8 *data, size_t len)
1240560424e9SKalle Valo {
1241560424e9SKalle Valo struct wsm_buf buf;
1242560424e9SKalle Valo u32 reason;
1243560424e9SKalle Valo u32 reg[18];
1244560424e9SKalle Valo char fname[48];
1245560424e9SKalle Valo unsigned int i;
1246560424e9SKalle Valo
1247560424e9SKalle Valo static const char * const reason_str[] = {
1248560424e9SKalle Valo "undefined instruction",
1249560424e9SKalle Valo "prefetch abort",
1250560424e9SKalle Valo "data abort",
1251560424e9SKalle Valo "unknown error",
1252560424e9SKalle Valo };
1253560424e9SKalle Valo
1254560424e9SKalle Valo buf.begin = buf.data = data;
1255560424e9SKalle Valo buf.end = &buf.begin[len];
1256560424e9SKalle Valo
1257560424e9SKalle Valo reason = WSM_GET32(&buf);
1258560424e9SKalle Valo for (i = 0; i < ARRAY_SIZE(reg); ++i)
1259560424e9SKalle Valo reg[i] = WSM_GET32(&buf);
1260560424e9SKalle Valo WSM_GET(&buf, fname, sizeof(fname));
1261560424e9SKalle Valo
1262560424e9SKalle Valo if (reason < 4)
1263560424e9SKalle Valo wiphy_err(priv->hw->wiphy,
1264560424e9SKalle Valo "Firmware exception: %s.\n",
1265560424e9SKalle Valo reason_str[reason]);
1266560424e9SKalle Valo else
1267560424e9SKalle Valo wiphy_err(priv->hw->wiphy,
1268560424e9SKalle Valo "Firmware assert at %.*s, line %d\n",
1269560424e9SKalle Valo (int) sizeof(fname), fname, reg[1]);
1270560424e9SKalle Valo
1271560424e9SKalle Valo for (i = 0; i < 12; i += 4)
1272560424e9SKalle Valo wiphy_err(priv->hw->wiphy,
1273560424e9SKalle Valo "R%d: 0x%.8X, R%d: 0x%.8X, R%d: 0x%.8X, R%d: 0x%.8X,\n",
1274560424e9SKalle Valo i + 0, reg[i + 0], i + 1, reg[i + 1],
1275560424e9SKalle Valo i + 2, reg[i + 2], i + 3, reg[i + 3]);
1276560424e9SKalle Valo wiphy_err(priv->hw->wiphy,
1277560424e9SKalle Valo "R12: 0x%.8X, SP: 0x%.8X, LR: 0x%.8X, PC: 0x%.8X,\n",
1278560424e9SKalle Valo reg[i + 0], reg[i + 1], reg[i + 2], reg[i + 3]);
1279560424e9SKalle Valo i += 4;
1280560424e9SKalle Valo wiphy_err(priv->hw->wiphy,
1281560424e9SKalle Valo "CPSR: 0x%.8X, SPSR: 0x%.8X\n",
1282560424e9SKalle Valo reg[i + 0], reg[i + 1]);
1283560424e9SKalle Valo
1284560424e9SKalle Valo print_hex_dump_bytes("R1: ", DUMP_PREFIX_NONE,
1285560424e9SKalle Valo fname, sizeof(fname));
1286560424e9SKalle Valo return 0;
1287560424e9SKalle Valo
1288560424e9SKalle Valo underflow:
1289560424e9SKalle Valo wiphy_err(priv->hw->wiphy, "Firmware exception.\n");
1290560424e9SKalle Valo print_hex_dump_bytes("Exception: ", DUMP_PREFIX_NONE,
1291560424e9SKalle Valo data, len);
1292560424e9SKalle Valo return -EINVAL;
1293560424e9SKalle Valo }
1294560424e9SKalle Valo
wsm_handle_rx(struct cw1200_common * priv,u16 id,struct wsm_hdr * wsm,struct sk_buff ** skb_p)1295560424e9SKalle Valo int wsm_handle_rx(struct cw1200_common *priv, u16 id,
1296560424e9SKalle Valo struct wsm_hdr *wsm, struct sk_buff **skb_p)
1297560424e9SKalle Valo {
1298560424e9SKalle Valo int ret = 0;
1299560424e9SKalle Valo struct wsm_buf wsm_buf;
1300560424e9SKalle Valo int link_id = (id >> 6) & 0x0F;
1301560424e9SKalle Valo
1302560424e9SKalle Valo /* Strip link id. */
1303560424e9SKalle Valo id &= ~WSM_TX_LINK_ID(WSM_TX_LINK_ID_MAX);
1304560424e9SKalle Valo
1305560424e9SKalle Valo wsm_buf.begin = (u8 *)&wsm[0];
1306560424e9SKalle Valo wsm_buf.data = (u8 *)&wsm[1];
1307560424e9SKalle Valo wsm_buf.end = &wsm_buf.begin[__le16_to_cpu(wsm->len)];
1308560424e9SKalle Valo
1309560424e9SKalle Valo pr_debug("[WSM] <<< 0x%.4X (%td)\n", id,
1310560424e9SKalle Valo wsm_buf.end - wsm_buf.begin);
1311560424e9SKalle Valo
1312560424e9SKalle Valo if (id == WSM_TX_CONFIRM_IND_ID) {
1313560424e9SKalle Valo ret = wsm_tx_confirm(priv, &wsm_buf, link_id);
1314560424e9SKalle Valo } else if (id == WSM_MULTI_TX_CONFIRM_ID) {
1315560424e9SKalle Valo ret = wsm_multi_tx_confirm(priv, &wsm_buf, link_id);
1316560424e9SKalle Valo } else if (id & 0x0400) {
1317560424e9SKalle Valo void *wsm_arg;
1318560424e9SKalle Valo u16 wsm_cmd;
1319560424e9SKalle Valo
1320560424e9SKalle Valo /* Do not trust FW too much. Protection against repeated
1321560424e9SKalle Valo * response and race condition removal (see above).
1322560424e9SKalle Valo */
1323560424e9SKalle Valo spin_lock(&priv->wsm_cmd.lock);
1324560424e9SKalle Valo wsm_arg = priv->wsm_cmd.arg;
1325560424e9SKalle Valo wsm_cmd = priv->wsm_cmd.cmd &
1326560424e9SKalle Valo ~WSM_TX_LINK_ID(WSM_TX_LINK_ID_MAX);
1327560424e9SKalle Valo priv->wsm_cmd.cmd = 0xFFFF;
1328560424e9SKalle Valo spin_unlock(&priv->wsm_cmd.lock);
1329560424e9SKalle Valo
1330560424e9SKalle Valo if (WARN_ON((id & ~0x0400) != wsm_cmd)) {
1331560424e9SKalle Valo /* Note that any non-zero is a fatal retcode. */
1332560424e9SKalle Valo ret = -EINVAL;
1333560424e9SKalle Valo goto out;
1334560424e9SKalle Valo }
1335560424e9SKalle Valo
1336560424e9SKalle Valo /* Note that wsm_arg can be NULL in case of timeout in
1337560424e9SKalle Valo * wsm_cmd_send().
1338560424e9SKalle Valo */
1339560424e9SKalle Valo
1340560424e9SKalle Valo switch (id) {
1341560424e9SKalle Valo case WSM_READ_MIB_RESP_ID:
1342560424e9SKalle Valo if (wsm_arg)
1343560424e9SKalle Valo ret = wsm_read_mib_confirm(priv, wsm_arg,
1344560424e9SKalle Valo &wsm_buf);
1345560424e9SKalle Valo break;
1346560424e9SKalle Valo case WSM_WRITE_MIB_RESP_ID:
1347560424e9SKalle Valo if (wsm_arg)
1348560424e9SKalle Valo ret = wsm_write_mib_confirm(priv, wsm_arg,
1349560424e9SKalle Valo &wsm_buf);
1350560424e9SKalle Valo break;
1351560424e9SKalle Valo case WSM_START_SCAN_RESP_ID:
1352560424e9SKalle Valo if (wsm_arg)
1353560424e9SKalle Valo ret = wsm_scan_started(priv, wsm_arg, &wsm_buf);
1354560424e9SKalle Valo break;
1355560424e9SKalle Valo case WSM_CONFIGURATION_RESP_ID:
1356560424e9SKalle Valo if (wsm_arg)
1357560424e9SKalle Valo ret = wsm_configuration_confirm(priv, wsm_arg,
1358560424e9SKalle Valo &wsm_buf);
1359560424e9SKalle Valo break;
1360560424e9SKalle Valo case WSM_JOIN_RESP_ID:
1361560424e9SKalle Valo if (wsm_arg)
1362560424e9SKalle Valo ret = wsm_join_confirm(priv, wsm_arg, &wsm_buf);
1363560424e9SKalle Valo break;
1364560424e9SKalle Valo case WSM_STOP_SCAN_RESP_ID:
1365560424e9SKalle Valo case WSM_RESET_RESP_ID:
1366560424e9SKalle Valo case WSM_ADD_KEY_RESP_ID:
1367560424e9SKalle Valo case WSM_REMOVE_KEY_RESP_ID:
1368560424e9SKalle Valo case WSM_SET_PM_RESP_ID:
1369560424e9SKalle Valo case WSM_SET_BSS_PARAMS_RESP_ID:
1370560424e9SKalle Valo case 0x0412: /* set_tx_queue_params */
1371560424e9SKalle Valo case WSM_EDCA_PARAMS_RESP_ID:
1372560424e9SKalle Valo case WSM_SWITCH_CHANNEL_RESP_ID:
1373560424e9SKalle Valo case WSM_START_RESP_ID:
1374560424e9SKalle Valo case WSM_BEACON_TRANSMIT_RESP_ID:
1375560424e9SKalle Valo case 0x0419: /* start_find */
1376560424e9SKalle Valo case 0x041A: /* stop_find */
1377560424e9SKalle Valo case 0x041B: /* update_ie */
1378560424e9SKalle Valo case 0x041C: /* map_link */
1379560424e9SKalle Valo WARN_ON(wsm_arg != NULL);
1380560424e9SKalle Valo ret = wsm_generic_confirm(priv, wsm_arg, &wsm_buf);
1381560424e9SKalle Valo if (ret) {
1382560424e9SKalle Valo wiphy_warn(priv->hw->wiphy,
1383560424e9SKalle Valo "wsm_generic_confirm failed for request 0x%04x.\n",
1384560424e9SKalle Valo id & ~0x0400);
1385560424e9SKalle Valo
1386560424e9SKalle Valo /* often 0x407 and 0x410 occur, this means we're dead.. */
1387560424e9SKalle Valo if (priv->join_status >= CW1200_JOIN_STATUS_JOINING) {
1388560424e9SKalle Valo wsm_lock_tx(priv);
1389560424e9SKalle Valo if (queue_work(priv->workqueue, &priv->unjoin_work) <= 0)
1390560424e9SKalle Valo wsm_unlock_tx(priv);
1391560424e9SKalle Valo }
1392560424e9SKalle Valo }
1393560424e9SKalle Valo break;
1394560424e9SKalle Valo default:
1395560424e9SKalle Valo wiphy_warn(priv->hw->wiphy,
1396560424e9SKalle Valo "Unrecognized confirmation 0x%04x\n",
1397560424e9SKalle Valo id & ~0x0400);
1398560424e9SKalle Valo }
1399560424e9SKalle Valo
1400560424e9SKalle Valo spin_lock(&priv->wsm_cmd.lock);
1401560424e9SKalle Valo priv->wsm_cmd.ret = ret;
1402560424e9SKalle Valo priv->wsm_cmd.done = 1;
1403560424e9SKalle Valo spin_unlock(&priv->wsm_cmd.lock);
1404560424e9SKalle Valo
1405560424e9SKalle Valo ret = 0; /* Error response from device should ne stop BH. */
1406560424e9SKalle Valo
1407560424e9SKalle Valo wake_up(&priv->wsm_cmd_wq);
1408560424e9SKalle Valo } else if (id & 0x0800) {
1409560424e9SKalle Valo switch (id) {
1410560424e9SKalle Valo case WSM_STARTUP_IND_ID:
1411560424e9SKalle Valo ret = wsm_startup_indication(priv, &wsm_buf);
1412560424e9SKalle Valo break;
1413560424e9SKalle Valo case WSM_RECEIVE_IND_ID:
1414560424e9SKalle Valo ret = wsm_receive_indication(priv, link_id,
1415560424e9SKalle Valo &wsm_buf, skb_p);
1416560424e9SKalle Valo break;
1417560424e9SKalle Valo case 0x0805:
1418560424e9SKalle Valo ret = wsm_event_indication(priv, &wsm_buf);
1419560424e9SKalle Valo break;
1420560424e9SKalle Valo case WSM_SCAN_COMPLETE_IND_ID:
1421560424e9SKalle Valo ret = wsm_scan_complete_indication(priv, &wsm_buf);
1422560424e9SKalle Valo break;
1423560424e9SKalle Valo case 0x0808:
1424560424e9SKalle Valo ret = wsm_ba_timeout_indication(priv, &wsm_buf);
1425560424e9SKalle Valo break;
1426560424e9SKalle Valo case 0x0809:
1427560424e9SKalle Valo ret = wsm_set_pm_indication(priv, &wsm_buf);
1428560424e9SKalle Valo break;
1429560424e9SKalle Valo case 0x080A:
1430560424e9SKalle Valo ret = wsm_channel_switch_indication(priv, &wsm_buf);
1431560424e9SKalle Valo break;
1432560424e9SKalle Valo case 0x080B:
1433560424e9SKalle Valo ret = wsm_find_complete_indication(priv, &wsm_buf);
1434560424e9SKalle Valo break;
1435560424e9SKalle Valo case 0x080C:
1436560424e9SKalle Valo ret = wsm_suspend_resume_indication(priv,
1437560424e9SKalle Valo link_id, &wsm_buf);
1438560424e9SKalle Valo break;
1439560424e9SKalle Valo case 0x080F:
1440560424e9SKalle Valo ret = wsm_join_complete_indication(priv, &wsm_buf);
1441560424e9SKalle Valo break;
1442560424e9SKalle Valo default:
1443560424e9SKalle Valo pr_warn("Unrecognised WSM ID %04x\n", id);
1444560424e9SKalle Valo }
1445560424e9SKalle Valo } else {
1446560424e9SKalle Valo WARN_ON(1);
1447560424e9SKalle Valo ret = -EINVAL;
1448560424e9SKalle Valo }
1449560424e9SKalle Valo out:
1450560424e9SKalle Valo return ret;
1451560424e9SKalle Valo }
1452560424e9SKalle Valo
wsm_handle_tx_data(struct cw1200_common * priv,struct wsm_tx * wsm,const struct ieee80211_tx_info * tx_info,const struct cw1200_txpriv * txpriv,struct cw1200_queue * queue)1453560424e9SKalle Valo static bool wsm_handle_tx_data(struct cw1200_common *priv,
1454560424e9SKalle Valo struct wsm_tx *wsm,
1455560424e9SKalle Valo const struct ieee80211_tx_info *tx_info,
1456560424e9SKalle Valo const struct cw1200_txpriv *txpriv,
1457560424e9SKalle Valo struct cw1200_queue *queue)
1458560424e9SKalle Valo {
1459560424e9SKalle Valo bool handled = false;
1460560424e9SKalle Valo const struct ieee80211_hdr *frame =
1461560424e9SKalle Valo (struct ieee80211_hdr *)&((u8 *)wsm)[txpriv->offset];
1462560424e9SKalle Valo __le16 fctl = frame->frame_control;
1463560424e9SKalle Valo enum {
1464560424e9SKalle Valo do_probe,
1465560424e9SKalle Valo do_drop,
1466560424e9SKalle Valo do_wep,
1467560424e9SKalle Valo do_tx,
1468560424e9SKalle Valo } action = do_tx;
1469560424e9SKalle Valo
1470560424e9SKalle Valo switch (priv->mode) {
1471560424e9SKalle Valo case NL80211_IFTYPE_STATION:
1472560424e9SKalle Valo if (priv->join_status == CW1200_JOIN_STATUS_MONITOR)
1473560424e9SKalle Valo action = do_tx;
1474560424e9SKalle Valo else if (priv->join_status < CW1200_JOIN_STATUS_PRE_STA)
1475560424e9SKalle Valo action = do_drop;
1476560424e9SKalle Valo break;
1477560424e9SKalle Valo case NL80211_IFTYPE_AP:
1478560424e9SKalle Valo if (!priv->join_status) {
1479560424e9SKalle Valo action = do_drop;
1480560424e9SKalle Valo } else if (!(BIT(txpriv->raw_link_id) &
1481560424e9SKalle Valo (BIT(0) | priv->link_id_map))) {
1482560424e9SKalle Valo wiphy_warn(priv->hw->wiphy,
1483560424e9SKalle Valo "A frame with expired link id is dropped.\n");
1484560424e9SKalle Valo action = do_drop;
1485560424e9SKalle Valo }
1486560424e9SKalle Valo if (cw1200_queue_get_generation(wsm->packet_id) >
1487560424e9SKalle Valo CW1200_MAX_REQUEUE_ATTEMPTS) {
1488560424e9SKalle Valo /* HACK!!! WSM324 firmware has tendency to requeue
1489560424e9SKalle Valo * multicast frames in a loop, causing performance
1490560424e9SKalle Valo * drop and high power consumption of the driver.
1491560424e9SKalle Valo * In this situation it is better just to drop
1492560424e9SKalle Valo * the problematic frame.
1493560424e9SKalle Valo */
1494560424e9SKalle Valo wiphy_warn(priv->hw->wiphy,
1495560424e9SKalle Valo "Too many attempts to requeue a frame; dropped.\n");
1496560424e9SKalle Valo action = do_drop;
1497560424e9SKalle Valo }
1498560424e9SKalle Valo break;
1499560424e9SKalle Valo case NL80211_IFTYPE_ADHOC:
1500560424e9SKalle Valo if (priv->join_status != CW1200_JOIN_STATUS_IBSS)
1501560424e9SKalle Valo action = do_drop;
1502560424e9SKalle Valo break;
1503560424e9SKalle Valo case NL80211_IFTYPE_MESH_POINT:
1504560424e9SKalle Valo action = do_tx; /* TODO: Test me! */
1505560424e9SKalle Valo break;
1506560424e9SKalle Valo case NL80211_IFTYPE_MONITOR:
1507560424e9SKalle Valo default:
1508560424e9SKalle Valo action = do_drop;
1509560424e9SKalle Valo break;
1510560424e9SKalle Valo }
1511560424e9SKalle Valo
1512560424e9SKalle Valo if (action == do_tx) {
1513560424e9SKalle Valo if (ieee80211_is_nullfunc(fctl)) {
1514560424e9SKalle Valo spin_lock(&priv->bss_loss_lock);
1515560424e9SKalle Valo if (priv->bss_loss_state) {
1516560424e9SKalle Valo priv->bss_loss_confirm_id = wsm->packet_id;
1517560424e9SKalle Valo wsm->queue_id = WSM_QUEUE_VOICE;
1518560424e9SKalle Valo }
1519560424e9SKalle Valo spin_unlock(&priv->bss_loss_lock);
1520560424e9SKalle Valo } else if (ieee80211_is_probe_req(fctl)) {
1521560424e9SKalle Valo action = do_probe;
1522560424e9SKalle Valo } else if (ieee80211_is_deauth(fctl) &&
1523560424e9SKalle Valo priv->mode != NL80211_IFTYPE_AP) {
1524560424e9SKalle Valo pr_debug("[WSM] Issue unjoin command due to tx deauth.\n");
1525560424e9SKalle Valo wsm_lock_tx_async(priv);
1526560424e9SKalle Valo if (queue_work(priv->workqueue,
1527560424e9SKalle Valo &priv->unjoin_work) <= 0)
1528560424e9SKalle Valo wsm_unlock_tx(priv);
1529560424e9SKalle Valo } else if (ieee80211_has_protected(fctl) &&
1530560424e9SKalle Valo tx_info->control.hw_key &&
1531560424e9SKalle Valo tx_info->control.hw_key->keyidx != priv->wep_default_key_id &&
1532560424e9SKalle Valo (tx_info->control.hw_key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
1533560424e9SKalle Valo tx_info->control.hw_key->cipher == WLAN_CIPHER_SUITE_WEP104)) {
1534560424e9SKalle Valo action = do_wep;
1535560424e9SKalle Valo }
1536560424e9SKalle Valo }
1537560424e9SKalle Valo
1538560424e9SKalle Valo switch (action) {
1539560424e9SKalle Valo case do_probe:
1540560424e9SKalle Valo /* An interesting FW "feature". Device filters probe responses.
1541560424e9SKalle Valo * The easiest way to get it back is to convert
1542560424e9SKalle Valo * probe request into WSM start_scan command.
1543560424e9SKalle Valo */
1544560424e9SKalle Valo pr_debug("[WSM] Convert probe request to scan.\n");
1545560424e9SKalle Valo wsm_lock_tx_async(priv);
1546560424e9SKalle Valo priv->pending_frame_id = wsm->packet_id;
1547560424e9SKalle Valo if (queue_delayed_work(priv->workqueue,
1548560424e9SKalle Valo &priv->scan.probe_work, 0) <= 0)
1549560424e9SKalle Valo wsm_unlock_tx(priv);
1550560424e9SKalle Valo handled = true;
1551560424e9SKalle Valo break;
1552560424e9SKalle Valo case do_drop:
1553560424e9SKalle Valo pr_debug("[WSM] Drop frame (0x%.4X).\n", fctl);
1554560424e9SKalle Valo BUG_ON(cw1200_queue_remove(queue, wsm->packet_id));
1555560424e9SKalle Valo handled = true;
1556560424e9SKalle Valo break;
1557560424e9SKalle Valo case do_wep:
1558560424e9SKalle Valo pr_debug("[WSM] Issue set_default_wep_key.\n");
1559560424e9SKalle Valo wsm_lock_tx_async(priv);
1560560424e9SKalle Valo priv->wep_default_key_id = tx_info->control.hw_key->keyidx;
1561560424e9SKalle Valo priv->pending_frame_id = wsm->packet_id;
1562560424e9SKalle Valo if (queue_work(priv->workqueue, &priv->wep_key_work) <= 0)
1563560424e9SKalle Valo wsm_unlock_tx(priv);
1564560424e9SKalle Valo handled = true;
1565560424e9SKalle Valo break;
1566560424e9SKalle Valo case do_tx:
1567560424e9SKalle Valo pr_debug("[WSM] Transmit frame.\n");
1568560424e9SKalle Valo break;
1569560424e9SKalle Valo default:
1570560424e9SKalle Valo /* Do nothing */
1571560424e9SKalle Valo break;
1572560424e9SKalle Valo }
1573560424e9SKalle Valo return handled;
1574560424e9SKalle Valo }
1575560424e9SKalle Valo
cw1200_get_prio_queue(struct cw1200_common * priv,u32 link_id_map,int * total)1576560424e9SKalle Valo static int cw1200_get_prio_queue(struct cw1200_common *priv,
1577560424e9SKalle Valo u32 link_id_map, int *total)
1578560424e9SKalle Valo {
1579560424e9SKalle Valo static const int urgent = BIT(CW1200_LINK_ID_AFTER_DTIM) |
1580560424e9SKalle Valo BIT(CW1200_LINK_ID_UAPSD);
1581560424e9SKalle Valo struct wsm_edca_queue_params *edca;
1582560424e9SKalle Valo unsigned score, best = -1;
1583560424e9SKalle Valo int winner = -1;
1584560424e9SKalle Valo int queued;
1585560424e9SKalle Valo int i;
1586560424e9SKalle Valo
1587560424e9SKalle Valo /* search for a winner using edca params */
1588560424e9SKalle Valo for (i = 0; i < 4; ++i) {
1589560424e9SKalle Valo queued = cw1200_queue_get_num_queued(&priv->tx_queue[i],
1590560424e9SKalle Valo link_id_map);
1591560424e9SKalle Valo if (!queued)
1592560424e9SKalle Valo continue;
1593560424e9SKalle Valo *total += queued;
1594560424e9SKalle Valo edca = &priv->edca.params[i];
1595560424e9SKalle Valo score = ((edca->aifns + edca->cwmin) << 16) +
1596560424e9SKalle Valo ((edca->cwmax - edca->cwmin) *
1597*7e3cf084SJason A. Donenfeld get_random_u16());
1598560424e9SKalle Valo if (score < best && (winner < 0 || i != 3)) {
1599560424e9SKalle Valo best = score;
1600560424e9SKalle Valo winner = i;
1601560424e9SKalle Valo }
1602560424e9SKalle Valo }
1603560424e9SKalle Valo
1604560424e9SKalle Valo /* override winner if bursting */
1605560424e9SKalle Valo if (winner >= 0 && priv->tx_burst_idx >= 0 &&
1606560424e9SKalle Valo winner != priv->tx_burst_idx &&
1607560424e9SKalle Valo !cw1200_queue_get_num_queued(
1608560424e9SKalle Valo &priv->tx_queue[winner],
1609560424e9SKalle Valo link_id_map & urgent) &&
1610560424e9SKalle Valo cw1200_queue_get_num_queued(
1611560424e9SKalle Valo &priv->tx_queue[priv->tx_burst_idx],
1612560424e9SKalle Valo link_id_map))
1613560424e9SKalle Valo winner = priv->tx_burst_idx;
1614560424e9SKalle Valo
1615560424e9SKalle Valo return winner;
1616560424e9SKalle Valo }
1617560424e9SKalle Valo
wsm_get_tx_queue_and_mask(struct cw1200_common * priv,struct cw1200_queue ** queue_p,u32 * tx_allowed_mask_p,bool * more)1618560424e9SKalle Valo static int wsm_get_tx_queue_and_mask(struct cw1200_common *priv,
1619560424e9SKalle Valo struct cw1200_queue **queue_p,
1620560424e9SKalle Valo u32 *tx_allowed_mask_p,
1621560424e9SKalle Valo bool *more)
1622560424e9SKalle Valo {
1623560424e9SKalle Valo int idx;
1624560424e9SKalle Valo u32 tx_allowed_mask;
1625560424e9SKalle Valo int total = 0;
1626560424e9SKalle Valo
1627560424e9SKalle Valo /* Search for a queue with multicast frames buffered */
1628560424e9SKalle Valo if (priv->tx_multicast) {
1629560424e9SKalle Valo tx_allowed_mask = BIT(CW1200_LINK_ID_AFTER_DTIM);
1630560424e9SKalle Valo idx = cw1200_get_prio_queue(priv,
1631560424e9SKalle Valo tx_allowed_mask, &total);
1632560424e9SKalle Valo if (idx >= 0) {
1633560424e9SKalle Valo *more = total > 1;
1634560424e9SKalle Valo goto found;
1635560424e9SKalle Valo }
1636560424e9SKalle Valo }
1637560424e9SKalle Valo
1638560424e9SKalle Valo /* Search for unicast traffic */
1639560424e9SKalle Valo tx_allowed_mask = ~priv->sta_asleep_mask;
1640560424e9SKalle Valo tx_allowed_mask |= BIT(CW1200_LINK_ID_UAPSD);
1641560424e9SKalle Valo if (priv->sta_asleep_mask) {
1642560424e9SKalle Valo tx_allowed_mask |= priv->pspoll_mask;
1643560424e9SKalle Valo tx_allowed_mask &= ~BIT(CW1200_LINK_ID_AFTER_DTIM);
1644560424e9SKalle Valo } else {
1645560424e9SKalle Valo tx_allowed_mask |= BIT(CW1200_LINK_ID_AFTER_DTIM);
1646560424e9SKalle Valo }
1647560424e9SKalle Valo idx = cw1200_get_prio_queue(priv,
1648560424e9SKalle Valo tx_allowed_mask, &total);
1649560424e9SKalle Valo if (idx < 0)
1650560424e9SKalle Valo return -ENOENT;
1651560424e9SKalle Valo
1652560424e9SKalle Valo found:
1653560424e9SKalle Valo *queue_p = &priv->tx_queue[idx];
1654560424e9SKalle Valo *tx_allowed_mask_p = tx_allowed_mask;
1655560424e9SKalle Valo return 0;
1656560424e9SKalle Valo }
1657560424e9SKalle Valo
wsm_get_tx(struct cw1200_common * priv,u8 ** data,size_t * tx_len,int * burst)1658560424e9SKalle Valo int wsm_get_tx(struct cw1200_common *priv, u8 **data,
1659560424e9SKalle Valo size_t *tx_len, int *burst)
1660560424e9SKalle Valo {
1661560424e9SKalle Valo struct wsm_tx *wsm = NULL;
1662560424e9SKalle Valo struct ieee80211_tx_info *tx_info;
1663560424e9SKalle Valo struct cw1200_queue *queue = NULL;
1664560424e9SKalle Valo int queue_num;
1665560424e9SKalle Valo u32 tx_allowed_mask = 0;
1666560424e9SKalle Valo const struct cw1200_txpriv *txpriv = NULL;
1667560424e9SKalle Valo int count = 0;
1668560424e9SKalle Valo
1669560424e9SKalle Valo /* More is used only for broadcasts. */
1670560424e9SKalle Valo bool more = false;
1671560424e9SKalle Valo
1672560424e9SKalle Valo if (priv->wsm_cmd.ptr) { /* CMD request */
1673560424e9SKalle Valo ++count;
1674560424e9SKalle Valo spin_lock(&priv->wsm_cmd.lock);
1675560424e9SKalle Valo BUG_ON(!priv->wsm_cmd.ptr);
1676560424e9SKalle Valo *data = priv->wsm_cmd.ptr;
1677560424e9SKalle Valo *tx_len = priv->wsm_cmd.len;
1678560424e9SKalle Valo *burst = 1;
1679560424e9SKalle Valo spin_unlock(&priv->wsm_cmd.lock);
1680560424e9SKalle Valo } else {
1681560424e9SKalle Valo for (;;) {
1682560424e9SKalle Valo int ret;
1683560424e9SKalle Valo
1684560424e9SKalle Valo if (atomic_add_return(0, &priv->tx_lock))
1685560424e9SKalle Valo break;
1686560424e9SKalle Valo
1687560424e9SKalle Valo spin_lock_bh(&priv->ps_state_lock);
1688560424e9SKalle Valo
1689560424e9SKalle Valo ret = wsm_get_tx_queue_and_mask(priv, &queue,
1690560424e9SKalle Valo &tx_allowed_mask, &more);
1691560424e9SKalle Valo queue_num = queue - priv->tx_queue;
1692560424e9SKalle Valo
1693560424e9SKalle Valo if (priv->buffered_multicasts &&
1694560424e9SKalle Valo (ret || !more) &&
1695560424e9SKalle Valo (priv->tx_multicast || !priv->sta_asleep_mask)) {
1696560424e9SKalle Valo priv->buffered_multicasts = false;
1697560424e9SKalle Valo if (priv->tx_multicast) {
1698560424e9SKalle Valo priv->tx_multicast = false;
1699560424e9SKalle Valo queue_work(priv->workqueue,
1700560424e9SKalle Valo &priv->multicast_stop_work);
1701560424e9SKalle Valo }
1702560424e9SKalle Valo }
1703560424e9SKalle Valo
1704560424e9SKalle Valo spin_unlock_bh(&priv->ps_state_lock);
1705560424e9SKalle Valo
1706560424e9SKalle Valo if (ret)
1707560424e9SKalle Valo break;
1708560424e9SKalle Valo
1709560424e9SKalle Valo if (cw1200_queue_get(queue,
1710560424e9SKalle Valo tx_allowed_mask,
1711560424e9SKalle Valo &wsm, &tx_info, &txpriv))
1712560424e9SKalle Valo continue;
1713560424e9SKalle Valo
1714560424e9SKalle Valo if (wsm_handle_tx_data(priv, wsm,
1715560424e9SKalle Valo tx_info, txpriv, queue))
1716560424e9SKalle Valo continue; /* Handled by WSM */
1717560424e9SKalle Valo
1718560424e9SKalle Valo wsm->hdr.id &= __cpu_to_le16(
1719560424e9SKalle Valo ~WSM_TX_LINK_ID(WSM_TX_LINK_ID_MAX));
1720560424e9SKalle Valo wsm->hdr.id |= cpu_to_le16(
1721560424e9SKalle Valo WSM_TX_LINK_ID(txpriv->raw_link_id));
1722560424e9SKalle Valo priv->pspoll_mask &= ~BIT(txpriv->raw_link_id);
1723560424e9SKalle Valo
1724560424e9SKalle Valo *data = (u8 *)wsm;
1725560424e9SKalle Valo *tx_len = __le16_to_cpu(wsm->hdr.len);
1726560424e9SKalle Valo
1727560424e9SKalle Valo /* allow bursting if txop is set */
1728560424e9SKalle Valo if (priv->edca.params[queue_num].txop_limit)
1729560424e9SKalle Valo *burst = min(*burst,
1730560424e9SKalle Valo (int)cw1200_queue_get_num_queued(queue, tx_allowed_mask) + 1);
1731560424e9SKalle Valo else
1732560424e9SKalle Valo *burst = 1;
1733560424e9SKalle Valo
1734560424e9SKalle Valo /* store index of bursting queue */
1735560424e9SKalle Valo if (*burst > 1)
1736560424e9SKalle Valo priv->tx_burst_idx = queue_num;
1737560424e9SKalle Valo else
1738560424e9SKalle Valo priv->tx_burst_idx = -1;
1739560424e9SKalle Valo
1740560424e9SKalle Valo if (more) {
1741560424e9SKalle Valo struct ieee80211_hdr *hdr =
1742560424e9SKalle Valo (struct ieee80211_hdr *)
1743560424e9SKalle Valo &((u8 *)wsm)[txpriv->offset];
1744560424e9SKalle Valo /* more buffered multicast/broadcast frames
1745560424e9SKalle Valo * ==> set MoreData flag in IEEE 802.11 header
1746560424e9SKalle Valo * to inform PS STAs
1747560424e9SKalle Valo */
1748560424e9SKalle Valo hdr->frame_control |=
1749560424e9SKalle Valo cpu_to_le16(IEEE80211_FCTL_MOREDATA);
1750560424e9SKalle Valo }
1751560424e9SKalle Valo
1752560424e9SKalle Valo pr_debug("[WSM] >>> 0x%.4X (%zu) %p %c\n",
1753560424e9SKalle Valo 0x0004, *tx_len, *data,
1754560424e9SKalle Valo wsm->more ? 'M' : ' ');
1755560424e9SKalle Valo ++count;
1756560424e9SKalle Valo break;
1757560424e9SKalle Valo }
1758560424e9SKalle Valo }
1759560424e9SKalle Valo
1760560424e9SKalle Valo return count;
1761560424e9SKalle Valo }
1762560424e9SKalle Valo
wsm_txed(struct cw1200_common * priv,u8 * data)1763560424e9SKalle Valo void wsm_txed(struct cw1200_common *priv, u8 *data)
1764560424e9SKalle Valo {
1765560424e9SKalle Valo if (data == priv->wsm_cmd.ptr) {
1766560424e9SKalle Valo spin_lock(&priv->wsm_cmd.lock);
1767560424e9SKalle Valo priv->wsm_cmd.ptr = NULL;
1768560424e9SKalle Valo spin_unlock(&priv->wsm_cmd.lock);
1769560424e9SKalle Valo }
1770560424e9SKalle Valo }
1771560424e9SKalle Valo
1772560424e9SKalle Valo /* ******************************************************************** */
1773560424e9SKalle Valo /* WSM buffer */
1774560424e9SKalle Valo
wsm_buf_init(struct wsm_buf * buf)1775560424e9SKalle Valo void wsm_buf_init(struct wsm_buf *buf)
1776560424e9SKalle Valo {
1777560424e9SKalle Valo BUG_ON(buf->begin);
1778560424e9SKalle Valo buf->begin = kmalloc(FWLOAD_BLOCK_SIZE, GFP_KERNEL | GFP_DMA);
1779560424e9SKalle Valo buf->end = buf->begin ? &buf->begin[FWLOAD_BLOCK_SIZE] : buf->begin;
1780560424e9SKalle Valo wsm_buf_reset(buf);
1781560424e9SKalle Valo }
1782560424e9SKalle Valo
wsm_buf_deinit(struct wsm_buf * buf)1783560424e9SKalle Valo void wsm_buf_deinit(struct wsm_buf *buf)
1784560424e9SKalle Valo {
1785560424e9SKalle Valo kfree(buf->begin);
1786560424e9SKalle Valo buf->begin = buf->data = buf->end = NULL;
1787560424e9SKalle Valo }
1788560424e9SKalle Valo
wsm_buf_reset(struct wsm_buf * buf)1789560424e9SKalle Valo static void wsm_buf_reset(struct wsm_buf *buf)
1790560424e9SKalle Valo {
1791560424e9SKalle Valo if (buf->begin) {
1792560424e9SKalle Valo buf->data = &buf->begin[4];
1793560424e9SKalle Valo *(u32 *)buf->begin = 0;
1794560424e9SKalle Valo } else {
1795560424e9SKalle Valo buf->data = buf->begin;
1796560424e9SKalle Valo }
1797560424e9SKalle Valo }
1798560424e9SKalle Valo
wsm_buf_reserve(struct wsm_buf * buf,size_t extra_size)1799560424e9SKalle Valo static int wsm_buf_reserve(struct wsm_buf *buf, size_t extra_size)
1800560424e9SKalle Valo {
1801560424e9SKalle Valo size_t pos = buf->data - buf->begin;
1802560424e9SKalle Valo size_t size = pos + extra_size;
18039afdd612SJohannes Thumshirn u8 *tmp;
1804560424e9SKalle Valo
1805560424e9SKalle Valo size = round_up(size, FWLOAD_BLOCK_SIZE);
1806560424e9SKalle Valo
18079afdd612SJohannes Thumshirn tmp = krealloc(buf->begin, size, GFP_KERNEL | GFP_DMA);
18089afdd612SJohannes Thumshirn if (!tmp) {
18099afdd612SJohannes Thumshirn wsm_buf_deinit(buf);
18109afdd612SJohannes Thumshirn return -ENOMEM;
18119afdd612SJohannes Thumshirn }
18129afdd612SJohannes Thumshirn
18139afdd612SJohannes Thumshirn buf->begin = tmp;
1814560424e9SKalle Valo buf->data = &buf->begin[pos];
1815560424e9SKalle Valo buf->end = &buf->begin[size];
1816560424e9SKalle Valo return 0;
1817560424e9SKalle Valo }
1818