1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * This file is part of wl1271 |
4 | * |
5 | * Copyright (C) 2009 Nokia Corporation |
6 | * |
7 | * Contact: Luciano Coelho <luciano.coelho@nokia.com> |
8 | */ |
9 | |
10 | #include <linux/gfp.h> |
11 | #include <linux/sched.h> |
12 | |
13 | #include "wlcore.h" |
14 | #include "debug.h" |
15 | #include "acx.h" |
16 | #include "rx.h" |
17 | #include "tx.h" |
18 | #include "io.h" |
19 | #include "hw_ops.h" |
20 | |
21 | /* |
22 | * TODO: this is here just for now, it must be removed when the data |
23 | * operations are in place. |
24 | */ |
25 | #include "../wl12xx/reg.h" |
26 | |
27 | static u32 wlcore_rx_get_buf_size(struct wl1271 *wl, |
28 | u32 rx_pkt_desc) |
29 | { |
30 | if (wl->quirks & WLCORE_QUIRK_RX_BLOCKSIZE_ALIGN) |
31 | return (rx_pkt_desc & ALIGNED_RX_BUF_SIZE_MASK) >> |
32 | ALIGNED_RX_BUF_SIZE_SHIFT; |
33 | |
34 | return (rx_pkt_desc & RX_BUF_SIZE_MASK) >> RX_BUF_SIZE_SHIFT_DIV; |
35 | } |
36 | |
37 | static u32 wlcore_rx_get_align_buf_size(struct wl1271 *wl, u32 pkt_len) |
38 | { |
39 | if (wl->quirks & WLCORE_QUIRK_RX_BLOCKSIZE_ALIGN) |
40 | return ALIGN(pkt_len, WL12XX_BUS_BLOCK_SIZE); |
41 | |
42 | return pkt_len; |
43 | } |
44 | |
45 | static void wl1271_rx_status(struct wl1271 *wl, |
46 | struct wl1271_rx_descriptor *desc, |
47 | struct ieee80211_rx_status *status, |
48 | u8 beacon, u8 probe_rsp) |
49 | { |
50 | memset(status, 0, sizeof(struct ieee80211_rx_status)); |
51 | |
52 | if ((desc->flags & WL1271_RX_DESC_BAND_MASK) == WL1271_RX_DESC_BAND_BG) |
53 | status->band = NL80211_BAND_2GHZ; |
54 | else |
55 | status->band = NL80211_BAND_5GHZ; |
56 | |
57 | status->rate_idx = wlcore_rate_to_idx(wl, rate: desc->rate, band: status->band); |
58 | |
59 | /* 11n support */ |
60 | if (desc->rate <= wl->hw_min_ht_rate) |
61 | status->encoding = RX_ENC_HT; |
62 | |
63 | /* |
64 | * Read the signal level and antenna diversity indication. |
65 | * The msb in the signal level is always set as it is a |
66 | * negative number. |
67 | * The antenna indication is the msb of the rssi. |
68 | */ |
69 | status->signal = ((desc->rssi & RSSI_LEVEL_BITMASK) | BIT(7)); |
70 | status->antenna = ((desc->rssi & ANT_DIVERSITY_BITMASK) >> 7); |
71 | |
72 | /* |
73 | * FIXME: In wl1251, the SNR should be divided by two. In wl1271 we |
74 | * need to divide by two for now, but TI has been discussing about |
75 | * changing it. This needs to be rechecked. |
76 | */ |
77 | wl->noise = desc->rssi - (desc->snr >> 1); |
78 | |
79 | status->freq = ieee80211_channel_to_frequency(chan: desc->channel, |
80 | band: status->band); |
81 | |
82 | if (desc->flags & WL1271_RX_DESC_ENCRYPT_MASK) { |
83 | u8 desc_err_code = desc->status & WL1271_RX_DESC_STATUS_MASK; |
84 | |
85 | status->flag |= RX_FLAG_IV_STRIPPED | RX_FLAG_MMIC_STRIPPED | |
86 | RX_FLAG_DECRYPTED; |
87 | |
88 | if (unlikely(desc_err_code & WL1271_RX_DESC_MIC_FAIL)) { |
89 | status->flag |= RX_FLAG_MMIC_ERROR; |
90 | wl1271_warning("Michael MIC error. Desc: 0x%x" , |
91 | desc_err_code); |
92 | } |
93 | } |
94 | |
95 | if (beacon || probe_rsp) |
96 | status->boottime_ns = ktime_get_boottime_ns(); |
97 | |
98 | if (beacon) |
99 | wlcore_set_pending_regdomain_ch(wl, channel: (u16)desc->channel, |
100 | band: status->band); |
101 | } |
102 | |
103 | static int wl1271_rx_handle_data(struct wl1271 *wl, u8 *data, u32 length, |
104 | enum wl_rx_buf_align rx_align, u8 *hlid) |
105 | { |
106 | struct wl1271_rx_descriptor *desc; |
107 | struct sk_buff *skb; |
108 | struct ieee80211_hdr *hdr; |
109 | u8 beacon = 0; |
110 | u8 is_data = 0; |
111 | u8 reserved = 0, offset_to_data = 0; |
112 | u16 seq_num; |
113 | u32 pkt_data_len; |
114 | |
115 | /* |
116 | * In PLT mode we seem to get frames and mac80211 warns about them, |
117 | * workaround this by not retrieving them at all. |
118 | */ |
119 | if (unlikely(wl->plt)) |
120 | return -EINVAL; |
121 | |
122 | pkt_data_len = wlcore_hw_get_rx_packet_len(wl, rx_data: data, data_len: length); |
123 | if (!pkt_data_len) { |
124 | wl1271_error("Invalid packet arrived from HW. length %d" , |
125 | length); |
126 | return -EINVAL; |
127 | } |
128 | |
129 | if (rx_align == WLCORE_RX_BUF_UNALIGNED) |
130 | reserved = RX_BUF_ALIGN; |
131 | else if (rx_align == WLCORE_RX_BUF_PADDED) |
132 | offset_to_data = RX_BUF_ALIGN; |
133 | |
134 | /* the data read starts with the descriptor */ |
135 | desc = (struct wl1271_rx_descriptor *) data; |
136 | |
137 | if (desc->packet_class == WL12XX_RX_CLASS_LOGGER) { |
138 | size_t len = length - sizeof(*desc); |
139 | wl12xx_copy_fwlog(wl, memblock: data + sizeof(*desc), maxlen: len); |
140 | return 0; |
141 | } |
142 | |
143 | /* discard corrupted packets */ |
144 | if (desc->status & WL1271_RX_DESC_DECRYPT_FAIL) { |
145 | hdr = (void *)(data + sizeof(*desc) + offset_to_data); |
146 | wl1271_warning("corrupted packet in RX: status: 0x%x len: %d" , |
147 | desc->status & WL1271_RX_DESC_STATUS_MASK, |
148 | pkt_data_len); |
149 | wl1271_dump((DEBUG_RX|DEBUG_CMD), "PKT: " , data + sizeof(*desc), |
150 | min(pkt_data_len, |
151 | ieee80211_hdrlen(hdr->frame_control))); |
152 | return -EINVAL; |
153 | } |
154 | |
155 | /* skb length not including rx descriptor */ |
156 | skb = __dev_alloc_skb(length: pkt_data_len + reserved, GFP_KERNEL); |
157 | if (!skb) { |
158 | wl1271_error("Couldn't allocate RX frame" ); |
159 | return -ENOMEM; |
160 | } |
161 | |
162 | /* reserve the unaligned payload(if any) */ |
163 | skb_reserve(skb, len: reserved); |
164 | |
165 | /* |
166 | * Copy packets from aggregation buffer to the skbs without rx |
167 | * descriptor and with packet payload aligned care. In case of unaligned |
168 | * packets copy the packets in offset of 2 bytes guarantee IP header |
169 | * payload aligned to 4 bytes. |
170 | */ |
171 | skb_put_data(skb, data: data + sizeof(*desc), len: pkt_data_len); |
172 | if (rx_align == WLCORE_RX_BUF_PADDED) |
173 | skb_pull(skb, RX_BUF_ALIGN); |
174 | |
175 | *hlid = desc->hlid; |
176 | |
177 | hdr = (struct ieee80211_hdr *)skb->data; |
178 | if (ieee80211_is_beacon(fc: hdr->frame_control)) |
179 | beacon = 1; |
180 | if (ieee80211_is_data_present(fc: hdr->frame_control)) |
181 | is_data = 1; |
182 | |
183 | wl1271_rx_status(wl, desc, status: IEEE80211_SKB_RXCB(skb), beacon, |
184 | probe_rsp: ieee80211_is_probe_resp(fc: hdr->frame_control)); |
185 | wlcore_hw_set_rx_csum(wl, desc, skb); |
186 | |
187 | seq_num = (le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_SEQ) >> 4; |
188 | wl1271_debug(DEBUG_RX, "rx skb 0x%p: %d B %s seq %d hlid %d" , skb, |
189 | skb->len - desc->pad_len, |
190 | beacon ? "beacon" : "" , |
191 | seq_num, *hlid); |
192 | |
193 | skb_queue_tail(list: &wl->deferred_rx_queue, newsk: skb); |
194 | queue_work(wq: wl->freezable_wq, work: &wl->netstack_work); |
195 | |
196 | return is_data; |
197 | } |
198 | |
199 | int wlcore_rx(struct wl1271 *wl, struct wl_fw_status *status) |
200 | { |
201 | unsigned long active_hlids[BITS_TO_LONGS(WLCORE_MAX_LINKS)] = {0}; |
202 | u32 buf_size; |
203 | u32 fw_rx_counter = status->fw_rx_counter % wl->num_rx_desc; |
204 | u32 drv_rx_counter = wl->rx_counter % wl->num_rx_desc; |
205 | u32 rx_counter; |
206 | u32 pkt_len, align_pkt_len; |
207 | u32 pkt_offset, des; |
208 | u8 hlid; |
209 | enum wl_rx_buf_align rx_align; |
210 | int ret = 0; |
211 | |
212 | /* update rates per link */ |
213 | hlid = status->counters.hlid; |
214 | |
215 | if (hlid < WLCORE_MAX_LINKS) |
216 | wl->links[hlid].fw_rate_mbps = |
217 | status->counters.tx_last_rate_mbps; |
218 | |
219 | while (drv_rx_counter != fw_rx_counter) { |
220 | buf_size = 0; |
221 | rx_counter = drv_rx_counter; |
222 | while (rx_counter != fw_rx_counter) { |
223 | des = le32_to_cpu(status->rx_pkt_descs[rx_counter]); |
224 | pkt_len = wlcore_rx_get_buf_size(wl, rx_pkt_desc: des); |
225 | align_pkt_len = wlcore_rx_get_align_buf_size(wl, |
226 | pkt_len); |
227 | if (buf_size + align_pkt_len > wl->aggr_buf_size) |
228 | break; |
229 | buf_size += align_pkt_len; |
230 | rx_counter++; |
231 | rx_counter %= wl->num_rx_desc; |
232 | } |
233 | |
234 | if (buf_size == 0) { |
235 | wl1271_warning("received empty data" ); |
236 | break; |
237 | } |
238 | |
239 | /* Read all available packets at once */ |
240 | des = le32_to_cpu(status->rx_pkt_descs[drv_rx_counter]); |
241 | ret = wlcore_hw_prepare_read(wl, rx_desc: des, len: buf_size); |
242 | if (ret < 0) |
243 | goto out; |
244 | |
245 | ret = wlcore_read_data(wl, reg: REG_SLV_MEM_DATA, buf: wl->aggr_buf, |
246 | len: buf_size, fixed: true); |
247 | if (ret < 0) |
248 | goto out; |
249 | |
250 | /* Split data into separate packets */ |
251 | pkt_offset = 0; |
252 | while (pkt_offset < buf_size) { |
253 | des = le32_to_cpu(status->rx_pkt_descs[drv_rx_counter]); |
254 | pkt_len = wlcore_rx_get_buf_size(wl, rx_pkt_desc: des); |
255 | rx_align = wlcore_hw_get_rx_buf_align(wl, rx_desc: des); |
256 | |
257 | /* |
258 | * the handle data call can only fail in memory-outage |
259 | * conditions, in that case the received frame will just |
260 | * be dropped. |
261 | */ |
262 | if (wl1271_rx_handle_data(wl, |
263 | data: wl->aggr_buf + pkt_offset, |
264 | length: pkt_len, rx_align, |
265 | hlid: &hlid) == 1) { |
266 | if (hlid < wl->num_links) |
267 | __set_bit(hlid, active_hlids); |
268 | else |
269 | WARN(1, |
270 | "hlid (%d) exceeded MAX_LINKS\n" , |
271 | hlid); |
272 | } |
273 | |
274 | wl->rx_counter++; |
275 | drv_rx_counter++; |
276 | drv_rx_counter %= wl->num_rx_desc; |
277 | pkt_offset += wlcore_rx_get_align_buf_size(wl, pkt_len); |
278 | } |
279 | } |
280 | |
281 | /* |
282 | * Write the driver's packet counter to the FW. This is only required |
283 | * for older hardware revisions |
284 | */ |
285 | if (wl->quirks & WLCORE_QUIRK_END_OF_TRANSACTION) { |
286 | ret = wlcore_write32(wl, WL12XX_REG_RX_DRIVER_COUNTER, |
287 | val: wl->rx_counter); |
288 | if (ret < 0) |
289 | goto out; |
290 | } |
291 | |
292 | wl12xx_rearm_rx_streaming(wl, active_hlids); |
293 | |
294 | out: |
295 | return ret; |
296 | } |
297 | |
298 | #ifdef CONFIG_PM |
299 | int wl1271_rx_filter_enable(struct wl1271 *wl, |
300 | int index, bool enable, |
301 | struct wl12xx_rx_filter *filter) |
302 | { |
303 | int ret; |
304 | |
305 | if (!!test_bit(index, wl->rx_filter_enabled) == enable) { |
306 | wl1271_warning("Request to enable an already " |
307 | "enabled rx filter %d" , index); |
308 | return 0; |
309 | } |
310 | |
311 | ret = wl1271_acx_set_rx_filter(wl, index, enable, filter); |
312 | |
313 | if (ret) { |
314 | wl1271_error("Failed to %s rx data filter %d (err=%d)" , |
315 | enable ? "enable" : "disable" , index, ret); |
316 | return ret; |
317 | } |
318 | |
319 | if (enable) |
320 | __set_bit(index, wl->rx_filter_enabled); |
321 | else |
322 | __clear_bit(index, wl->rx_filter_enabled); |
323 | |
324 | return 0; |
325 | } |
326 | |
327 | int wl1271_rx_filter_clear_all(struct wl1271 *wl) |
328 | { |
329 | int i, ret = 0; |
330 | |
331 | for (i = 0; i < WL1271_MAX_RX_FILTERS; i++) { |
332 | if (!test_bit(i, wl->rx_filter_enabled)) |
333 | continue; |
334 | ret = wl1271_rx_filter_enable(wl, index: i, enable: 0, NULL); |
335 | if (ret) |
336 | goto out; |
337 | } |
338 | |
339 | out: |
340 | return ret; |
341 | } |
342 | #endif /* CONFIG_PM */ |
343 | |