1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * NXP Wireless LAN device driver: SDIO specific handling
4 *
5 * Copyright 2011-2024 NXP
6 */
7
8 #include <linux/firmware.h>
9 #include <linux/completion.h>
10 #include <linux/mmc/sdio.h>
11 #include <linux/mmc/sdio_ids.h>
12 #include <linux/mmc/sdio_func.h>
13 #include <linux/mmc/card.h>
14 #include <linux/mmc/host.h>
15 #include <linux/iopoll.h>
16 #include "cfg.h"
17 #include "util.h"
18 #include "fw.h"
19 #include "main.h"
20 #include "wmm.h"
21 #include "11n.h"
22 #include "sdio.h"
23
24 #define SDIO_VERSION "1.0"
25
26 /* Process deferred SDIO work items. */
27 static void nxpwifi_sdio_work(struct work_struct *work);
28
29 static struct nxpwifi_if_ops sdio_ops;
30
31 static const struct nxpwifi_sdio_card_reg nxpwifi_reg_iw61x = {
32 .start_rd_port = 0,
33 .start_wr_port = 0,
34 .base_0_reg = 0xF8,
35 .base_1_reg = 0xF9,
36 .poll_reg = 0x5C,
37 .host_int_enable = UP_LD_HOST_INT_MASK | DN_LD_HOST_INT_MASK |
38 CMD_PORT_UPLD_INT_MASK | CMD_PORT_DNLD_INT_MASK,
39 .host_int_rsr_reg = 0x4,
40 .host_int_status_reg = 0x0C,
41 .host_int_mask_reg = 0x08,
42 .host_strap_reg = 0xF4,
43 .host_strap_mask = 0x01,
44 .host_strap_value = 0x00,
45 .status_reg_0 = 0xE8,
46 .status_reg_1 = 0xE9,
47 .sdio_int_mask = 0xff,
48 .data_port_mask = 0xffffffff,
49 .io_port_0_reg = 0xE4,
50 .io_port_1_reg = 0xE5,
51 .io_port_2_reg = 0xE6,
52 .max_mp_regs = 196,
53 .rd_bitmap_l = 0x10,
54 .rd_bitmap_u = 0x11,
55 .rd_bitmap_1l = 0x12,
56 .rd_bitmap_1u = 0x13,
57 .wr_bitmap_l = 0x14,
58 .wr_bitmap_u = 0x15,
59 .wr_bitmap_1l = 0x16,
60 .wr_bitmap_1u = 0x17,
61 .rd_len_p0_l = 0x18,
62 .rd_len_p0_u = 0x19,
63 .card_misc_cfg_reg = 0xd8,
64 .card_cfg_2_1_reg = 0xd9,
65 .cmd_rd_len_0 = 0xc0,
66 .cmd_rd_len_1 = 0xc1,
67 .cmd_rd_len_2 = 0xc2,
68 .cmd_rd_len_3 = 0xc3,
69 .cmd_cfg_0 = 0xc4,
70 .cmd_cfg_1 = 0xc5,
71 .cmd_cfg_2 = 0xc6,
72 .cmd_cfg_3 = 0xc7,
73 .fw_dump_host_ready = 0xcc,
74 .fw_dump_ctrl = 0xf9,
75 .fw_dump_start = 0xf1,
76 .fw_dump_end = 0xf8,
77 .func1_dump_reg_start = 0x10,
78 .func1_dump_reg_end = 0x17,
79 .func1_scratch_reg = 0xE8,
80 .func1_spec_reg_num = 13,
81 .func1_spec_reg_table = {0x08, 0x58, 0x5C, 0x5D, 0x60,
82 0x61, 0x62, 0x64, 0x65, 0x66,
83 0x68, 0x69, 0x6a},
84 };
85
86 static const struct nxpwifi_sdio_device nxpwifi_sdio_iw61x = {
87 .firmware = IW61X_SDIO_FW_NAME,
88 .reg = &nxpwifi_reg_iw61x,
89 .max_ports = 32,
90 .mp_agg_pkt_limit = 16,
91 .tx_buf_size = NXPWIFI_TX_DATA_BUF_SIZE_4K,
92 .mp_tx_agg_buf_size = NXPWIFI_MP_AGGR_BSIZE_MAX,
93 .mp_rx_agg_buf_size = NXPWIFI_MP_AGGR_BSIZE_MAX,
94 .can_dump_fw = true,
95 .fw_dump_enh = true,
96 .can_ext_scan = true,
97 };
98
99 static struct memory_type_mapping generic_mem_type_map[] = {
100 {"DUMP", NULL, 0, 0xDD},
101 };
102
103 static struct memory_type_mapping mem_type_mapping_tbl[] = {
104 {"ITCM", NULL, 0, 0xF0},
105 {"DTCM", NULL, 0, 0xF1},
106 {"SQRAM", NULL, 0, 0xF2},
107 {"APU", NULL, 0, 0xF3},
108 {"CIU", NULL, 0, 0xF4},
109 {"ICU", NULL, 0, 0xF5},
110 {"MAC", NULL, 0, 0xF6},
111 {"EXT7", NULL, 0, 0xF7},
112 {"EXT8", NULL, 0, 0xF8},
113 {"EXT9", NULL, 0, 0xF9},
114 {"EXT10", NULL, 0, 0xFA},
115 {"EXT11", NULL, 0, 0xFB},
116 {"EXT12", NULL, 0, 0xFC},
117 {"EXT13", NULL, 0, 0xFD},
118 {"EXTLAST", NULL, 0, 0xFE},
119 };
120
121 /* Bind the SDIO function and start device registration. */
122 static int
nxpwifi_sdio_probe(struct sdio_func * func,const struct sdio_device_id * id)123 nxpwifi_sdio_probe(struct sdio_func *func, const struct sdio_device_id *id)
124 {
125 int ret;
126 struct sdio_mmc_card *card = NULL;
127
128 card = devm_kzalloc(&func->dev, sizeof(*card), GFP_KERNEL);
129 if (!card)
130 return -ENOMEM;
131
132 init_completion(&card->fw_done);
133
134 card->func = func;
135
136 if (id->driver_data) {
137 struct nxpwifi_sdio_device *data = (void *)id->driver_data;
138
139 card->firmware = data->firmware;
140 card->firmware_sdiouart = data->firmware_sdiouart;
141 card->reg = data->reg;
142 card->max_ports = data->max_ports;
143 card->mp_agg_pkt_limit = data->mp_agg_pkt_limit;
144 card->tx_buf_size = data->tx_buf_size;
145 card->mp_tx_agg_buf_size = data->mp_tx_agg_buf_size;
146 card->mp_rx_agg_buf_size = data->mp_rx_agg_buf_size;
147 card->can_dump_fw = data->can_dump_fw;
148 card->fw_dump_enh = data->fw_dump_enh;
149 card->can_ext_scan = data->can_ext_scan;
150 INIT_WORK(&card->work, nxpwifi_sdio_work);
151 }
152
153 sdio_claim_host(func);
154 ret = sdio_enable_func(func);
155 sdio_release_host(func);
156
157 if (ret) {
158 dev_err(&func->dev, "failed to enable function\n");
159 return ret;
160 }
161
162 ret = nxpwifi_add_card(card, &card->fw_done, &sdio_ops,
163 NXPWIFI_SDIO, &func->dev);
164 if (ret) {
165 dev_err(&func->dev, "add card failed\n");
166 goto err_disable;
167 }
168
169 return 0;
170
171 err_disable:
172 sdio_claim_host(func);
173 sdio_disable_func(func);
174 sdio_release_host(func);
175
176 return ret;
177 }
178
179 /* Resume the SDIO function and cancel host sleep. */
nxpwifi_sdio_resume(struct device * dev)180 static int nxpwifi_sdio_resume(struct device *dev)
181 {
182 struct sdio_func *func = dev_to_sdio_func(dev);
183 struct sdio_mmc_card *card;
184 struct nxpwifi_adapter *adapter;
185
186 card = sdio_get_drvdata(func);
187
188 if (unlikely(!card || !card->adapter)) {
189 dev_dbg(dev, "resume: %s not ready\n", !card ? "card" : "adapter");
190 return -ENODEV;
191 }
192
193 adapter = card->adapter;
194
195 if (!test_bit(NXPWIFI_IS_SUSPENDED, &adapter->work_flags))
196 return 0;
197
198 clear_bit(NXPWIFI_IS_SUSPENDED, &adapter->work_flags);
199
200 /* Disable Host Sleep */
201 nxpwifi_cancel_hs(nxpwifi_get_priv(adapter, NXPWIFI_BSS_ROLE_STA),
202 NXPWIFI_SYNC_CMD);
203
204 return 0;
205 }
206
207 static int
nxpwifi_write_reg_locked(struct sdio_func * func,u32 reg,u8 data)208 nxpwifi_write_reg_locked(struct sdio_func *func, u32 reg, u8 data)
209 {
210 int ret;
211
212 sdio_writeb(func, data, reg, &ret);
213 return ret;
214 }
215
216 static int
nxpwifi_write_reg(struct nxpwifi_adapter * adapter,u32 reg,u8 data)217 nxpwifi_write_reg(struct nxpwifi_adapter *adapter, u32 reg, u8 data)
218 {
219 struct sdio_mmc_card *card = adapter->card;
220 int ret;
221
222 sdio_claim_host(card->func);
223 ret = nxpwifi_write_reg_locked(card->func, reg, data);
224 sdio_release_host(card->func);
225
226 return ret;
227 }
228
229 static int
nxpwifi_read_reg(struct nxpwifi_adapter * adapter,u32 reg,u8 * data)230 nxpwifi_read_reg(struct nxpwifi_adapter *adapter, u32 reg, u8 *data)
231 {
232 struct sdio_mmc_card *card = adapter->card;
233 int ret;
234 u8 val;
235
236 sdio_claim_host(card->func);
237 val = sdio_readb(card->func, reg, &ret);
238 sdio_release_host(card->func);
239
240 *data = val;
241
242 return ret;
243 }
244
245 static int
nxpwifi_write_data_sync(struct nxpwifi_adapter * adapter,u8 * buffer,u32 pkt_len,u32 port)246 nxpwifi_write_data_sync(struct nxpwifi_adapter *adapter,
247 u8 *buffer, u32 pkt_len, u32 port)
248 {
249 struct sdio_mmc_card *card = adapter->card;
250 int ret;
251 u8 blk_mode =
252 (port & NXPWIFI_SDIO_BYTE_MODE_MASK) ? BYTE_MODE : BLOCK_MODE;
253 u32 blk_size = (blk_mode == BLOCK_MODE) ? NXPWIFI_SDIO_BLOCK_SIZE : 1;
254 u32 blk_cnt =
255 (blk_mode ==
256 BLOCK_MODE) ? (pkt_len /
257 NXPWIFI_SDIO_BLOCK_SIZE) : pkt_len;
258 u32 ioport = (port & NXPWIFI_SDIO_IO_PORT_MASK);
259
260 if (test_bit(NXPWIFI_IS_SUSPENDED, &adapter->work_flags)) {
261 nxpwifi_dbg(adapter, ERROR,
262 "%s: not allowed while suspended\n", __func__);
263 return -EPERM;
264 }
265
266 sdio_claim_host(card->func);
267
268 ret = sdio_writesb(card->func, ioport, buffer, blk_cnt * blk_size);
269
270 sdio_release_host(card->func);
271
272 return ret;
273 }
274
nxpwifi_read_data_sync(struct nxpwifi_adapter * adapter,u8 * buffer,u32 len,u32 port,u8 claim)275 static int nxpwifi_read_data_sync(struct nxpwifi_adapter *adapter, u8 *buffer,
276 u32 len, u32 port, u8 claim)
277 {
278 struct sdio_mmc_card *card = adapter->card;
279 int ret;
280 u8 blk_mode = (port & NXPWIFI_SDIO_BYTE_MODE_MASK) ? BYTE_MODE
281 : BLOCK_MODE;
282 u32 blk_size = (blk_mode == BLOCK_MODE) ? NXPWIFI_SDIO_BLOCK_SIZE : 1;
283 u32 blk_cnt = (blk_mode == BLOCK_MODE) ? (len / NXPWIFI_SDIO_BLOCK_SIZE)
284 : len;
285 u32 ioport = (port & NXPWIFI_SDIO_IO_PORT_MASK);
286
287 if (claim)
288 sdio_claim_host(card->func);
289
290 ret = sdio_readsb(card->func, buffer, ioport, blk_cnt * blk_size);
291
292 if (claim)
293 sdio_release_host(card->func);
294
295 return ret;
296 }
297
298 static int
nxpwifi_sdio_read_fw_status(struct nxpwifi_adapter * adapter,u16 * dat)299 nxpwifi_sdio_read_fw_status(struct nxpwifi_adapter *adapter, u16 *dat)
300 {
301 struct sdio_mmc_card *card = adapter->card;
302 const struct nxpwifi_sdio_card_reg *reg = card->reg;
303 u8 fws0, fws1;
304 int ret;
305
306 ret = nxpwifi_read_reg(adapter, reg->status_reg_0, &fws0);
307 if (ret)
308 return ret;
309
310 ret = nxpwifi_read_reg(adapter, reg->status_reg_1, &fws1);
311 if (ret)
312 return ret;
313
314 *dat = (u16)((fws1 << 8) | fws0);
315 return ret;
316 }
317
nxpwifi_check_fw_status(struct nxpwifi_adapter * adapter,u32 poll_num)318 static int nxpwifi_check_fw_status(struct nxpwifi_adapter *adapter,
319 u32 poll_num)
320 {
321 int ret = 0;
322 u16 firmware_stat = 0;
323
324 unsigned int timeout_us = poll_num * 100000; /* 100 ms * poll_num */
325 /*
326 * Poll every 100 ms until firmware reports FIRMWARE_READY_SDIO.
327 * On timeout, read_poll_timeout() returns -ETIMEDOUT.
328 */
329 ret = read_poll_timeout(nxpwifi_sdio_read_fw_status, ret,
330 (!ret && firmware_stat == FIRMWARE_READY_SDIO),
331 100000, timeout_us, true, /* sleep */
332 adapter, &firmware_stat);
333
334 /* FW may appear ready; wait a bit to avoid early races. */
335 if (firmware_stat == FIRMWARE_READY_SDIO)
336 msleep(100);
337
338 return ret;
339 }
340
nxpwifi_check_winner_status(struct nxpwifi_adapter * adapter)341 static int nxpwifi_check_winner_status(struct nxpwifi_adapter *adapter)
342 {
343 int ret;
344 u8 winner = 0;
345 struct sdio_mmc_card *card = adapter->card;
346
347 ret = nxpwifi_read_reg(adapter, card->reg->status_reg_0, &winner);
348 if (ret)
349 return ret;
350
351 if (winner)
352 adapter->winner = 0;
353 else
354 adapter->winner = 1;
355
356 return ret;
357 }
358
359 /* Remove the SDIO function and tear down the adapter. */
360 static void
nxpwifi_sdio_remove(struct sdio_func * func)361 nxpwifi_sdio_remove(struct sdio_func *func)
362 {
363 struct sdio_mmc_card *card;
364 struct nxpwifi_adapter *adapter;
365 struct nxpwifi_private *priv;
366 int ret = 0;
367 u16 firmware_stat;
368
369 card = sdio_get_drvdata(func);
370 if (!card)
371 return;
372
373 wait_for_completion(&card->fw_done);
374
375 adapter = card->adapter;
376 if (!adapter || !adapter->priv_num)
377 return;
378
379 ret = nxpwifi_sdio_read_fw_status(adapter, &firmware_stat);
380 if (!ret && firmware_stat == FIRMWARE_READY_SDIO) {
381 nxpwifi_deauthenticate_all(adapter);
382
383 priv = nxpwifi_get_priv(adapter, NXPWIFI_BSS_ROLE_ANY);
384 nxpwifi_disable_auto_ds(priv);
385 nxpwifi_init_shutdown_fw(priv, NXPWIFI_FUNC_SHUTDOWN);
386 }
387
388 nxpwifi_remove_card(adapter);
389 }
390
391 /* Suspend the SDIO function while keeping SDIO power. */
nxpwifi_sdio_suspend(struct device * dev)392 static int nxpwifi_sdio_suspend(struct device *dev)
393 {
394 struct sdio_func *func = dev_to_sdio_func(dev);
395 struct sdio_mmc_card *card;
396 struct nxpwifi_adapter *adapter;
397 mmc_pm_flag_t caps;
398 unsigned long flags = 0;
399 int ret = 0;
400
401 caps = sdio_get_host_pm_caps(func);
402
403 if (!(caps & MMC_PM_KEEP_POWER)) {
404 /* host lacks keep-power capability */
405 dev_warn(dev, "suspend: host does not support MMC_PM_KEEP_POWER\n");
406 return -EOPNOTSUPP;
407 }
408
409 card = sdio_get_drvdata(func);
410
411 if (!card) {
412 dev_warn(dev, "suspend: card not ready\n");
413 return -ENODEV;
414 }
415
416 /* Might still be loading firmware */
417 wait_for_completion(&card->fw_done);
418
419 adapter = card->adapter;
420 if (!adapter) {
421 dev_warn(dev, "suspend: adapter not ready\n");
422 return -ENODEV;
423 }
424
425 /* Enable the Host Sleep */
426 if (!nxpwifi_enable_hs(adapter)) {
427 nxpwifi_dbg(adapter, ERROR, "suspend: enable host sleep failed\n");
428 clear_bit(NXPWIFI_IS_HS_ENABLING, &adapter->work_flags);
429 return -ETIMEDOUT;
430 }
431
432 flags |= MMC_PM_KEEP_POWER;
433
434 if (adapter->wowlan_enabled && (caps & MMC_PM_WAKE_SDIO_IRQ))
435 flags |= MMC_PM_WAKE_SDIO_IRQ;
436
437 ret = sdio_set_host_pm_flags(func, flags);
438
439 /* Indicate device suspended */
440 set_bit(NXPWIFI_IS_SUSPENDED, &adapter->work_flags);
441 clear_bit(NXPWIFI_IS_HS_ENABLING, &adapter->work_flags);
442
443 return ret;
444 }
445
nxpwifi_sdio_coredump(struct device * dev)446 static void nxpwifi_sdio_coredump(struct device *dev)
447 {
448 struct sdio_func *func = dev_to_sdio_func(dev);
449 struct sdio_mmc_card *card;
450
451 card = sdio_get_drvdata(func);
452 if (!test_and_set_bit(NXPWIFI_IFACE_WORK_DEVICE_DUMP,
453 &card->work_flags))
454 nxpwifi_queue_work(card->adapter, &card->work);
455 }
456
457 /* WLAN IDs */
458 static const struct sdio_device_id nxpwifi_ids[] = {
459 {SDIO_DEVICE(SDIO_VENDOR_ID_NXP, SDIO_DEVICE_ID_NXP_IW61X),
460 .driver_data = (unsigned long)&nxpwifi_sdio_iw61x},
461 {},
462 };
463
464 MODULE_DEVICE_TABLE(sdio, nxpwifi_ids);
465
466 static const struct dev_pm_ops nxpwifi_sdio_pm_ops = {
467 .suspend = nxpwifi_sdio_suspend,
468 .resume = nxpwifi_sdio_resume,
469 };
470
471 static struct sdio_driver nxpwifi_sdio = {
472 .name = "nxpwifi_sdio",
473 .id_table = nxpwifi_ids,
474 .probe = nxpwifi_sdio_probe,
475 .remove = nxpwifi_sdio_remove,
476 .drv = {
477 .coredump = nxpwifi_sdio_coredump,
478 .pm = &nxpwifi_sdio_pm_ops,
479 }
480 };
481
nxpwifi_pm_wakeup_card(struct nxpwifi_adapter * adapter)482 static int nxpwifi_pm_wakeup_card(struct nxpwifi_adapter *adapter)
483 {
484 nxpwifi_dbg(adapter, EVENT, "event: wakeup device...\n");
485
486 return nxpwifi_write_reg(adapter, CONFIGURATION_REG, HOST_POWER_UP);
487 }
488
nxpwifi_pm_wakeup_card_complete(struct nxpwifi_adapter * adapter)489 static int nxpwifi_pm_wakeup_card_complete(struct nxpwifi_adapter *adapter)
490 {
491 nxpwifi_dbg(adapter, EVENT, "cmd: wakeup device completed\n");
492
493 return nxpwifi_write_reg(adapter, CONFIGURATION_REG, 0);
494 }
495
496 /* SDIO wrapper for firmware download (claims host). */
nxpwifi_sdio_dnld_fw(struct nxpwifi_adapter * adapter,struct nxpwifi_fw_image * fw)497 static int nxpwifi_sdio_dnld_fw(struct nxpwifi_adapter *adapter,
498 struct nxpwifi_fw_image *fw)
499 {
500 struct sdio_mmc_card *card = adapter->card;
501 int ret;
502
503 sdio_claim_host(card->func);
504 ret = nxpwifi_dnld_fw(adapter, fw);
505 sdio_release_host(card->func);
506
507 return ret;
508 }
509
nxpwifi_init_sdio_new_mode(struct nxpwifi_adapter * adapter)510 static int nxpwifi_init_sdio_new_mode(struct nxpwifi_adapter *adapter)
511 {
512 u8 reg;
513 struct sdio_mmc_card *card = adapter->card;
514 int ret;
515
516 adapter->ioport = MEM_PORT;
517
518 /* enable sdio new mode */
519 ret = nxpwifi_read_reg(adapter, card->reg->card_cfg_2_1_reg, ®);
520 if (ret)
521 return ret;
522 ret = nxpwifi_write_reg(adapter, card->reg->card_cfg_2_1_reg,
523 reg | CMD53_NEW_MODE);
524 if (ret)
525 return ret;
526
527 /* Configure cmd port and enable reading rx length from the register */
528 ret = nxpwifi_read_reg(adapter, card->reg->cmd_cfg_0, ®);
529 if (ret)
530 return ret;
531 ret = nxpwifi_write_reg(adapter, card->reg->cmd_cfg_0,
532 reg | CMD_PORT_RD_LEN_EN);
533 if (ret)
534 return ret;
535
536 /*
537 * Enable Dnld/Upld ready auto reset for cmd port after cmd53 is
538 * completed
539 */
540 ret = nxpwifi_read_reg(adapter, card->reg->cmd_cfg_1, ®);
541 if (ret)
542 return ret;
543 ret = nxpwifi_write_reg(adapter, card->reg->cmd_cfg_1,
544 reg | CMD_PORT_AUTO_EN);
545
546 return ret;
547 }
548
549 /* Initialize SDIO IO ports and host-int behavior. */
nxpwifi_init_sdio_ioport(struct nxpwifi_adapter * adapter)550 static int nxpwifi_init_sdio_ioport(struct nxpwifi_adapter *adapter)
551 {
552 u8 reg;
553 struct sdio_mmc_card *card = adapter->card;
554 int ret;
555
556 ret = nxpwifi_init_sdio_new_mode(adapter);
557 if (ret)
558 return ret;
559
560 /* Set Host interrupt reset to read to clear */
561 ret = nxpwifi_read_reg(adapter, card->reg->host_int_rsr_reg, ®);
562 if (ret)
563 return ret;
564 ret = nxpwifi_write_reg(adapter, card->reg->host_int_rsr_reg,
565 reg | card->reg->sdio_int_mask);
566 if (ret)
567 return ret;
568
569 /* Dnld/Upld ready set to auto reset */
570 ret = nxpwifi_read_reg(adapter, card->reg->card_misc_cfg_reg, ®);
571 if (ret)
572 return ret;
573 ret = nxpwifi_write_reg(adapter, card->reg->card_misc_cfg_reg,
574 reg | AUTO_RE_ENABLE_INT);
575
576 return ret;
577 }
578
nxpwifi_write_data_to_card(struct nxpwifi_adapter * adapter,u8 * payload,u32 pkt_len,u32 port)579 static int nxpwifi_write_data_to_card(struct nxpwifi_adapter *adapter,
580 u8 *payload, u32 pkt_len, u32 port)
581 {
582 u32 i = 0;
583 int ret;
584
585 do {
586 ret = nxpwifi_write_data_sync(adapter, payload, pkt_len, port);
587 if (ret) {
588 i++;
589 nxpwifi_dbg(adapter, ERROR, "host_to_card, write iomem\t"
590 "(%d) failed: %d\n", i, ret);
591 if (nxpwifi_write_reg(adapter, CONFIGURATION_REG, 0x04))
592 nxpwifi_dbg(adapter, ERROR, "write CFG reg failed\n");
593
594 if (i > MAX_WRITE_IOMEM_RETRY)
595 return ret;
596 }
597 } while (ret);
598
599 return ret;
600 }
601
nxpwifi_get_rd_port(struct nxpwifi_adapter * adapter,u8 * port)602 static int nxpwifi_get_rd_port(struct nxpwifi_adapter *adapter, u8 *port)
603 {
604 struct sdio_mmc_card *card = adapter->card;
605 const struct nxpwifi_sdio_card_reg *reg = card->reg;
606 u32 rd_bitmap = card->mp_rd_bitmap;
607
608 if (!(rd_bitmap & reg->data_port_mask))
609 return -EINVAL;
610
611 if (!(card->mp_rd_bitmap & (1 << card->curr_rd_port)))
612 return -EINVAL;
613
614 /* We are now handling the SDIO data ports */
615 card->mp_rd_bitmap &= (u32)(~(1 << card->curr_rd_port));
616 *port = card->curr_rd_port;
617
618 if (++card->curr_rd_port == card->max_ports)
619 card->curr_rd_port = reg->start_rd_port;
620
621 return 0;
622 }
623
nxpwifi_get_wr_port_data(struct nxpwifi_adapter * adapter,u32 * port)624 static int nxpwifi_get_wr_port_data(struct nxpwifi_adapter *adapter, u32 *port)
625 {
626 struct sdio_mmc_card *card = adapter->card;
627 const struct nxpwifi_sdio_card_reg *reg = card->reg;
628 u32 wr_bitmap = card->mp_wr_bitmap;
629
630 if (!(wr_bitmap & card->mp_data_port_mask)) {
631 adapter->data_sent = true;
632 return -EBUSY;
633 }
634
635 if (card->mp_wr_bitmap & (1 << card->curr_wr_port)) {
636 card->mp_wr_bitmap &= (u32)(~(1 << card->curr_wr_port));
637 *port = card->curr_wr_port;
638 if (++card->curr_wr_port == card->mp_end_port)
639 card->curr_wr_port = reg->start_wr_port;
640 } else {
641 adapter->data_sent = true;
642 return -EBUSY;
643 }
644
645 return 0;
646 }
647
648 static int
nxpwifi_sdio_poll_card_status(struct nxpwifi_adapter * adapter,u8 bits)649 nxpwifi_sdio_poll_card_status(struct nxpwifi_adapter *adapter, u8 bits)
650 {
651 struct sdio_mmc_card *card = adapter->card;
652 u32 tries;
653 u8 cs;
654 int ret;
655
656 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
657 ret = nxpwifi_read_reg(adapter, card->reg->poll_reg, &cs);
658 if (ret)
659 break;
660 else if ((cs & bits) == bits)
661 return 0;
662
663 usleep_range(10, 20);
664 }
665
666 nxpwifi_dbg(adapter, ERROR, "poll card status failed, tries = %d\n", tries);
667
668 return ret;
669 }
670
671 /* Disable SDIO host interrupt and release IRQ. */
nxpwifi_sdio_disable_host_int(struct nxpwifi_adapter * adapter)672 static void nxpwifi_sdio_disable_host_int(struct nxpwifi_adapter *adapter)
673 {
674 struct sdio_mmc_card *card = adapter->card;
675 struct sdio_func *func = card->func;
676
677 sdio_claim_host(func);
678 nxpwifi_write_reg_locked(func, card->reg->host_int_mask_reg, 0);
679 sdio_release_irq(func);
680 sdio_release_host(func);
681 }
682
nxpwifi_interrupt_status(struct nxpwifi_adapter * adapter)683 static void nxpwifi_interrupt_status(struct nxpwifi_adapter *adapter)
684 {
685 struct sdio_mmc_card *card = adapter->card;
686 u8 sdio_ireg;
687 unsigned long flags;
688
689 if (nxpwifi_read_data_sync(adapter, card->mp_regs,
690 card->reg->max_mp_regs,
691 REG_PORT | NXPWIFI_SDIO_BYTE_MODE_MASK, 0)) {
692 nxpwifi_dbg(adapter, ERROR, "read mp_regs failed\n");
693 return;
694 }
695
696 sdio_ireg = card->mp_regs[card->reg->host_int_status_reg];
697 if (sdio_ireg) {
698 nxpwifi_dbg(adapter, INTR, "intr: sdio_ireg = %#x\n", sdio_ireg);
699 spin_lock_irqsave(&adapter->int_lock, flags);
700 adapter->int_status |= sdio_ireg;
701 spin_unlock_irqrestore(&adapter->int_lock, flags);
702 }
703 }
704
705 /* SDIO IRQ handler: snapshot status and schedule main work. */
706 static void
nxpwifi_sdio_interrupt(struct sdio_func * func)707 nxpwifi_sdio_interrupt(struct sdio_func *func)
708 {
709 struct nxpwifi_adapter *adapter;
710 struct sdio_mmc_card *card;
711
712 card = sdio_get_drvdata(func);
713
714 if (!card || !card->adapter) {
715 /* device-scoped error logging (rate-limited to avoid flood) */
716 dev_err_ratelimited(&func->dev, "interrupt: missing card/adapter\n");
717 return;
718 }
719
720 adapter = card->adapter;
721
722 if (!adapter->pps_uapsd_mode && adapter->ps_state == PS_STATE_SLEEP)
723 adapter->ps_state = PS_STATE_AWAKE;
724
725 nxpwifi_interrupt_status(adapter);
726 nxpwifi_queue_work(adapter, &adapter->main_work);
727 }
728
729 /* Enable SDIO host interrupt and claim IRQ. */
nxpwifi_sdio_enable_host_int(struct nxpwifi_adapter * adapter)730 static int nxpwifi_sdio_enable_host_int(struct nxpwifi_adapter *adapter)
731 {
732 struct sdio_mmc_card *card = adapter->card;
733 struct sdio_func *func = card->func;
734 int ret;
735
736 sdio_claim_host(func);
737
738 /* Request the SDIO IRQ */
739 ret = sdio_claim_irq(func, nxpwifi_sdio_interrupt);
740 if (ret) {
741 nxpwifi_dbg(adapter, ERROR, "claim irq failed: ret=%d\n", ret);
742 goto done;
743 }
744
745 /* Simply write the mask to the register */
746 ret = nxpwifi_write_reg_locked(func, card->reg->host_int_mask_reg,
747 card->reg->host_int_enable);
748 if (ret) {
749 nxpwifi_dbg(adapter, ERROR, "enable host interrupt failed\n");
750 sdio_release_irq(func);
751 }
752
753 done:
754 sdio_release_host(func);
755 return ret;
756 }
757
nxpwifi_sdio_card_to_host(struct nxpwifi_adapter * adapter,u32 * type,u8 * buffer,u32 npayload,u32 ioport)758 static int nxpwifi_sdio_card_to_host(struct nxpwifi_adapter *adapter,
759 u32 *type, u8 *buffer,
760 u32 npayload, u32 ioport)
761 {
762 int ret;
763 u32 nb;
764
765 if (!buffer)
766 return -EINVAL;
767
768 ret = nxpwifi_read_data_sync(adapter, buffer, npayload, ioport, 1);
769
770 if (ret) {
771 nxpwifi_dbg(adapter, ERROR,
772 "read iomem failed (ioport=%#x, len=%u): %d",
773 ioport, npayload, ret);
774
775 return ret;
776 }
777
778 nb = get_unaligned_le16((buffer));
779 if (nb > npayload) {
780 nxpwifi_dbg(adapter, ERROR,
781 "invalid packet len: nb=%u > npayload=%u (ioport=%#x)",
782 nb, npayload, ioport);
783 return -EINVAL;
784 }
785
786 *type = get_unaligned_le16((buffer + 2));
787
788 return ret;
789 }
790
791 /* Download firmware using the helper protocol. */
nxpwifi_prog_fw_w_helper(struct nxpwifi_adapter * adapter,struct nxpwifi_fw_image * fw)792 static int nxpwifi_prog_fw_w_helper(struct nxpwifi_adapter *adapter,
793 struct nxpwifi_fw_image *fw)
794 {
795 struct sdio_mmc_card *card = adapter->card;
796 const struct nxpwifi_sdio_card_reg *reg = card->reg;
797 int ret;
798 u8 *firmware = fw->fw_buf;
799 u32 firmware_len = fw->fw_len;
800 u32 offset = 0;
801 u8 base0, base1;
802 u8 *fwbuf;
803 u16 len = 0;
804 u32 txlen, tx_blocks = 0, tries;
805 u32 i = 0;
806
807 if (!firmware_len) {
808 nxpwifi_dbg(adapter, ERROR,
809 "firmware image not found! Terminating download\n");
810 return -EINVAL;
811 }
812
813 /* Assume that the allocated buffer is 8-byte aligned */
814 fwbuf = kzalloc(NXPWIFI_UPLD_SIZE, GFP_KERNEL);
815 if (!fwbuf)
816 return -ENOMEM;
817
818 sdio_claim_host(card->func);
819
820 /* Perform firmware data transfer */
821 do {
822 /*
823 * The host polls for the DN_LD_CARD_RDY and CARD_IO_READY
824 * bits
825 */
826 ret = nxpwifi_sdio_poll_card_status(adapter, CARD_IO_READY |
827 DN_LD_CARD_RDY);
828 if (ret) {
829 nxpwifi_dbg(adapter, ERROR,
830 "FW download with helper:\t"
831 "poll status timeout @ %d\n", offset);
832 goto done;
833 }
834
835 /* More data? */
836 if (offset >= firmware_len)
837 break;
838
839 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
840 ret = nxpwifi_read_reg(adapter, reg->base_0_reg,
841 &base0);
842 if (ret) {
843 nxpwifi_dbg(adapter, ERROR,
844 "dev BASE0 register read failed:\t"
845 "base0=%#04X(%d). Terminating dnld\n",
846 base0, base0);
847 goto done;
848 }
849 ret = nxpwifi_read_reg(adapter, reg->base_1_reg,
850 &base1);
851 if (ret) {
852 nxpwifi_dbg(adapter, ERROR,
853 "dev BASE1 register read failed:\t"
854 "base1=%#04X(%d). Terminating dnld\n",
855 base1, base1);
856 goto done;
857 }
858 len = (u16)(((base1 & 0xff) << 8) | (base0 & 0xff));
859
860 if (len)
861 break;
862
863 usleep_range(10, 20);
864 }
865
866 if (!len) {
867 break;
868 } else if (len > NXPWIFI_UPLD_SIZE) {
869 nxpwifi_dbg(adapter, ERROR,
870 "FW dnld failed @ %d, invalid length %d\n",
871 offset, len);
872 ret = -EINVAL;
873 goto done;
874 }
875
876 txlen = len;
877
878 if (len & BIT(0)) {
879 i++;
880 if (i > MAX_WRITE_IOMEM_RETRY) {
881 nxpwifi_dbg(adapter, ERROR,
882 "FW dnld failed @ %d, over max retry\n",
883 offset);
884 ret = -EIO;
885 goto done;
886 }
887 nxpwifi_dbg(adapter, ERROR,
888 "CRC indicated by the helper:\t"
889 "len = 0x%04X, txlen = %d\n", len, txlen);
890 len &= ~BIT(0);
891 /* Setting this to 0 to resend from same offset */
892 txlen = 0;
893 } else {
894 i = 0;
895
896 /*
897 * Set blocksize to transfer - checking for last
898 * block
899 */
900 if (firmware_len - offset < txlen)
901 txlen = firmware_len - offset;
902
903 tx_blocks = (txlen + NXPWIFI_SDIO_BLOCK_SIZE - 1)
904 / NXPWIFI_SDIO_BLOCK_SIZE;
905
906 /* Copy payload to buffer */
907 memcpy(fwbuf, &firmware[offset], txlen);
908 }
909
910 ret = nxpwifi_write_data_sync(adapter, fwbuf, tx_blocks *
911 NXPWIFI_SDIO_BLOCK_SIZE,
912 adapter->ioport);
913 if (ret) {
914 nxpwifi_dbg(adapter, ERROR,
915 "FW download, write iomem (%d) failed @ %d\n",
916 i, offset);
917 if (nxpwifi_write_reg(adapter, CONFIGURATION_REG, 0x04))
918 nxpwifi_dbg(adapter, ERROR, "write CFG reg failed\n");
919
920 goto done;
921 }
922
923 offset += txlen;
924 } while (true);
925
926 nxpwifi_dbg(adapter, MSG, "FW download complete (%u bytes)\n", offset);
927
928 ret = 0;
929 done:
930 sdio_release_host(card->func);
931 kfree(fwbuf);
932 return ret;
933 }
934
935 /* Deaggregate an SDIO RX aggregation packet. */
nxpwifi_deaggr_sdio_pkt(struct nxpwifi_adapter * adapter,struct sk_buff * skb)936 static void nxpwifi_deaggr_sdio_pkt(struct nxpwifi_adapter *adapter,
937 struct sk_buff *skb)
938 {
939 u32 total_pkt_len, pkt_len;
940 struct sk_buff *skb_deaggr;
941 u16 blk_size;
942 u8 blk_num;
943 u8 *data;
944
945 data = skb->data;
946 total_pkt_len = skb->len;
947
948 while (total_pkt_len >= (SDIO_HEADER_OFFSET + adapter->intf_hdr_len)) {
949 if (total_pkt_len < adapter->sdio_rx_block_size)
950 break;
951 blk_num = *(data + BLOCK_NUMBER_OFFSET);
952 blk_size = adapter->sdio_rx_block_size * blk_num;
953 if (blk_size > total_pkt_len) {
954 nxpwifi_dbg(adapter, ERROR,
955 "%s: error in blk_size,\t"
956 "blk_num=%d, blk_size=%d, total_pkt_len=%d\n",
957 __func__, blk_num, blk_size, total_pkt_len);
958 break;
959 }
960 pkt_len = get_unaligned_le16((data +
961 SDIO_HEADER_OFFSET));
962 if ((pkt_len + SDIO_HEADER_OFFSET) > blk_size) {
963 nxpwifi_dbg(adapter, ERROR,
964 "%s: error in pkt_len,\t"
965 "pkt_len=%d, blk_size=%d\n",
966 __func__, pkt_len, blk_size);
967 break;
968 }
969
970 skb_deaggr = nxpwifi_alloc_dma_align_buf(pkt_len, GFP_KERNEL);
971 if (!skb_deaggr)
972 break;
973 skb_put(skb_deaggr, pkt_len);
974 memcpy(skb_deaggr->data, data + SDIO_HEADER_OFFSET, pkt_len);
975 skb_pull(skb_deaggr, adapter->intf_hdr_len);
976
977 nxpwifi_handle_rx_packet(adapter, skb_deaggr);
978 data += blk_size;
979 total_pkt_len -= blk_size;
980 }
981 }
982
nxpwifi_decode_rx_packet(struct nxpwifi_adapter * adapter,struct sk_buff * skb,u32 upld_typ)983 static void nxpwifi_decode_rx_packet(struct nxpwifi_adapter *adapter,
984 struct sk_buff *skb, u32 upld_typ)
985 {
986 u8 *cmd_buf;
987 u16 pkt_len;
988 struct nxpwifi_rxinfo *rx_info;
989
990 pkt_len = get_unaligned_le16(skb->data);
991
992 if (upld_typ != NXPWIFI_TYPE_AGGR_DATA) {
993 skb_trim(skb, pkt_len);
994 skb_pull(skb, adapter->intf_hdr_len);
995 }
996
997 switch (upld_typ) {
998 case NXPWIFI_TYPE_AGGR_DATA:
999 nxpwifi_dbg(adapter, DATA,
1000 "Rx Aggr Data packet\n");
1001 rx_info = NXPWIFI_SKB_RXCB(skb);
1002 rx_info->buf_type = NXPWIFI_TYPE_AGGR_DATA;
1003 if (adapter->rx_work_enabled) {
1004 skb_queue_tail(&adapter->rx_data_q, skb);
1005 atomic_inc(&adapter->rx_pending);
1006 adapter->data_received = true;
1007 } else {
1008 /* Deaggregate an SDIO RX aggregation packet. */
1009 nxpwifi_deaggr_sdio_pkt(adapter, skb);
1010 dev_kfree_skb_any(skb);
1011 }
1012 break;
1013
1014 case NXPWIFI_TYPE_DATA:
1015 nxpwifi_dbg(adapter, DATA, "Rx Data packet\n");
1016 if (adapter->rx_work_enabled) {
1017 skb_queue_tail(&adapter->rx_data_q, skb);
1018 adapter->data_received = true;
1019 atomic_inc(&adapter->rx_pending);
1020 } else {
1021 nxpwifi_handle_rx_packet(adapter, skb);
1022 }
1023 break;
1024
1025 case NXPWIFI_TYPE_CMD:
1026 nxpwifi_dbg(adapter, CMD, "Rx Cmd Response\n");
1027 /* take care of curr_cmd = NULL case */
1028 if (!adapter->curr_cmd) {
1029 cmd_buf = adapter->upld_buf;
1030
1031 if (adapter->ps_state == PS_STATE_SLEEP_CFM)
1032 nxpwifi_process_sleep_confirm_resp(adapter,
1033 skb->data,
1034 skb->len);
1035
1036 memcpy(cmd_buf, skb->data,
1037 min_t(u32, NXPWIFI_SIZE_OF_CMD_BUFFER,
1038 skb->len));
1039
1040 dev_kfree_skb_any(skb);
1041 } else {
1042 adapter->cmd_resp_received = true;
1043 adapter->curr_cmd->resp_skb = skb;
1044 }
1045 break;
1046
1047 case NXPWIFI_TYPE_EVENT:
1048 nxpwifi_dbg(adapter, EVENT, "Rx Event\n");
1049 adapter->event_cause = get_unaligned_le32(skb->data);
1050
1051 if (skb->len > NXPWIFI_EVENT_HEADER_LEN) {
1052 u32 body_len = min_t(u32, skb->len - NXPWIFI_EVENT_HEADER_LEN,
1053 MAX_EVENT_SIZE);
1054 memcpy(adapter->event_body, skb->data + NXPWIFI_EVENT_HEADER_LEN,
1055 body_len);
1056 }
1057
1058 /* event cause has been saved to adapter->event_cause */
1059 adapter->event_received = true;
1060 adapter->event_skb = skb;
1061
1062 break;
1063
1064 default:
1065 nxpwifi_dbg(adapter, ERROR, "unknown upload type %#x\n", upld_typ);
1066 dev_kfree_skb_any(skb);
1067 break;
1068 }
1069 }
1070
1071 /* Receive path with SDIO multi-port aggregation. */
nxpwifi_sdio_card_to_host_mp_aggr(struct nxpwifi_adapter * adapter,u16 rx_len,u8 port)1072 static int nxpwifi_sdio_card_to_host_mp_aggr(struct nxpwifi_adapter *adapter,
1073 u16 rx_len, u8 port)
1074 {
1075 struct sdio_mmc_card *card = adapter->card;
1076 s32 f_do_rx_aggr = 0;
1077 s32 f_do_rx_cur = 0;
1078 s32 f_aggr_cur = 0;
1079 s32 f_post_aggr_cur = 0;
1080 struct sk_buff *skb_deaggr;
1081 struct sk_buff *skb = NULL;
1082 u32 pkt_len, pkt_type, mport, pind;
1083 u8 *curr_ptr;
1084 int ret = 0;
1085
1086 if (!card->mpa_rx.enabled) {
1087 nxpwifi_dbg(adapter, WARN, "rx aggregation disabled\n");
1088 f_do_rx_cur = 1;
1089 goto rx_curr_single;
1090 }
1091
1092 if (card->mp_rd_bitmap & card->reg->data_port_mask) {
1093 /* Some more data RX pending */
1094
1095 if (MP_RX_AGGR_IN_PROGRESS(card)) {
1096 if (MP_RX_AGGR_BUF_HAS_ROOM(card, rx_len)) {
1097 f_aggr_cur = 1;
1098 } else {
1099 /* No room in Aggr buf, do rx aggr now */
1100 f_do_rx_aggr = 1;
1101 f_post_aggr_cur = 1;
1102 }
1103 } else {
1104 /* Rx aggr not in progress */
1105 f_aggr_cur = 1;
1106 }
1107
1108 } else {
1109 /* No more data RX pending */
1110
1111 if (MP_RX_AGGR_IN_PROGRESS(card)) {
1112 f_do_rx_aggr = 1;
1113 if (MP_RX_AGGR_BUF_HAS_ROOM(card, rx_len))
1114 f_aggr_cur = 1;
1115 else
1116 /* No room in Aggr buf, do rx aggr now */
1117 f_do_rx_cur = 1;
1118 } else {
1119 f_do_rx_cur = 1;
1120 }
1121 }
1122
1123 if (f_aggr_cur) {
1124 /* Curr pkt can be aggregated */
1125 mp_rx_aggr_setup(card, rx_len, port);
1126
1127 if (MP_RX_AGGR_PKT_LIMIT_REACHED(card) ||
1128 mp_rx_aggr_port_limit_reached(card)) {
1129 /* No more pkts allowed in Aggr buf, rx it */
1130 f_do_rx_aggr = 1;
1131 }
1132 }
1133
1134 if (f_do_rx_aggr) {
1135 u32 port_count;
1136 int i;
1137
1138 /* do aggr RX now */
1139 for (i = 0, port_count = 0; i < card->max_ports; i++)
1140 if (card->mpa_rx.ports & BIT(i))
1141 port_count++;
1142
1143 /*
1144 * Reading data from "start_port + 0" to "start_port +
1145 * port_count -1", so decrease the count by 1
1146 */
1147 port_count--;
1148 mport = (adapter->ioport | SDIO_MPA_ADDR_BASE |
1149 (port_count << 8)) + card->mpa_rx.start_port;
1150
1151 if (card->mpa_rx.pkt_cnt == 1)
1152 mport = adapter->ioport + card->mpa_rx.start_port;
1153
1154 ret = nxpwifi_read_data_sync(adapter, card->mpa_rx.buf,
1155 card->mpa_rx.buf_len, mport, 1);
1156 if (ret)
1157 goto error;
1158
1159 curr_ptr = card->mpa_rx.buf;
1160
1161 for (pind = 0; pind < card->mpa_rx.pkt_cnt; pind++) {
1162 u32 *len_arr = card->mpa_rx.len_arr;
1163
1164 /* get curr PKT len & type */
1165 pkt_len = get_unaligned_le16(&curr_ptr[0]);
1166 pkt_type = get_unaligned_le16(&curr_ptr[2]);
1167
1168 /* copy pkt to deaggr buf */
1169 skb_deaggr = nxpwifi_alloc_dma_align_buf(len_arr[pind],
1170 GFP_KERNEL);
1171 if (!skb_deaggr) {
1172 nxpwifi_dbg(adapter, ERROR, "skb allocation failure\t"
1173 "drop pkt len=%d type=%d\n",
1174 pkt_len, pkt_type);
1175 curr_ptr += len_arr[pind];
1176 continue;
1177 }
1178
1179 skb_put(skb_deaggr, len_arr[pind]);
1180
1181 if ((pkt_type == NXPWIFI_TYPE_DATA ||
1182 (pkt_type == NXPWIFI_TYPE_AGGR_DATA &&
1183 adapter->sdio_rx_aggr_enable)) &&
1184 pkt_len <= len_arr[pind]) {
1185 memcpy(skb_deaggr->data, curr_ptr, pkt_len);
1186
1187 skb_trim(skb_deaggr, pkt_len);
1188
1189 nxpwifi_decode_rx_packet(adapter, skb_deaggr,
1190 pkt_type);
1191 } else {
1192 nxpwifi_dbg(adapter, ERROR,
1193 "drop wrong aggr pkt:\t"
1194 "sdio_single_port_rx_aggr=%d\t"
1195 "type=%d len=%d max_len=%d\n",
1196 adapter->sdio_rx_aggr_enable,
1197 pkt_type, pkt_len, len_arr[pind]);
1198 dev_kfree_skb_any(skb_deaggr);
1199 }
1200 curr_ptr += len_arr[pind];
1201 }
1202 MP_RX_AGGR_BUF_RESET(card);
1203 }
1204
1205 rx_curr_single:
1206 if (f_do_rx_cur) {
1207 skb = nxpwifi_alloc_dma_align_buf(rx_len, GFP_KERNEL);
1208 if (!skb) {
1209 nxpwifi_dbg(adapter, ERROR,
1210 "single skb allocated fail,\t"
1211 "drop pkt port=%d len=%d\n", port, rx_len);
1212 ret = nxpwifi_sdio_card_to_host(adapter, &pkt_type,
1213 card->mpa_rx.buf,
1214 rx_len,
1215 adapter->ioport + port);
1216 if (ret)
1217 goto error;
1218 return 0;
1219 }
1220
1221 skb_put(skb, rx_len);
1222
1223 ret = nxpwifi_sdio_card_to_host(adapter, &pkt_type,
1224 skb->data, skb->len,
1225 adapter->ioport + port);
1226 if (ret)
1227 goto error;
1228 if (!adapter->sdio_rx_aggr_enable &&
1229 pkt_type == NXPWIFI_TYPE_AGGR_DATA) {
1230 nxpwifi_dbg(adapter, ERROR, "drop wrong pkt type %d\t"
1231 "current SDIO RX Aggr not enabled\n",
1232 pkt_type);
1233 dev_kfree_skb_any(skb);
1234 return 0;
1235 }
1236
1237 nxpwifi_decode_rx_packet(adapter, skb, pkt_type);
1238 }
1239 if (f_post_aggr_cur) /* Curr pkt can be aggregated */
1240 mp_rx_aggr_setup(card, rx_len, port);
1241
1242 return 0;
1243 error:
1244 if (MP_RX_AGGR_IN_PROGRESS(card))
1245 MP_RX_AGGR_BUF_RESET(card);
1246
1247 if (f_do_rx_cur && skb) /* Single transfer pending. Free curr buff also */
1248 dev_kfree_skb_any(skb);
1249
1250 return ret;
1251 }
1252
nxpwifi_process_int_status(struct nxpwifi_adapter * adapter,u8 sdio_ireg)1253 static int nxpwifi_process_int_status(struct nxpwifi_adapter *adapter, u8 sdio_ireg)
1254 {
1255 struct sdio_mmc_card *card = adapter->card;
1256 const struct nxpwifi_sdio_card_reg *reg = card->reg;
1257 int ret = 0;
1258 struct sk_buff *skb;
1259 u8 port;
1260 u32 len_reg_l, len_reg_u;
1261 u32 rx_blocks;
1262 u16 rx_len;
1263 u32 bitmap;
1264 u8 cr;
1265
1266 if (!sdio_ireg)
1267 return ret;
1268
1269 if (sdio_ireg & DN_LD_CMD_PORT_HOST_INT_STATUS && adapter->cmd_sent)
1270 adapter->cmd_sent = false;
1271
1272 if (sdio_ireg & UP_LD_CMD_PORT_HOST_INT_STATUS) {
1273 u32 pkt_type;
1274
1275 /* read the len of control packet */
1276 rx_len = card->mp_regs[reg->cmd_rd_len_1] << 8;
1277 rx_len |= (u16)card->mp_regs[reg->cmd_rd_len_0];
1278 rx_blocks = DIV_ROUND_UP(rx_len, NXPWIFI_SDIO_BLOCK_SIZE);
1279 if (rx_len <= adapter->intf_hdr_len ||
1280 (rx_blocks * NXPWIFI_SDIO_BLOCK_SIZE) >
1281 NXPWIFI_RX_DATA_BUF_SIZE)
1282 return -EINVAL;
1283 rx_len = (u16)(rx_blocks * NXPWIFI_SDIO_BLOCK_SIZE);
1284
1285 skb = nxpwifi_alloc_dma_align_buf(rx_len, GFP_KERNEL);
1286 if (!skb)
1287 return -ENOMEM;
1288
1289 skb_put(skb, rx_len);
1290
1291 ret = nxpwifi_sdio_card_to_host(adapter, &pkt_type, skb->data,
1292 skb->len, adapter->ioport |
1293 CMD_PORT_SLCT);
1294 if (ret) {
1295 nxpwifi_dbg(adapter, ERROR, "failed to card_to_host");
1296 dev_kfree_skb_any(skb);
1297 goto term_cmd;
1298 }
1299
1300 if (pkt_type != NXPWIFI_TYPE_CMD &&
1301 pkt_type != NXPWIFI_TYPE_EVENT)
1302 nxpwifi_dbg(adapter, ERROR, "Received wrong packet on cmd port");
1303
1304 nxpwifi_decode_rx_packet(adapter, skb, pkt_type);
1305 }
1306
1307 if (sdio_ireg & DN_LD_HOST_INT_STATUS) {
1308 bitmap = (u32)card->mp_regs[reg->wr_bitmap_l];
1309 bitmap |= ((u32)card->mp_regs[reg->wr_bitmap_u]) << 8;
1310 bitmap |= ((u32)card->mp_regs[reg->wr_bitmap_1l]) << 16;
1311 bitmap |= ((u32)card->mp_regs[reg->wr_bitmap_1u]) << 24;
1312 card->mp_wr_bitmap = bitmap;
1313
1314 nxpwifi_dbg(adapter, INTR, "intr: wr_bitmap=0x%x\n", card->mp_wr_bitmap);
1315 if (adapter->data_sent &&
1316 (card->mp_wr_bitmap & card->mp_data_port_mask)) {
1317 nxpwifi_dbg(adapter, INTR, "Tx DONE\n");
1318 adapter->data_sent = false;
1319 }
1320 }
1321
1322 nxpwifi_dbg(adapter, INTR, "cmd_sent=%d data_sent=%d\n",
1323 adapter->cmd_sent, adapter->data_sent);
1324 if (sdio_ireg & UP_LD_HOST_INT_STATUS) {
1325 bitmap = (u32)card->mp_regs[reg->rd_bitmap_l];
1326 bitmap |= ((u32)card->mp_regs[reg->rd_bitmap_u]) << 8;
1327 bitmap |= ((u32)card->mp_regs[reg->rd_bitmap_1l]) << 16;
1328 bitmap |= ((u32)card->mp_regs[reg->rd_bitmap_1u]) << 24;
1329 card->mp_rd_bitmap = bitmap;
1330 nxpwifi_dbg(adapter, INTR, "intr: rd_bitmap=0x%x\n", card->mp_rd_bitmap);
1331
1332 while (true) {
1333 ret = nxpwifi_get_rd_port(adapter, &port);
1334
1335 if (ret)
1336 break;
1337
1338 len_reg_l = reg->rd_len_p0_l + (port << 1);
1339 len_reg_u = reg->rd_len_p0_u + (port << 1);
1340 rx_len = ((u16)card->mp_regs[len_reg_u]) << 8;
1341 rx_len |= (u16)card->mp_regs[len_reg_l];
1342 rx_blocks =
1343 (rx_len + NXPWIFI_SDIO_BLOCK_SIZE -
1344 1) / NXPWIFI_SDIO_BLOCK_SIZE;
1345 if (rx_len <= adapter->intf_hdr_len ||
1346 (card->mpa_rx.enabled &&
1347 ((rx_blocks * NXPWIFI_SDIO_BLOCK_SIZE) >
1348 card->mpa_rx.buf_size))) {
1349 nxpwifi_dbg(adapter, ERROR, "invalid rx_len=%d\n", rx_len);
1350 ret = -EINVAL;
1351 goto term_cmd;
1352 }
1353
1354 rx_len = (u16)(rx_blocks * NXPWIFI_SDIO_BLOCK_SIZE);
1355
1356 ret = nxpwifi_sdio_card_to_host_mp_aggr(adapter, rx_len,
1357 port);
1358 if (ret) {
1359 nxpwifi_dbg(adapter, ERROR,
1360 "card_to_host_mpa failed: int status=%#x\n",
1361 sdio_ireg);
1362 goto term_cmd;
1363 }
1364 }
1365 }
1366
1367 return 0;
1368
1369 term_cmd:
1370 /* terminate cmd */
1371 if (nxpwifi_read_reg(adapter, CONFIGURATION_REG, &cr))
1372 nxpwifi_dbg(adapter, ERROR, "read CFG reg failed\n");
1373 else
1374 nxpwifi_dbg(adapter, INFO, "info: CFG reg val = %d\n", cr);
1375
1376 if (nxpwifi_write_reg(adapter, CONFIGURATION_REG, (cr | 0x04)))
1377 nxpwifi_dbg(adapter, ERROR, "write CFG reg failed\n");
1378 else
1379 nxpwifi_dbg(adapter, INFO, "info: write success\n");
1380
1381 if (nxpwifi_read_reg(adapter, CONFIGURATION_REG, &cr))
1382 nxpwifi_dbg(adapter, ERROR, "read CFG reg failed\n");
1383 else
1384 nxpwifi_dbg(adapter, INFO, "info: CFG reg val =%x\n", cr);
1385
1386 return ret;
1387 }
1388
1389 /* Transmit using SDIO multi-port aggregation. */
nxpwifi_host_to_card_mp_aggr(struct nxpwifi_adapter * adapter,u8 * payload,u32 pkt_len,u32 port,u32 next_pkt_len)1390 static int nxpwifi_host_to_card_mp_aggr(struct nxpwifi_adapter *adapter,
1391 u8 *payload, u32 pkt_len, u32 port,
1392 u32 next_pkt_len)
1393 {
1394 struct sdio_mmc_card *card = adapter->card;
1395 int ret = 0;
1396 s32 f_send_aggr_buf = 0;
1397 s32 f_send_cur_buf = 0;
1398 s32 f_precopy_cur_buf = 0;
1399 s32 f_postcopy_cur_buf = 0;
1400 u32 mport;
1401 int index;
1402
1403 if (!card->mpa_tx.enabled || port == CMD_PORT_SLCT) {
1404 nxpwifi_dbg(adapter, WARN, "tx aggregation disabled\n");
1405 f_send_cur_buf = 1;
1406 goto tx_curr_single;
1407 }
1408
1409 if (next_pkt_len) {
1410 /* More pkt in TX queue */
1411
1412 if (MP_TX_AGGR_IN_PROGRESS(card)) {
1413 if (MP_TX_AGGR_BUF_HAS_ROOM(card, pkt_len)) {
1414 f_precopy_cur_buf = 1;
1415
1416 if (!(card->mp_wr_bitmap &
1417 (1 << card->curr_wr_port)) ||
1418 !MP_TX_AGGR_BUF_HAS_ROOM
1419 (card, pkt_len + next_pkt_len))
1420 f_send_aggr_buf = 1;
1421 } else {
1422 /* No room in Aggr buf, send it */
1423 f_send_aggr_buf = 1;
1424
1425 if (!(card->mp_wr_bitmap &
1426 (1 << card->curr_wr_port)))
1427 f_send_cur_buf = 1;
1428 else
1429 f_postcopy_cur_buf = 1;
1430 }
1431 } else {
1432 if (MP_TX_AGGR_BUF_HAS_ROOM(card, pkt_len) &&
1433 (card->mp_wr_bitmap & (1 << card->curr_wr_port)))
1434 f_precopy_cur_buf = 1;
1435 else
1436 f_send_cur_buf = 1;
1437 }
1438 } else {
1439 /* Last pkt in TX queue */
1440
1441 if (MP_TX_AGGR_IN_PROGRESS(card)) {
1442 /* some packs in Aggr buf already */
1443 f_send_aggr_buf = 1;
1444
1445 if (MP_TX_AGGR_BUF_HAS_ROOM(card, pkt_len))
1446 f_precopy_cur_buf = 1;
1447 else
1448 /* No room in Aggr buf, send it */
1449 f_send_cur_buf = 1;
1450 } else {
1451 f_send_cur_buf = 1;
1452 }
1453 }
1454
1455 if (f_precopy_cur_buf) {
1456 MP_TX_AGGR_BUF_PUT(card, payload, pkt_len, port);
1457
1458 if (MP_TX_AGGR_PKT_LIMIT_REACHED(card) ||
1459 mp_tx_aggr_port_limit_reached(card))
1460 /* No more pkts allowed in Aggr buf, send it */
1461 f_send_aggr_buf = 1;
1462 }
1463
1464 if (f_send_aggr_buf) {
1465 u32 port_count;
1466 int i;
1467
1468 for (i = 0, port_count = 0; i < card->max_ports; i++)
1469 if (card->mpa_tx.ports & BIT(i))
1470 port_count++;
1471
1472 /*
1473 * Writing data from "start_port + 0" to "start_port +
1474 * port_count -1", so decrease the count by 1
1475 */
1476 port_count--;
1477 mport = (adapter->ioport | SDIO_MPA_ADDR_BASE |
1478 (port_count << 8)) + card->mpa_tx.start_port;
1479
1480 if (card->mpa_tx.pkt_cnt == 1)
1481 mport = adapter->ioport + card->mpa_tx.start_port;
1482
1483 ret = nxpwifi_write_data_to_card(adapter, card->mpa_tx.buf,
1484 card->mpa_tx.buf_len, mport);
1485
1486 /* Save the last multi port tx aggregation info to debug log */
1487 index = adapter->dbg.last_sdio_mp_index;
1488 index = (index + 1) % NXPWIFI_DBG_SDIO_MP_NUM;
1489 adapter->dbg.last_sdio_mp_index = index;
1490 adapter->dbg.last_mp_wr_ports[index] = mport;
1491 adapter->dbg.last_mp_wr_bitmap[index] = card->mp_wr_bitmap;
1492 adapter->dbg.last_mp_wr_len[index] = card->mpa_tx.buf_len;
1493 adapter->dbg.last_mp_curr_wr_port[index] = card->curr_wr_port;
1494
1495 MP_TX_AGGR_BUF_RESET(card);
1496 }
1497
1498 tx_curr_single:
1499 if (f_send_cur_buf)
1500 ret = nxpwifi_write_data_to_card(adapter, payload, pkt_len,
1501 adapter->ioport + port);
1502
1503 if (f_postcopy_cur_buf)
1504 MP_TX_AGGR_BUF_PUT(card, payload, pkt_len, port);
1505
1506 return ret;
1507 }
1508
nxpwifi_sdio_host_to_card(struct nxpwifi_adapter * adapter,u8 type,struct sk_buff * skb,struct nxpwifi_tx_param * tx_param)1509 static int nxpwifi_sdio_host_to_card(struct nxpwifi_adapter *adapter,
1510 u8 type, struct sk_buff *skb,
1511 struct nxpwifi_tx_param *tx_param)
1512 {
1513 struct sdio_mmc_card *card = adapter->card;
1514 int ret;
1515 u32 buf_block_len;
1516 u32 blk_size;
1517 u32 port;
1518 u8 *payload = (u8 *)skb->data;
1519 u32 pkt_len = skb->len;
1520
1521 /* Allocate buffer and copy payload */
1522 blk_size = NXPWIFI_SDIO_BLOCK_SIZE;
1523 buf_block_len = (pkt_len + blk_size - 1) / blk_size;
1524 put_unaligned_le16((u16)pkt_len, payload + 0);
1525 put_unaligned_le16((u16)type, payload + 2);
1526
1527 /*
1528 * This is SDIO specific header
1529 * u16 length,
1530 * u16 type (NXPWIFI_TYPE_DATA = 0, NXPWIFI_TYPE_CMD = 1,
1531 * NXPWIFI_TYPE_EVENT = 3)
1532 */
1533 if (type == NXPWIFI_TYPE_DATA) {
1534 ret = nxpwifi_get_wr_port_data(adapter, &port);
1535 if (ret) {
1536 nxpwifi_dbg(adapter, ERROR, "no wr_port available\n");
1537 return ret;
1538 }
1539 } else {
1540 adapter->cmd_sent = true;
1541
1542 if (pkt_len <= adapter->intf_hdr_len ||
1543 pkt_len > NXPWIFI_UPLD_SIZE) {
1544 nxpwifi_dbg(adapter, ERROR,
1545 "invalid upld pkt_len=%u (hdr_len=%u, max=%u)\n",
1546 pkt_len, adapter->intf_hdr_len, NXPWIFI_UPLD_SIZE);
1547 return -EINVAL;
1548 }
1549
1550 port = CMD_PORT_SLCT;
1551 }
1552
1553 /* Transfer data to card */
1554 pkt_len = buf_block_len * blk_size;
1555
1556 if (tx_param)
1557 ret = nxpwifi_host_to_card_mp_aggr(adapter, payload, pkt_len,
1558 port, tx_param->next_pkt_len
1559 );
1560 else
1561 ret = nxpwifi_host_to_card_mp_aggr(adapter, payload, pkt_len,
1562 port, 0);
1563
1564 if (ret) {
1565 if (type == NXPWIFI_TYPE_CMD ||
1566 type == NXPWIFI_TYPE_VDLL)
1567 adapter->cmd_sent = false;
1568 if (type == NXPWIFI_TYPE_DATA) {
1569 adapter->data_sent = false;
1570 /* restore curr_wr_port in error cases */
1571 card->curr_wr_port = port;
1572 card->mp_wr_bitmap |= (u32)(1 << card->curr_wr_port);
1573 }
1574 } else {
1575 if (type == NXPWIFI_TYPE_DATA) {
1576 if (!(card->mp_wr_bitmap & (1 << card->curr_wr_port)))
1577 adapter->data_sent = true;
1578 else
1579 adapter->data_sent = false;
1580 }
1581 }
1582
1583 return ret;
1584 }
1585
nxpwifi_alloc_sdio_mpa_buffers(struct nxpwifi_adapter * adapter,u32 mpa_tx_buf_size,u32 mpa_rx_buf_size)1586 static int nxpwifi_alloc_sdio_mpa_buffers(struct nxpwifi_adapter *adapter,
1587 u32 mpa_tx_buf_size,
1588 u32 mpa_rx_buf_size)
1589 {
1590 struct sdio_mmc_card *card = adapter->card;
1591 u32 rx_buf_size;
1592 int ret = 0;
1593
1594 card->mpa_tx.buf = kzalloc(mpa_tx_buf_size, GFP_KERNEL);
1595 if (!card->mpa_tx.buf) {
1596 ret = -ENOMEM;
1597 goto error;
1598 }
1599
1600 card->mpa_tx.buf_size = mpa_tx_buf_size;
1601
1602 rx_buf_size = max_t(u32, mpa_rx_buf_size,
1603 (u32)SDIO_MAX_AGGR_BUF_SIZE);
1604 card->mpa_rx.buf = kzalloc(rx_buf_size, GFP_KERNEL);
1605 if (!card->mpa_rx.buf) {
1606 ret = -ENOMEM;
1607 goto error;
1608 }
1609
1610 card->mpa_rx.buf_size = rx_buf_size;
1611
1612 error:
1613 if (ret) {
1614 kfree(card->mpa_tx.buf);
1615 kfree(card->mpa_rx.buf);
1616 card->mpa_tx.buf_size = 0;
1617 card->mpa_rx.buf_size = 0;
1618 card->mpa_tx.buf = NULL;
1619 card->mpa_rx.buf = NULL;
1620 }
1621
1622 return ret;
1623 }
1624
1625 static void
nxpwifi_unregister_dev(struct nxpwifi_adapter * adapter)1626 nxpwifi_unregister_dev(struct nxpwifi_adapter *adapter)
1627 {
1628 struct sdio_mmc_card *card = adapter->card;
1629
1630 if (adapter->card) {
1631 card->adapter = NULL;
1632 sdio_claim_host(card->func);
1633 sdio_disable_func(card->func);
1634 sdio_release_host(card->func);
1635 }
1636 }
1637
nxpwifi_register_dev(struct nxpwifi_adapter * adapter)1638 static int nxpwifi_register_dev(struct nxpwifi_adapter *adapter)
1639 {
1640 int ret;
1641 struct sdio_mmc_card *card = adapter->card;
1642 struct sdio_func *func = card->func;
1643 const char *firmware = card->firmware;
1644
1645 /* save adapter pointer in card */
1646 card->adapter = adapter;
1647 adapter->tx_buf_size = card->tx_buf_size;
1648
1649 sdio_claim_host(func);
1650
1651 /* Set block size */
1652 ret = sdio_set_block_size(card->func, NXPWIFI_SDIO_BLOCK_SIZE);
1653 sdio_release_host(func);
1654 if (ret) {
1655 nxpwifi_dbg(adapter, ERROR, "cannot set SDIO block size\n");
1656 return ret;
1657 }
1658
1659 /*
1660 * Select correct firmware (sdsd or sdiouart) firmware based on the strapping
1661 * option
1662 */
1663 if (card->firmware_sdiouart) {
1664 u8 val;
1665
1666 nxpwifi_read_reg(adapter, card->reg->host_strap_reg, &val);
1667 if ((val & card->reg->host_strap_mask) == card->reg->host_strap_value)
1668 firmware = card->firmware_sdiouart;
1669 }
1670 strscpy(adapter->fw_name, firmware, sizeof(adapter->fw_name));
1671
1672 if (card->fw_dump_enh) {
1673 adapter->mem_type_mapping_tbl = generic_mem_type_map;
1674 adapter->num_mem_types = 1;
1675 } else {
1676 adapter->mem_type_mapping_tbl = mem_type_mapping_tbl;
1677 adapter->num_mem_types = ARRAY_SIZE(mem_type_mapping_tbl);
1678 }
1679
1680 return 0;
1681 }
1682
nxpwifi_init_sdio(struct nxpwifi_adapter * adapter)1683 static int nxpwifi_init_sdio(struct nxpwifi_adapter *adapter)
1684 {
1685 struct sdio_mmc_card *card = adapter->card;
1686 const struct nxpwifi_sdio_card_reg *reg = card->reg;
1687 int ret;
1688 u8 sdio_ireg;
1689
1690 sdio_set_drvdata(card->func, card);
1691
1692 /*
1693 * Read the host_int_status_reg for ACK the first interrupt got
1694 * from the bootloader. If we don't do this we get a interrupt
1695 * as soon as we register the irq.
1696 */
1697 nxpwifi_read_reg(adapter, card->reg->host_int_status_reg, &sdio_ireg);
1698
1699 /* Get SDIO ioport */
1700 if (nxpwifi_init_sdio_ioport(adapter))
1701 return -EIO;
1702
1703 /* Initialize SDIO variables in card */
1704 card->mp_rd_bitmap = 0;
1705 card->mp_wr_bitmap = 0;
1706 card->curr_rd_port = reg->start_rd_port;
1707 card->curr_wr_port = reg->start_wr_port;
1708
1709 card->mp_data_port_mask = reg->data_port_mask;
1710
1711 card->mpa_tx.buf_len = 0;
1712 card->mpa_tx.pkt_cnt = 0;
1713 card->mpa_tx.start_port = 0;
1714
1715 card->mpa_tx.enabled = 1;
1716 card->mpa_tx.pkt_aggr_limit = card->mp_agg_pkt_limit;
1717
1718 card->mpa_rx.buf_len = 0;
1719 card->mpa_rx.pkt_cnt = 0;
1720 card->mpa_rx.start_port = 0;
1721
1722 card->mpa_rx.enabled = 1;
1723 card->mpa_rx.pkt_aggr_limit = card->mp_agg_pkt_limit;
1724
1725 /* Allocate buffers for SDIO MP-A */
1726 card->mp_regs = devm_kzalloc(&card->func->dev, reg->max_mp_regs, GFP_KERNEL);
1727
1728 if (!card->mp_regs)
1729 return -ENOMEM;
1730
1731 card->mpa_rx.len_arr =
1732 devm_kcalloc(&card->func->dev, card->mp_agg_pkt_limit,
1733 sizeof(*card->mpa_rx.len_arr), GFP_KERNEL);
1734
1735 if (!card->mpa_rx.len_arr)
1736 return -ENOMEM;
1737
1738 ret = nxpwifi_alloc_sdio_mpa_buffers(adapter,
1739 card->mp_tx_agg_buf_size,
1740 card->mp_rx_agg_buf_size);
1741
1742 /* Allocate 32k MPA Tx/Rx buffers if 64k memory allocation fails */
1743 if (ret && (card->mp_tx_agg_buf_size == NXPWIFI_MP_AGGR_BSIZE_MAX ||
1744 card->mp_rx_agg_buf_size == NXPWIFI_MP_AGGR_BSIZE_MAX)) {
1745 /* Disable rx single port aggregation */
1746 adapter->host_disable_sdio_rx_aggr = true;
1747
1748 ret = nxpwifi_alloc_sdio_mpa_buffers(adapter,
1749 NXPWIFI_MP_AGGR_BSIZE_32K,
1750 NXPWIFI_MP_AGGR_BSIZE_32K);
1751 if (ret) {
1752 /* Disable multi port aggregation */
1753 card->mpa_tx.enabled = 0;
1754 card->mpa_rx.enabled = 0;
1755 }
1756 }
1757
1758 adapter->ext_scan = card->can_ext_scan;
1759 return ret;
1760 }
1761
nxpwifi_cleanup_mpa_buf(struct nxpwifi_adapter * adapter)1762 static void nxpwifi_cleanup_mpa_buf(struct nxpwifi_adapter *adapter)
1763 {
1764 struct sdio_mmc_card *card = adapter->card;
1765
1766 MP_TX_AGGR_BUF_RESET(card);
1767 MP_RX_AGGR_BUF_RESET(card);
1768 }
1769
nxpwifi_cleanup_sdio(struct nxpwifi_adapter * adapter)1770 static void nxpwifi_cleanup_sdio(struct nxpwifi_adapter *adapter)
1771 {
1772 struct sdio_mmc_card *card = adapter->card;
1773
1774 cancel_work_sync(&card->work);
1775
1776 kfree(card->mpa_tx.buf);
1777 kfree(card->mpa_rx.buf);
1778 }
1779
1780 static void
nxpwifi_update_mp_end_port(struct nxpwifi_adapter * adapter,u16 port)1781 nxpwifi_update_mp_end_port(struct nxpwifi_adapter *adapter, u16 port)
1782 {
1783 struct sdio_mmc_card *card = adapter->card;
1784 const struct nxpwifi_sdio_card_reg *reg = card->reg;
1785 int i;
1786
1787 card->mp_end_port = port;
1788
1789 card->mp_data_port_mask = reg->data_port_mask;
1790
1791 if (reg->start_wr_port) {
1792 for (i = 1; i <= card->max_ports - card->mp_end_port; i++)
1793 card->mp_data_port_mask &=
1794 ~(1 << (card->max_ports - i));
1795 }
1796
1797 card->curr_wr_port = reg->start_wr_port;
1798 }
1799
1800 /* Perform an SDIO card reset in workqueue context. */
nxpwifi_sdio_card_reset_work(struct nxpwifi_adapter * adapter)1801 static void nxpwifi_sdio_card_reset_work(struct nxpwifi_adapter *adapter)
1802 {
1803 struct sdio_mmc_card *card = adapter->card;
1804 struct sdio_func *func = card->func;
1805 int ret;
1806
1807 /* Prepare the adapter for the reset. */
1808 nxpwifi_shutdown_sw(adapter);
1809 clear_bit(NXPWIFI_IFACE_WORK_DEVICE_DUMP, &card->work_flags);
1810 clear_bit(NXPWIFI_IFACE_WORK_CARD_RESET, &card->work_flags);
1811
1812 /* Run a HW reset of the SDIO interface. */
1813 sdio_claim_host(func);
1814 ret = mmc_hw_reset(func->card);
1815 sdio_release_host(func);
1816
1817 switch (ret) {
1818 case 1:
1819 nxpwifi_dbg(adapter, MSG, "SDIO HW reset asynchronous\n");
1820 complete_all(adapter->fw_done);
1821 break;
1822 case 0:
1823 ret = nxpwifi_reinit_sw(adapter);
1824 if (ret)
1825 dev_err(&func->dev, "reinit failed: %d\n", ret);
1826 break;
1827 default:
1828 dev_err(&func->dev, "SDIO HW reset failed: %d\n", ret);
1829 break;
1830 }
1831 }
1832
1833 static enum
nxpwifi_sdio_rdwr_firmware(struct nxpwifi_adapter * adapter,u8 doneflag)1834 rdwr_status nxpwifi_sdio_rdwr_firmware(struct nxpwifi_adapter *adapter,
1835 u8 doneflag)
1836 {
1837 struct sdio_mmc_card *card = adapter->card;
1838 int ret, tries;
1839 u8 ctrl_data = 0;
1840
1841 sdio_writeb(card->func, card->reg->fw_dump_host_ready,
1842 card->reg->fw_dump_ctrl, &ret);
1843 if (ret) {
1844 nxpwifi_dbg(adapter, ERROR, "SDIO Write ERR\n");
1845 return RDWR_STATUS_FAILURE;
1846 }
1847 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
1848 ctrl_data = sdio_readb(card->func, card->reg->fw_dump_ctrl,
1849 &ret);
1850 if (ret) {
1851 nxpwifi_dbg(adapter, ERROR, "SDIO read err\n");
1852 return RDWR_STATUS_FAILURE;
1853 }
1854 if (ctrl_data == FW_DUMP_DONE)
1855 break;
1856 if (doneflag && ctrl_data == doneflag)
1857 return RDWR_STATUS_DONE;
1858 if (ctrl_data != card->reg->fw_dump_host_ready) {
1859 nxpwifi_dbg(adapter, WARN,
1860 "The ctrl reg was changed, re-try again\n");
1861 sdio_writeb(card->func, card->reg->fw_dump_host_ready,
1862 card->reg->fw_dump_ctrl, &ret);
1863 if (ret) {
1864 nxpwifi_dbg(adapter, ERROR, "SDIO write err\n");
1865 return RDWR_STATUS_FAILURE;
1866 }
1867 }
1868 usleep_range(100, 200);
1869 }
1870 if (ctrl_data == card->reg->fw_dump_host_ready) {
1871 nxpwifi_dbg(adapter, ERROR, "Fail to pull ctrl_data\n");
1872 return RDWR_STATUS_FAILURE;
1873 }
1874
1875 return RDWR_STATUS_SUCCESS;
1876 }
1877
1878 /* Dump firmware memories for post-mortem analysis. */
nxpwifi_sdio_fw_dump(struct nxpwifi_adapter * adapter)1879 static void nxpwifi_sdio_fw_dump(struct nxpwifi_adapter *adapter)
1880 {
1881 struct sdio_mmc_card *card = adapter->card;
1882 int ret = 0;
1883 unsigned int reg, reg_start, reg_end;
1884 u8 *dbg_ptr, *end_ptr, dump_num, idx, i, read_reg, doneflag = 0;
1885 enum rdwr_status stat;
1886 u32 memory_size;
1887
1888 if (!card->can_dump_fw)
1889 return;
1890
1891 for (idx = 0; idx < ARRAY_SIZE(mem_type_mapping_tbl); idx++) {
1892 struct memory_type_mapping *entry = &mem_type_mapping_tbl[idx];
1893
1894 if (entry->mem_ptr) {
1895 vfree(entry->mem_ptr);
1896 entry->mem_ptr = NULL;
1897 }
1898 entry->mem_size = 0;
1899 }
1900
1901 nxpwifi_pm_wakeup_card(adapter);
1902 sdio_claim_host(card->func);
1903
1904 nxpwifi_dbg(adapter, MSG, "== nxpwifi firmware dump start ==\n");
1905
1906 stat = nxpwifi_sdio_rdwr_firmware(adapter, doneflag);
1907 if (stat == RDWR_STATUS_FAILURE)
1908 goto done;
1909
1910 reg = card->reg->fw_dump_start;
1911 /* Read the number of the memories which will dump */
1912 dump_num = sdio_readb(card->func, reg, &ret);
1913 if (ret) {
1914 nxpwifi_dbg(adapter, ERROR, "SDIO read memory length err\n");
1915 goto done;
1916 }
1917
1918 /* Read the length of every memory which will dump */
1919 for (idx = 0; idx < dump_num; idx++) {
1920 struct memory_type_mapping *entry = &mem_type_mapping_tbl[idx];
1921
1922 stat = nxpwifi_sdio_rdwr_firmware(adapter, doneflag);
1923 if (stat == RDWR_STATUS_FAILURE)
1924 goto done;
1925
1926 memory_size = 0;
1927 reg = card->reg->fw_dump_start;
1928 for (i = 0; i < 4; i++) {
1929 read_reg = sdio_readb(card->func, reg, &ret);
1930 if (ret) {
1931 nxpwifi_dbg(adapter, ERROR, "SDIO read err\n");
1932 goto done;
1933 }
1934 memory_size |= (read_reg << i * 8);
1935 reg++;
1936 }
1937
1938 if (memory_size == 0) {
1939 nxpwifi_dbg(adapter, DUMP, "Firmware dump Finished!\n");
1940 ret = nxpwifi_write_reg(adapter,
1941 card->reg->fw_dump_ctrl,
1942 FW_DUMP_READ_DONE);
1943 if (ret) {
1944 nxpwifi_dbg(adapter, ERROR, "SDIO write err\n");
1945 return;
1946 }
1947 break;
1948 }
1949
1950 nxpwifi_dbg(adapter, DUMP,
1951 "%s_SIZE=0x%x\n", entry->mem_name, memory_size);
1952 entry->mem_ptr = vmalloc(memory_size + 1);
1953 entry->mem_size = memory_size;
1954 if (!entry->mem_ptr)
1955 goto done;
1956 dbg_ptr = entry->mem_ptr;
1957 end_ptr = dbg_ptr + memory_size;
1958
1959 doneflag = entry->done_flag;
1960 nxpwifi_dbg(adapter, DUMP, "Start %s output, please wait...\n",
1961 entry->mem_name);
1962
1963 do {
1964 stat = nxpwifi_sdio_rdwr_firmware(adapter, doneflag);
1965 if (stat == RDWR_STATUS_FAILURE)
1966 goto done;
1967
1968 reg_start = card->reg->fw_dump_start;
1969 reg_end = card->reg->fw_dump_end;
1970 for (reg = reg_start; reg <= reg_end; reg++) {
1971 *dbg_ptr = sdio_readb(card->func, reg, &ret);
1972 if (ret) {
1973 nxpwifi_dbg(adapter, ERROR, "SDIO read err\n");
1974 goto done;
1975 }
1976 if (dbg_ptr < end_ptr)
1977 dbg_ptr++;
1978 else
1979 nxpwifi_dbg(adapter, ERROR, "Allocated buf not enough\n");
1980 }
1981
1982 if (stat != RDWR_STATUS_DONE)
1983 continue;
1984
1985 nxpwifi_dbg(adapter, DUMP, "%s done: size=0x%tx\n",
1986 entry->mem_name, dbg_ptr - entry->mem_ptr);
1987 break;
1988 } while (1);
1989 }
1990 nxpwifi_dbg(adapter, MSG, "== nxpwifi firmware dump end ==\n");
1991
1992 done:
1993 sdio_release_host(card->func);
1994 }
1995
1996 /* Generic firmware dump flow for enhanced devices. */
nxpwifi_sdio_generic_fw_dump(struct nxpwifi_adapter * adapter)1997 static void nxpwifi_sdio_generic_fw_dump(struct nxpwifi_adapter *adapter)
1998 {
1999 struct sdio_mmc_card *card = adapter->card;
2000 struct memory_type_mapping *entry = &generic_mem_type_map[0];
2001 unsigned int reg, reg_start, reg_end;
2002 u8 start_flag = 0, done_flag = 0;
2003 u8 *dbg_ptr, *end_ptr;
2004 enum rdwr_status stat;
2005 int ret = -EPERM, tries;
2006
2007 if (!card->fw_dump_enh)
2008 return;
2009
2010 if (entry->mem_ptr) {
2011 vfree(entry->mem_ptr);
2012 entry->mem_ptr = NULL;
2013 }
2014 entry->mem_size = 0;
2015
2016 nxpwifi_pm_wakeup_card(adapter);
2017 sdio_claim_host(card->func);
2018
2019 nxpwifi_dbg(adapter, MSG, "== nxpwifi firmware dump start ==\n");
2020
2021 stat = nxpwifi_sdio_rdwr_firmware(adapter, done_flag);
2022 if (stat == RDWR_STATUS_FAILURE)
2023 goto done;
2024
2025 reg_start = card->reg->fw_dump_start;
2026 reg_end = card->reg->fw_dump_end;
2027 for (reg = reg_start; reg <= reg_end; reg++) {
2028 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
2029 start_flag = sdio_readb(card->func, reg, &ret);
2030 if (ret) {
2031 nxpwifi_dbg(adapter, ERROR, "SDIO read err\n");
2032 goto done;
2033 }
2034 if (start_flag == 0)
2035 break;
2036 if (tries == MAX_POLL_TRIES) {
2037 nxpwifi_dbg(adapter, ERROR, "FW not ready to dump\n");
2038 ret = -EPERM;
2039 goto done;
2040 }
2041 }
2042 usleep_range(100, 200);
2043 }
2044
2045 entry->mem_ptr = vmalloc(0xf0000 + 1);
2046 if (!entry->mem_ptr) {
2047 ret = -ENOMEM;
2048 goto done;
2049 }
2050 dbg_ptr = entry->mem_ptr;
2051 entry->mem_size = 0xf0000;
2052 end_ptr = dbg_ptr + entry->mem_size;
2053
2054 done_flag = entry->done_flag;
2055 nxpwifi_dbg(adapter, DUMP,
2056 "Start %s output, please wait...\n", entry->mem_name);
2057
2058 while (true) {
2059 stat = nxpwifi_sdio_rdwr_firmware(adapter, done_flag);
2060 if (stat == RDWR_STATUS_FAILURE)
2061 goto done;
2062 for (reg = reg_start; reg <= reg_end; reg++) {
2063 *dbg_ptr = sdio_readb(card->func, reg, &ret);
2064 if (ret) {
2065 nxpwifi_dbg(adapter, ERROR, "SDIO read err\n");
2066 goto done;
2067 }
2068 dbg_ptr++;
2069 if (dbg_ptr >= end_ptr) {
2070 u8 *tmp_ptr;
2071
2072 tmp_ptr = vmalloc(entry->mem_size + 0x4000 + 1);
2073 if (!tmp_ptr)
2074 goto done;
2075
2076 memcpy(tmp_ptr, entry->mem_ptr,
2077 entry->mem_size);
2078 vfree(entry->mem_ptr);
2079 entry->mem_ptr = tmp_ptr;
2080 tmp_ptr = NULL;
2081 dbg_ptr = entry->mem_ptr + entry->mem_size;
2082 entry->mem_size += 0x4000;
2083 end_ptr = entry->mem_ptr + entry->mem_size;
2084 }
2085 }
2086 if (stat == RDWR_STATUS_DONE) {
2087 entry->mem_size = dbg_ptr - entry->mem_ptr;
2088 nxpwifi_dbg(adapter, DUMP, "dump %s done size=0x%x\n",
2089 entry->mem_name, entry->mem_size);
2090 ret = 0;
2091 break;
2092 }
2093 }
2094 nxpwifi_dbg(adapter, MSG, "== nxpwifi firmware dump end ==\n");
2095
2096 done:
2097 if (ret) {
2098 nxpwifi_dbg(adapter, ERROR, "firmware dump failed\n");
2099 if (entry->mem_ptr) {
2100 vfree(entry->mem_ptr);
2101 entry->mem_ptr = NULL;
2102 }
2103 entry->mem_size = 0;
2104 }
2105 sdio_release_host(card->func);
2106 }
2107
2108 /* Build and upload consolidated device dump. */
nxpwifi_sdio_device_dump_work(struct nxpwifi_adapter * adapter)2109 static void nxpwifi_sdio_device_dump_work(struct nxpwifi_adapter *adapter)
2110 {
2111 struct sdio_mmc_card *card = adapter->card;
2112
2113 adapter->devdump_data = vzalloc(NXPWIFI_FW_DUMP_SIZE);
2114 if (!adapter->devdump_data)
2115 return;
2116
2117 nxpwifi_drv_info_dump(adapter);
2118
2119 /* Generic firmware dump flow for enhanced devices. */
2120 if (card->fw_dump_enh)
2121 nxpwifi_sdio_generic_fw_dump(adapter);
2122 /* Dump firmware memories for post-mortem analysis. */
2123 else
2124 nxpwifi_sdio_fw_dump(adapter);
2125
2126 nxpwifi_prepare_fw_dump_info(adapter);
2127 nxpwifi_upload_device_dump(adapter);
2128 }
2129
2130 /* Process deferred SDIO work items. */
nxpwifi_sdio_work(struct work_struct * work)2131 static void nxpwifi_sdio_work(struct work_struct *work)
2132 {
2133 struct sdio_mmc_card *card =
2134 container_of(work, struct sdio_mmc_card, work);
2135
2136 /* Build and upload consolidated device dump. */
2137 if (test_and_clear_bit(NXPWIFI_IFACE_WORK_DEVICE_DUMP,
2138 &card->work_flags))
2139 nxpwifi_sdio_device_dump_work(card->adapter);
2140
2141 /* Perform an SDIO card reset in workqueue context. */
2142 if (test_and_clear_bit(NXPWIFI_IFACE_WORK_CARD_RESET,
2143 &card->work_flags))
2144 nxpwifi_sdio_card_reset_work(card->adapter);
2145 }
2146
2147 /* Schedule SDIO card reset. */
nxpwifi_sdio_card_reset(struct nxpwifi_adapter * adapter)2148 static void nxpwifi_sdio_card_reset(struct nxpwifi_adapter *adapter)
2149 {
2150 struct sdio_mmc_card *card = adapter->card;
2151
2152 if (!test_and_set_bit(NXPWIFI_IFACE_WORK_CARD_RESET, &card->work_flags))
2153 nxpwifi_queue_work(adapter, &card->work);
2154 }
2155
nxpwifi_sdio_device_dump(struct nxpwifi_adapter * adapter)2156 static void nxpwifi_sdio_device_dump(struct nxpwifi_adapter *adapter)
2157 {
2158 struct sdio_mmc_card *card = adapter->card;
2159
2160 if (!test_and_set_bit(NXPWIFI_IFACE_WORK_DEVICE_DUMP,
2161 &card->work_flags))
2162 nxpwifi_queue_work(adapter, &card->work);
2163 }
2164
2165 /* Dump SDIO function and scratch registers into drv_buf. */
2166 static int
nxpwifi_sdio_reg_dump(struct nxpwifi_adapter * adapter,char * drv_buf)2167 nxpwifi_sdio_reg_dump(struct nxpwifi_adapter *adapter, char *drv_buf)
2168 {
2169 char *p = drv_buf;
2170 struct sdio_mmc_card *cardp = adapter->card;
2171 int ret = 0;
2172 u8 count, func, data, index = 0, size = 0;
2173 u8 reg, reg_start, reg_end;
2174 char buf[256], *ptr;
2175
2176 if (!p)
2177 return 0;
2178
2179 nxpwifi_dbg(adapter, MSG, "SDIO register dump start\n");
2180
2181 nxpwifi_pm_wakeup_card(adapter);
2182
2183 sdio_claim_host(cardp->func);
2184
2185 for (count = 0; count < 5; count++) {
2186 memset(buf, 0, sizeof(buf));
2187 ptr = buf;
2188
2189 switch (count) {
2190 case 0:
2191 /* Read the registers of SDIO function0 */
2192 func = count;
2193 reg_start = 0;
2194 reg_end = 9;
2195 break;
2196 case 1:
2197 /* Read the registers of SDIO function1 */
2198 func = count;
2199 reg_start = cardp->reg->func1_dump_reg_start;
2200 reg_end = cardp->reg->func1_dump_reg_end;
2201 break;
2202 case 2:
2203 index = 0;
2204 func = 1;
2205 reg_start = cardp->reg->func1_spec_reg_table[index++];
2206 size = cardp->reg->func1_spec_reg_num;
2207 reg_end = cardp->reg->func1_spec_reg_table[size - 1];
2208 break;
2209 default:
2210 /* Read the scratch registers of SDIO function1 */
2211 if (count == 4)
2212 msleep(100);
2213 func = 1;
2214 reg_start = cardp->reg->func1_scratch_reg;
2215 reg_end = reg_start + NXPWIFI_SDIO_SCRATCH_SIZE;
2216 }
2217
2218 if (count != 2)
2219 ptr += scnprintf(ptr, sizeof(buf) - (ptr - buf),
2220 "SDIO Func%d (%#x-%#x): ", func, reg_start,
2221 reg_end);
2222 else
2223 ptr += scnprintf(ptr, sizeof(buf) - (ptr - buf),
2224 "SDIO Func%d: ", func);
2225
2226 for (reg = reg_start; reg <= reg_end;) {
2227 if (func == 0)
2228 data = sdio_f0_readb(cardp->func, reg, &ret);
2229 else
2230 data = sdio_readb(cardp->func, reg, &ret);
2231
2232 if (count == 2)
2233 ptr += scnprintf(ptr, sizeof(buf) - (ptr - buf), "(%#x) ", reg);
2234 if (!ret) {
2235 ptr += scnprintf(ptr, sizeof(buf) - (ptr - buf), "%02x ", data);
2236 } else {
2237 ptr += scnprintf(ptr, sizeof(buf) - (ptr - buf), "ERR");
2238 break;
2239 }
2240
2241 if (count == 2 && reg < reg_end)
2242 reg = cardp->reg->func1_spec_reg_table[index++];
2243 else
2244 reg++;
2245 }
2246
2247 nxpwifi_dbg(adapter, MSG, "%s\n", buf);
2248 p += sprintf(p, "%s\n", buf);
2249 }
2250
2251 sdio_release_host(cardp->func);
2252
2253 nxpwifi_dbg(adapter, MSG, "SDIO register dump end\n");
2254
2255 return p - drv_buf;
2256 }
2257
nxpwifi_sdio_up_dev(struct nxpwifi_adapter * adapter)2258 static void nxpwifi_sdio_up_dev(struct nxpwifi_adapter *adapter)
2259 {
2260 struct sdio_mmc_card *card = adapter->card;
2261 u8 sdio_ireg;
2262 int ret = 0;
2263
2264 sdio_claim_host(card->func);
2265 ret = sdio_enable_func(card->func);
2266
2267 if (ret)
2268 nxpwifi_dbg(adapter, ERROR, "sdio_enable_func failed: %d\n", ret);
2269
2270 ret = sdio_set_block_size(card->func, NXPWIFI_SDIO_BLOCK_SIZE);
2271
2272 if (ret)
2273 nxpwifi_dbg(adapter, ERROR, "sdio_set_block_size failed: %d\n", ret);
2274
2275 sdio_release_host(card->func);
2276
2277 /*
2278 * tx_buf_size might be changed to 3584 by firmware during
2279 * data transfer, we will reset to default size.
2280 */
2281 adapter->tx_buf_size = card->tx_buf_size;
2282
2283 /*
2284 * Read the host_int_status_reg for ACK the first interrupt got
2285 * from the bootloader. If we don't do this we get a interrupt
2286 * as soon as we register the irq.
2287 */
2288 nxpwifi_read_reg(adapter, card->reg->host_int_status_reg, &sdio_ireg);
2289
2290 if (nxpwifi_init_sdio_ioport(adapter))
2291 nxpwifi_dbg(adapter, ERROR, "error enabling SDIO port\n");
2292 }
2293
2294 static struct nxpwifi_if_ops sdio_ops = {
2295 .init_if = nxpwifi_init_sdio,
2296 .cleanup_if = nxpwifi_cleanup_sdio,
2297 .check_fw_status = nxpwifi_check_fw_status,
2298 .check_winner_status = nxpwifi_check_winner_status,
2299 .prog_fw = nxpwifi_prog_fw_w_helper,
2300 .register_dev = nxpwifi_register_dev,
2301 .unregister_dev = nxpwifi_unregister_dev,
2302 .enable_int = nxpwifi_sdio_enable_host_int,
2303 .disable_int = nxpwifi_sdio_disable_host_int,
2304 .process_int_status = nxpwifi_process_int_status,
2305 .host_to_card = nxpwifi_sdio_host_to_card,
2306 .wakeup = nxpwifi_pm_wakeup_card,
2307 .wakeup_complete = nxpwifi_pm_wakeup_card_complete,
2308
2309 /* SDIO specific */
2310 .update_mp_end_port = nxpwifi_update_mp_end_port,
2311 .cleanup_mpa_buf = nxpwifi_cleanup_mpa_buf,
2312 .cmdrsp_complete = nxpwifi_sdio_cmdrsp_complete,
2313 .event_complete = nxpwifi_sdio_event_complete,
2314 .dnld_fw = nxpwifi_sdio_dnld_fw,
2315 .card_reset = nxpwifi_sdio_card_reset,
2316 .reg_dump = nxpwifi_sdio_reg_dump,
2317 .device_dump = nxpwifi_sdio_device_dump,
2318 .deaggr_pkt = nxpwifi_deaggr_sdio_pkt,
2319 .up_dev = nxpwifi_sdio_up_dev,
2320 };
2321
2322 module_sdio_driver(nxpwifi_sdio);
2323
2324 MODULE_AUTHOR("NXP International Ltd.");
2325 MODULE_DESCRIPTION("NXP WiFi SDIO Driver version " SDIO_VERSION);
2326 MODULE_VERSION(SDIO_VERSION);
2327 MODULE_LICENSE("GPL");
2328 MODULE_FIRMWARE(IW61X_SDIO_FW_NAME);
2329