Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/* Copyright (C) 2022 MediaTek Inc.
3 *
4 * Author: Lorenzo Bianconi <lorenzo@kernel.org>
5 * Sujuan Chen <sujuan.chen@mediatek.com>
6 */
7
8#include <linux/firmware.h>
9#include <linux/of_address.h>
10#include <linux/of_reserved_mem.h>
11#include <linux/mfd/syscon.h>
12#include <linux/soc/mediatek/mtk_wed.h>
13#include <asm/unaligned.h>
14
15#include "mtk_wed_regs.h"
16#include "mtk_wed_wo.h"
17#include "mtk_wed.h"
18
19static struct mtk_wed_wo_memory_region mem_region[] = {
20 [MTK_WED_WO_REGION_EMI] = {
21 .name = "wo-emi",
22 },
23 [MTK_WED_WO_REGION_ILM] = {
24 .name = "wo-ilm",
25 },
26 [MTK_WED_WO_REGION_DATA] = {
27 .name = "wo-data",
28 .shared = true,
29 },
30 [MTK_WED_WO_REGION_BOOT] = {
31 .name = "wo-boot",
32 },
33};
34
35static u32 wo_r32(u32 reg)
36{
37 return readl(mem_region[MTK_WED_WO_REGION_BOOT].addr + reg);
38}
39
40static void wo_w32(u32 reg, u32 val)
41{
42 writel(val, mem_region[MTK_WED_WO_REGION_BOOT].addr + reg);
43}
44
45static struct sk_buff *
46mtk_wed_mcu_msg_alloc(const void *data, int data_len)
47{
48 int length = sizeof(struct mtk_wed_mcu_hdr) + data_len;
49 struct sk_buff *skb;
50
51 skb = alloc_skb(length, GFP_KERNEL);
52 if (!skb)
53 return NULL;
54
55 memset(skb->head, 0, length);
56 skb_reserve(skb, sizeof(struct mtk_wed_mcu_hdr));
57 if (data && data_len)
58 skb_put_data(skb, data, data_len);
59
60 return skb;
61}
62
63static struct sk_buff *
64mtk_wed_mcu_get_response(struct mtk_wed_wo *wo, unsigned long expires)
65{
66 if (!time_is_after_jiffies(expires))
67 return NULL;
68
69 wait_event_timeout(wo->mcu.wait, !skb_queue_empty(&wo->mcu.res_q),
70 expires - jiffies);
71 return skb_dequeue(&wo->mcu.res_q);
72}
73
74void mtk_wed_mcu_rx_event(struct mtk_wed_wo *wo, struct sk_buff *skb)
75{
76 skb_queue_tail(&wo->mcu.res_q, skb);
77 wake_up(&wo->mcu.wait);
78}
79
80static void
81mtk_wed_update_rx_stats(struct mtk_wed_device *wed, struct sk_buff *skb)
82{
83 u32 count = get_unaligned_le32(skb->data);
84 struct mtk_wed_wo_rx_stats *stats;
85 int i;
86
87 if (!wed->wlan.update_wo_rx_stats)
88 return;
89
90 if (count * sizeof(*stats) > skb->len - sizeof(u32))
91 return;
92
93 stats = (struct mtk_wed_wo_rx_stats *)(skb->data + sizeof(u32));
94 for (i = 0 ; i < count ; i++)
95 wed->wlan.update_wo_rx_stats(wed, &stats[i]);
96}
97
98void mtk_wed_mcu_rx_unsolicited_event(struct mtk_wed_wo *wo,
99 struct sk_buff *skb)
100{
101 struct mtk_wed_mcu_hdr *hdr = (struct mtk_wed_mcu_hdr *)skb->data;
102
103 skb_pull(skb, sizeof(*hdr));
104
105 switch (hdr->cmd) {
106 case MTK_WED_WO_EVT_LOG_DUMP:
107 dev_notice(wo->hw->dev, "%s\n", skb->data);
108 break;
109 case MTK_WED_WO_EVT_PROFILING: {
110 struct mtk_wed_wo_log_info *info = (void *)skb->data;
111 u32 count = skb->len / sizeof(*info);
112 int i;
113
114 for (i = 0 ; i < count ; i++)
115 dev_notice(wo->hw->dev,
116 "SN:%u latency: total=%u, rro:%u, mod:%u\n",
117 le32_to_cpu(info[i].sn),
118 le32_to_cpu(info[i].total),
119 le32_to_cpu(info[i].rro),
120 le32_to_cpu(info[i].mod));
121 break;
122 }
123 case MTK_WED_WO_EVT_RXCNT_INFO:
124 mtk_wed_update_rx_stats(wo->hw->wed_dev, skb);
125 break;
126 default:
127 break;
128 }
129
130 dev_kfree_skb(skb);
131}
132
133static int
134mtk_wed_mcu_skb_send_msg(struct mtk_wed_wo *wo, struct sk_buff *skb,
135 int id, int cmd, u16 *wait_seq, bool wait_resp)
136{
137 struct mtk_wed_mcu_hdr *hdr;
138
139 /* TODO: make it dynamic based on cmd */
140 wo->mcu.timeout = 20 * HZ;
141
142 hdr = (struct mtk_wed_mcu_hdr *)skb_push(skb, sizeof(*hdr));
143 hdr->cmd = cmd;
144 hdr->length = cpu_to_le16(skb->len);
145
146 if (wait_resp && wait_seq) {
147 u16 seq = ++wo->mcu.seq;
148
149 if (!seq)
150 seq = ++wo->mcu.seq;
151 *wait_seq = seq;
152
153 hdr->flag |= cpu_to_le16(MTK_WED_WARP_CMD_FLAG_NEED_RSP);
154 hdr->seq = cpu_to_le16(seq);
155 }
156 if (id == MTK_WED_MODULE_ID_WO)
157 hdr->flag |= cpu_to_le16(MTK_WED_WARP_CMD_FLAG_FROM_TO_WO);
158
159 return mtk_wed_wo_queue_tx_skb(wo, &wo->q_tx, skb);
160}
161
162static int
163mtk_wed_mcu_parse_response(struct mtk_wed_wo *wo, struct sk_buff *skb,
164 int cmd, int seq)
165{
166 struct mtk_wed_mcu_hdr *hdr;
167
168 if (!skb) {
169 dev_err(wo->hw->dev, "Message %08x (seq %d) timeout\n",
170 cmd, seq);
171 return -ETIMEDOUT;
172 }
173
174 hdr = (struct mtk_wed_mcu_hdr *)skb->data;
175 if (le16_to_cpu(hdr->seq) != seq)
176 return -EAGAIN;
177
178 skb_pull(skb, sizeof(*hdr));
179 switch (cmd) {
180 case MTK_WED_WO_CMD_RXCNT_INFO:
181 mtk_wed_update_rx_stats(wo->hw->wed_dev, skb);
182 break;
183 default:
184 break;
185 }
186
187 return 0;
188}
189
190int mtk_wed_mcu_send_msg(struct mtk_wed_wo *wo, int id, int cmd,
191 const void *data, int len, bool wait_resp)
192{
193 unsigned long expires;
194 struct sk_buff *skb;
195 u16 seq;
196 int ret;
197
198 skb = mtk_wed_mcu_msg_alloc(data, len);
199 if (!skb)
200 return -ENOMEM;
201
202 mutex_lock(&wo->mcu.mutex);
203
204 ret = mtk_wed_mcu_skb_send_msg(wo, skb, id, cmd, &seq, wait_resp);
205 if (ret || !wait_resp)
206 goto unlock;
207
208 expires = jiffies + wo->mcu.timeout;
209 do {
210 skb = mtk_wed_mcu_get_response(wo, expires);
211 ret = mtk_wed_mcu_parse_response(wo, skb, cmd, seq);
212 dev_kfree_skb(skb);
213 } while (ret == -EAGAIN);
214
215unlock:
216 mutex_unlock(&wo->mcu.mutex);
217
218 return ret;
219}
220
221int mtk_wed_mcu_msg_update(struct mtk_wed_device *dev, int id, void *data,
222 int len)
223{
224 struct mtk_wed_wo *wo = dev->hw->wed_wo;
225
226 if (!mtk_wed_get_rx_capa(dev))
227 return 0;
228
229 if (WARN_ON(!wo))
230 return -ENODEV;
231
232 return mtk_wed_mcu_send_msg(wo, MTK_WED_MODULE_ID_WO, id, data, len,
233 true);
234}
235
236static int
237mtk_wed_get_memory_region(struct mtk_wed_hw *hw, int index,
238 struct mtk_wed_wo_memory_region *region)
239{
240 struct reserved_mem *rmem;
241 struct device_node *np;
242
243 np = of_parse_phandle(hw->node, "memory-region", index);
244 if (!np)
245 return -ENODEV;
246
247 rmem = of_reserved_mem_lookup(np);
248 of_node_put(np);
249
250 if (!rmem)
251 return -ENODEV;
252
253 region->phy_addr = rmem->base;
254 region->size = rmem->size;
255 region->addr = devm_ioremap(hw->dev, region->phy_addr, region->size);
256
257 return !region->addr ? -EINVAL : 0;
258}
259
260static int
261mtk_wed_mcu_run_firmware(struct mtk_wed_wo *wo, const struct firmware *fw)
262{
263 const u8 *first_region_ptr, *region_ptr, *trailer_ptr, *ptr = fw->data;
264 const struct mtk_wed_fw_trailer *trailer;
265 const struct mtk_wed_fw_region *fw_region;
266
267 trailer_ptr = fw->data + fw->size - sizeof(*trailer);
268 trailer = (const struct mtk_wed_fw_trailer *)trailer_ptr;
269 region_ptr = trailer_ptr - trailer->num_region * sizeof(*fw_region);
270 first_region_ptr = region_ptr;
271
272 while (region_ptr < trailer_ptr) {
273 u32 length;
274 int i;
275
276 fw_region = (const struct mtk_wed_fw_region *)region_ptr;
277 length = le32_to_cpu(fw_region->len);
278 if (first_region_ptr < ptr + length)
279 goto next;
280
281 for (i = 0; i < ARRAY_SIZE(mem_region); i++) {
282 struct mtk_wed_wo_memory_region *region;
283
284 region = &mem_region[i];
285 if (region->phy_addr != le32_to_cpu(fw_region->addr))
286 continue;
287
288 if (region->size < length)
289 continue;
290
291 if (region->shared && region->consumed)
292 break;
293
294 if (!region->shared || !region->consumed) {
295 memcpy_toio(region->addr, ptr, length);
296 region->consumed = true;
297 break;
298 }
299 }
300
301 if (i == ARRAY_SIZE(mem_region))
302 return -EINVAL;
303next:
304 region_ptr += sizeof(*fw_region);
305 ptr += length;
306 }
307
308 return 0;
309}
310
311static int
312mtk_wed_mcu_load_firmware(struct mtk_wed_wo *wo)
313{
314 const struct mtk_wed_fw_trailer *trailer;
315 const struct firmware *fw;
316 const char *fw_name;
317 u32 val, boot_cr;
318 int ret, i;
319
320 /* load firmware region metadata */
321 for (i = 0; i < ARRAY_SIZE(mem_region); i++) {
322 int index = of_property_match_string(wo->hw->node,
323 "memory-region-names",
324 mem_region[i].name);
325 if (index < 0)
326 continue;
327
328 ret = mtk_wed_get_memory_region(wo->hw, index, &mem_region[i]);
329 if (ret)
330 return ret;
331 }
332
333 /* set dummy cr */
334 wed_w32(wo->hw->wed_dev, MTK_WED_SCR0 + 4 * MTK_WED_DUMMY_CR_FWDL,
335 wo->hw->index + 1);
336
337 /* load firmware */
338 switch (wo->hw->version) {
339 case 2:
340 if (of_device_is_compatible(wo->hw->node,
341 "mediatek,mt7981-wed"))
342 fw_name = MT7981_FIRMWARE_WO;
343 else
344 fw_name = wo->hw->index ? MT7986_FIRMWARE_WO1
345 : MT7986_FIRMWARE_WO0;
346 break;
347 case 3:
348 fw_name = wo->hw->index ? MT7988_FIRMWARE_WO1
349 : MT7988_FIRMWARE_WO0;
350 break;
351 default:
352 return -EINVAL;
353 }
354
355 ret = request_firmware(&fw, fw_name, wo->hw->dev);
356 if (ret)
357 return ret;
358
359 trailer = (void *)(fw->data + fw->size -
360 sizeof(struct mtk_wed_fw_trailer));
361 dev_info(wo->hw->dev,
362 "MTK WED WO Firmware Version: %.10s, Build Time: %.15s\n",
363 trailer->fw_ver, trailer->build_date);
364 dev_info(wo->hw->dev, "MTK WED WO Chip ID %02x Region %d\n",
365 trailer->chip_id, trailer->num_region);
366
367 ret = mtk_wed_mcu_run_firmware(wo, fw);
368 if (ret)
369 goto out;
370
371 /* set the start address */
372 if (!mtk_wed_is_v3_or_greater(wo->hw) && wo->hw->index)
373 boot_cr = MTK_WO_MCU_CFG_LS_WA_BOOT_ADDR_ADDR;
374 else
375 boot_cr = MTK_WO_MCU_CFG_LS_WM_BOOT_ADDR_ADDR;
376 wo_w32(boot_cr, mem_region[MTK_WED_WO_REGION_EMI].phy_addr >> 16);
377 /* wo firmware reset */
378 wo_w32(MTK_WO_MCU_CFG_LS_WF_MCCR_CLR_ADDR, 0xc00);
379
380 val = wo_r32(MTK_WO_MCU_CFG_LS_WF_MCU_CFG_WM_WA_ADDR) |
381 MTK_WO_MCU_CFG_LS_WF_WM_WA_WM_CPU_RSTB_MASK;
382 wo_w32(MTK_WO_MCU_CFG_LS_WF_MCU_CFG_WM_WA_ADDR, val);
383out:
384 release_firmware(fw);
385
386 return ret;
387}
388
389static u32
390mtk_wed_mcu_read_fw_dl(struct mtk_wed_wo *wo)
391{
392 return wed_r32(wo->hw->wed_dev,
393 MTK_WED_SCR0 + 4 * MTK_WED_DUMMY_CR_FWDL);
394}
395
396int mtk_wed_mcu_init(struct mtk_wed_wo *wo)
397{
398 u32 val;
399 int ret;
400
401 skb_queue_head_init(&wo->mcu.res_q);
402 init_waitqueue_head(&wo->mcu.wait);
403 mutex_init(&wo->mcu.mutex);
404
405 ret = mtk_wed_mcu_load_firmware(wo);
406 if (ret)
407 return ret;
408
409 return readx_poll_timeout(mtk_wed_mcu_read_fw_dl, wo, val, !val,
410 100, MTK_FW_DL_TIMEOUT);
411}
412
413MODULE_FIRMWARE(MT7981_FIRMWARE_WO);
414MODULE_FIRMWARE(MT7986_FIRMWARE_WO0);
415MODULE_FIRMWARE(MT7986_FIRMWARE_WO1);
416MODULE_FIRMWARE(MT7988_FIRMWARE_WO0);
417MODULE_FIRMWARE(MT7988_FIRMWARE_WO1);
1// SPDX-License-Identifier: GPL-2.0-only
2/* Copyright (C) 2022 MediaTek Inc.
3 *
4 * Author: Lorenzo Bianconi <lorenzo@kernel.org>
5 * Sujuan Chen <sujuan.chen@mediatek.com>
6 */
7
8#include <linux/firmware.h>
9#include <linux/of_address.h>
10#include <linux/of_reserved_mem.h>
11#include <linux/mfd/syscon.h>
12#include <linux/soc/mediatek/mtk_wed.h>
13#include <asm/unaligned.h>
14
15#include "mtk_wed_regs.h"
16#include "mtk_wed_wo.h"
17#include "mtk_wed.h"
18
19static u32 wo_r32(struct mtk_wed_wo *wo, u32 reg)
20{
21 return readl(wo->boot.addr + reg);
22}
23
24static void wo_w32(struct mtk_wed_wo *wo, u32 reg, u32 val)
25{
26 writel(val, wo->boot.addr + reg);
27}
28
29static struct sk_buff *
30mtk_wed_mcu_msg_alloc(const void *data, int data_len)
31{
32 int length = sizeof(struct mtk_wed_mcu_hdr) + data_len;
33 struct sk_buff *skb;
34
35 skb = alloc_skb(length, GFP_KERNEL);
36 if (!skb)
37 return NULL;
38
39 memset(skb->head, 0, length);
40 skb_reserve(skb, sizeof(struct mtk_wed_mcu_hdr));
41 if (data && data_len)
42 skb_put_data(skb, data, data_len);
43
44 return skb;
45}
46
47static struct sk_buff *
48mtk_wed_mcu_get_response(struct mtk_wed_wo *wo, unsigned long expires)
49{
50 if (!time_is_after_jiffies(expires))
51 return NULL;
52
53 wait_event_timeout(wo->mcu.wait, !skb_queue_empty(&wo->mcu.res_q),
54 expires - jiffies);
55 return skb_dequeue(&wo->mcu.res_q);
56}
57
58void mtk_wed_mcu_rx_event(struct mtk_wed_wo *wo, struct sk_buff *skb)
59{
60 skb_queue_tail(&wo->mcu.res_q, skb);
61 wake_up(&wo->mcu.wait);
62}
63
64static void
65mtk_wed_update_rx_stats(struct mtk_wed_device *wed, struct sk_buff *skb)
66{
67 u32 count = get_unaligned_le32(skb->data);
68 struct mtk_wed_wo_rx_stats *stats;
69 int i;
70
71 if (count * sizeof(*stats) > skb->len - sizeof(u32))
72 return;
73
74 stats = (struct mtk_wed_wo_rx_stats *)(skb->data + sizeof(u32));
75 for (i = 0 ; i < count ; i++)
76 wed->wlan.update_wo_rx_stats(wed, &stats[i]);
77}
78
79void mtk_wed_mcu_rx_unsolicited_event(struct mtk_wed_wo *wo,
80 struct sk_buff *skb)
81{
82 struct mtk_wed_mcu_hdr *hdr = (struct mtk_wed_mcu_hdr *)skb->data;
83
84 skb_pull(skb, sizeof(*hdr));
85
86 switch (hdr->cmd) {
87 case MTK_WED_WO_EVT_LOG_DUMP:
88 dev_notice(wo->hw->dev, "%s\n", skb->data);
89 break;
90 case MTK_WED_WO_EVT_PROFILING: {
91 struct mtk_wed_wo_log_info *info = (void *)skb->data;
92 u32 count = skb->len / sizeof(*info);
93 int i;
94
95 for (i = 0 ; i < count ; i++)
96 dev_notice(wo->hw->dev,
97 "SN:%u latency: total=%u, rro:%u, mod:%u\n",
98 le32_to_cpu(info[i].sn),
99 le32_to_cpu(info[i].total),
100 le32_to_cpu(info[i].rro),
101 le32_to_cpu(info[i].mod));
102 break;
103 }
104 case MTK_WED_WO_EVT_RXCNT_INFO:
105 mtk_wed_update_rx_stats(wo->hw->wed_dev, skb);
106 break;
107 default:
108 break;
109 }
110
111 dev_kfree_skb(skb);
112}
113
114static int
115mtk_wed_mcu_skb_send_msg(struct mtk_wed_wo *wo, struct sk_buff *skb,
116 int id, int cmd, u16 *wait_seq, bool wait_resp)
117{
118 struct mtk_wed_mcu_hdr *hdr;
119
120 /* TODO: make it dynamic based on cmd */
121 wo->mcu.timeout = 20 * HZ;
122
123 hdr = (struct mtk_wed_mcu_hdr *)skb_push(skb, sizeof(*hdr));
124 hdr->cmd = cmd;
125 hdr->length = cpu_to_le16(skb->len);
126
127 if (wait_resp && wait_seq) {
128 u16 seq = ++wo->mcu.seq;
129
130 if (!seq)
131 seq = ++wo->mcu.seq;
132 *wait_seq = seq;
133
134 hdr->flag |= cpu_to_le16(MTK_WED_WARP_CMD_FLAG_NEED_RSP);
135 hdr->seq = cpu_to_le16(seq);
136 }
137 if (id == MTK_WED_MODULE_ID_WO)
138 hdr->flag |= cpu_to_le16(MTK_WED_WARP_CMD_FLAG_FROM_TO_WO);
139
140 return mtk_wed_wo_queue_tx_skb(wo, &wo->q_tx, skb);
141}
142
143static int
144mtk_wed_mcu_parse_response(struct mtk_wed_wo *wo, struct sk_buff *skb,
145 int cmd, int seq)
146{
147 struct mtk_wed_mcu_hdr *hdr;
148
149 if (!skb) {
150 dev_err(wo->hw->dev, "Message %08x (seq %d) timeout\n",
151 cmd, seq);
152 return -ETIMEDOUT;
153 }
154
155 hdr = (struct mtk_wed_mcu_hdr *)skb->data;
156 if (le16_to_cpu(hdr->seq) != seq)
157 return -EAGAIN;
158
159 skb_pull(skb, sizeof(*hdr));
160 switch (cmd) {
161 case MTK_WED_WO_CMD_RXCNT_INFO:
162 mtk_wed_update_rx_stats(wo->hw->wed_dev, skb);
163 break;
164 default:
165 break;
166 }
167
168 return 0;
169}
170
171int mtk_wed_mcu_send_msg(struct mtk_wed_wo *wo, int id, int cmd,
172 const void *data, int len, bool wait_resp)
173{
174 unsigned long expires;
175 struct sk_buff *skb;
176 u16 seq;
177 int ret;
178
179 skb = mtk_wed_mcu_msg_alloc(data, len);
180 if (!skb)
181 return -ENOMEM;
182
183 mutex_lock(&wo->mcu.mutex);
184
185 ret = mtk_wed_mcu_skb_send_msg(wo, skb, id, cmd, &seq, wait_resp);
186 if (ret || !wait_resp)
187 goto unlock;
188
189 expires = jiffies + wo->mcu.timeout;
190 do {
191 skb = mtk_wed_mcu_get_response(wo, expires);
192 ret = mtk_wed_mcu_parse_response(wo, skb, cmd, seq);
193 dev_kfree_skb(skb);
194 } while (ret == -EAGAIN);
195
196unlock:
197 mutex_unlock(&wo->mcu.mutex);
198
199 return ret;
200}
201
202int mtk_wed_mcu_msg_update(struct mtk_wed_device *dev, int id, void *data,
203 int len)
204{
205 struct mtk_wed_wo *wo = dev->hw->wed_wo;
206
207 if (dev->hw->version == 1)
208 return 0;
209
210 if (WARN_ON(!wo))
211 return -ENODEV;
212
213 return mtk_wed_mcu_send_msg(wo, MTK_WED_MODULE_ID_WO, id, data, len,
214 true);
215}
216
217static int
218mtk_wed_get_memory_region(struct mtk_wed_wo *wo,
219 struct mtk_wed_wo_memory_region *region)
220{
221 struct reserved_mem *rmem;
222 struct device_node *np;
223 int index;
224
225 index = of_property_match_string(wo->hw->node, "memory-region-names",
226 region->name);
227 if (index < 0)
228 return index;
229
230 np = of_parse_phandle(wo->hw->node, "memory-region", index);
231 if (!np)
232 return -ENODEV;
233
234 rmem = of_reserved_mem_lookup(np);
235 of_node_put(np);
236
237 if (!rmem)
238 return -ENODEV;
239
240 region->phy_addr = rmem->base;
241 region->size = rmem->size;
242 region->addr = devm_ioremap(wo->hw->dev, region->phy_addr, region->size);
243
244 return !region->addr ? -EINVAL : 0;
245}
246
247static int
248mtk_wed_mcu_run_firmware(struct mtk_wed_wo *wo, const struct firmware *fw,
249 struct mtk_wed_wo_memory_region *region)
250{
251 const u8 *first_region_ptr, *region_ptr, *trailer_ptr, *ptr = fw->data;
252 const struct mtk_wed_fw_trailer *trailer;
253 const struct mtk_wed_fw_region *fw_region;
254
255 trailer_ptr = fw->data + fw->size - sizeof(*trailer);
256 trailer = (const struct mtk_wed_fw_trailer *)trailer_ptr;
257 region_ptr = trailer_ptr - trailer->num_region * sizeof(*fw_region);
258 first_region_ptr = region_ptr;
259
260 while (region_ptr < trailer_ptr) {
261 u32 length;
262
263 fw_region = (const struct mtk_wed_fw_region *)region_ptr;
264 length = le32_to_cpu(fw_region->len);
265
266 if (region->phy_addr != le32_to_cpu(fw_region->addr))
267 goto next;
268
269 if (region->size < length)
270 goto next;
271
272 if (first_region_ptr < ptr + length)
273 goto next;
274
275 if (region->shared && region->consumed)
276 return 0;
277
278 if (!region->shared || !region->consumed) {
279 memcpy_toio(region->addr, ptr, length);
280 region->consumed = true;
281 return 0;
282 }
283next:
284 region_ptr += sizeof(*fw_region);
285 ptr += length;
286 }
287
288 return -EINVAL;
289}
290
291static int
292mtk_wed_mcu_load_firmware(struct mtk_wed_wo *wo)
293{
294 static struct mtk_wed_wo_memory_region mem_region[] = {
295 [MTK_WED_WO_REGION_EMI] = {
296 .name = "wo-emi",
297 },
298 [MTK_WED_WO_REGION_ILM] = {
299 .name = "wo-ilm",
300 },
301 [MTK_WED_WO_REGION_DATA] = {
302 .name = "wo-data",
303 .shared = true,
304 },
305 };
306 const struct mtk_wed_fw_trailer *trailer;
307 const struct firmware *fw;
308 const char *fw_name;
309 u32 val, boot_cr;
310 int ret, i;
311
312 /* load firmware region metadata */
313 for (i = 0; i < ARRAY_SIZE(mem_region); i++) {
314 ret = mtk_wed_get_memory_region(wo, &mem_region[i]);
315 if (ret)
316 return ret;
317 }
318
319 wo->boot.name = "wo-boot";
320 ret = mtk_wed_get_memory_region(wo, &wo->boot);
321 if (ret)
322 return ret;
323
324 /* set dummy cr */
325 wed_w32(wo->hw->wed_dev, MTK_WED_SCR0 + 4 * MTK_WED_DUMMY_CR_FWDL,
326 wo->hw->index + 1);
327
328 /* load firmware */
329 fw_name = wo->hw->index ? MT7986_FIRMWARE_WO1 : MT7986_FIRMWARE_WO0;
330 ret = request_firmware(&fw, fw_name, wo->hw->dev);
331 if (ret)
332 return ret;
333
334 trailer = (void *)(fw->data + fw->size -
335 sizeof(struct mtk_wed_fw_trailer));
336 dev_info(wo->hw->dev,
337 "MTK WED WO Firmware Version: %.10s, Build Time: %.15s\n",
338 trailer->fw_ver, trailer->build_date);
339 dev_info(wo->hw->dev, "MTK WED WO Chip ID %02x Region %d\n",
340 trailer->chip_id, trailer->num_region);
341
342 for (i = 0; i < ARRAY_SIZE(mem_region); i++) {
343 ret = mtk_wed_mcu_run_firmware(wo, fw, &mem_region[i]);
344 if (ret)
345 goto out;
346 }
347
348 /* set the start address */
349 boot_cr = wo->hw->index ? MTK_WO_MCU_CFG_LS_WA_BOOT_ADDR_ADDR
350 : MTK_WO_MCU_CFG_LS_WM_BOOT_ADDR_ADDR;
351 wo_w32(wo, boot_cr, mem_region[MTK_WED_WO_REGION_EMI].phy_addr >> 16);
352 /* wo firmware reset */
353 wo_w32(wo, MTK_WO_MCU_CFG_LS_WF_MCCR_CLR_ADDR, 0xc00);
354
355 val = wo_r32(wo, MTK_WO_MCU_CFG_LS_WF_MCU_CFG_WM_WA_ADDR);
356 val |= wo->hw->index ? MTK_WO_MCU_CFG_LS_WF_WM_WA_WA_CPU_RSTB_MASK
357 : MTK_WO_MCU_CFG_LS_WF_WM_WA_WM_CPU_RSTB_MASK;
358 wo_w32(wo, MTK_WO_MCU_CFG_LS_WF_MCU_CFG_WM_WA_ADDR, val);
359out:
360 release_firmware(fw);
361
362 return ret;
363}
364
365static u32
366mtk_wed_mcu_read_fw_dl(struct mtk_wed_wo *wo)
367{
368 return wed_r32(wo->hw->wed_dev,
369 MTK_WED_SCR0 + 4 * MTK_WED_DUMMY_CR_FWDL);
370}
371
372int mtk_wed_mcu_init(struct mtk_wed_wo *wo)
373{
374 u32 val;
375 int ret;
376
377 skb_queue_head_init(&wo->mcu.res_q);
378 init_waitqueue_head(&wo->mcu.wait);
379 mutex_init(&wo->mcu.mutex);
380
381 ret = mtk_wed_mcu_load_firmware(wo);
382 if (ret)
383 return ret;
384
385 return readx_poll_timeout(mtk_wed_mcu_read_fw_dl, wo, val, !val,
386 100, MTK_FW_DL_TIMEOUT);
387}
388
389MODULE_FIRMWARE(MT7986_FIRMWARE_WO0);
390MODULE_FIRMWARE(MT7986_FIRMWARE_WO1);