1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/firmware.h>
21
22#include "decl.h"
23#include "ioctl.h"
24#include "util.h"
25#include "fw.h"
26#include "main.h"
27#include "wmm.h"
28#include "11n.h"
29#include "sdio.h"
30
31
32#define SDIO_VERSION "1.0"
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47static u8 user_rmmod;
48
49static struct mwifiex_if_ops sdio_ops;
50static unsigned long iface_work_flags;
51
52static struct semaphore add_remove_card_sem;
53
54static struct memory_type_mapping generic_mem_type_map[] = {
55 {"DUMP", NULL, 0, 0xDD},
56};
57
58static struct memory_type_mapping mem_type_mapping_tbl[] = {
59 {"ITCM", NULL, 0, 0xF0},
60 {"DTCM", NULL, 0, 0xF1},
61 {"SQRAM", NULL, 0, 0xF2},
62 {"APU", NULL, 0, 0xF3},
63 {"CIU", NULL, 0, 0xF4},
64 {"ICU", NULL, 0, 0xF5},
65 {"MAC", NULL, 0, 0xF6},
66 {"EXT7", NULL, 0, 0xF7},
67 {"EXT8", NULL, 0, 0xF8},
68 {"EXT9", NULL, 0, 0xF9},
69 {"EXT10", NULL, 0, 0xFA},
70 {"EXT11", NULL, 0, 0xFB},
71 {"EXT12", NULL, 0, 0xFC},
72 {"EXT13", NULL, 0, 0xFD},
73 {"EXTLAST", NULL, 0, 0xFE},
74};
75
76static const struct of_device_id mwifiex_sdio_of_match_table[] = {
77 { .compatible = "marvell,sd8897" },
78 { .compatible = "marvell,sd8997" },
79 { }
80};
81
82static irqreturn_t mwifiex_wake_irq_wifi(int irq, void *priv)
83{
84 struct mwifiex_plt_wake_cfg *cfg = priv;
85
86 if (cfg->irq_wifi >= 0) {
87 pr_info("%s: wake by wifi", __func__);
88 cfg->wake_by_wifi = true;
89 disable_irq_nosync(irq);
90 }
91
92 return IRQ_HANDLED;
93}
94
95
96
97
98
99
100static int mwifiex_sdio_probe_of(struct device *dev, struct sdio_mmc_card *card)
101{
102 struct mwifiex_plt_wake_cfg *cfg;
103 int ret;
104
105 if (!of_match_node(mwifiex_sdio_of_match_table, dev->of_node)) {
106 dev_err(dev, "required compatible string missing\n");
107 return -EINVAL;
108 }
109
110 card->plt_of_node = dev->of_node;
111 card->plt_wake_cfg = devm_kzalloc(dev, sizeof(*card->plt_wake_cfg),
112 GFP_KERNEL);
113 cfg = card->plt_wake_cfg;
114 if (cfg && card->plt_of_node) {
115 cfg->irq_wifi = irq_of_parse_and_map(card->plt_of_node, 0);
116 if (!cfg->irq_wifi) {
117 dev_dbg(dev,
118 "fail to parse irq_wifi from device tree\n");
119 } else {
120 ret = devm_request_irq(dev, cfg->irq_wifi,
121 mwifiex_wake_irq_wifi,
122 IRQF_TRIGGER_LOW,
123 "wifi_wake", cfg);
124 if (ret) {
125 dev_dbg(dev,
126 "Failed to request irq_wifi %d (%d)\n",
127 cfg->irq_wifi, ret);
128 card->plt_wake_cfg = NULL;
129 return 0;
130 }
131 disable_irq(cfg->irq_wifi);
132 }
133 }
134
135 return 0;
136}
137
138
139
140
141
142
143
144
145
146static int
147mwifiex_sdio_probe(struct sdio_func *func, const struct sdio_device_id *id)
148{
149 int ret;
150 struct sdio_mmc_card *card = NULL;
151
152 pr_debug("info: vendor=0x%4.04X device=0x%4.04X class=%d function=%d\n",
153 func->vendor, func->device, func->class, func->num);
154
155 card = kzalloc(sizeof(struct sdio_mmc_card), GFP_KERNEL);
156 if (!card)
157 return -ENOMEM;
158
159 card->func = func;
160 card->device_id = id;
161
162 func->card->quirks |= MMC_QUIRK_BLKSZ_FOR_BYTE_MODE;
163
164 if (id->driver_data) {
165 struct mwifiex_sdio_device *data = (void *)id->driver_data;
166
167 card->firmware = data->firmware;
168 card->reg = data->reg;
169 card->max_ports = data->max_ports;
170 card->mp_agg_pkt_limit = data->mp_agg_pkt_limit;
171 card->supports_sdio_new_mode = data->supports_sdio_new_mode;
172 card->has_control_mask = data->has_control_mask;
173 card->tx_buf_size = data->tx_buf_size;
174 card->mp_tx_agg_buf_size = data->mp_tx_agg_buf_size;
175 card->mp_rx_agg_buf_size = data->mp_rx_agg_buf_size;
176 card->can_dump_fw = data->can_dump_fw;
177 card->fw_dump_enh = data->fw_dump_enh;
178 card->can_auto_tdls = data->can_auto_tdls;
179 card->can_ext_scan = data->can_ext_scan;
180 }
181
182 sdio_claim_host(func);
183 ret = sdio_enable_func(func);
184 sdio_release_host(func);
185
186 if (ret) {
187 dev_err(&func->dev, "failed to enable function\n");
188 goto err_free;
189 }
190
191
192 if (func->dev.of_node) {
193 ret = mwifiex_sdio_probe_of(&func->dev, card);
194 if (ret) {
195 dev_err(&func->dev, "SDIO dt node parse failed\n");
196 goto err_disable;
197 }
198 }
199
200 ret = mwifiex_add_card(card, &add_remove_card_sem, &sdio_ops,
201 MWIFIEX_SDIO);
202 if (ret) {
203 dev_err(&func->dev, "add card failed\n");
204 goto err_disable;
205 }
206
207 return 0;
208
209err_disable:
210 sdio_claim_host(func);
211 sdio_disable_func(func);
212 sdio_release_host(func);
213err_free:
214 kfree(card);
215
216 return ret;
217}
218
219
220
221
222
223
224
225
226
227
228
229static int mwifiex_sdio_resume(struct device *dev)
230{
231 struct sdio_func *func = dev_to_sdio_func(dev);
232 struct sdio_mmc_card *card;
233 struct mwifiex_adapter *adapter;
234 mmc_pm_flag_t pm_flag = 0;
235
236 if (func) {
237 pm_flag = sdio_get_host_pm_caps(func);
238 card = sdio_get_drvdata(func);
239 if (!card || !card->adapter) {
240 pr_err("resume: invalid card or adapter\n");
241 return 0;
242 }
243 } else {
244 pr_err("resume: sdio_func is not specified\n");
245 return 0;
246 }
247
248 adapter = card->adapter;
249
250 if (!adapter->is_suspended) {
251 mwifiex_dbg(adapter, WARN,
252 "device already resumed\n");
253 return 0;
254 }
255
256 adapter->is_suspended = false;
257
258
259 mwifiex_cancel_hs(mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA),
260 MWIFIEX_SYNC_CMD);
261
262
263 if (card->plt_wake_cfg && card->plt_wake_cfg->irq_wifi >= 0) {
264 disable_irq_wake(card->plt_wake_cfg->irq_wifi);
265 if (!card->plt_wake_cfg->wake_by_wifi)
266 disable_irq(card->plt_wake_cfg->irq_wifi);
267 }
268
269 return 0;
270}
271
272
273
274
275
276
277static void
278mwifiex_sdio_remove(struct sdio_func *func)
279{
280 struct sdio_mmc_card *card;
281 struct mwifiex_adapter *adapter;
282 struct mwifiex_private *priv;
283
284 card = sdio_get_drvdata(func);
285 if (!card)
286 return;
287
288 adapter = card->adapter;
289 if (!adapter || !adapter->priv_num)
290 return;
291
292 mwifiex_dbg(adapter, INFO, "info: SDIO func num=%d\n", func->num);
293
294 if (user_rmmod && !adapter->mfg_mode) {
295 if (adapter->is_suspended)
296 mwifiex_sdio_resume(adapter->dev);
297
298 mwifiex_deauthenticate_all(adapter);
299
300 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
301 mwifiex_disable_auto_ds(priv);
302 mwifiex_init_shutdown_fw(priv, MWIFIEX_FUNC_SHUTDOWN);
303 }
304
305 mwifiex_remove_card(card->adapter, &add_remove_card_sem);
306}
307
308
309
310
311
312
313
314
315
316
317
318static int mwifiex_sdio_suspend(struct device *dev)
319{
320 struct sdio_func *func = dev_to_sdio_func(dev);
321 struct sdio_mmc_card *card;
322 struct mwifiex_adapter *adapter;
323 mmc_pm_flag_t pm_flag = 0;
324 int ret = 0;
325
326 if (func) {
327 pm_flag = sdio_get_host_pm_caps(func);
328 pr_debug("cmd: %s: suspend: PM flag = 0x%x\n",
329 sdio_func_id(func), pm_flag);
330 if (!(pm_flag & MMC_PM_KEEP_POWER)) {
331 pr_err("%s: cannot remain alive while host is"
332 " suspended\n", sdio_func_id(func));
333 return -ENOSYS;
334 }
335
336 card = sdio_get_drvdata(func);
337 if (!card || !card->adapter) {
338 pr_err("suspend: invalid card or adapter\n");
339 return 0;
340 }
341 } else {
342 pr_err("suspend: sdio_func is not specified\n");
343 return 0;
344 }
345
346 adapter = card->adapter;
347
348
349 if (card->plt_wake_cfg && card->plt_wake_cfg->irq_wifi >= 0) {
350 card->plt_wake_cfg->wake_by_wifi = false;
351 enable_irq(card->plt_wake_cfg->irq_wifi);
352 enable_irq_wake(card->plt_wake_cfg->irq_wifi);
353 }
354
355
356 if (!mwifiex_enable_hs(adapter)) {
357 mwifiex_dbg(adapter, ERROR,
358 "cmd: failed to suspend\n");
359 adapter->hs_enabling = false;
360 return -EFAULT;
361 }
362
363 mwifiex_dbg(adapter, INFO,
364 "cmd: suspend with MMC_PM_KEEP_POWER\n");
365 ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
366
367
368 adapter->is_suspended = true;
369 adapter->hs_enabling = false;
370
371 return ret;
372}
373
374
375#define SDIO_DEVICE_ID_MARVELL_8786 (0x9116)
376
377#define SDIO_DEVICE_ID_MARVELL_8787 (0x9119)
378
379#define SDIO_DEVICE_ID_MARVELL_8797 (0x9129)
380
381#define SDIO_DEVICE_ID_MARVELL_8897 (0x912d)
382
383#define SDIO_DEVICE_ID_MARVELL_8887 (0x9135)
384
385#define SDIO_DEVICE_ID_MARVELL_8801 (0x9139)
386
387#define SDIO_DEVICE_ID_MARVELL_8997 (0x9141)
388
389
390
391static const struct sdio_device_id mwifiex_ids[] = {
392 {SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8786),
393 .driver_data = (unsigned long) &mwifiex_sdio_sd8786},
394 {SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8787),
395 .driver_data = (unsigned long) &mwifiex_sdio_sd8787},
396 {SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8797),
397 .driver_data = (unsigned long) &mwifiex_sdio_sd8797},
398 {SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8897),
399 .driver_data = (unsigned long) &mwifiex_sdio_sd8897},
400 {SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8887),
401 .driver_data = (unsigned long)&mwifiex_sdio_sd8887},
402 {SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8801),
403 .driver_data = (unsigned long)&mwifiex_sdio_sd8801},
404 {SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8997),
405 .driver_data = (unsigned long)&mwifiex_sdio_sd8997},
406 {},
407};
408
409MODULE_DEVICE_TABLE(sdio, mwifiex_ids);
410
411static const struct dev_pm_ops mwifiex_sdio_pm_ops = {
412 .suspend = mwifiex_sdio_suspend,
413 .resume = mwifiex_sdio_resume,
414};
415
416static struct sdio_driver mwifiex_sdio = {
417 .name = "mwifiex_sdio",
418 .id_table = mwifiex_ids,
419 .probe = mwifiex_sdio_probe,
420 .remove = mwifiex_sdio_remove,
421 .drv = {
422 .owner = THIS_MODULE,
423 .pm = &mwifiex_sdio_pm_ops,
424 }
425};
426
427
428static int
429mwifiex_write_reg_locked(struct sdio_func *func, u32 reg, u8 data)
430{
431 int ret = -1;
432 sdio_writeb(func, data, reg, &ret);
433 return ret;
434}
435
436
437
438
439static int
440mwifiex_write_reg(struct mwifiex_adapter *adapter, u32 reg, u8 data)
441{
442 struct sdio_mmc_card *card = adapter->card;
443 int ret;
444
445 sdio_claim_host(card->func);
446 ret = mwifiex_write_reg_locked(card->func, reg, data);
447 sdio_release_host(card->func);
448
449 return ret;
450}
451
452
453
454
455static int
456mwifiex_read_reg(struct mwifiex_adapter *adapter, u32 reg, u8 *data)
457{
458 struct sdio_mmc_card *card = adapter->card;
459 int ret = -1;
460 u8 val;
461
462 sdio_claim_host(card->func);
463 val = sdio_readb(card->func, reg, &ret);
464 sdio_release_host(card->func);
465
466 *data = val;
467
468 return ret;
469}
470
471
472
473
474
475
476static int
477mwifiex_write_data_sync(struct mwifiex_adapter *adapter,
478 u8 *buffer, u32 pkt_len, u32 port)
479{
480 struct sdio_mmc_card *card = adapter->card;
481 int ret;
482 u8 blk_mode =
483 (port & MWIFIEX_SDIO_BYTE_MODE_MASK) ? BYTE_MODE : BLOCK_MODE;
484 u32 blk_size = (blk_mode == BLOCK_MODE) ? MWIFIEX_SDIO_BLOCK_SIZE : 1;
485 u32 blk_cnt =
486 (blk_mode ==
487 BLOCK_MODE) ? (pkt_len /
488 MWIFIEX_SDIO_BLOCK_SIZE) : pkt_len;
489 u32 ioport = (port & MWIFIEX_SDIO_IO_PORT_MASK);
490
491 if (adapter->is_suspended) {
492 mwifiex_dbg(adapter, ERROR,
493 "%s: not allowed while suspended\n", __func__);
494 return -1;
495 }
496
497 sdio_claim_host(card->func);
498
499 ret = sdio_writesb(card->func, ioport, buffer, blk_cnt * blk_size);
500
501 sdio_release_host(card->func);
502
503 return ret;
504}
505
506
507
508
509static int mwifiex_read_data_sync(struct mwifiex_adapter *adapter, u8 *buffer,
510 u32 len, u32 port, u8 claim)
511{
512 struct sdio_mmc_card *card = adapter->card;
513 int ret;
514 u8 blk_mode = (port & MWIFIEX_SDIO_BYTE_MODE_MASK) ? BYTE_MODE
515 : BLOCK_MODE;
516 u32 blk_size = (blk_mode == BLOCK_MODE) ? MWIFIEX_SDIO_BLOCK_SIZE : 1;
517 u32 blk_cnt = (blk_mode == BLOCK_MODE) ? (len / MWIFIEX_SDIO_BLOCK_SIZE)
518 : len;
519 u32 ioport = (port & MWIFIEX_SDIO_IO_PORT_MASK);
520
521 if (claim)
522 sdio_claim_host(card->func);
523
524 ret = sdio_readsb(card->func, buffer, ioport, blk_cnt * blk_size);
525
526 if (claim)
527 sdio_release_host(card->func);
528
529 return ret;
530}
531
532
533
534
535
536
537
538static int mwifiex_pm_wakeup_card(struct mwifiex_adapter *adapter)
539{
540 mwifiex_dbg(adapter, EVENT,
541 "event: wakeup device...\n");
542
543 return mwifiex_write_reg(adapter, CONFIGURATION_REG, HOST_POWER_UP);
544}
545
546
547
548
549
550
551static int mwifiex_pm_wakeup_card_complete(struct mwifiex_adapter *adapter)
552{
553 mwifiex_dbg(adapter, EVENT,
554 "cmd: wakeup device completed\n");
555
556 return mwifiex_write_reg(adapter, CONFIGURATION_REG, 0);
557}
558
559static int mwifiex_sdio_dnld_fw(struct mwifiex_adapter *adapter,
560 struct mwifiex_fw_image *fw)
561{
562 struct sdio_mmc_card *card = adapter->card;
563 int ret;
564
565 sdio_claim_host(card->func);
566 ret = mwifiex_dnld_fw(adapter, fw);
567 sdio_release_host(card->func);
568
569 return ret;
570}
571
572
573
574
575
576static int mwifiex_init_sdio_new_mode(struct mwifiex_adapter *adapter)
577{
578 u8 reg;
579 struct sdio_mmc_card *card = adapter->card;
580
581 adapter->ioport = MEM_PORT;
582
583
584 if (mwifiex_read_reg(adapter, card->reg->card_cfg_2_1_reg, ®))
585 return -1;
586 if (mwifiex_write_reg(adapter, card->reg->card_cfg_2_1_reg,
587 reg | CMD53_NEW_MODE))
588 return -1;
589
590
591 if (mwifiex_read_reg(adapter, card->reg->cmd_cfg_0, ®))
592 return -1;
593 if (mwifiex_write_reg(adapter, card->reg->cmd_cfg_0,
594 reg | CMD_PORT_RD_LEN_EN))
595 return -1;
596
597
598
599
600 if (mwifiex_read_reg(adapter, card->reg->cmd_cfg_1, ®))
601 return -1;
602 if (mwifiex_write_reg(adapter, card->reg->cmd_cfg_1,
603 reg | CMD_PORT_AUTO_EN))
604 return -1;
605
606 return 0;
607}
608
609
610
611
612
613
614
615
616static int mwifiex_init_sdio_ioport(struct mwifiex_adapter *adapter)
617{
618 u8 reg;
619 struct sdio_mmc_card *card = adapter->card;
620
621 adapter->ioport = 0;
622
623 if (card->supports_sdio_new_mode) {
624 if (mwifiex_init_sdio_new_mode(adapter))
625 return -1;
626 goto cont;
627 }
628
629
630 if (!mwifiex_read_reg(adapter, card->reg->io_port_0_reg, ®))
631 adapter->ioport |= (reg & 0xff);
632 else
633 return -1;
634
635 if (!mwifiex_read_reg(adapter, card->reg->io_port_1_reg, ®))
636 adapter->ioport |= ((reg & 0xff) << 8);
637 else
638 return -1;
639
640 if (!mwifiex_read_reg(adapter, card->reg->io_port_2_reg, ®))
641 adapter->ioport |= ((reg & 0xff) << 16);
642 else
643 return -1;
644cont:
645 mwifiex_dbg(adapter, INFO,
646 "info: SDIO FUNC1 IO port: %#x\n", adapter->ioport);
647
648
649 if (!mwifiex_read_reg(adapter, card->reg->host_int_rsr_reg, ®))
650 mwifiex_write_reg(adapter, card->reg->host_int_rsr_reg,
651 reg | card->reg->sdio_int_mask);
652 else
653 return -1;
654
655
656 if (!mwifiex_read_reg(adapter, card->reg->card_misc_cfg_reg, ®))
657 mwifiex_write_reg(adapter, card->reg->card_misc_cfg_reg,
658 reg | AUTO_RE_ENABLE_INT);
659 else
660 return -1;
661
662 return 0;
663}
664
665
666
667
668static int mwifiex_write_data_to_card(struct mwifiex_adapter *adapter,
669 u8 *payload, u32 pkt_len, u32 port)
670{
671 u32 i = 0;
672 int ret;
673
674 do {
675 ret = mwifiex_write_data_sync(adapter, payload, pkt_len, port);
676 if (ret) {
677 i++;
678 mwifiex_dbg(adapter, ERROR,
679 "host_to_card, write iomem\t"
680 "(%d) failed: %d\n", i, ret);
681 if (mwifiex_write_reg(adapter, CONFIGURATION_REG, 0x04))
682 mwifiex_dbg(adapter, ERROR,
683 "write CFG reg failed\n");
684
685 ret = -1;
686 if (i > MAX_WRITE_IOMEM_RETRY)
687 return ret;
688 }
689 } while (ret == -1);
690
691 return ret;
692}
693
694
695
696
697
698
699
700
701
702static int mwifiex_get_rd_port(struct mwifiex_adapter *adapter, u8 *port)
703{
704 struct sdio_mmc_card *card = adapter->card;
705 const struct mwifiex_sdio_card_reg *reg = card->reg;
706 u32 rd_bitmap = card->mp_rd_bitmap;
707
708 mwifiex_dbg(adapter, DATA,
709 "data: mp_rd_bitmap=0x%08x\n", rd_bitmap);
710
711 if (card->supports_sdio_new_mode) {
712 if (!(rd_bitmap & reg->data_port_mask))
713 return -1;
714 } else {
715 if (!(rd_bitmap & (CTRL_PORT_MASK | reg->data_port_mask)))
716 return -1;
717 }
718
719 if ((card->has_control_mask) &&
720 (card->mp_rd_bitmap & CTRL_PORT_MASK)) {
721 card->mp_rd_bitmap &= (u32) (~CTRL_PORT_MASK);
722 *port = CTRL_PORT;
723 mwifiex_dbg(adapter, DATA,
724 "data: port=%d mp_rd_bitmap=0x%08x\n",
725 *port, card->mp_rd_bitmap);
726 return 0;
727 }
728
729 if (!(card->mp_rd_bitmap & (1 << card->curr_rd_port)))
730 return -1;
731
732
733 card->mp_rd_bitmap &= (u32)(~(1 << card->curr_rd_port));
734 *port = card->curr_rd_port;
735
736 if (++card->curr_rd_port == card->max_ports)
737 card->curr_rd_port = reg->start_rd_port;
738
739 mwifiex_dbg(adapter, DATA,
740 "data: port=%d mp_rd_bitmap=0x%08x -> 0x%08x\n",
741 *port, rd_bitmap, card->mp_rd_bitmap);
742
743 return 0;
744}
745
746
747
748
749
750
751
752
753static int mwifiex_get_wr_port_data(struct mwifiex_adapter *adapter, u32 *port)
754{
755 struct sdio_mmc_card *card = adapter->card;
756 const struct mwifiex_sdio_card_reg *reg = card->reg;
757 u32 wr_bitmap = card->mp_wr_bitmap;
758
759 mwifiex_dbg(adapter, DATA,
760 "data: mp_wr_bitmap=0x%08x\n", wr_bitmap);
761
762 if (!(wr_bitmap & card->mp_data_port_mask)) {
763 adapter->data_sent = true;
764 return -EBUSY;
765 }
766
767 if (card->mp_wr_bitmap & (1 << card->curr_wr_port)) {
768 card->mp_wr_bitmap &= (u32) (~(1 << card->curr_wr_port));
769 *port = card->curr_wr_port;
770 if (++card->curr_wr_port == card->mp_end_port)
771 card->curr_wr_port = reg->start_wr_port;
772 } else {
773 adapter->data_sent = true;
774 return -EBUSY;
775 }
776
777 if ((card->has_control_mask) && (*port == CTRL_PORT)) {
778 mwifiex_dbg(adapter, ERROR,
779 "invalid data port=%d cur port=%d mp_wr_bitmap=0x%08x -> 0x%08x\n",
780 *port, card->curr_wr_port, wr_bitmap,
781 card->mp_wr_bitmap);
782 return -1;
783 }
784
785 mwifiex_dbg(adapter, DATA,
786 "data: port=%d mp_wr_bitmap=0x%08x -> 0x%08x\n",
787 *port, wr_bitmap, card->mp_wr_bitmap);
788
789 return 0;
790}
791
792
793
794
795static int
796mwifiex_sdio_poll_card_status(struct mwifiex_adapter *adapter, u8 bits)
797{
798 struct sdio_mmc_card *card = adapter->card;
799 u32 tries;
800 u8 cs;
801
802 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
803 if (mwifiex_read_reg(adapter, card->reg->poll_reg, &cs))
804 break;
805 else if ((cs & bits) == bits)
806 return 0;
807
808 usleep_range(10, 20);
809 }
810
811 mwifiex_dbg(adapter, ERROR,
812 "poll card status failed, tries = %d\n", tries);
813
814 return -1;
815}
816
817
818
819
820static int
821mwifiex_sdio_read_fw_status(struct mwifiex_adapter *adapter, u16 *dat)
822{
823 struct sdio_mmc_card *card = adapter->card;
824 const struct mwifiex_sdio_card_reg *reg = card->reg;
825 u8 fws0, fws1;
826
827 if (mwifiex_read_reg(adapter, reg->status_reg_0, &fws0))
828 return -1;
829
830 if (mwifiex_read_reg(adapter, reg->status_reg_1, &fws1))
831 return -1;
832
833 *dat = (u16) ((fws1 << 8) | fws0);
834
835 return 0;
836}
837
838
839
840
841
842
843
844static void mwifiex_sdio_disable_host_int(struct mwifiex_adapter *adapter)
845{
846 struct sdio_mmc_card *card = adapter->card;
847 struct sdio_func *func = card->func;
848
849 sdio_claim_host(func);
850 mwifiex_write_reg_locked(func, card->reg->host_int_mask_reg, 0);
851 sdio_release_irq(func);
852 sdio_release_host(func);
853}
854
855
856
857
858static void mwifiex_interrupt_status(struct mwifiex_adapter *adapter)
859{
860 struct sdio_mmc_card *card = adapter->card;
861 u8 sdio_ireg;
862 unsigned long flags;
863
864 if (mwifiex_read_data_sync(adapter, card->mp_regs,
865 card->reg->max_mp_regs,
866 REG_PORT | MWIFIEX_SDIO_BYTE_MODE_MASK, 0)) {
867 mwifiex_dbg(adapter, ERROR, "read mp_regs failed\n");
868 return;
869 }
870
871 sdio_ireg = card->mp_regs[card->reg->host_int_status_reg];
872 if (sdio_ireg) {
873
874
875
876
877
878
879
880 mwifiex_dbg(adapter, INTR,
881 "int: sdio_ireg = %#x\n", sdio_ireg);
882 spin_lock_irqsave(&adapter->int_lock, flags);
883 adapter->int_status |= sdio_ireg;
884 spin_unlock_irqrestore(&adapter->int_lock, flags);
885 }
886}
887
888
889
890
891
892
893
894static void
895mwifiex_sdio_interrupt(struct sdio_func *func)
896{
897 struct mwifiex_adapter *adapter;
898 struct sdio_mmc_card *card;
899
900 card = sdio_get_drvdata(func);
901 if (!card || !card->adapter) {
902 pr_err("int: func=%p card=%p adapter=%p\n",
903 func, card, card ? card->adapter : NULL);
904 return;
905 }
906 adapter = card->adapter;
907
908 if (!adapter->pps_uapsd_mode && adapter->ps_state == PS_STATE_SLEEP)
909 adapter->ps_state = PS_STATE_AWAKE;
910
911 mwifiex_interrupt_status(adapter);
912 mwifiex_main_process(adapter);
913}
914
915
916
917
918
919
920
921static int mwifiex_sdio_enable_host_int(struct mwifiex_adapter *adapter)
922{
923 struct sdio_mmc_card *card = adapter->card;
924 struct sdio_func *func = card->func;
925 int ret;
926
927 sdio_claim_host(func);
928
929
930 ret = sdio_claim_irq(func, mwifiex_sdio_interrupt);
931 if (ret) {
932 mwifiex_dbg(adapter, ERROR,
933 "claim irq failed: ret=%d\n", ret);
934 goto out;
935 }
936
937
938 ret = mwifiex_write_reg_locked(func, card->reg->host_int_mask_reg,
939 card->reg->host_int_enable);
940 if (ret) {
941 mwifiex_dbg(adapter, ERROR,
942 "enable host interrupt failed\n");
943 sdio_release_irq(func);
944 }
945
946out:
947 sdio_release_host(func);
948 return ret;
949}
950
951
952
953
954static int mwifiex_sdio_card_to_host(struct mwifiex_adapter *adapter,
955 u32 *type, u8 *buffer,
956 u32 npayload, u32 ioport)
957{
958 int ret;
959 u32 nb;
960
961 if (!buffer) {
962 mwifiex_dbg(adapter, ERROR,
963 "%s: buffer is NULL\n", __func__);
964 return -1;
965 }
966
967 ret = mwifiex_read_data_sync(adapter, buffer, npayload, ioport, 1);
968
969 if (ret) {
970 mwifiex_dbg(adapter, ERROR,
971 "%s: read iomem failed: %d\n", __func__,
972 ret);
973 return -1;
974 }
975
976 nb = le16_to_cpu(*(__le16 *) (buffer));
977 if (nb > npayload) {
978 mwifiex_dbg(adapter, ERROR,
979 "%s: invalid packet, nb=%d npayload=%d\n",
980 __func__, nb, npayload);
981 return -1;
982 }
983
984 *type = le16_to_cpu(*(__le16 *) (buffer + 2));
985
986 return ret;
987}
988
989
990
991
992
993
994
995
996static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter *adapter,
997 struct mwifiex_fw_image *fw)
998{
999 struct sdio_mmc_card *card = adapter->card;
1000 const struct mwifiex_sdio_card_reg *reg = card->reg;
1001 int ret;
1002 u8 *firmware = fw->fw_buf;
1003 u32 firmware_len = fw->fw_len;
1004 u32 offset = 0;
1005 u8 base0, base1;
1006 u8 *fwbuf;
1007 u16 len = 0;
1008 u32 txlen, tx_blocks = 0, tries;
1009 u32 i = 0;
1010
1011 if (!firmware_len) {
1012 mwifiex_dbg(adapter, ERROR,
1013 "firmware image not found! Terminating download\n");
1014 return -1;
1015 }
1016
1017 mwifiex_dbg(adapter, INFO,
1018 "info: downloading FW image (%d bytes)\n",
1019 firmware_len);
1020
1021
1022 fwbuf = kzalloc(MWIFIEX_UPLD_SIZE, GFP_KERNEL);
1023 if (!fwbuf)
1024 return -ENOMEM;
1025
1026 sdio_claim_host(card->func);
1027
1028
1029 do {
1030
1031
1032 ret = mwifiex_sdio_poll_card_status(adapter, CARD_IO_READY |
1033 DN_LD_CARD_RDY);
1034 if (ret) {
1035 mwifiex_dbg(adapter, ERROR,
1036 "FW download with helper:\t"
1037 "poll status timeout @ %d\n", offset);
1038 goto done;
1039 }
1040
1041
1042 if (offset >= firmware_len)
1043 break;
1044
1045 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
1046 ret = mwifiex_read_reg(adapter, reg->base_0_reg,
1047 &base0);
1048 if (ret) {
1049 mwifiex_dbg(adapter, ERROR,
1050 "dev BASE0 register read failed:\t"
1051 "base0=%#04X(%d). Terminating dnld\n",
1052 base0, base0);
1053 goto done;
1054 }
1055 ret = mwifiex_read_reg(adapter, reg->base_1_reg,
1056 &base1);
1057 if (ret) {
1058 mwifiex_dbg(adapter, ERROR,
1059 "dev BASE1 register read failed:\t"
1060 "base1=%#04X(%d). Terminating dnld\n",
1061 base1, base1);
1062 goto done;
1063 }
1064 len = (u16) (((base1 & 0xff) << 8) | (base0 & 0xff));
1065
1066 if (len)
1067 break;
1068
1069 usleep_range(10, 20);
1070 }
1071
1072 if (!len) {
1073 break;
1074 } else if (len > MWIFIEX_UPLD_SIZE) {
1075 mwifiex_dbg(adapter, ERROR,
1076 "FW dnld failed @ %d, invalid length %d\n",
1077 offset, len);
1078 ret = -1;
1079 goto done;
1080 }
1081
1082 txlen = len;
1083
1084 if (len & BIT(0)) {
1085 i++;
1086 if (i > MAX_WRITE_IOMEM_RETRY) {
1087 mwifiex_dbg(adapter, ERROR,
1088 "FW dnld failed @ %d, over max retry\n",
1089 offset);
1090 ret = -1;
1091 goto done;
1092 }
1093 mwifiex_dbg(adapter, ERROR,
1094 "CRC indicated by the helper:\t"
1095 "len = 0x%04X, txlen = %d\n", len, txlen);
1096 len &= ~BIT(0);
1097
1098 txlen = 0;
1099 } else {
1100 i = 0;
1101
1102
1103
1104 if (firmware_len - offset < txlen)
1105 txlen = firmware_len - offset;
1106
1107 tx_blocks = (txlen + MWIFIEX_SDIO_BLOCK_SIZE - 1)
1108 / MWIFIEX_SDIO_BLOCK_SIZE;
1109
1110
1111 memmove(fwbuf, &firmware[offset], txlen);
1112 }
1113
1114 ret = mwifiex_write_data_sync(adapter, fwbuf, tx_blocks *
1115 MWIFIEX_SDIO_BLOCK_SIZE,
1116 adapter->ioport);
1117 if (ret) {
1118 mwifiex_dbg(adapter, ERROR,
1119 "FW download, write iomem (%d) failed @ %d\n",
1120 i, offset);
1121 if (mwifiex_write_reg(adapter, CONFIGURATION_REG, 0x04))
1122 mwifiex_dbg(adapter, ERROR,
1123 "write CFG reg failed\n");
1124
1125 ret = -1;
1126 goto done;
1127 }
1128
1129 offset += txlen;
1130 } while (true);
1131
1132 mwifiex_dbg(adapter, MSG,
1133 "info: FW download over, size %d bytes\n", offset);
1134
1135 ret = 0;
1136done:
1137 sdio_release_host(card->func);
1138 kfree(fwbuf);
1139 return ret;
1140}
1141
1142
1143
1144
1145static int mwifiex_check_fw_status(struct mwifiex_adapter *adapter,
1146 u32 poll_num)
1147{
1148 int ret = 0;
1149 u16 firmware_stat;
1150 u32 tries;
1151
1152 for (tries = 0; tries < poll_num; tries++) {
1153 ret = mwifiex_sdio_read_fw_status(adapter, &firmware_stat);
1154 if (ret)
1155 continue;
1156 if (firmware_stat == FIRMWARE_READY_SDIO) {
1157 ret = 0;
1158 break;
1159 } else {
1160 msleep(100);
1161 ret = -1;
1162 }
1163 }
1164
1165 return ret;
1166}
1167
1168
1169
1170static int mwifiex_check_winner_status(struct mwifiex_adapter *adapter)
1171{
1172 int ret = 0;
1173 u8 winner = 0;
1174 struct sdio_mmc_card *card = adapter->card;
1175
1176 if (mwifiex_read_reg(adapter, card->reg->status_reg_0, &winner))
1177 return -1;
1178
1179 if (winner)
1180 adapter->winner = 0;
1181 else
1182 adapter->winner = 1;
1183
1184 return ret;
1185}
1186
1187
1188
1189
1190
1191
1192
1193static void mwifiex_deaggr_sdio_pkt(struct mwifiex_adapter *adapter,
1194 struct sk_buff *skb)
1195{
1196 u32 total_pkt_len, pkt_len;
1197 struct sk_buff *skb_deaggr;
1198 u32 pkt_type;
1199 u16 blk_size;
1200 u8 blk_num;
1201 u8 *data;
1202
1203 data = skb->data;
1204 total_pkt_len = skb->len;
1205
1206 while (total_pkt_len >= (SDIO_HEADER_OFFSET + INTF_HEADER_LEN)) {
1207 if (total_pkt_len < adapter->sdio_rx_block_size)
1208 break;
1209 blk_num = *(data + BLOCK_NUMBER_OFFSET);
1210 blk_size = adapter->sdio_rx_block_size * blk_num;
1211 if (blk_size > total_pkt_len) {
1212 mwifiex_dbg(adapter, ERROR,
1213 "%s: error in blk_size,\t"
1214 "blk_num=%d, blk_size=%d, total_pkt_len=%d\n",
1215 __func__, blk_num, blk_size, total_pkt_len);
1216 break;
1217 }
1218 pkt_len = le16_to_cpu(*(__le16 *)(data + SDIO_HEADER_OFFSET));
1219 pkt_type = le16_to_cpu(*(__le16 *)(data + SDIO_HEADER_OFFSET +
1220 2));
1221 if ((pkt_len + SDIO_HEADER_OFFSET) > blk_size) {
1222 mwifiex_dbg(adapter, ERROR,
1223 "%s: error in pkt_len,\t"
1224 "pkt_len=%d, blk_size=%d\n",
1225 __func__, pkt_len, blk_size);
1226 break;
1227 }
1228
1229 skb_deaggr = mwifiex_alloc_dma_align_buf(pkt_len, GFP_KERNEL);
1230 if (!skb_deaggr)
1231 break;
1232 skb_put(skb_deaggr, pkt_len);
1233 memcpy(skb_deaggr->data, data + SDIO_HEADER_OFFSET, pkt_len);
1234 skb_pull(skb_deaggr, INTF_HEADER_LEN);
1235
1236 mwifiex_handle_rx_packet(adapter, skb_deaggr);
1237 data += blk_size;
1238 total_pkt_len -= blk_size;
1239 }
1240}
1241
1242
1243
1244
1245
1246
1247
1248
1249static int mwifiex_decode_rx_packet(struct mwifiex_adapter *adapter,
1250 struct sk_buff *skb, u32 upld_typ)
1251{
1252 u8 *cmd_buf;
1253 __le16 *curr_ptr = (__le16 *)skb->data;
1254 u16 pkt_len = le16_to_cpu(*curr_ptr);
1255 struct mwifiex_rxinfo *rx_info;
1256
1257 if (upld_typ != MWIFIEX_TYPE_AGGR_DATA) {
1258 skb_trim(skb, pkt_len);
1259 skb_pull(skb, INTF_HEADER_LEN);
1260 }
1261
1262 switch (upld_typ) {
1263 case MWIFIEX_TYPE_AGGR_DATA:
1264 mwifiex_dbg(adapter, INFO,
1265 "info: --- Rx: Aggr Data packet ---\n");
1266 rx_info = MWIFIEX_SKB_RXCB(skb);
1267 rx_info->buf_type = MWIFIEX_TYPE_AGGR_DATA;
1268 if (adapter->rx_work_enabled) {
1269 skb_queue_tail(&adapter->rx_data_q, skb);
1270 atomic_inc(&adapter->rx_pending);
1271 adapter->data_received = true;
1272 } else {
1273 mwifiex_deaggr_sdio_pkt(adapter, skb);
1274 dev_kfree_skb_any(skb);
1275 }
1276 break;
1277
1278 case MWIFIEX_TYPE_DATA:
1279 mwifiex_dbg(adapter, DATA,
1280 "info: --- Rx: Data packet ---\n");
1281 if (adapter->rx_work_enabled) {
1282 skb_queue_tail(&adapter->rx_data_q, skb);
1283 adapter->data_received = true;
1284 atomic_inc(&adapter->rx_pending);
1285 } else {
1286 mwifiex_handle_rx_packet(adapter, skb);
1287 }
1288 break;
1289
1290 case MWIFIEX_TYPE_CMD:
1291 mwifiex_dbg(adapter, CMD,
1292 "info: --- Rx: Cmd Response ---\n");
1293
1294 if (!adapter->curr_cmd) {
1295 cmd_buf = adapter->upld_buf;
1296
1297 if (adapter->ps_state == PS_STATE_SLEEP_CFM)
1298 mwifiex_process_sleep_confirm_resp(adapter,
1299 skb->data,
1300 skb->len);
1301
1302 memcpy(cmd_buf, skb->data,
1303 min_t(u32, MWIFIEX_SIZE_OF_CMD_BUFFER,
1304 skb->len));
1305
1306 dev_kfree_skb_any(skb);
1307 } else {
1308 adapter->cmd_resp_received = true;
1309 adapter->curr_cmd->resp_skb = skb;
1310 }
1311 break;
1312
1313 case MWIFIEX_TYPE_EVENT:
1314 mwifiex_dbg(adapter, EVENT,
1315 "info: --- Rx: Event ---\n");
1316 adapter->event_cause = le32_to_cpu(*(__le32 *) skb->data);
1317
1318 if ((skb->len > 0) && (skb->len < MAX_EVENT_SIZE))
1319 memcpy(adapter->event_body,
1320 skb->data + MWIFIEX_EVENT_HEADER_LEN,
1321 skb->len);
1322
1323
1324 adapter->event_received = true;
1325 adapter->event_skb = skb;
1326
1327 break;
1328
1329 default:
1330 mwifiex_dbg(adapter, ERROR,
1331 "unknown upload type %#x\n", upld_typ);
1332 dev_kfree_skb_any(skb);
1333 break;
1334 }
1335
1336 return 0;
1337}
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348static int mwifiex_sdio_card_to_host_mp_aggr(struct mwifiex_adapter *adapter,
1349 u16 rx_len, u8 port)
1350{
1351 struct sdio_mmc_card *card = adapter->card;
1352 s32 f_do_rx_aggr = 0;
1353 s32 f_do_rx_cur = 0;
1354 s32 f_aggr_cur = 0;
1355 s32 f_post_aggr_cur = 0;
1356 struct sk_buff *skb_deaggr;
1357 struct sk_buff *skb = NULL;
1358 u32 pkt_len, pkt_type, mport, pind;
1359 u8 *curr_ptr;
1360
1361 if ((card->has_control_mask) && (port == CTRL_PORT)) {
1362
1363 mwifiex_dbg(adapter, CMD,
1364 "info: %s: no aggregation for cmd\t"
1365 "response\n", __func__);
1366
1367 f_do_rx_cur = 1;
1368 goto rx_curr_single;
1369 }
1370
1371 if (!card->mpa_rx.enabled) {
1372 mwifiex_dbg(adapter, WARN,
1373 "info: %s: rx aggregation disabled\n",
1374 __func__);
1375
1376 f_do_rx_cur = 1;
1377 goto rx_curr_single;
1378 }
1379
1380 if ((!card->has_control_mask && (card->mp_rd_bitmap &
1381 card->reg->data_port_mask)) ||
1382 (card->has_control_mask && (card->mp_rd_bitmap &
1383 (~((u32) CTRL_PORT_MASK))))) {
1384
1385 mwifiex_dbg(adapter, INFO,
1386 "info: %s: not last packet\n", __func__);
1387
1388 if (MP_RX_AGGR_IN_PROGRESS(card)) {
1389 if (MP_RX_AGGR_BUF_HAS_ROOM(card, rx_len)) {
1390 f_aggr_cur = 1;
1391 } else {
1392
1393 f_do_rx_aggr = 1;
1394 f_post_aggr_cur = 1;
1395 }
1396 } else {
1397
1398 f_aggr_cur = 1;
1399 }
1400
1401 } else {
1402
1403 mwifiex_dbg(adapter, INFO,
1404 "info: %s: last packet\n", __func__);
1405
1406 if (MP_RX_AGGR_IN_PROGRESS(card)) {
1407 f_do_rx_aggr = 1;
1408 if (MP_RX_AGGR_BUF_HAS_ROOM(card, rx_len))
1409 f_aggr_cur = 1;
1410 else
1411
1412 f_do_rx_cur = 1;
1413 } else {
1414 f_do_rx_cur = 1;
1415 }
1416 }
1417
1418 if (f_aggr_cur) {
1419 mwifiex_dbg(adapter, INFO,
1420 "info: current packet aggregation\n");
1421
1422 mp_rx_aggr_setup(card, rx_len, port);
1423
1424 if (MP_RX_AGGR_PKT_LIMIT_REACHED(card) ||
1425 mp_rx_aggr_port_limit_reached(card)) {
1426 mwifiex_dbg(adapter, INFO,
1427 "info: %s: aggregated packet\t"
1428 "limit reached\n", __func__);
1429
1430 f_do_rx_aggr = 1;
1431 }
1432 }
1433
1434 if (f_do_rx_aggr) {
1435
1436 mwifiex_dbg(adapter, DATA,
1437 "info: do_rx_aggr: num of packets: %d\n",
1438 card->mpa_rx.pkt_cnt);
1439
1440 if (card->supports_sdio_new_mode) {
1441 int i;
1442 u32 port_count;
1443
1444 for (i = 0, port_count = 0; i < card->max_ports; i++)
1445 if (card->mpa_rx.ports & BIT(i))
1446 port_count++;
1447
1448
1449
1450
1451 port_count--;
1452 mport = (adapter->ioport | SDIO_MPA_ADDR_BASE |
1453 (port_count << 8)) + card->mpa_rx.start_port;
1454 } else {
1455 mport = (adapter->ioport | SDIO_MPA_ADDR_BASE |
1456 (card->mpa_rx.ports << 4)) +
1457 card->mpa_rx.start_port;
1458 }
1459
1460 if (card->mpa_rx.pkt_cnt == 1)
1461 mport = adapter->ioport + port;
1462
1463 if (mwifiex_read_data_sync(adapter, card->mpa_rx.buf,
1464 card->mpa_rx.buf_len, mport, 1))
1465 goto error;
1466
1467 curr_ptr = card->mpa_rx.buf;
1468
1469 for (pind = 0; pind < card->mpa_rx.pkt_cnt; pind++) {
1470 u32 *len_arr = card->mpa_rx.len_arr;
1471
1472
1473 pkt_len = le16_to_cpu(*(__le16 *) &curr_ptr[0]);
1474 pkt_type = le16_to_cpu(*(__le16 *) &curr_ptr[2]);
1475
1476
1477 skb_deaggr = mwifiex_alloc_dma_align_buf(len_arr[pind],
1478 GFP_KERNEL);
1479 if (!skb_deaggr) {
1480 mwifiex_dbg(adapter, ERROR, "skb allocation failure\t"
1481 "drop pkt len=%d type=%d\n",
1482 pkt_len, pkt_type);
1483 curr_ptr += len_arr[pind];
1484 continue;
1485 }
1486
1487 skb_put(skb_deaggr, len_arr[pind]);
1488
1489 if ((pkt_type == MWIFIEX_TYPE_DATA ||
1490 (pkt_type == MWIFIEX_TYPE_AGGR_DATA &&
1491 adapter->sdio_rx_aggr_enable)) &&
1492 (pkt_len <= len_arr[pind])) {
1493
1494 memcpy(skb_deaggr->data, curr_ptr, pkt_len);
1495
1496 skb_trim(skb_deaggr, pkt_len);
1497
1498
1499 mwifiex_decode_rx_packet(adapter, skb_deaggr,
1500 pkt_type);
1501 } else {
1502 mwifiex_dbg(adapter, ERROR,
1503 "drop wrong aggr pkt:\t"
1504 "sdio_single_port_rx_aggr=%d\t"
1505 "type=%d len=%d max_len=%d\n",
1506 adapter->sdio_rx_aggr_enable,
1507 pkt_type, pkt_len, len_arr[pind]);
1508 dev_kfree_skb_any(skb_deaggr);
1509 }
1510 curr_ptr += len_arr[pind];
1511 }
1512 MP_RX_AGGR_BUF_RESET(card);
1513 }
1514
1515rx_curr_single:
1516 if (f_do_rx_cur) {
1517 mwifiex_dbg(adapter, INFO, "info: RX: port: %d, rx_len: %d\n",
1518 port, rx_len);
1519
1520 skb = mwifiex_alloc_dma_align_buf(rx_len, GFP_KERNEL);
1521 if (!skb) {
1522 mwifiex_dbg(adapter, ERROR,
1523 "single skb allocated fail,\t"
1524 "drop pkt port=%d len=%d\n", port, rx_len);
1525 if (mwifiex_sdio_card_to_host(adapter, &pkt_type,
1526 card->mpa_rx.buf, rx_len,
1527 adapter->ioport + port))
1528 goto error;
1529 return 0;
1530 }
1531
1532 skb_put(skb, rx_len);
1533
1534 if (mwifiex_sdio_card_to_host(adapter, &pkt_type,
1535 skb->data, skb->len,
1536 adapter->ioport + port))
1537 goto error;
1538 if (!adapter->sdio_rx_aggr_enable &&
1539 pkt_type == MWIFIEX_TYPE_AGGR_DATA) {
1540 mwifiex_dbg(adapter, ERROR, "drop wrong pkt type %d\t"
1541 "current SDIO RX Aggr not enabled\n",
1542 pkt_type);
1543 dev_kfree_skb_any(skb);
1544 return 0;
1545 }
1546
1547 mwifiex_decode_rx_packet(adapter, skb, pkt_type);
1548 }
1549 if (f_post_aggr_cur) {
1550 mwifiex_dbg(adapter, INFO,
1551 "info: current packet aggregation\n");
1552
1553 mp_rx_aggr_setup(card, rx_len, port);
1554 }
1555
1556 return 0;
1557error:
1558 if (MP_RX_AGGR_IN_PROGRESS(card))
1559 MP_RX_AGGR_BUF_RESET(card);
1560
1561 if (f_do_rx_cur && skb)
1562
1563 dev_kfree_skb_any(skb);
1564
1565 return -1;
1566}
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583static int mwifiex_process_int_status(struct mwifiex_adapter *adapter)
1584{
1585 struct sdio_mmc_card *card = adapter->card;
1586 const struct mwifiex_sdio_card_reg *reg = card->reg;
1587 int ret = 0;
1588 u8 sdio_ireg;
1589 struct sk_buff *skb;
1590 u8 port = CTRL_PORT;
1591 u32 len_reg_l, len_reg_u;
1592 u32 rx_blocks;
1593 u16 rx_len;
1594 unsigned long flags;
1595 u32 bitmap;
1596 u8 cr;
1597
1598 spin_lock_irqsave(&adapter->int_lock, flags);
1599 sdio_ireg = adapter->int_status;
1600 adapter->int_status = 0;
1601 spin_unlock_irqrestore(&adapter->int_lock, flags);
1602
1603 if (!sdio_ireg)
1604 return ret;
1605
1606
1607 if (sdio_ireg & DN_LD_CMD_PORT_HOST_INT_STATUS && adapter->cmd_sent)
1608 adapter->cmd_sent = false;
1609
1610
1611 if (sdio_ireg & UP_LD_CMD_PORT_HOST_INT_STATUS) {
1612 u32 pkt_type;
1613
1614
1615 rx_len = card->mp_regs[reg->cmd_rd_len_1] << 8;
1616 rx_len |= (u16)card->mp_regs[reg->cmd_rd_len_0];
1617 rx_blocks = DIV_ROUND_UP(rx_len, MWIFIEX_SDIO_BLOCK_SIZE);
1618 if (rx_len <= INTF_HEADER_LEN ||
1619 (rx_blocks * MWIFIEX_SDIO_BLOCK_SIZE) >
1620 MWIFIEX_RX_DATA_BUF_SIZE)
1621 return -1;
1622 rx_len = (u16) (rx_blocks * MWIFIEX_SDIO_BLOCK_SIZE);
1623 mwifiex_dbg(adapter, INFO, "info: rx_len = %d\n", rx_len);
1624
1625 skb = mwifiex_alloc_dma_align_buf(rx_len, GFP_KERNEL);
1626 if (!skb)
1627 return -1;
1628
1629 skb_put(skb, rx_len);
1630
1631 if (mwifiex_sdio_card_to_host(adapter, &pkt_type, skb->data,
1632 skb->len, adapter->ioport |
1633 CMD_PORT_SLCT)) {
1634 mwifiex_dbg(adapter, ERROR,
1635 "%s: failed to card_to_host", __func__);
1636 dev_kfree_skb_any(skb);
1637 goto term_cmd;
1638 }
1639
1640 if ((pkt_type != MWIFIEX_TYPE_CMD) &&
1641 (pkt_type != MWIFIEX_TYPE_EVENT))
1642 mwifiex_dbg(adapter, ERROR,
1643 "%s:Received wrong packet on cmd port",
1644 __func__);
1645
1646 mwifiex_decode_rx_packet(adapter, skb, pkt_type);
1647 }
1648
1649 if (sdio_ireg & DN_LD_HOST_INT_STATUS) {
1650 bitmap = (u32) card->mp_regs[reg->wr_bitmap_l];
1651 bitmap |= ((u32) card->mp_regs[reg->wr_bitmap_u]) << 8;
1652 if (card->supports_sdio_new_mode) {
1653 bitmap |=
1654 ((u32) card->mp_regs[reg->wr_bitmap_1l]) << 16;
1655 bitmap |=
1656 ((u32) card->mp_regs[reg->wr_bitmap_1u]) << 24;
1657 }
1658 card->mp_wr_bitmap = bitmap;
1659
1660 mwifiex_dbg(adapter, INTR,
1661 "int: DNLD: wr_bitmap=0x%x\n",
1662 card->mp_wr_bitmap);
1663 if (adapter->data_sent &&
1664 (card->mp_wr_bitmap & card->mp_data_port_mask)) {
1665 mwifiex_dbg(adapter, INTR,
1666 "info: <--- Tx DONE Interrupt --->\n");
1667 adapter->data_sent = false;
1668 }
1669 }
1670
1671
1672
1673
1674 if (card->has_control_mask && adapter->cmd_sent) {
1675
1676
1677 card->mp_wr_bitmap |=
1678 (u32) card->mp_regs[reg->wr_bitmap_l] & CTRL_PORT_MASK;
1679 if (card->mp_wr_bitmap & CTRL_PORT_MASK)
1680 adapter->cmd_sent = false;
1681 }
1682
1683 mwifiex_dbg(adapter, INTR, "info: cmd_sent=%d data_sent=%d\n",
1684 adapter->cmd_sent, adapter->data_sent);
1685 if (sdio_ireg & UP_LD_HOST_INT_STATUS) {
1686 bitmap = (u32) card->mp_regs[reg->rd_bitmap_l];
1687 bitmap |= ((u32) card->mp_regs[reg->rd_bitmap_u]) << 8;
1688 if (card->supports_sdio_new_mode) {
1689 bitmap |=
1690 ((u32) card->mp_regs[reg->rd_bitmap_1l]) << 16;
1691 bitmap |=
1692 ((u32) card->mp_regs[reg->rd_bitmap_1u]) << 24;
1693 }
1694 card->mp_rd_bitmap = bitmap;
1695 mwifiex_dbg(adapter, INTR,
1696 "int: UPLD: rd_bitmap=0x%x\n",
1697 card->mp_rd_bitmap);
1698
1699 while (true) {
1700 ret = mwifiex_get_rd_port(adapter, &port);
1701 if (ret) {
1702 mwifiex_dbg(adapter, INFO,
1703 "info: no more rd_port available\n");
1704 break;
1705 }
1706 len_reg_l = reg->rd_len_p0_l + (port << 1);
1707 len_reg_u = reg->rd_len_p0_u + (port << 1);
1708 rx_len = ((u16) card->mp_regs[len_reg_u]) << 8;
1709 rx_len |= (u16) card->mp_regs[len_reg_l];
1710 mwifiex_dbg(adapter, INFO,
1711 "info: RX: port=%d rx_len=%u\n",
1712 port, rx_len);
1713 rx_blocks =
1714 (rx_len + MWIFIEX_SDIO_BLOCK_SIZE -
1715 1) / MWIFIEX_SDIO_BLOCK_SIZE;
1716 if (rx_len <= INTF_HEADER_LEN ||
1717 (card->mpa_rx.enabled &&
1718 ((rx_blocks * MWIFIEX_SDIO_BLOCK_SIZE) >
1719 card->mpa_rx.buf_size))) {
1720 mwifiex_dbg(adapter, ERROR,
1721 "invalid rx_len=%d\n",
1722 rx_len);
1723 return -1;
1724 }
1725
1726 rx_len = (u16) (rx_blocks * MWIFIEX_SDIO_BLOCK_SIZE);
1727 mwifiex_dbg(adapter, INFO, "info: rx_len = %d\n",
1728 rx_len);
1729
1730 if (mwifiex_sdio_card_to_host_mp_aggr(adapter, rx_len,
1731 port)) {
1732 mwifiex_dbg(adapter, ERROR,
1733 "card_to_host_mpa failed: int status=%#x\n",
1734 sdio_ireg);
1735 goto term_cmd;
1736 }
1737 }
1738 }
1739
1740 return 0;
1741
1742term_cmd:
1743
1744 if (mwifiex_read_reg(adapter, CONFIGURATION_REG, &cr))
1745 mwifiex_dbg(adapter, ERROR, "read CFG reg failed\n");
1746 else
1747 mwifiex_dbg(adapter, INFO,
1748 "info: CFG reg val = %d\n", cr);
1749
1750 if (mwifiex_write_reg(adapter, CONFIGURATION_REG, (cr | 0x04)))
1751 mwifiex_dbg(adapter, ERROR,
1752 "write CFG reg failed\n");
1753 else
1754 mwifiex_dbg(adapter, INFO, "info: write success\n");
1755
1756 if (mwifiex_read_reg(adapter, CONFIGURATION_REG, &cr))
1757 mwifiex_dbg(adapter, ERROR,
1758 "read CFG reg failed\n");
1759 else
1760 mwifiex_dbg(adapter, INFO,
1761 "info: CFG reg val =%x\n", cr);
1762
1763 return -1;
1764}
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780static int mwifiex_host_to_card_mp_aggr(struct mwifiex_adapter *adapter,
1781 u8 *payload, u32 pkt_len, u32 port,
1782 u32 next_pkt_len)
1783{
1784 struct sdio_mmc_card *card = adapter->card;
1785 int ret = 0;
1786 s32 f_send_aggr_buf = 0;
1787 s32 f_send_cur_buf = 0;
1788 s32 f_precopy_cur_buf = 0;
1789 s32 f_postcopy_cur_buf = 0;
1790 u32 mport;
1791 int index;
1792
1793 if (!card->mpa_tx.enabled ||
1794 (card->has_control_mask && (port == CTRL_PORT)) ||
1795 (card->supports_sdio_new_mode && (port == CMD_PORT_SLCT))) {
1796 mwifiex_dbg(adapter, WARN,
1797 "info: %s: tx aggregation disabled\n",
1798 __func__);
1799
1800 f_send_cur_buf = 1;
1801 goto tx_curr_single;
1802 }
1803
1804 if (next_pkt_len) {
1805
1806 mwifiex_dbg(adapter, INFO,
1807 "info: %s: more packets in queue.\n",
1808 __func__);
1809
1810 if (MP_TX_AGGR_IN_PROGRESS(card)) {
1811 if (MP_TX_AGGR_BUF_HAS_ROOM(card, pkt_len)) {
1812 f_precopy_cur_buf = 1;
1813
1814 if (!(card->mp_wr_bitmap &
1815 (1 << card->curr_wr_port)) ||
1816 !MP_TX_AGGR_BUF_HAS_ROOM(
1817 card, pkt_len + next_pkt_len))
1818 f_send_aggr_buf = 1;
1819 } else {
1820
1821 f_send_aggr_buf = 1;
1822
1823 if (!(card->mp_wr_bitmap &
1824 (1 << card->curr_wr_port)))
1825 f_send_cur_buf = 1;
1826 else
1827 f_postcopy_cur_buf = 1;
1828 }
1829 } else {
1830 if (MP_TX_AGGR_BUF_HAS_ROOM(card, pkt_len) &&
1831 (card->mp_wr_bitmap & (1 << card->curr_wr_port)))
1832 f_precopy_cur_buf = 1;
1833 else
1834 f_send_cur_buf = 1;
1835 }
1836 } else {
1837
1838 mwifiex_dbg(adapter, INFO,
1839 "info: %s: Last packet in Tx Queue.\n",
1840 __func__);
1841
1842 if (MP_TX_AGGR_IN_PROGRESS(card)) {
1843
1844 f_send_aggr_buf = 1;
1845
1846 if (MP_TX_AGGR_BUF_HAS_ROOM(card, pkt_len))
1847 f_precopy_cur_buf = 1;
1848 else
1849
1850 f_send_cur_buf = 1;
1851 } else {
1852 f_send_cur_buf = 1;
1853 }
1854 }
1855
1856 if (f_precopy_cur_buf) {
1857 mwifiex_dbg(adapter, DATA,
1858 "data: %s: precopy current buffer\n",
1859 __func__);
1860 MP_TX_AGGR_BUF_PUT(card, payload, pkt_len, port);
1861
1862 if (MP_TX_AGGR_PKT_LIMIT_REACHED(card) ||
1863 mp_tx_aggr_port_limit_reached(card))
1864
1865 f_send_aggr_buf = 1;
1866 }
1867
1868 if (f_send_aggr_buf) {
1869 mwifiex_dbg(adapter, DATA,
1870 "data: %s: send aggr buffer: %d %d\n",
1871 __func__, card->mpa_tx.start_port,
1872 card->mpa_tx.ports);
1873 if (card->supports_sdio_new_mode) {
1874 u32 port_count;
1875 int i;
1876
1877 for (i = 0, port_count = 0; i < card->max_ports; i++)
1878 if (card->mpa_tx.ports & BIT(i))
1879 port_count++;
1880
1881
1882
1883
1884 port_count--;
1885 mport = (adapter->ioport | SDIO_MPA_ADDR_BASE |
1886 (port_count << 8)) + card->mpa_tx.start_port;
1887 } else {
1888 mport = (adapter->ioport | SDIO_MPA_ADDR_BASE |
1889 (card->mpa_tx.ports << 4)) +
1890 card->mpa_tx.start_port;
1891 }
1892
1893 if (card->mpa_tx.pkt_cnt == 1)
1894 mport = adapter->ioport + port;
1895
1896 ret = mwifiex_write_data_to_card(adapter, card->mpa_tx.buf,
1897 card->mpa_tx.buf_len, mport);
1898
1899
1900 index = adapter->dbg.last_sdio_mp_index;
1901 index = (index + 1) % MWIFIEX_DBG_SDIO_MP_NUM;
1902 adapter->dbg.last_sdio_mp_index = index;
1903 adapter->dbg.last_mp_wr_ports[index] = mport;
1904 adapter->dbg.last_mp_wr_bitmap[index] = card->mp_wr_bitmap;
1905 adapter->dbg.last_mp_wr_len[index] = card->mpa_tx.buf_len;
1906 adapter->dbg.last_mp_curr_wr_port[index] = card->curr_wr_port;
1907
1908 MP_TX_AGGR_BUF_RESET(card);
1909 }
1910
1911tx_curr_single:
1912 if (f_send_cur_buf) {
1913 mwifiex_dbg(adapter, DATA,
1914 "data: %s: send current buffer %d\n",
1915 __func__, port);
1916 ret = mwifiex_write_data_to_card(adapter, payload, pkt_len,
1917 adapter->ioport + port);
1918 }
1919
1920 if (f_postcopy_cur_buf) {
1921 mwifiex_dbg(adapter, DATA,
1922 "data: %s: postcopy current buffer\n",
1923 __func__);
1924 MP_TX_AGGR_BUF_PUT(card, payload, pkt_len, port);
1925 }
1926
1927 return ret;
1928}
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940static int mwifiex_sdio_host_to_card(struct mwifiex_adapter *adapter,
1941 u8 type, struct sk_buff *skb,
1942 struct mwifiex_tx_param *tx_param)
1943{
1944 struct sdio_mmc_card *card = adapter->card;
1945 int ret;
1946 u32 buf_block_len;
1947 u32 blk_size;
1948 u32 port = CTRL_PORT;
1949 u8 *payload = (u8 *)skb->data;
1950 u32 pkt_len = skb->len;
1951
1952
1953 blk_size = MWIFIEX_SDIO_BLOCK_SIZE;
1954 buf_block_len = (pkt_len + blk_size - 1) / blk_size;
1955 *(__le16 *)&payload[0] = cpu_to_le16((u16)pkt_len);
1956 *(__le16 *)&payload[2] = cpu_to_le16(type);
1957
1958
1959
1960
1961
1962
1963
1964 if (type == MWIFIEX_TYPE_DATA) {
1965 ret = mwifiex_get_wr_port_data(adapter, &port);
1966 if (ret) {
1967 mwifiex_dbg(adapter, ERROR,
1968 "%s: no wr_port available\n",
1969 __func__);
1970 return ret;
1971 }
1972 } else {
1973 adapter->cmd_sent = true;
1974
1975
1976 if (pkt_len <= INTF_HEADER_LEN ||
1977 pkt_len > MWIFIEX_UPLD_SIZE)
1978 mwifiex_dbg(adapter, ERROR,
1979 "%s: payload=%p, nb=%d\n",
1980 __func__, payload, pkt_len);
1981
1982 if (card->supports_sdio_new_mode)
1983 port = CMD_PORT_SLCT;
1984 }
1985
1986
1987 pkt_len = buf_block_len * blk_size;
1988
1989 if (tx_param)
1990 ret = mwifiex_host_to_card_mp_aggr(adapter, payload, pkt_len,
1991 port, tx_param->next_pkt_len
1992 );
1993 else
1994 ret = mwifiex_host_to_card_mp_aggr(adapter, payload, pkt_len,
1995 port, 0);
1996
1997 if (ret) {
1998 if (type == MWIFIEX_TYPE_CMD)
1999 adapter->cmd_sent = false;
2000 if (type == MWIFIEX_TYPE_DATA) {
2001 adapter->data_sent = false;
2002
2003 card->curr_wr_port = port;
2004 card->mp_wr_bitmap |= (u32)(1 << card->curr_wr_port);
2005 }
2006 } else {
2007 if (type == MWIFIEX_TYPE_DATA) {
2008 if (!(card->mp_wr_bitmap & (1 << card->curr_wr_port)))
2009 adapter->data_sent = true;
2010 else
2011 adapter->data_sent = false;
2012 }
2013 }
2014
2015 return ret;
2016}
2017
2018
2019
2020
2021static int mwifiex_alloc_sdio_mpa_buffers(struct mwifiex_adapter *adapter,
2022 u32 mpa_tx_buf_size, u32 mpa_rx_buf_size)
2023{
2024 struct sdio_mmc_card *card = adapter->card;
2025 u32 rx_buf_size;
2026 int ret = 0;
2027
2028 card->mpa_tx.buf = kzalloc(mpa_tx_buf_size, GFP_KERNEL);
2029 if (!card->mpa_tx.buf) {
2030 ret = -1;
2031 goto error;
2032 }
2033
2034 card->mpa_tx.buf_size = mpa_tx_buf_size;
2035
2036 rx_buf_size = max_t(u32, mpa_rx_buf_size,
2037 (u32)SDIO_MAX_AGGR_BUF_SIZE);
2038 card->mpa_rx.buf = kzalloc(rx_buf_size, GFP_KERNEL);
2039 if (!card->mpa_rx.buf) {
2040 ret = -1;
2041 goto error;
2042 }
2043
2044 card->mpa_rx.buf_size = rx_buf_size;
2045
2046error:
2047 if (ret) {
2048 kfree(card->mpa_tx.buf);
2049 kfree(card->mpa_rx.buf);
2050 card->mpa_tx.buf_size = 0;
2051 card->mpa_rx.buf_size = 0;
2052 }
2053
2054 return ret;
2055}
2056
2057
2058
2059
2060
2061
2062
2063static void
2064mwifiex_unregister_dev(struct mwifiex_adapter *adapter)
2065{
2066 struct sdio_mmc_card *card = adapter->card;
2067
2068 if (adapter->card) {
2069 sdio_claim_host(card->func);
2070 sdio_disable_func(card->func);
2071 sdio_release_host(card->func);
2072 }
2073}
2074
2075
2076
2077
2078
2079
2080static int mwifiex_register_dev(struct mwifiex_adapter *adapter)
2081{
2082 int ret;
2083 struct sdio_mmc_card *card = adapter->card;
2084 struct sdio_func *func = card->func;
2085
2086
2087 card->adapter = adapter;
2088 adapter->tx_buf_size = card->tx_buf_size;
2089
2090 sdio_claim_host(func);
2091
2092
2093 ret = sdio_set_block_size(card->func, MWIFIEX_SDIO_BLOCK_SIZE);
2094 sdio_release_host(func);
2095 if (ret) {
2096 mwifiex_dbg(adapter, ERROR,
2097 "cannot set SDIO block size\n");
2098 return ret;
2099 }
2100
2101
2102 adapter->dev = &func->dev;
2103
2104 strcpy(adapter->fw_name, card->firmware);
2105 if (card->fw_dump_enh) {
2106 adapter->mem_type_mapping_tbl = generic_mem_type_map;
2107 adapter->num_mem_types = 1;
2108 } else {
2109 adapter->mem_type_mapping_tbl = mem_type_mapping_tbl;
2110 adapter->num_mem_types = ARRAY_SIZE(mem_type_mapping_tbl);
2111 }
2112
2113 return 0;
2114}
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128static int mwifiex_init_sdio(struct mwifiex_adapter *adapter)
2129{
2130 struct sdio_mmc_card *card = adapter->card;
2131 const struct mwifiex_sdio_card_reg *reg = card->reg;
2132 int ret;
2133 u8 sdio_ireg;
2134
2135 sdio_set_drvdata(card->func, card);
2136
2137
2138
2139
2140
2141
2142 mwifiex_read_reg(adapter, card->reg->host_int_status_reg, &sdio_ireg);
2143
2144
2145 mwifiex_init_sdio_ioport(adapter);
2146
2147
2148 card->mp_rd_bitmap = 0;
2149 card->mp_wr_bitmap = 0;
2150 card->curr_rd_port = reg->start_rd_port;
2151 card->curr_wr_port = reg->start_wr_port;
2152
2153 card->mp_data_port_mask = reg->data_port_mask;
2154
2155 card->mpa_tx.buf_len = 0;
2156 card->mpa_tx.pkt_cnt = 0;
2157 card->mpa_tx.start_port = 0;
2158
2159 card->mpa_tx.enabled = 1;
2160 card->mpa_tx.pkt_aggr_limit = card->mp_agg_pkt_limit;
2161
2162 card->mpa_rx.buf_len = 0;
2163 card->mpa_rx.pkt_cnt = 0;
2164 card->mpa_rx.start_port = 0;
2165
2166 card->mpa_rx.enabled = 1;
2167 card->mpa_rx.pkt_aggr_limit = card->mp_agg_pkt_limit;
2168
2169
2170 card->mp_regs = kzalloc(reg->max_mp_regs, GFP_KERNEL);
2171 if (!card->mp_regs)
2172 return -ENOMEM;
2173
2174
2175 card->mpa_rx.skb_arr = kzalloc((sizeof(void *)) *
2176 card->mp_agg_pkt_limit, GFP_KERNEL);
2177 if (!card->mpa_rx.skb_arr) {
2178 kfree(card->mp_regs);
2179 return -ENOMEM;
2180 }
2181
2182 card->mpa_rx.len_arr = kzalloc(sizeof(*card->mpa_rx.len_arr) *
2183 card->mp_agg_pkt_limit, GFP_KERNEL);
2184 if (!card->mpa_rx.len_arr) {
2185 kfree(card->mp_regs);
2186 kfree(card->mpa_rx.skb_arr);
2187 return -ENOMEM;
2188 }
2189
2190 ret = mwifiex_alloc_sdio_mpa_buffers(adapter,
2191 card->mp_tx_agg_buf_size,
2192 card->mp_rx_agg_buf_size);
2193
2194
2195 if (ret && (card->mp_tx_agg_buf_size == MWIFIEX_MP_AGGR_BUF_SIZE_MAX ||
2196 card->mp_rx_agg_buf_size == MWIFIEX_MP_AGGR_BUF_SIZE_MAX)) {
2197
2198 adapter->host_disable_sdio_rx_aggr = true;
2199
2200 ret = mwifiex_alloc_sdio_mpa_buffers
2201 (adapter, MWIFIEX_MP_AGGR_BUF_SIZE_32K,
2202 MWIFIEX_MP_AGGR_BUF_SIZE_32K);
2203 if (ret) {
2204
2205 card->mpa_tx.enabled = 0;
2206 card->mpa_rx.enabled = 0;
2207 }
2208 }
2209
2210 adapter->auto_tdls = card->can_auto_tdls;
2211 adapter->ext_scan = card->can_ext_scan;
2212 return 0;
2213}
2214
2215
2216
2217
2218static void mwifiex_cleanup_mpa_buf(struct mwifiex_adapter *adapter)
2219{
2220 struct sdio_mmc_card *card = adapter->card;
2221
2222 MP_TX_AGGR_BUF_RESET(card);
2223 MP_RX_AGGR_BUF_RESET(card);
2224}
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234static void mwifiex_cleanup_sdio(struct mwifiex_adapter *adapter)
2235{
2236 struct sdio_mmc_card *card = adapter->card;
2237
2238 kfree(card->mp_regs);
2239 kfree(card->mpa_rx.skb_arr);
2240 kfree(card->mpa_rx.len_arr);
2241 kfree(card->mpa_tx.buf);
2242 kfree(card->mpa_rx.buf);
2243 sdio_set_drvdata(card->func, NULL);
2244 kfree(card);
2245}
2246
2247
2248
2249
2250static void
2251mwifiex_update_mp_end_port(struct mwifiex_adapter *adapter, u16 port)
2252{
2253 struct sdio_mmc_card *card = adapter->card;
2254 const struct mwifiex_sdio_card_reg *reg = card->reg;
2255 int i;
2256
2257 card->mp_end_port = port;
2258
2259 card->mp_data_port_mask = reg->data_port_mask;
2260
2261 if (reg->start_wr_port) {
2262 for (i = 1; i <= card->max_ports - card->mp_end_port; i++)
2263 card->mp_data_port_mask &=
2264 ~(1 << (card->max_ports - i));
2265 }
2266
2267 card->curr_wr_port = reg->start_wr_port;
2268
2269 mwifiex_dbg(adapter, CMD,
2270 "cmd: mp_end_port %d, data port mask 0x%x\n",
2271 port, card->mp_data_port_mask);
2272}
2273
2274static void mwifiex_recreate_adapter(struct sdio_mmc_card *card)
2275{
2276 struct sdio_func *func = card->func;
2277 const struct sdio_device_id *device_id = card->device_id;
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292 mwifiex_sdio_remove(func);
2293
2294
2295 sdio_claim_host(func);
2296 mmc_hw_reset(func->card->host);
2297 sdio_release_host(func);
2298
2299 mwifiex_sdio_probe(func, device_id);
2300}
2301
2302static struct mwifiex_adapter *save_adapter;
2303static void mwifiex_sdio_card_reset_work(struct mwifiex_adapter *adapter)
2304{
2305 struct sdio_mmc_card *card = adapter->card;
2306
2307
2308
2309
2310
2311
2312
2313 mwifiex_recreate_adapter(card);
2314}
2315
2316
2317static enum
2318rdwr_status mwifiex_sdio_rdwr_firmware(struct mwifiex_adapter *adapter,
2319 u8 doneflag)
2320{
2321 struct sdio_mmc_card *card = adapter->card;
2322 int ret, tries;
2323 u8 ctrl_data = 0;
2324
2325 sdio_writeb(card->func, card->reg->fw_dump_host_ready,
2326 card->reg->fw_dump_ctrl, &ret);
2327 if (ret) {
2328 mwifiex_dbg(adapter, ERROR, "SDIO Write ERR\n");
2329 return RDWR_STATUS_FAILURE;
2330 }
2331 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
2332 ctrl_data = sdio_readb(card->func, card->reg->fw_dump_ctrl,
2333 &ret);
2334 if (ret) {
2335 mwifiex_dbg(adapter, ERROR, "SDIO read err\n");
2336 return RDWR_STATUS_FAILURE;
2337 }
2338 if (ctrl_data == FW_DUMP_DONE)
2339 break;
2340 if (doneflag && ctrl_data == doneflag)
2341 return RDWR_STATUS_DONE;
2342 if (ctrl_data != card->reg->fw_dump_host_ready) {
2343 mwifiex_dbg(adapter, WARN,
2344 "The ctrl reg was changed, re-try again\n");
2345 sdio_writeb(card->func, card->reg->fw_dump_host_ready,
2346 card->reg->fw_dump_ctrl, &ret);
2347 if (ret) {
2348 mwifiex_dbg(adapter, ERROR, "SDIO write err\n");
2349 return RDWR_STATUS_FAILURE;
2350 }
2351 }
2352 usleep_range(100, 200);
2353 }
2354 if (ctrl_data == card->reg->fw_dump_host_ready) {
2355 mwifiex_dbg(adapter, ERROR,
2356 "Fail to pull ctrl_data\n");
2357 return RDWR_STATUS_FAILURE;
2358 }
2359
2360 return RDWR_STATUS_SUCCESS;
2361}
2362
2363
2364static void mwifiex_sdio_fw_dump(struct mwifiex_adapter *adapter)
2365{
2366 struct sdio_mmc_card *card = adapter->card;
2367 int ret = 0;
2368 unsigned int reg, reg_start, reg_end;
2369 u8 *dbg_ptr, *end_ptr, dump_num, idx, i, read_reg, doneflag = 0;
2370 enum rdwr_status stat;
2371 u32 memory_size;
2372
2373 if (!card->can_dump_fw)
2374 return;
2375
2376 for (idx = 0; idx < ARRAY_SIZE(mem_type_mapping_tbl); idx++) {
2377 struct memory_type_mapping *entry = &mem_type_mapping_tbl[idx];
2378
2379 if (entry->mem_ptr) {
2380 vfree(entry->mem_ptr);
2381 entry->mem_ptr = NULL;
2382 }
2383 entry->mem_size = 0;
2384 }
2385
2386 mwifiex_pm_wakeup_card(adapter);
2387 sdio_claim_host(card->func);
2388
2389 mwifiex_dbg(adapter, MSG, "== mwifiex firmware dump start ==\n");
2390
2391 stat = mwifiex_sdio_rdwr_firmware(adapter, doneflag);
2392 if (stat == RDWR_STATUS_FAILURE)
2393 goto done;
2394
2395 reg = card->reg->fw_dump_start;
2396
2397 dump_num = sdio_readb(card->func, reg, &ret);
2398 if (ret) {
2399 mwifiex_dbg(adapter, ERROR, "SDIO read memory length err\n");
2400 goto done;
2401 }
2402
2403
2404 for (idx = 0; idx < dump_num; idx++) {
2405 struct memory_type_mapping *entry = &mem_type_mapping_tbl[idx];
2406
2407 stat = mwifiex_sdio_rdwr_firmware(adapter, doneflag);
2408 if (stat == RDWR_STATUS_FAILURE)
2409 goto done;
2410
2411 memory_size = 0;
2412 reg = card->reg->fw_dump_start;
2413 for (i = 0; i < 4; i++) {
2414 read_reg = sdio_readb(card->func, reg, &ret);
2415 if (ret) {
2416 mwifiex_dbg(adapter, ERROR, "SDIO read err\n");
2417 goto done;
2418 }
2419 memory_size |= (read_reg << i*8);
2420 reg++;
2421 }
2422
2423 if (memory_size == 0) {
2424 mwifiex_dbg(adapter, DUMP, "Firmware dump Finished!\n");
2425 ret = mwifiex_write_reg(adapter,
2426 card->reg->fw_dump_ctrl,
2427 FW_DUMP_READ_DONE);
2428 if (ret) {
2429 mwifiex_dbg(adapter, ERROR, "SDIO write err\n");
2430 return;
2431 }
2432 break;
2433 }
2434
2435 mwifiex_dbg(adapter, DUMP,
2436 "%s_SIZE=0x%x\n", entry->mem_name, memory_size);
2437 entry->mem_ptr = vmalloc(memory_size + 1);
2438 entry->mem_size = memory_size;
2439 if (!entry->mem_ptr) {
2440 mwifiex_dbg(adapter, ERROR, "Vmalloc %s failed\n",
2441 entry->mem_name);
2442 goto done;
2443 }
2444 dbg_ptr = entry->mem_ptr;
2445 end_ptr = dbg_ptr + memory_size;
2446
2447 doneflag = entry->done_flag;
2448 mwifiex_dbg(adapter, DUMP,
2449 "Start %s output, please wait...\n",
2450 entry->mem_name);
2451
2452 do {
2453 stat = mwifiex_sdio_rdwr_firmware(adapter, doneflag);
2454 if (stat == RDWR_STATUS_FAILURE)
2455 goto done;
2456
2457 reg_start = card->reg->fw_dump_start;
2458 reg_end = card->reg->fw_dump_end;
2459 for (reg = reg_start; reg <= reg_end; reg++) {
2460 *dbg_ptr = sdio_readb(card->func, reg, &ret);
2461 if (ret) {
2462 mwifiex_dbg(adapter, ERROR,
2463 "SDIO read err\n");
2464 goto done;
2465 }
2466 if (dbg_ptr < end_ptr)
2467 dbg_ptr++;
2468 else
2469 mwifiex_dbg(adapter, ERROR,
2470 "Allocated buf not enough\n");
2471 }
2472
2473 if (stat != RDWR_STATUS_DONE)
2474 continue;
2475
2476 mwifiex_dbg(adapter, DUMP, "%s done: size=0x%tx\n",
2477 entry->mem_name, dbg_ptr - entry->mem_ptr);
2478 break;
2479 } while (1);
2480 }
2481 mwifiex_dbg(adapter, MSG, "== mwifiex firmware dump end ==\n");
2482
2483done:
2484 sdio_release_host(card->func);
2485}
2486
2487static void mwifiex_sdio_generic_fw_dump(struct mwifiex_adapter *adapter)
2488{
2489 struct sdio_mmc_card *card = adapter->card;
2490 struct memory_type_mapping *entry = &generic_mem_type_map[0];
2491 unsigned int reg, reg_start, reg_end;
2492 u8 start_flag = 0, done_flag = 0;
2493 u8 *dbg_ptr, *end_ptr;
2494 enum rdwr_status stat;
2495 int ret = -1, tries;
2496
2497 if (!card->fw_dump_enh)
2498 return;
2499
2500 if (entry->mem_ptr) {
2501 vfree(entry->mem_ptr);
2502 entry->mem_ptr = NULL;
2503 }
2504 entry->mem_size = 0;
2505
2506 mwifiex_pm_wakeup_card(adapter);
2507 sdio_claim_host(card->func);
2508
2509 mwifiex_dbg(adapter, MSG, "== mwifiex firmware dump start ==\n");
2510
2511 stat = mwifiex_sdio_rdwr_firmware(adapter, done_flag);
2512 if (stat == RDWR_STATUS_FAILURE)
2513 goto done;
2514
2515 reg_start = card->reg->fw_dump_start;
2516 reg_end = card->reg->fw_dump_end;
2517 for (reg = reg_start; reg <= reg_end; reg++) {
2518 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
2519 start_flag = sdio_readb(card->func, reg, &ret);
2520 if (ret) {
2521 mwifiex_dbg(adapter, ERROR,
2522 "SDIO read err\n");
2523 goto done;
2524 }
2525 if (start_flag == 0)
2526 break;
2527 if (tries == MAX_POLL_TRIES) {
2528 mwifiex_dbg(adapter, ERROR,
2529 "FW not ready to dump\n");
2530 ret = -1;
2531 goto done;
2532 }
2533 }
2534 usleep_range(100, 200);
2535 }
2536
2537 entry->mem_ptr = vmalloc(0xf0000 + 1);
2538 if (!entry->mem_ptr) {
2539 ret = -1;
2540 goto done;
2541 }
2542 dbg_ptr = entry->mem_ptr;
2543 entry->mem_size = 0xf0000;
2544 end_ptr = dbg_ptr + entry->mem_size;
2545
2546 done_flag = entry->done_flag;
2547 mwifiex_dbg(adapter, DUMP,
2548 "Start %s output, please wait...\n", entry->mem_name);
2549
2550 while (true) {
2551 stat = mwifiex_sdio_rdwr_firmware(adapter, done_flag);
2552 if (stat == RDWR_STATUS_FAILURE)
2553 goto done;
2554 for (reg = reg_start; reg <= reg_end; reg++) {
2555 *dbg_ptr = sdio_readb(card->func, reg, &ret);
2556 if (ret) {
2557 mwifiex_dbg(adapter, ERROR,
2558 "SDIO read err\n");
2559 goto done;
2560 }
2561 dbg_ptr++;
2562 if (dbg_ptr >= end_ptr) {
2563 u8 *tmp_ptr;
2564
2565 tmp_ptr = vmalloc(entry->mem_size + 0x4000 + 1);
2566 if (!tmp_ptr)
2567 goto done;
2568
2569 memcpy(tmp_ptr, entry->mem_ptr,
2570 entry->mem_size);
2571 vfree(entry->mem_ptr);
2572 entry->mem_ptr = tmp_ptr;
2573 tmp_ptr = NULL;
2574 dbg_ptr = entry->mem_ptr + entry->mem_size;
2575 entry->mem_size += 0x4000;
2576 end_ptr = entry->mem_ptr + entry->mem_size;
2577 }
2578 }
2579 if (stat == RDWR_STATUS_DONE) {
2580 entry->mem_size = dbg_ptr - entry->mem_ptr;
2581 mwifiex_dbg(adapter, DUMP, "dump %s done size=0x%x\n",
2582 entry->mem_name, entry->mem_size);
2583 ret = 0;
2584 break;
2585 }
2586 }
2587 mwifiex_dbg(adapter, MSG, "== mwifiex firmware dump end ==\n");
2588
2589done:
2590 if (ret) {
2591 mwifiex_dbg(adapter, ERROR, "firmware dump failed\n");
2592 if (entry->mem_ptr) {
2593 vfree(entry->mem_ptr);
2594 entry->mem_ptr = NULL;
2595 }
2596 entry->mem_size = 0;
2597 }
2598 sdio_release_host(card->func);
2599}
2600
2601static void mwifiex_sdio_device_dump_work(struct mwifiex_adapter *adapter)
2602{
2603 struct sdio_mmc_card *card = adapter->card;
2604
2605 mwifiex_drv_info_dump(adapter);
2606 if (card->fw_dump_enh)
2607 mwifiex_sdio_generic_fw_dump(adapter);
2608 else
2609 mwifiex_sdio_fw_dump(adapter);
2610 mwifiex_upload_device_dump(adapter);
2611}
2612
2613static void mwifiex_sdio_work(struct work_struct *work)
2614{
2615 if (test_and_clear_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP,
2616 &iface_work_flags))
2617 mwifiex_sdio_device_dump_work(save_adapter);
2618 if (test_and_clear_bit(MWIFIEX_IFACE_WORK_CARD_RESET,
2619 &iface_work_flags))
2620 mwifiex_sdio_card_reset_work(save_adapter);
2621}
2622
2623static DECLARE_WORK(sdio_work, mwifiex_sdio_work);
2624
2625static void mwifiex_sdio_card_reset(struct mwifiex_adapter *adapter)
2626{
2627 save_adapter = adapter;
2628 if (test_bit(MWIFIEX_IFACE_WORK_CARD_RESET, &iface_work_flags))
2629 return;
2630
2631 set_bit(MWIFIEX_IFACE_WORK_CARD_RESET, &iface_work_flags);
2632
2633 schedule_work(&sdio_work);
2634}
2635
2636
2637static void mwifiex_sdio_device_dump(struct mwifiex_adapter *adapter)
2638{
2639 save_adapter = adapter;
2640 if (test_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP, &iface_work_flags))
2641 return;
2642
2643 set_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP, &iface_work_flags);
2644 schedule_work(&sdio_work);
2645}
2646
2647
2648
2649
2650static int
2651mwifiex_sdio_reg_dump(struct mwifiex_adapter *adapter, char *drv_buf)
2652{
2653 char *p = drv_buf;
2654 struct sdio_mmc_card *cardp = adapter->card;
2655 int ret = 0;
2656 u8 count, func, data, index = 0, size = 0;
2657 u8 reg, reg_start, reg_end;
2658 char buf[256], *ptr;
2659
2660 if (!p)
2661 return 0;
2662
2663 mwifiex_dbg(adapter, MSG, "SDIO register dump start\n");
2664
2665 mwifiex_pm_wakeup_card(adapter);
2666
2667 sdio_claim_host(cardp->func);
2668
2669 for (count = 0; count < 5; count++) {
2670 memset(buf, 0, sizeof(buf));
2671 ptr = buf;
2672
2673 switch (count) {
2674 case 0:
2675
2676 func = count;
2677 reg_start = 0;
2678 reg_end = 9;
2679 break;
2680 case 1:
2681
2682 func = count;
2683 reg_start = cardp->reg->func1_dump_reg_start;
2684 reg_end = cardp->reg->func1_dump_reg_end;
2685 break;
2686 case 2:
2687 index = 0;
2688 func = 1;
2689 reg_start = cardp->reg->func1_spec_reg_table[index++];
2690 size = cardp->reg->func1_spec_reg_num;
2691 reg_end = cardp->reg->func1_spec_reg_table[size-1];
2692 break;
2693 default:
2694
2695 if (count == 4)
2696 mdelay(100);
2697 func = 1;
2698 reg_start = cardp->reg->func1_scratch_reg;
2699 reg_end = reg_start + MWIFIEX_SDIO_SCRATCH_SIZE;
2700 }
2701
2702 if (count != 2)
2703 ptr += sprintf(ptr, "SDIO Func%d (%#x-%#x): ",
2704 func, reg_start, reg_end);
2705 else
2706 ptr += sprintf(ptr, "SDIO Func%d: ", func);
2707
2708 for (reg = reg_start; reg <= reg_end;) {
2709 if (func == 0)
2710 data = sdio_f0_readb(cardp->func, reg, &ret);
2711 else
2712 data = sdio_readb(cardp->func, reg, &ret);
2713
2714 if (count == 2)
2715 ptr += sprintf(ptr, "(%#x) ", reg);
2716 if (!ret) {
2717 ptr += sprintf(ptr, "%02x ", data);
2718 } else {
2719 ptr += sprintf(ptr, "ERR");
2720 break;
2721 }
2722
2723 if (count == 2 && reg < reg_end)
2724 reg = cardp->reg->func1_spec_reg_table[index++];
2725 else
2726 reg++;
2727 }
2728
2729 mwifiex_dbg(adapter, MSG, "%s\n", buf);
2730 p += sprintf(p, "%s\n", buf);
2731 }
2732
2733 sdio_release_host(cardp->func);
2734
2735 mwifiex_dbg(adapter, MSG, "SDIO register dump end\n");
2736
2737 return p - drv_buf;
2738}
2739
2740static struct mwifiex_if_ops sdio_ops = {
2741 .init_if = mwifiex_init_sdio,
2742 .cleanup_if = mwifiex_cleanup_sdio,
2743 .check_fw_status = mwifiex_check_fw_status,
2744 .check_winner_status = mwifiex_check_winner_status,
2745 .prog_fw = mwifiex_prog_fw_w_helper,
2746 .register_dev = mwifiex_register_dev,
2747 .unregister_dev = mwifiex_unregister_dev,
2748 .enable_int = mwifiex_sdio_enable_host_int,
2749 .disable_int = mwifiex_sdio_disable_host_int,
2750 .process_int_status = mwifiex_process_int_status,
2751 .host_to_card = mwifiex_sdio_host_to_card,
2752 .wakeup = mwifiex_pm_wakeup_card,
2753 .wakeup_complete = mwifiex_pm_wakeup_card_complete,
2754
2755
2756 .update_mp_end_port = mwifiex_update_mp_end_port,
2757 .cleanup_mpa_buf = mwifiex_cleanup_mpa_buf,
2758 .cmdrsp_complete = mwifiex_sdio_cmdrsp_complete,
2759 .event_complete = mwifiex_sdio_event_complete,
2760 .dnld_fw = mwifiex_sdio_dnld_fw,
2761 .card_reset = mwifiex_sdio_card_reset,
2762 .reg_dump = mwifiex_sdio_reg_dump,
2763 .device_dump = mwifiex_sdio_device_dump,
2764 .deaggr_pkt = mwifiex_deaggr_sdio_pkt,
2765};
2766
2767
2768
2769
2770
2771
2772
2773static int
2774mwifiex_sdio_init_module(void)
2775{
2776 sema_init(&add_remove_card_sem, 1);
2777
2778
2779 user_rmmod = 0;
2780
2781 return sdio_register_driver(&mwifiex_sdio);
2782}
2783
2784
2785
2786
2787
2788
2789
2790
2791
2792
2793static void
2794mwifiex_sdio_cleanup_module(void)
2795{
2796 if (!down_interruptible(&add_remove_card_sem))
2797 up(&add_remove_card_sem);
2798
2799
2800 user_rmmod = 1;
2801 cancel_work_sync(&sdio_work);
2802
2803 sdio_unregister_driver(&mwifiex_sdio);
2804}
2805
2806module_init(mwifiex_sdio_init_module);
2807module_exit(mwifiex_sdio_cleanup_module);
2808
2809MODULE_AUTHOR("Marvell International Ltd.");
2810MODULE_DESCRIPTION("Marvell WiFi-Ex SDIO Driver version " SDIO_VERSION);
2811MODULE_VERSION(SDIO_VERSION);
2812MODULE_LICENSE("GPL v2");
2813MODULE_FIRMWARE(SD8786_DEFAULT_FW_NAME);
2814MODULE_FIRMWARE(SD8787_DEFAULT_FW_NAME);
2815MODULE_FIRMWARE(SD8797_DEFAULT_FW_NAME);
2816MODULE_FIRMWARE(SD8897_DEFAULT_FW_NAME);
2817MODULE_FIRMWARE(SD8887_DEFAULT_FW_NAME);
2818MODULE_FIRMWARE(SD8997_DEFAULT_FW_NAME);
2819