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 "pcie.h"
30
31#define PCIE_VERSION "1.0"
32#define DRV_NAME "Marvell mwifiex PCIe"
33
34static u8 user_rmmod;
35
36static struct mwifiex_if_ops pcie_ops;
37
38static struct semaphore add_remove_card_sem;
39
40static int
41mwifiex_map_pci_memory(struct mwifiex_adapter *adapter, struct sk_buff *skb,
42 int size, int flags)
43{
44 struct pcie_service_card *card = adapter->card;
45 dma_addr_t buf_pa;
46
47 buf_pa = pci_map_single(card->dev, skb->data, size, flags);
48 if (pci_dma_mapping_error(card->dev, buf_pa)) {
49 dev_err(adapter->dev, "failed to map pci memory!\n");
50 return -1;
51 }
52 memcpy(skb->cb, &buf_pa, sizeof(dma_addr_t));
53 return 0;
54}
55
56
57
58
59static bool mwifiex_pcie_ok_to_access_hw(struct mwifiex_adapter *adapter)
60{
61 u32 *cookie_addr;
62 struct pcie_service_card *card = adapter->card;
63 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
64
65 if (!reg->sleep_cookie)
66 return true;
67
68 if (card->sleep_cookie_vbase) {
69 cookie_addr = (u32 *)card->sleep_cookie_vbase;
70 dev_dbg(adapter->dev, "info: ACCESS_HW: sleep cookie=0x%x\n",
71 *cookie_addr);
72 if (*cookie_addr == FW_AWAKE_COOKIE)
73 return true;
74 }
75
76 return false;
77}
78
79#ifdef CONFIG_PM_SLEEP
80
81
82
83
84
85
86
87
88static int mwifiex_pcie_suspend(struct device *dev)
89{
90 struct mwifiex_adapter *adapter;
91 struct pcie_service_card *card;
92 int hs_actived;
93 struct pci_dev *pdev = to_pci_dev(dev);
94
95 if (pdev) {
96 card = (struct pcie_service_card *) pci_get_drvdata(pdev);
97 if (!card || !card->adapter) {
98 pr_err("Card or adapter structure is not valid\n");
99 return 0;
100 }
101 } else {
102 pr_err("PCIE device is not specified\n");
103 return 0;
104 }
105
106 adapter = card->adapter;
107
108 hs_actived = mwifiex_enable_hs(adapter);
109
110
111 adapter->is_suspended = true;
112
113 return 0;
114}
115
116
117
118
119
120
121
122
123
124static int mwifiex_pcie_resume(struct device *dev)
125{
126 struct mwifiex_adapter *adapter;
127 struct pcie_service_card *card;
128 struct pci_dev *pdev = to_pci_dev(dev);
129
130 if (pdev) {
131 card = (struct pcie_service_card *) pci_get_drvdata(pdev);
132 if (!card || !card->adapter) {
133 pr_err("Card or adapter structure is not valid\n");
134 return 0;
135 }
136 } else {
137 pr_err("PCIE device is not specified\n");
138 return 0;
139 }
140
141 adapter = card->adapter;
142
143 if (!adapter->is_suspended) {
144 dev_warn(adapter->dev, "Device already resumed\n");
145 return 0;
146 }
147
148 adapter->is_suspended = false;
149
150 mwifiex_cancel_hs(mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA),
151 MWIFIEX_ASYNC_CMD);
152
153 return 0;
154}
155#endif
156
157
158
159
160
161
162
163static int mwifiex_pcie_probe(struct pci_dev *pdev,
164 const struct pci_device_id *ent)
165{
166 struct pcie_service_card *card;
167
168 pr_debug("info: vendor=0x%4.04X device=0x%4.04X rev=%d\n",
169 pdev->vendor, pdev->device, pdev->revision);
170
171 card = kzalloc(sizeof(struct pcie_service_card), GFP_KERNEL);
172 if (!card)
173 return -ENOMEM;
174
175 card->dev = pdev;
176
177 if (ent->driver_data) {
178 struct mwifiex_pcie_device *data = (void *)ent->driver_data;
179 card->pcie.firmware = data->firmware;
180 card->pcie.reg = data->reg;
181 card->pcie.blksz_fw_dl = data->blksz_fw_dl;
182 }
183
184 if (mwifiex_add_card(card, &add_remove_card_sem, &pcie_ops,
185 MWIFIEX_PCIE)) {
186 pr_err("%s failed\n", __func__);
187 kfree(card);
188 return -1;
189 }
190
191 return 0;
192}
193
194
195
196
197static void mwifiex_pcie_remove(struct pci_dev *pdev)
198{
199 struct pcie_service_card *card;
200 struct mwifiex_adapter *adapter;
201 struct mwifiex_private *priv;
202 int i;
203
204 card = pci_get_drvdata(pdev);
205 if (!card)
206 return;
207
208 adapter = card->adapter;
209 if (!adapter || !adapter->priv_num)
210 return;
211
212
213 wait_for_completion(&adapter->fw_load);
214
215 if (user_rmmod) {
216#ifdef CONFIG_PM_SLEEP
217 if (adapter->is_suspended)
218 mwifiex_pcie_resume(&pdev->dev);
219#endif
220
221 for (i = 0; i < adapter->priv_num; i++)
222 if ((GET_BSS_ROLE(adapter->priv[i]) ==
223 MWIFIEX_BSS_ROLE_STA) &&
224 adapter->priv[i]->media_connected)
225 mwifiex_deauthenticate(adapter->priv[i], NULL);
226
227 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
228
229 mwifiex_disable_auto_ds(priv);
230
231 mwifiex_init_shutdown_fw(priv, MWIFIEX_FUNC_SHUTDOWN);
232 }
233
234 mwifiex_remove_card(card->adapter, &add_remove_card_sem);
235 kfree(card);
236}
237
238static void mwifiex_pcie_shutdown(struct pci_dev *pdev)
239{
240 user_rmmod = 1;
241 mwifiex_pcie_remove(pdev);
242
243 return;
244}
245
246static DEFINE_PCI_DEVICE_TABLE(mwifiex_ids) = {
247 {
248 PCIE_VENDOR_ID_MARVELL, PCIE_DEVICE_ID_MARVELL_88W8766P,
249 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
250 .driver_data = (unsigned long) &mwifiex_pcie8766,
251 },
252 {
253 PCIE_VENDOR_ID_MARVELL, PCIE_DEVICE_ID_MARVELL_88W8897,
254 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
255 .driver_data = (unsigned long) &mwifiex_pcie8897,
256 },
257 {},
258};
259
260MODULE_DEVICE_TABLE(pci, mwifiex_ids);
261
262#ifdef CONFIG_PM_SLEEP
263
264static SIMPLE_DEV_PM_OPS(mwifiex_pcie_pm_ops, mwifiex_pcie_suspend,
265 mwifiex_pcie_resume);
266#endif
267
268
269static struct pci_driver __refdata mwifiex_pcie = {
270 .name = "mwifiex_pcie",
271 .id_table = mwifiex_ids,
272 .probe = mwifiex_pcie_probe,
273 .remove = mwifiex_pcie_remove,
274#ifdef CONFIG_PM_SLEEP
275 .driver = {
276 .pm = &mwifiex_pcie_pm_ops,
277 },
278#endif
279 .shutdown = mwifiex_pcie_shutdown,
280};
281
282
283
284
285static int mwifiex_write_reg(struct mwifiex_adapter *adapter, int reg, u32 data)
286{
287 struct pcie_service_card *card = adapter->card;
288
289 iowrite32(data, card->pci_mmap1 + reg);
290
291 return 0;
292}
293
294
295
296
297static int mwifiex_read_reg(struct mwifiex_adapter *adapter, int reg, u32 *data)
298{
299 struct pcie_service_card *card = adapter->card;
300
301 *data = ioread32(card->pci_mmap1 + reg);
302
303 return 0;
304}
305
306
307
308
309static void mwifiex_pcie_dev_wakeup_delay(struct mwifiex_adapter *adapter)
310{
311 int i = 0;
312
313 while (mwifiex_pcie_ok_to_access_hw(adapter)) {
314 i++;
315 usleep_range(10, 20);
316
317 if (i == 5000)
318 break;
319 }
320
321 return;
322}
323
324
325static int mwifiex_pm_wakeup_card(struct mwifiex_adapter *adapter)
326{
327 u32 fw_status;
328 struct pcie_service_card *card = adapter->card;
329 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
330
331 dev_dbg(adapter->dev, "event: Wakeup device...\n");
332
333 if (reg->sleep_cookie)
334 mwifiex_pcie_dev_wakeup_delay(adapter);
335
336
337 if (mwifiex_read_reg(adapter, reg->fw_status, &fw_status)) {
338 dev_warn(adapter->dev, "Reading fw_status register failed\n");
339 return -1;
340 }
341
342 if (reg->sleep_cookie) {
343 mwifiex_pcie_dev_wakeup_delay(adapter);
344 dev_dbg(adapter->dev, "PCIE wakeup: Setting PS_STATE_AWAKE\n");
345 adapter->ps_state = PS_STATE_AWAKE;
346 }
347
348 return 0;
349}
350
351
352
353
354
355
356static int mwifiex_pm_wakeup_card_complete(struct mwifiex_adapter *adapter)
357{
358 dev_dbg(adapter->dev, "cmd: Wakeup device completed\n");
359
360 return 0;
361}
362
363
364
365
366
367
368
369static int mwifiex_pcie_disable_host_int(struct mwifiex_adapter *adapter)
370{
371 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
372 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK,
373 0x00000000)) {
374 dev_warn(adapter->dev, "Disable host interrupt failed\n");
375 return -1;
376 }
377 }
378
379 return 0;
380}
381
382
383
384
385
386
387
388static int mwifiex_pcie_enable_host_int(struct mwifiex_adapter *adapter)
389{
390 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
391
392 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK,
393 HOST_INTR_MASK)) {
394 dev_warn(adapter->dev, "Enable host interrupt failed\n");
395 return -1;
396 }
397 }
398
399 return 0;
400}
401
402
403
404
405static int mwifiex_init_txq_ring(struct mwifiex_adapter *adapter)
406{
407 struct pcie_service_card *card = adapter->card;
408 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
409 struct mwifiex_pcie_buf_desc *desc;
410 struct mwifiex_pfu_buf_desc *desc2;
411 int i;
412
413 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
414 card->tx_buf_list[i] = NULL;
415 if (reg->pfu_enabled) {
416 card->txbd_ring[i] = (void *)card->txbd_ring_vbase +
417 (sizeof(*desc2) * i);
418 desc2 = card->txbd_ring[i];
419 memset(desc2, 0, sizeof(*desc2));
420 } else {
421 card->txbd_ring[i] = (void *)card->txbd_ring_vbase +
422 (sizeof(*desc) * i);
423 desc = card->txbd_ring[i];
424 memset(desc, 0, sizeof(*desc));
425 }
426 }
427
428 return 0;
429}
430
431
432
433
434
435static int mwifiex_init_rxq_ring(struct mwifiex_adapter *adapter)
436{
437 struct pcie_service_card *card = adapter->card;
438 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
439 struct sk_buff *skb;
440 struct mwifiex_pcie_buf_desc *desc;
441 struct mwifiex_pfu_buf_desc *desc2;
442 dma_addr_t buf_pa;
443 int i;
444
445 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
446
447 skb = dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE);
448 if (!skb) {
449 dev_err(adapter->dev,
450 "Unable to allocate skb for RX ring.\n");
451 kfree(card->rxbd_ring_vbase);
452 return -ENOMEM;
453 }
454
455 if (mwifiex_map_pci_memory(adapter, skb,
456 MWIFIEX_RX_DATA_BUF_SIZE,
457 PCI_DMA_FROMDEVICE))
458 return -1;
459
460 MWIFIEX_SKB_PACB(skb, &buf_pa);
461
462 dev_dbg(adapter->dev,
463 "info: RX ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
464 skb, skb->len, skb->data, (u32)buf_pa,
465 (u32)((u64)buf_pa >> 32));
466
467 card->rx_buf_list[i] = skb;
468 if (reg->pfu_enabled) {
469 card->rxbd_ring[i] = (void *)card->rxbd_ring_vbase +
470 (sizeof(*desc2) * i);
471 desc2 = card->rxbd_ring[i];
472 desc2->paddr = buf_pa;
473 desc2->len = (u16)skb->len;
474 desc2->frag_len = (u16)skb->len;
475 desc2->flags = reg->ring_flag_eop | reg->ring_flag_sop;
476 desc2->offset = 0;
477 } else {
478 card->rxbd_ring[i] = (void *)(card->rxbd_ring_vbase +
479 (sizeof(*desc) * i));
480 desc = card->rxbd_ring[i];
481 desc->paddr = buf_pa;
482 desc->len = (u16)skb->len;
483 desc->flags = 0;
484 }
485 }
486
487 return 0;
488}
489
490
491
492
493
494static int mwifiex_pcie_init_evt_ring(struct mwifiex_adapter *adapter)
495{
496 struct pcie_service_card *card = adapter->card;
497 struct mwifiex_evt_buf_desc *desc;
498 struct sk_buff *skb;
499 dma_addr_t buf_pa;
500 int i;
501
502 for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) {
503
504 skb = dev_alloc_skb(MAX_EVENT_SIZE);
505 if (!skb) {
506 dev_err(adapter->dev,
507 "Unable to allocate skb for EVENT buf.\n");
508 kfree(card->evtbd_ring_vbase);
509 return -ENOMEM;
510 }
511 skb_put(skb, MAX_EVENT_SIZE);
512
513 if (mwifiex_map_pci_memory(adapter, skb, MAX_EVENT_SIZE,
514 PCI_DMA_FROMDEVICE))
515 return -1;
516
517 MWIFIEX_SKB_PACB(skb, &buf_pa);
518
519 dev_dbg(adapter->dev,
520 "info: EVT ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
521 skb, skb->len, skb->data, (u32)buf_pa,
522 (u32)((u64)buf_pa >> 32));
523
524 card->evt_buf_list[i] = skb;
525 card->evtbd_ring[i] = (void *)(card->evtbd_ring_vbase +
526 (sizeof(*desc) * i));
527 desc = card->evtbd_ring[i];
528 desc->paddr = buf_pa;
529 desc->len = (u16)skb->len;
530 desc->flags = 0;
531 }
532
533 return 0;
534}
535
536
537
538
539static void mwifiex_cleanup_txq_ring(struct mwifiex_adapter *adapter)
540{
541 struct pcie_service_card *card = adapter->card;
542 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
543 struct sk_buff *skb;
544 struct mwifiex_pcie_buf_desc *desc;
545 struct mwifiex_pfu_buf_desc *desc2;
546 int i;
547
548 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
549 if (reg->pfu_enabled) {
550 desc2 = card->txbd_ring[i];
551 if (card->tx_buf_list[i]) {
552 skb = card->tx_buf_list[i];
553 pci_unmap_single(card->dev, desc2->paddr,
554 skb->len, PCI_DMA_TODEVICE);
555 dev_kfree_skb_any(skb);
556 }
557 memset(desc2, 0, sizeof(*desc2));
558 } else {
559 desc = card->txbd_ring[i];
560 if (card->tx_buf_list[i]) {
561 skb = card->tx_buf_list[i];
562 pci_unmap_single(card->dev, desc->paddr,
563 skb->len, PCI_DMA_TODEVICE);
564 dev_kfree_skb_any(skb);
565 }
566 memset(desc, 0, sizeof(*desc));
567 }
568 card->tx_buf_list[i] = NULL;
569 }
570
571 return;
572}
573
574
575
576
577static void mwifiex_cleanup_rxq_ring(struct mwifiex_adapter *adapter)
578{
579 struct pcie_service_card *card = adapter->card;
580 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
581 struct mwifiex_pcie_buf_desc *desc;
582 struct mwifiex_pfu_buf_desc *desc2;
583 struct sk_buff *skb;
584 int i;
585
586 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
587 if (reg->pfu_enabled) {
588 desc2 = card->rxbd_ring[i];
589 if (card->rx_buf_list[i]) {
590 skb = card->rx_buf_list[i];
591 pci_unmap_single(card->dev, desc2->paddr,
592 skb->len, PCI_DMA_FROMDEVICE);
593 dev_kfree_skb_any(skb);
594 }
595 memset(desc2, 0, sizeof(*desc2));
596 } else {
597 desc = card->rxbd_ring[i];
598 if (card->rx_buf_list[i]) {
599 skb = card->rx_buf_list[i];
600 pci_unmap_single(card->dev, desc->paddr,
601 skb->len, PCI_DMA_FROMDEVICE);
602 dev_kfree_skb_any(skb);
603 }
604 memset(desc, 0, sizeof(*desc));
605 }
606 card->rx_buf_list[i] = NULL;
607 }
608
609 return;
610}
611
612
613
614
615static void mwifiex_cleanup_evt_ring(struct mwifiex_adapter *adapter)
616{
617 struct pcie_service_card *card = adapter->card;
618 struct mwifiex_evt_buf_desc *desc;
619 struct sk_buff *skb;
620 int i;
621
622 for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) {
623 desc = card->evtbd_ring[i];
624 if (card->evt_buf_list[i]) {
625 skb = card->evt_buf_list[i];
626 pci_unmap_single(card->dev, desc->paddr, MAX_EVENT_SIZE,
627 PCI_DMA_FROMDEVICE);
628 dev_kfree_skb_any(skb);
629 }
630 card->evt_buf_list[i] = NULL;
631 memset(desc, 0, sizeof(*desc));
632 }
633
634 return;
635}
636
637
638
639static int mwifiex_pcie_create_txbd_ring(struct mwifiex_adapter *adapter)
640{
641 struct pcie_service_card *card = adapter->card;
642 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
643
644
645
646
647
648
649 card->txbd_wrptr = 0;
650
651 if (reg->pfu_enabled)
652 card->txbd_rdptr = 0;
653 else
654 card->txbd_rdptr |= reg->tx_rollover_ind;
655
656
657
658 if (reg->pfu_enabled)
659 card->txbd_ring_size = sizeof(struct mwifiex_pfu_buf_desc) *
660 MWIFIEX_MAX_TXRX_BD;
661 else
662 card->txbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
663 MWIFIEX_MAX_TXRX_BD;
664
665 dev_dbg(adapter->dev, "info: txbd_ring: Allocating %d bytes\n",
666 card->txbd_ring_size);
667 card->txbd_ring_vbase = pci_alloc_consistent(card->dev,
668 card->txbd_ring_size,
669 &card->txbd_ring_pbase);
670 if (!card->txbd_ring_vbase) {
671 dev_err(adapter->dev,
672 "allocate consistent memory (%d bytes) failed!\n",
673 card->txbd_ring_size);
674 return -ENOMEM;
675 }
676 dev_dbg(adapter->dev,
677 "info: txbd_ring - base: %p, pbase: %#x:%x, len: %x\n",
678 card->txbd_ring_vbase, (unsigned int)card->txbd_ring_pbase,
679 (u32)((u64)card->txbd_ring_pbase >> 32), card->txbd_ring_size);
680
681 return mwifiex_init_txq_ring(adapter);
682}
683
684static int mwifiex_pcie_delete_txbd_ring(struct mwifiex_adapter *adapter)
685{
686 struct pcie_service_card *card = adapter->card;
687 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
688
689 mwifiex_cleanup_txq_ring(adapter);
690
691 if (card->txbd_ring_vbase)
692 pci_free_consistent(card->dev, card->txbd_ring_size,
693 card->txbd_ring_vbase,
694 card->txbd_ring_pbase);
695 card->txbd_ring_size = 0;
696 card->txbd_wrptr = 0;
697 card->txbd_rdptr = 0 | reg->tx_rollover_ind;
698 card->txbd_ring_vbase = NULL;
699 card->txbd_ring_pbase = 0;
700
701 return 0;
702}
703
704
705
706
707static int mwifiex_pcie_create_rxbd_ring(struct mwifiex_adapter *adapter)
708{
709 struct pcie_service_card *card = adapter->card;
710 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
711
712
713
714
715
716
717 card->rxbd_wrptr = 0;
718 card->rxbd_rdptr = reg->rx_rollover_ind;
719
720 if (reg->pfu_enabled)
721 card->rxbd_ring_size = sizeof(struct mwifiex_pfu_buf_desc) *
722 MWIFIEX_MAX_TXRX_BD;
723 else
724 card->rxbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
725 MWIFIEX_MAX_TXRX_BD;
726
727 dev_dbg(adapter->dev, "info: rxbd_ring: Allocating %d bytes\n",
728 card->rxbd_ring_size);
729 card->rxbd_ring_vbase = pci_alloc_consistent(card->dev,
730 card->rxbd_ring_size,
731 &card->rxbd_ring_pbase);
732 if (!card->rxbd_ring_vbase) {
733 dev_err(adapter->dev,
734 "allocate consistent memory (%d bytes) failed!\n",
735 card->rxbd_ring_size);
736 return -ENOMEM;
737 }
738
739 dev_dbg(adapter->dev,
740 "info: rxbd_ring - base: %p, pbase: %#x:%x, len: %#x\n",
741 card->rxbd_ring_vbase, (u32)card->rxbd_ring_pbase,
742 (u32)((u64)card->rxbd_ring_pbase >> 32),
743 card->rxbd_ring_size);
744
745 return mwifiex_init_rxq_ring(adapter);
746}
747
748
749
750
751static int mwifiex_pcie_delete_rxbd_ring(struct mwifiex_adapter *adapter)
752{
753 struct pcie_service_card *card = adapter->card;
754 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
755
756 mwifiex_cleanup_rxq_ring(adapter);
757
758 if (card->rxbd_ring_vbase)
759 pci_free_consistent(card->dev, card->rxbd_ring_size,
760 card->rxbd_ring_vbase,
761 card->rxbd_ring_pbase);
762 card->rxbd_ring_size = 0;
763 card->rxbd_wrptr = 0;
764 card->rxbd_rdptr = 0 | reg->rx_rollover_ind;
765 card->rxbd_ring_vbase = NULL;
766 card->rxbd_ring_pbase = 0;
767
768 return 0;
769}
770
771
772
773
774static int mwifiex_pcie_create_evtbd_ring(struct mwifiex_adapter *adapter)
775{
776 struct pcie_service_card *card = adapter->card;
777 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
778
779
780
781
782
783
784 card->evtbd_wrptr = 0;
785 card->evtbd_rdptr = reg->evt_rollover_ind;
786
787 card->evtbd_ring_size = sizeof(struct mwifiex_evt_buf_desc) *
788 MWIFIEX_MAX_EVT_BD;
789
790 dev_dbg(adapter->dev, "info: evtbd_ring: Allocating %d bytes\n",
791 card->evtbd_ring_size);
792 card->evtbd_ring_vbase = pci_alloc_consistent(card->dev,
793 card->evtbd_ring_size,
794 &card->evtbd_ring_pbase);
795 if (!card->evtbd_ring_vbase) {
796 dev_err(adapter->dev,
797 "allocate consistent memory (%d bytes) failed!\n",
798 card->evtbd_ring_size);
799 return -ENOMEM;
800 }
801
802 dev_dbg(adapter->dev,
803 "info: CMDRSP/EVT bd_ring - base: %p pbase: %#x:%x len: %#x\n",
804 card->evtbd_ring_vbase, (u32)card->evtbd_ring_pbase,
805 (u32)((u64)card->evtbd_ring_pbase >> 32),
806 card->evtbd_ring_size);
807
808 return mwifiex_pcie_init_evt_ring(adapter);
809}
810
811
812
813
814static int mwifiex_pcie_delete_evtbd_ring(struct mwifiex_adapter *adapter)
815{
816 struct pcie_service_card *card = adapter->card;
817 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
818
819 mwifiex_cleanup_evt_ring(adapter);
820
821 if (card->evtbd_ring_vbase)
822 pci_free_consistent(card->dev, card->evtbd_ring_size,
823 card->evtbd_ring_vbase,
824 card->evtbd_ring_pbase);
825 card->evtbd_wrptr = 0;
826 card->evtbd_rdptr = 0 | reg->evt_rollover_ind;
827 card->evtbd_ring_size = 0;
828 card->evtbd_ring_vbase = NULL;
829 card->evtbd_ring_pbase = 0;
830
831 return 0;
832}
833
834
835
836
837static int mwifiex_pcie_alloc_cmdrsp_buf(struct mwifiex_adapter *adapter)
838{
839 struct pcie_service_card *card = adapter->card;
840 struct sk_buff *skb;
841
842
843 skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
844 if (!skb) {
845 dev_err(adapter->dev,
846 "Unable to allocate skb for command response data.\n");
847 return -ENOMEM;
848 }
849 skb_put(skb, MWIFIEX_UPLD_SIZE);
850 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
851 PCI_DMA_FROMDEVICE))
852 return -1;
853
854 card->cmdrsp_buf = skb;
855
856 return 0;
857}
858
859
860
861
862static int mwifiex_pcie_delete_cmdrsp_buf(struct mwifiex_adapter *adapter)
863{
864 struct pcie_service_card *card;
865 dma_addr_t buf_pa;
866
867 if (!adapter)
868 return 0;
869
870 card = adapter->card;
871
872 if (card && card->cmdrsp_buf) {
873 MWIFIEX_SKB_PACB(card->cmdrsp_buf, &buf_pa);
874 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
875 PCI_DMA_FROMDEVICE);
876 dev_kfree_skb_any(card->cmdrsp_buf);
877 }
878
879 if (card && card->cmd_buf) {
880 MWIFIEX_SKB_PACB(card->cmd_buf, &buf_pa);
881 pci_unmap_single(card->dev, buf_pa, card->cmd_buf->len,
882 PCI_DMA_TODEVICE);
883 }
884 return 0;
885}
886
887
888
889
890static int mwifiex_pcie_alloc_sleep_cookie_buf(struct mwifiex_adapter *adapter)
891{
892 struct pcie_service_card *card = adapter->card;
893
894 card->sleep_cookie_vbase = pci_alloc_consistent(card->dev, sizeof(u32),
895 &card->sleep_cookie_pbase);
896 if (!card->sleep_cookie_vbase) {
897 dev_err(adapter->dev, "pci_alloc_consistent failed!\n");
898 return -ENOMEM;
899 }
900
901 *(u32 *)card->sleep_cookie_vbase = FW_AWAKE_COOKIE;
902
903 dev_dbg(adapter->dev, "alloc_scook: sleep cookie=0x%x\n",
904 *((u32 *)card->sleep_cookie_vbase));
905
906 return 0;
907}
908
909
910
911
912static int mwifiex_pcie_delete_sleep_cookie_buf(struct mwifiex_adapter *adapter)
913{
914 struct pcie_service_card *card;
915
916 if (!adapter)
917 return 0;
918
919 card = adapter->card;
920
921 if (card && card->sleep_cookie_vbase) {
922 pci_free_consistent(card->dev, sizeof(u32),
923 card->sleep_cookie_vbase,
924 card->sleep_cookie_pbase);
925 card->sleep_cookie_vbase = NULL;
926 }
927
928 return 0;
929}
930
931
932
933
934
935static int mwifiex_clean_pcie_ring_buf(struct mwifiex_adapter *adapter)
936{
937 struct pcie_service_card *card = adapter->card;
938
939 if (!mwifiex_pcie_txbd_empty(card, card->txbd_rdptr)) {
940 card->txbd_flush = 1;
941
942
943
944 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
945 CPU_INTR_DNLD_RDY)) {
946 dev_err(adapter->dev,
947 "failed to assert dnld-rdy interrupt.\n");
948 return -1;
949 }
950 }
951 return 0;
952}
953
954
955
956
957static int mwifiex_pcie_send_data_complete(struct mwifiex_adapter *adapter)
958{
959 struct sk_buff *skb;
960 dma_addr_t buf_pa;
961 u32 wrdoneidx, rdptr, num_tx_buffs, unmap_count = 0;
962 struct mwifiex_pcie_buf_desc *desc;
963 struct mwifiex_pfu_buf_desc *desc2;
964 struct pcie_service_card *card = adapter->card;
965 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
966
967 if (!mwifiex_pcie_ok_to_access_hw(adapter))
968 mwifiex_pm_wakeup_card(adapter);
969
970
971 if (mwifiex_read_reg(adapter, reg->tx_rdptr, &rdptr)) {
972 dev_err(adapter->dev,
973 "SEND COMP: failed to read reg->tx_rdptr\n");
974 return -1;
975 }
976
977 dev_dbg(adapter->dev, "SEND COMP: rdptr_prev=0x%x, rdptr=0x%x\n",
978 card->txbd_rdptr, rdptr);
979
980 num_tx_buffs = MWIFIEX_MAX_TXRX_BD << reg->tx_start_ptr;
981
982 while (((card->txbd_rdptr & reg->tx_mask) !=
983 (rdptr & reg->tx_mask)) ||
984 ((card->txbd_rdptr & reg->tx_rollover_ind) !=
985 (rdptr & reg->tx_rollover_ind))) {
986 wrdoneidx = (card->txbd_rdptr & reg->tx_mask) >>
987 reg->tx_start_ptr;
988
989 skb = card->tx_buf_list[wrdoneidx];
990 if (skb) {
991 dev_dbg(adapter->dev,
992 "SEND COMP: Detach skb %p at txbd_rdidx=%d\n",
993 skb, wrdoneidx);
994 MWIFIEX_SKB_PACB(skb, &buf_pa);
995 pci_unmap_single(card->dev, buf_pa, skb->len,
996 PCI_DMA_TODEVICE);
997
998 unmap_count++;
999
1000 if (card->txbd_flush)
1001 mwifiex_write_data_complete(adapter, skb, 0,
1002 -1);
1003 else
1004 mwifiex_write_data_complete(adapter, skb, 0, 0);
1005 }
1006
1007 card->tx_buf_list[wrdoneidx] = NULL;
1008
1009 if (reg->pfu_enabled) {
1010 desc2 = (void *)card->txbd_ring[wrdoneidx];
1011 memset(desc2, 0, sizeof(*desc2));
1012 } else {
1013 desc = card->txbd_ring[wrdoneidx];
1014 memset(desc, 0, sizeof(*desc));
1015 }
1016 switch (card->dev->device) {
1017 case PCIE_DEVICE_ID_MARVELL_88W8766P:
1018 card->txbd_rdptr++;
1019 break;
1020 case PCIE_DEVICE_ID_MARVELL_88W8897:
1021 card->txbd_rdptr += reg->ring_tx_start_ptr;
1022 break;
1023 }
1024
1025
1026 if ((card->txbd_rdptr & reg->tx_mask) == num_tx_buffs)
1027 card->txbd_rdptr = ((card->txbd_rdptr &
1028 reg->tx_rollover_ind) ^
1029 reg->tx_rollover_ind);
1030 }
1031
1032 if (unmap_count)
1033 adapter->data_sent = false;
1034
1035 if (card->txbd_flush) {
1036 if (mwifiex_pcie_txbd_empty(card, card->txbd_rdptr))
1037 card->txbd_flush = 0;
1038 else
1039 mwifiex_clean_pcie_ring_buf(adapter);
1040 }
1041
1042 return 0;
1043}
1044
1045
1046
1047
1048
1049
1050
1051static int
1052mwifiex_pcie_send_data(struct mwifiex_adapter *adapter, struct sk_buff *skb,
1053 struct mwifiex_tx_param *tx_param)
1054{
1055 struct pcie_service_card *card = adapter->card;
1056 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1057 u32 wrindx, num_tx_buffs, rx_val;
1058 int ret;
1059 dma_addr_t buf_pa;
1060 struct mwifiex_pcie_buf_desc *desc = NULL;
1061 struct mwifiex_pfu_buf_desc *desc2 = NULL;
1062 __le16 *tmp;
1063
1064 if (!(skb->data && skb->len)) {
1065 dev_err(adapter->dev, "%s(): invalid parameter <%p, %#x>\n",
1066 __func__, skb->data, skb->len);
1067 return -1;
1068 }
1069
1070 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1071 mwifiex_pm_wakeup_card(adapter);
1072
1073 num_tx_buffs = MWIFIEX_MAX_TXRX_BD << reg->tx_start_ptr;
1074 dev_dbg(adapter->dev, "info: SEND DATA: <Rd: %#x, Wr: %#x>\n",
1075 card->txbd_rdptr, card->txbd_wrptr);
1076 if (mwifiex_pcie_txbd_not_full(card)) {
1077 u8 *payload;
1078
1079 adapter->data_sent = true;
1080 payload = skb->data;
1081 tmp = (__le16 *)&payload[0];
1082 *tmp = cpu_to_le16((u16)skb->len);
1083 tmp = (__le16 *)&payload[2];
1084 *tmp = cpu_to_le16(MWIFIEX_TYPE_DATA);
1085
1086 if (mwifiex_map_pci_memory(adapter, skb, skb->len ,
1087 PCI_DMA_TODEVICE))
1088 return -1;
1089
1090 wrindx = (card->txbd_wrptr & reg->tx_mask) >> reg->tx_start_ptr;
1091 MWIFIEX_SKB_PACB(skb, &buf_pa);
1092 card->tx_buf_list[wrindx] = skb;
1093
1094 if (reg->pfu_enabled) {
1095 desc2 = (void *)card->txbd_ring[wrindx];
1096 desc2->paddr = buf_pa;
1097 desc2->len = (u16)skb->len;
1098 desc2->frag_len = (u16)skb->len;
1099 desc2->offset = 0;
1100 desc2->flags = MWIFIEX_BD_FLAG_FIRST_DESC |
1101 MWIFIEX_BD_FLAG_LAST_DESC;
1102 } else {
1103 desc = card->txbd_ring[wrindx];
1104 desc->paddr = buf_pa;
1105 desc->len = (u16)skb->len;
1106 desc->flags = MWIFIEX_BD_FLAG_FIRST_DESC |
1107 MWIFIEX_BD_FLAG_LAST_DESC;
1108 }
1109
1110 switch (card->dev->device) {
1111 case PCIE_DEVICE_ID_MARVELL_88W8766P:
1112 card->txbd_wrptr++;
1113 break;
1114 case PCIE_DEVICE_ID_MARVELL_88W8897:
1115 card->txbd_wrptr += reg->ring_tx_start_ptr;
1116 break;
1117 }
1118
1119 if ((card->txbd_wrptr & reg->tx_mask) == num_tx_buffs)
1120 card->txbd_wrptr = ((card->txbd_wrptr &
1121 reg->tx_rollover_ind) ^
1122 reg->tx_rollover_ind);
1123
1124 rx_val = card->rxbd_rdptr & reg->rx_wrap_mask;
1125
1126 if (mwifiex_write_reg(adapter, reg->tx_wrptr,
1127 card->txbd_wrptr | rx_val)) {
1128 dev_err(adapter->dev,
1129 "SEND DATA: failed to write reg->tx_wrptr\n");
1130 ret = -1;
1131 goto done_unmap;
1132 }
1133 if ((mwifiex_pcie_txbd_not_full(card)) &&
1134 tx_param->next_pkt_len) {
1135
1136 dev_dbg(adapter->dev,
1137 "SEND DATA: delay dnld-rdy interrupt.\n");
1138 adapter->data_sent = false;
1139 } else {
1140
1141 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1142 CPU_INTR_DNLD_RDY)) {
1143 dev_err(adapter->dev,
1144 "SEND DATA: failed to assert dnld-rdy interrupt.\n");
1145 ret = -1;
1146 goto done_unmap;
1147 }
1148 }
1149 dev_dbg(adapter->dev, "info: SEND DATA: Updated <Rd: %#x, Wr: "
1150 "%#x> and sent packet to firmware successfully\n",
1151 card->txbd_rdptr, card->txbd_wrptr);
1152 } else {
1153 dev_dbg(adapter->dev,
1154 "info: TX Ring full, can't send packets to fw\n");
1155 adapter->data_sent = true;
1156
1157 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1158 CPU_INTR_DNLD_RDY))
1159 dev_err(adapter->dev,
1160 "SEND DATA: failed to assert door-bell intr\n");
1161 return -EBUSY;
1162 }
1163
1164 return -EINPROGRESS;
1165done_unmap:
1166 MWIFIEX_SKB_PACB(skb, &buf_pa);
1167 pci_unmap_single(card->dev, buf_pa, skb->len, PCI_DMA_TODEVICE);
1168 card->tx_buf_list[wrindx] = NULL;
1169 if (reg->pfu_enabled)
1170 memset(desc2, 0, sizeof(*desc2));
1171 else
1172 memset(desc, 0, sizeof(*desc));
1173
1174 return ret;
1175}
1176
1177
1178
1179
1180
1181static int mwifiex_pcie_process_recv_data(struct mwifiex_adapter *adapter)
1182{
1183 struct pcie_service_card *card = adapter->card;
1184 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1185 u32 wrptr, rd_index, tx_val;
1186 dma_addr_t buf_pa;
1187 int ret = 0;
1188 struct sk_buff *skb_tmp = NULL;
1189 struct mwifiex_pcie_buf_desc *desc;
1190 struct mwifiex_pfu_buf_desc *desc2;
1191
1192 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1193 mwifiex_pm_wakeup_card(adapter);
1194
1195
1196 if (mwifiex_read_reg(adapter, reg->rx_wrptr, &wrptr)) {
1197 dev_err(adapter->dev,
1198 "RECV DATA: failed to read reg->rx_wrptr\n");
1199 ret = -1;
1200 goto done;
1201 }
1202 card->rxbd_wrptr = wrptr;
1203
1204 while (((wrptr & reg->rx_mask) !=
1205 (card->rxbd_rdptr & reg->rx_mask)) ||
1206 ((wrptr & reg->rx_rollover_ind) ==
1207 (card->rxbd_rdptr & reg->rx_rollover_ind))) {
1208 struct sk_buff *skb_data;
1209 u16 rx_len;
1210 __le16 pkt_len;
1211
1212 rd_index = card->rxbd_rdptr & reg->rx_mask;
1213 skb_data = card->rx_buf_list[rd_index];
1214
1215 MWIFIEX_SKB_PACB(skb_data, &buf_pa);
1216 pci_unmap_single(card->dev, buf_pa, MWIFIEX_RX_DATA_BUF_SIZE,
1217 PCI_DMA_FROMDEVICE);
1218 card->rx_buf_list[rd_index] = NULL;
1219
1220
1221
1222
1223 pkt_len = *((__le16 *)skb_data->data);
1224 rx_len = le16_to_cpu(pkt_len);
1225 skb_put(skb_data, rx_len);
1226 dev_dbg(adapter->dev,
1227 "info: RECV DATA: Rd=%#x, Wr=%#x, Len=%d\n",
1228 card->rxbd_rdptr, wrptr, rx_len);
1229 skb_pull(skb_data, INTF_HEADER_LEN);
1230 mwifiex_handle_rx_packet(adapter, skb_data);
1231
1232 skb_tmp = dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE);
1233 if (!skb_tmp) {
1234 dev_err(adapter->dev,
1235 "Unable to allocate skb.\n");
1236 return -ENOMEM;
1237 }
1238
1239 if (mwifiex_map_pci_memory(adapter, skb_tmp,
1240 MWIFIEX_RX_DATA_BUF_SIZE,
1241 PCI_DMA_FROMDEVICE))
1242 return -1;
1243
1244 MWIFIEX_SKB_PACB(skb_tmp, &buf_pa);
1245
1246 dev_dbg(adapter->dev,
1247 "RECV DATA: Attach new sk_buff %p at rxbd_rdidx=%d\n",
1248 skb_tmp, rd_index);
1249 card->rx_buf_list[rd_index] = skb_tmp;
1250
1251 if (reg->pfu_enabled) {
1252 desc2 = (void *)card->rxbd_ring[rd_index];
1253 desc2->paddr = buf_pa;
1254 desc2->len = skb_tmp->len;
1255 desc2->frag_len = skb_tmp->len;
1256 desc2->offset = 0;
1257 desc2->flags = reg->ring_flag_sop | reg->ring_flag_eop;
1258 } else {
1259 desc = card->rxbd_ring[rd_index];
1260 desc->paddr = buf_pa;
1261 desc->len = skb_tmp->len;
1262 desc->flags = 0;
1263 }
1264
1265 if ((++card->rxbd_rdptr & reg->rx_mask) ==
1266 MWIFIEX_MAX_TXRX_BD) {
1267 card->rxbd_rdptr = ((card->rxbd_rdptr &
1268 reg->rx_rollover_ind) ^
1269 reg->rx_rollover_ind);
1270 }
1271 dev_dbg(adapter->dev, "info: RECV DATA: <Rd: %#x, Wr: %#x>\n",
1272 card->rxbd_rdptr, wrptr);
1273
1274 tx_val = card->txbd_wrptr & reg->tx_wrap_mask;
1275
1276 if (mwifiex_write_reg(adapter, reg->rx_rdptr,
1277 card->rxbd_rdptr | tx_val)) {
1278 dev_err(adapter->dev,
1279 "RECV DATA: failed to write reg->rx_rdptr\n");
1280 ret = -1;
1281 goto done;
1282 }
1283
1284
1285 if (mwifiex_read_reg(adapter, reg->rx_wrptr, &wrptr)) {
1286 dev_err(adapter->dev,
1287 "RECV DATA: failed to read reg->rx_wrptr\n");
1288 ret = -1;
1289 goto done;
1290 }
1291 dev_dbg(adapter->dev,
1292 "info: RECV DATA: Rcvd packet from fw successfully\n");
1293 card->rxbd_wrptr = wrptr;
1294 }
1295
1296done:
1297 return ret;
1298}
1299
1300
1301
1302
1303static int
1304mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
1305{
1306 dma_addr_t buf_pa;
1307 struct pcie_service_card *card = adapter->card;
1308 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1309
1310 if (!(skb->data && skb->len)) {
1311 dev_err(adapter->dev,
1312 "Invalid parameter in %s <%p. len %d>\n",
1313 __func__, skb->data, skb->len);
1314 return -1;
1315 }
1316
1317 if (mwifiex_map_pci_memory(adapter, skb, skb->len , PCI_DMA_TODEVICE))
1318 return -1;
1319
1320 MWIFIEX_SKB_PACB(skb, &buf_pa);
1321
1322
1323
1324
1325 if (mwifiex_write_reg(adapter, reg->cmd_addr_lo, (u32)buf_pa)) {
1326 dev_err(adapter->dev,
1327 "%s: failed to write download command to boot code.\n",
1328 __func__);
1329 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1330 PCI_DMA_TODEVICE);
1331 return -1;
1332 }
1333
1334
1335
1336
1337 if (mwifiex_write_reg(adapter, reg->cmd_addr_hi,
1338 (u32)((u64)buf_pa >> 32))) {
1339 dev_err(adapter->dev,
1340 "%s: failed to write download command to boot code.\n",
1341 __func__);
1342 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1343 PCI_DMA_TODEVICE);
1344 return -1;
1345 }
1346
1347
1348 if (mwifiex_write_reg(adapter, reg->cmd_size, skb->len)) {
1349 dev_err(adapter->dev,
1350 "%s: failed to write command len to cmd_size scratch reg\n",
1351 __func__);
1352 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1353 PCI_DMA_TODEVICE);
1354 return -1;
1355 }
1356
1357
1358 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1359 CPU_INTR_DOOR_BELL)) {
1360 dev_err(adapter->dev,
1361 "%s: failed to assert door-bell intr\n", __func__);
1362 pci_unmap_single(card->dev, buf_pa,
1363 MWIFIEX_UPLD_SIZE, PCI_DMA_TODEVICE);
1364 return -1;
1365 }
1366
1367 return 0;
1368}
1369
1370
1371
1372
1373static int mwifiex_pcie_init_fw_port(struct mwifiex_adapter *adapter)
1374{
1375 struct pcie_service_card *card = adapter->card;
1376 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1377 int tx_wrap = card->txbd_wrptr & reg->tx_wrap_mask;
1378
1379
1380 if (mwifiex_write_reg(adapter, reg->rx_rdptr, card->rxbd_rdptr |
1381 tx_wrap)) {
1382 dev_err(adapter->dev,
1383 "RECV DATA: failed to write reg->rx_rdptr\n");
1384 return -1;
1385 }
1386 return 0;
1387}
1388
1389
1390
1391static int
1392mwifiex_pcie_send_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
1393{
1394 struct pcie_service_card *card = adapter->card;
1395 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1396 int ret = 0;
1397 dma_addr_t cmd_buf_pa, cmdrsp_buf_pa;
1398 u8 *payload = (u8 *)skb->data;
1399
1400 if (!(skb->data && skb->len)) {
1401 dev_err(adapter->dev, "Invalid parameter in %s <%p, %#x>\n",
1402 __func__, skb->data, skb->len);
1403 return -1;
1404 }
1405
1406
1407 if (!card->cmdrsp_buf) {
1408 dev_err(adapter->dev,
1409 "No response buffer available, send command failed\n");
1410 return -EBUSY;
1411 }
1412
1413 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1414 mwifiex_pm_wakeup_card(adapter);
1415
1416 adapter->cmd_sent = true;
1417
1418 *(__le16 *)&payload[0] = cpu_to_le16((u16)skb->len);
1419 *(__le16 *)&payload[2] = cpu_to_le16(MWIFIEX_TYPE_CMD);
1420
1421 if (mwifiex_map_pci_memory(adapter, skb, skb->len, PCI_DMA_TODEVICE))
1422 return -1;
1423
1424 card->cmd_buf = skb;
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436 if (card->cmdrsp_buf) {
1437 MWIFIEX_SKB_PACB(card->cmdrsp_buf, &cmdrsp_buf_pa);
1438
1439
1440 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo,
1441 (u32)cmdrsp_buf_pa)) {
1442 dev_err(adapter->dev,
1443 "Failed to write download cmd to boot code.\n");
1444 ret = -1;
1445 goto done;
1446 }
1447
1448
1449 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi,
1450 (u32)((u64)cmdrsp_buf_pa >> 32))) {
1451 dev_err(adapter->dev,
1452 "Failed to write download cmd to boot code.\n");
1453 ret = -1;
1454 goto done;
1455 }
1456 }
1457
1458 MWIFIEX_SKB_PACB(card->cmd_buf, &cmd_buf_pa);
1459
1460 if (mwifiex_write_reg(adapter, reg->cmd_addr_lo,
1461 (u32)cmd_buf_pa)) {
1462 dev_err(adapter->dev,
1463 "Failed to write download cmd to boot code.\n");
1464 ret = -1;
1465 goto done;
1466 }
1467
1468 if (mwifiex_write_reg(adapter, reg->cmd_addr_hi,
1469 (u32)((u64)cmd_buf_pa >> 32))) {
1470 dev_err(adapter->dev,
1471 "Failed to write download cmd to boot code.\n");
1472 ret = -1;
1473 goto done;
1474 }
1475
1476
1477 if (mwifiex_write_reg(adapter, reg->cmd_size,
1478 card->cmd_buf->len)) {
1479 dev_err(adapter->dev,
1480 "Failed to write cmd len to reg->cmd_size\n");
1481 ret = -1;
1482 goto done;
1483 }
1484
1485
1486 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1487 CPU_INTR_DOOR_BELL)) {
1488 dev_err(adapter->dev,
1489 "Failed to assert door-bell intr\n");
1490 ret = -1;
1491 goto done;
1492 }
1493
1494done:
1495 if (ret)
1496 adapter->cmd_sent = false;
1497
1498 return 0;
1499}
1500
1501
1502
1503
1504static int mwifiex_pcie_process_cmd_complete(struct mwifiex_adapter *adapter)
1505{
1506 struct pcie_service_card *card = adapter->card;
1507 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1508 struct sk_buff *skb = card->cmdrsp_buf;
1509 int count = 0;
1510 u16 rx_len;
1511 __le16 pkt_len;
1512 dma_addr_t buf_pa;
1513
1514 dev_dbg(adapter->dev, "info: Rx CMD Response\n");
1515
1516 MWIFIEX_SKB_PACB(skb, &buf_pa);
1517 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1518 PCI_DMA_FROMDEVICE);
1519
1520 pkt_len = *((__le16 *)skb->data);
1521 rx_len = le16_to_cpu(pkt_len);
1522 skb_trim(skb, rx_len);
1523 skb_pull(skb, INTF_HEADER_LEN);
1524
1525 if (!adapter->curr_cmd) {
1526 if (adapter->ps_state == PS_STATE_SLEEP_CFM) {
1527 mwifiex_process_sleep_confirm_resp(adapter, skb->data,
1528 skb->len);
1529 while (reg->sleep_cookie && (count++ < 10) &&
1530 mwifiex_pcie_ok_to_access_hw(adapter))
1531 usleep_range(50, 60);
1532 } else {
1533 dev_err(adapter->dev,
1534 "There is no command but got cmdrsp\n");
1535 }
1536 memcpy(adapter->upld_buf, skb->data,
1537 min_t(u32, MWIFIEX_SIZE_OF_CMD_BUFFER, skb->len));
1538 skb_push(skb, INTF_HEADER_LEN);
1539 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1540 PCI_DMA_FROMDEVICE))
1541 return -1;
1542
1543 MWIFIEX_SKB_PACB(skb, &buf_pa);
1544 } else if (mwifiex_pcie_ok_to_access_hw(adapter)) {
1545 adapter->curr_cmd->resp_skb = skb;
1546 adapter->cmd_resp_received = true;
1547
1548
1549 card->cmdrsp_buf = NULL;
1550
1551
1552
1553
1554 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo, 0)) {
1555 dev_err(adapter->dev,
1556 "cmd_done: failed to clear cmd_rsp_addr_lo\n");
1557 return -1;
1558 }
1559
1560
1561 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi, 0)) {
1562 dev_err(adapter->dev,
1563 "cmd_done: failed to clear cmd_rsp_addr_hi\n");
1564 return -1;
1565 }
1566 }
1567
1568 return 0;
1569}
1570
1571
1572
1573
1574static int mwifiex_pcie_cmdrsp_complete(struct mwifiex_adapter *adapter,
1575 struct sk_buff *skb)
1576{
1577 struct pcie_service_card *card = adapter->card;
1578 dma_addr_t buf_pa;
1579 struct sk_buff *skb_tmp;
1580
1581 if (skb) {
1582 card->cmdrsp_buf = skb;
1583 skb_push(card->cmdrsp_buf, INTF_HEADER_LEN);
1584 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1585 PCI_DMA_FROMDEVICE))
1586 return -1;
1587 }
1588
1589 skb_tmp = card->cmd_buf;
1590 if (skb_tmp) {
1591 MWIFIEX_SKB_PACB(skb_tmp, &buf_pa);
1592 pci_unmap_single(card->dev, buf_pa, skb_tmp->len,
1593 PCI_DMA_FROMDEVICE);
1594 card->cmd_buf = NULL;
1595 }
1596
1597 return 0;
1598}
1599
1600
1601
1602
1603static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter *adapter)
1604{
1605 struct pcie_service_card *card = adapter->card;
1606 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1607 u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1608 u32 wrptr, event;
1609 dma_addr_t buf_pa;
1610 struct mwifiex_evt_buf_desc *desc;
1611
1612 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1613 mwifiex_pm_wakeup_card(adapter);
1614
1615 if (adapter->event_received) {
1616 dev_dbg(adapter->dev, "info: Event being processed, "
1617 "do not process this interrupt just yet\n");
1618 return 0;
1619 }
1620
1621 if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1622 dev_dbg(adapter->dev, "info: Invalid read pointer...\n");
1623 return -1;
1624 }
1625
1626
1627 if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1628 dev_err(adapter->dev,
1629 "EventReady: failed to read reg->evt_wrptr\n");
1630 return -1;
1631 }
1632
1633 dev_dbg(adapter->dev, "info: EventReady: Initial <Rd: 0x%x, Wr: 0x%x>",
1634 card->evtbd_rdptr, wrptr);
1635 if (((wrptr & MWIFIEX_EVTBD_MASK) != (card->evtbd_rdptr
1636 & MWIFIEX_EVTBD_MASK)) ||
1637 ((wrptr & reg->evt_rollover_ind) ==
1638 (card->evtbd_rdptr & reg->evt_rollover_ind))) {
1639 struct sk_buff *skb_cmd;
1640 __le16 data_len = 0;
1641 u16 evt_len;
1642
1643 dev_dbg(adapter->dev, "info: Read Index: %d\n", rdptr);
1644 skb_cmd = card->evt_buf_list[rdptr];
1645 MWIFIEX_SKB_PACB(skb_cmd, &buf_pa);
1646 pci_unmap_single(card->dev, buf_pa, MAX_EVENT_SIZE,
1647 PCI_DMA_FROMDEVICE);
1648
1649
1650
1651 card->evt_buf_list[rdptr] = NULL;
1652 desc = card->evtbd_ring[rdptr];
1653 memset(desc, 0, sizeof(*desc));
1654
1655 event = *(u32 *) &skb_cmd->data[INTF_HEADER_LEN];
1656 adapter->event_cause = event;
1657
1658
1659 memcpy(&data_len, skb_cmd->data, sizeof(__le16));
1660 evt_len = le16_to_cpu(data_len);
1661
1662 skb_pull(skb_cmd, INTF_HEADER_LEN);
1663 dev_dbg(adapter->dev, "info: Event length: %d\n", evt_len);
1664
1665 if ((evt_len > 0) && (evt_len < MAX_EVENT_SIZE))
1666 memcpy(adapter->event_body, skb_cmd->data +
1667 MWIFIEX_EVENT_HEADER_LEN, evt_len -
1668 MWIFIEX_EVENT_HEADER_LEN);
1669
1670 adapter->event_received = true;
1671 adapter->event_skb = skb_cmd;
1672
1673
1674
1675
1676
1677 }
1678
1679 return 0;
1680}
1681
1682
1683
1684
1685static int mwifiex_pcie_event_complete(struct mwifiex_adapter *adapter,
1686 struct sk_buff *skb)
1687{
1688 struct pcie_service_card *card = adapter->card;
1689 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1690 int ret = 0;
1691 u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1692 u32 wrptr;
1693 dma_addr_t buf_pa;
1694 struct mwifiex_evt_buf_desc *desc;
1695
1696 if (!skb)
1697 return 0;
1698
1699 if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1700 dev_err(adapter->dev, "event_complete: Invalid rdptr 0x%x\n",
1701 rdptr);
1702 return -EINVAL;
1703 }
1704
1705
1706 if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1707 dev_err(adapter->dev,
1708 "event_complete: failed to read reg->evt_wrptr\n");
1709 return -1;
1710 }
1711
1712 if (!card->evt_buf_list[rdptr]) {
1713 skb_push(skb, INTF_HEADER_LEN);
1714 if (mwifiex_map_pci_memory(adapter, skb,
1715 MAX_EVENT_SIZE,
1716 PCI_DMA_FROMDEVICE))
1717 return -1;
1718 MWIFIEX_SKB_PACB(skb, &buf_pa);
1719 card->evt_buf_list[rdptr] = skb;
1720 MWIFIEX_SKB_PACB(skb, &buf_pa);
1721 desc = card->evtbd_ring[rdptr];
1722 desc->paddr = buf_pa;
1723 desc->len = (u16)skb->len;
1724 desc->flags = 0;
1725 skb = NULL;
1726 } else {
1727 dev_dbg(adapter->dev,
1728 "info: ERROR: buf still valid at index %d, <%p, %p>\n",
1729 rdptr, card->evt_buf_list[rdptr], skb);
1730 }
1731
1732 if ((++card->evtbd_rdptr & MWIFIEX_EVTBD_MASK) == MWIFIEX_MAX_EVT_BD) {
1733 card->evtbd_rdptr = ((card->evtbd_rdptr &
1734 reg->evt_rollover_ind) ^
1735 reg->evt_rollover_ind);
1736 }
1737
1738 dev_dbg(adapter->dev, "info: Updated <Rd: 0x%x, Wr: 0x%x>",
1739 card->evtbd_rdptr, wrptr);
1740
1741
1742 if (mwifiex_write_reg(adapter, reg->evt_rdptr,
1743 card->evtbd_rdptr)) {
1744 dev_err(adapter->dev,
1745 "event_complete: failed to read reg->evt_rdptr\n");
1746 return -1;
1747 }
1748
1749 dev_dbg(adapter->dev, "info: Check Events Again\n");
1750 ret = mwifiex_pcie_process_event_ready(adapter);
1751
1752 return ret;
1753}
1754
1755
1756
1757
1758
1759
1760
1761
1762static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter *adapter,
1763 struct mwifiex_fw_image *fw)
1764{
1765 int ret;
1766 u8 *firmware = fw->fw_buf;
1767 u32 firmware_len = fw->fw_len;
1768 u32 offset = 0;
1769 struct sk_buff *skb;
1770 u32 txlen, tx_blocks = 0, tries, len;
1771 u32 block_retry_cnt = 0;
1772 dma_addr_t buf_pa;
1773 struct pcie_service_card *card = adapter->card;
1774 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1775
1776 if (!firmware || !firmware_len) {
1777 dev_err(adapter->dev,
1778 "No firmware image found! Terminating download\n");
1779 return -1;
1780 }
1781
1782 dev_dbg(adapter->dev, "info: Downloading FW image (%d bytes)\n",
1783 firmware_len);
1784
1785 if (mwifiex_pcie_disable_host_int(adapter)) {
1786 dev_err(adapter->dev,
1787 "%s: Disabling interrupts failed.\n", __func__);
1788 return -1;
1789 }
1790
1791 skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
1792 if (!skb) {
1793 ret = -ENOMEM;
1794 goto done;
1795 }
1796
1797
1798 do {
1799 u32 ireg_intr = 0;
1800
1801
1802 if (offset >= firmware_len)
1803 break;
1804
1805 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
1806 ret = mwifiex_read_reg(adapter, reg->cmd_size,
1807 &len);
1808 if (ret) {
1809 dev_warn(adapter->dev,
1810 "Failed reading len from boot code\n");
1811 goto done;
1812 }
1813 if (len)
1814 break;
1815 usleep_range(10, 20);
1816 }
1817
1818 if (!len) {
1819 break;
1820 } else if (len > MWIFIEX_UPLD_SIZE) {
1821 pr_err("FW download failure @ %d, invalid length %d\n",
1822 offset, len);
1823 ret = -1;
1824 goto done;
1825 }
1826
1827 txlen = len;
1828
1829 if (len & BIT(0)) {
1830 block_retry_cnt++;
1831 if (block_retry_cnt > MAX_WRITE_IOMEM_RETRY) {
1832 pr_err("FW download failure @ %d, over max "
1833 "retry count\n", offset);
1834 ret = -1;
1835 goto done;
1836 }
1837 dev_err(adapter->dev, "FW CRC error indicated by the "
1838 "helper: len = 0x%04X, txlen = %d\n",
1839 len, txlen);
1840 len &= ~BIT(0);
1841
1842 txlen = 0;
1843 } else {
1844 block_retry_cnt = 0;
1845
1846
1847 if (firmware_len - offset < txlen)
1848 txlen = firmware_len - offset;
1849
1850 dev_dbg(adapter->dev, ".");
1851
1852 tx_blocks = (txlen + card->pcie.blksz_fw_dl - 1) /
1853 card->pcie.blksz_fw_dl;
1854
1855
1856 memmove(skb->data, &firmware[offset], txlen);
1857 }
1858
1859 skb_put(skb, MWIFIEX_UPLD_SIZE - skb->len);
1860 skb_trim(skb, tx_blocks * card->pcie.blksz_fw_dl);
1861
1862
1863 if (mwifiex_pcie_send_boot_cmd(adapter, skb)) {
1864 dev_err(adapter->dev,
1865 "Failed to send firmware download command\n");
1866 ret = -1;
1867 goto done;
1868 }
1869
1870 MWIFIEX_SKB_PACB(skb, &buf_pa);
1871
1872
1873 do {
1874 if (mwifiex_read_reg(adapter, PCIE_CPU_INT_STATUS,
1875 &ireg_intr)) {
1876 dev_err(adapter->dev, "%s: Failed to read "
1877 "interrupt status during fw dnld.\n",
1878 __func__);
1879 pci_unmap_single(card->dev, buf_pa, skb->len,
1880 PCI_DMA_TODEVICE);
1881 ret = -1;
1882 goto done;
1883 }
1884 } while ((ireg_intr & CPU_INTR_DOOR_BELL) ==
1885 CPU_INTR_DOOR_BELL);
1886
1887 pci_unmap_single(card->dev, buf_pa, skb->len,
1888 PCI_DMA_TODEVICE);
1889
1890 offset += txlen;
1891 } while (true);
1892
1893 dev_dbg(adapter->dev, "info:\nFW download over, size %d bytes\n",
1894 offset);
1895
1896 ret = 0;
1897
1898done:
1899 dev_kfree_skb_any(skb);
1900 return ret;
1901}
1902
1903
1904
1905
1906
1907
1908static int
1909mwifiex_check_fw_status(struct mwifiex_adapter *adapter, u32 poll_num)
1910{
1911 int ret = 0;
1912 u32 firmware_stat, winner_status;
1913 struct pcie_service_card *card = adapter->card;
1914 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1915 u32 tries;
1916
1917
1918 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS_MASK,
1919 HOST_INTR_MASK)) {
1920 dev_warn(adapter->dev, "Write register failed\n");
1921 return -1;
1922 }
1923
1924 dev_dbg(adapter->dev, "Setting driver ready signature\n");
1925 if (mwifiex_write_reg(adapter, reg->drv_rdy,
1926 FIRMWARE_READY_PCIE)) {
1927 dev_err(adapter->dev,
1928 "Failed to write driver ready signature\n");
1929 return -1;
1930 }
1931
1932
1933 for (tries = 0; tries < poll_num; tries++) {
1934 if (mwifiex_read_reg(adapter, reg->fw_status,
1935 &firmware_stat))
1936 ret = -1;
1937 else
1938 ret = 0;
1939 if (ret)
1940 continue;
1941 if (firmware_stat == FIRMWARE_READY_PCIE) {
1942 ret = 0;
1943 break;
1944 } else {
1945 msleep(100);
1946 ret = -1;
1947 }
1948 }
1949
1950 if (ret) {
1951 if (mwifiex_read_reg(adapter, reg->fw_status,
1952 &winner_status))
1953 ret = -1;
1954 else if (!winner_status) {
1955 dev_err(adapter->dev, "PCI-E is the winner\n");
1956 adapter->winner = 1;
1957 } else {
1958 dev_err(adapter->dev,
1959 "PCI-E is not the winner <%#x,%d>, exit dnld\n",
1960 ret, adapter->winner);
1961 }
1962 }
1963
1964 return ret;
1965}
1966
1967
1968
1969
1970static void mwifiex_interrupt_status(struct mwifiex_adapter *adapter)
1971{
1972 u32 pcie_ireg;
1973 unsigned long flags;
1974
1975 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1976 return;
1977
1978 if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS, &pcie_ireg)) {
1979 dev_warn(adapter->dev, "Read register failed\n");
1980 return;
1981 }
1982
1983 if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
1984
1985 mwifiex_pcie_disable_host_int(adapter);
1986
1987
1988 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS,
1989 ~pcie_ireg)) {
1990 dev_warn(adapter->dev, "Write register failed\n");
1991 return;
1992 }
1993 spin_lock_irqsave(&adapter->int_lock, flags);
1994 adapter->int_status |= pcie_ireg;
1995 spin_unlock_irqrestore(&adapter->int_lock, flags);
1996
1997 if (pcie_ireg & HOST_INTR_CMD_DONE) {
1998 if ((adapter->ps_state == PS_STATE_SLEEP_CFM) ||
1999 (adapter->ps_state == PS_STATE_SLEEP)) {
2000 mwifiex_pcie_enable_host_int(adapter);
2001 if (mwifiex_write_reg(adapter,
2002 PCIE_CPU_INT_EVENT,
2003 CPU_INTR_SLEEP_CFM_DONE)
2004 ) {
2005 dev_warn(adapter->dev,
2006 "Write register failed\n");
2007 return;
2008
2009 }
2010 }
2011 } else if (!adapter->pps_uapsd_mode &&
2012 adapter->ps_state == PS_STATE_SLEEP &&
2013 mwifiex_pcie_ok_to_access_hw(adapter)) {
2014
2015
2016
2017 adapter->ps_state = PS_STATE_AWAKE;
2018 adapter->pm_wakeup_fw_try = false;
2019 }
2020 }
2021}
2022
2023
2024
2025
2026
2027
2028
2029static irqreturn_t mwifiex_pcie_interrupt(int irq, void *context)
2030{
2031 struct pci_dev *pdev = (struct pci_dev *)context;
2032 struct pcie_service_card *card;
2033 struct mwifiex_adapter *adapter;
2034
2035 if (!pdev) {
2036 pr_debug("info: %s: pdev is NULL\n", (u8 *)pdev);
2037 goto exit;
2038 }
2039
2040 card = (struct pcie_service_card *) pci_get_drvdata(pdev);
2041 if (!card || !card->adapter) {
2042 pr_debug("info: %s: card=%p adapter=%p\n", __func__, card,
2043 card ? card->adapter : NULL);
2044 goto exit;
2045 }
2046 adapter = card->adapter;
2047
2048 if (adapter->surprise_removed)
2049 goto exit;
2050
2051 mwifiex_interrupt_status(adapter);
2052 queue_work(adapter->workqueue, &adapter->main_work);
2053
2054exit:
2055 return IRQ_HANDLED;
2056}
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071static int mwifiex_process_int_status(struct mwifiex_adapter *adapter)
2072{
2073 int ret;
2074 u32 pcie_ireg;
2075 unsigned long flags;
2076
2077 spin_lock_irqsave(&adapter->int_lock, flags);
2078
2079 pcie_ireg = adapter->int_status;
2080 adapter->int_status = 0;
2081 spin_unlock_irqrestore(&adapter->int_lock, flags);
2082
2083 while (pcie_ireg & HOST_INTR_MASK) {
2084 if (pcie_ireg & HOST_INTR_DNLD_DONE) {
2085 pcie_ireg &= ~HOST_INTR_DNLD_DONE;
2086 dev_dbg(adapter->dev, "info: TX DNLD Done\n");
2087 ret = mwifiex_pcie_send_data_complete(adapter);
2088 if (ret)
2089 return ret;
2090 }
2091 if (pcie_ireg & HOST_INTR_UPLD_RDY) {
2092 pcie_ireg &= ~HOST_INTR_UPLD_RDY;
2093 dev_dbg(adapter->dev, "info: Rx DATA\n");
2094 ret = mwifiex_pcie_process_recv_data(adapter);
2095 if (ret)
2096 return ret;
2097 }
2098 if (pcie_ireg & HOST_INTR_EVENT_RDY) {
2099 pcie_ireg &= ~HOST_INTR_EVENT_RDY;
2100 dev_dbg(adapter->dev, "info: Rx EVENT\n");
2101 ret = mwifiex_pcie_process_event_ready(adapter);
2102 if (ret)
2103 return ret;
2104 }
2105
2106 if (pcie_ireg & HOST_INTR_CMD_DONE) {
2107 pcie_ireg &= ~HOST_INTR_CMD_DONE;
2108 if (adapter->cmd_sent) {
2109 dev_dbg(adapter->dev,
2110 "info: CMD sent Interrupt\n");
2111 adapter->cmd_sent = false;
2112 }
2113
2114 ret = mwifiex_pcie_process_cmd_complete(adapter);
2115 if (ret)
2116 return ret;
2117 }
2118
2119 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
2120 if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS,
2121 &pcie_ireg)) {
2122 dev_warn(adapter->dev,
2123 "Read register failed\n");
2124 return -1;
2125 }
2126
2127 if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
2128 if (mwifiex_write_reg(adapter,
2129 PCIE_HOST_INT_STATUS,
2130 ~pcie_ireg)) {
2131 dev_warn(adapter->dev,
2132 "Write register failed\n");
2133 return -1;
2134 }
2135 }
2136
2137 }
2138 }
2139 dev_dbg(adapter->dev, "info: cmd_sent=%d data_sent=%d\n",
2140 adapter->cmd_sent, adapter->data_sent);
2141 if (adapter->ps_state != PS_STATE_SLEEP)
2142 mwifiex_pcie_enable_host_int(adapter);
2143
2144 return 0;
2145}
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157static int mwifiex_pcie_host_to_card(struct mwifiex_adapter *adapter, u8 type,
2158 struct sk_buff *skb,
2159 struct mwifiex_tx_param *tx_param)
2160{
2161 if (!skb) {
2162 dev_err(adapter->dev, "Passed NULL skb to %s\n", __func__);
2163 return -1;
2164 }
2165
2166 if (type == MWIFIEX_TYPE_DATA)
2167 return mwifiex_pcie_send_data(adapter, skb, tx_param);
2168 else if (type == MWIFIEX_TYPE_CMD)
2169 return mwifiex_pcie_send_cmd(adapter, skb);
2170
2171 return 0;
2172}
2173
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184static int mwifiex_pcie_init(struct mwifiex_adapter *adapter)
2185{
2186 struct pcie_service_card *card = adapter->card;
2187 int ret;
2188 struct pci_dev *pdev = card->dev;
2189 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2190
2191 pci_set_drvdata(pdev, card);
2192
2193 ret = pci_enable_device(pdev);
2194 if (ret)
2195 goto err_enable_dev;
2196
2197 pci_set_master(pdev);
2198
2199 dev_dbg(adapter->dev, "try set_consistent_dma_mask(32)\n");
2200 ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2201 if (ret) {
2202 dev_err(adapter->dev, "set_dma_mask(32) failed\n");
2203 goto err_set_dma_mask;
2204 }
2205
2206 ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
2207 if (ret) {
2208 dev_err(adapter->dev, "set_consistent_dma_mask(64) failed\n");
2209 goto err_set_dma_mask;
2210 }
2211
2212 ret = pci_request_region(pdev, 0, DRV_NAME);
2213 if (ret) {
2214 dev_err(adapter->dev, "req_reg(0) error\n");
2215 goto err_req_region0;
2216 }
2217 card->pci_mmap = pci_iomap(pdev, 0, 0);
2218 if (!card->pci_mmap) {
2219 dev_err(adapter->dev, "iomap(0) error\n");
2220 ret = -EIO;
2221 goto err_iomap0;
2222 }
2223 ret = pci_request_region(pdev, 2, DRV_NAME);
2224 if (ret) {
2225 dev_err(adapter->dev, "req_reg(2) error\n");
2226 goto err_req_region2;
2227 }
2228 card->pci_mmap1 = pci_iomap(pdev, 2, 0);
2229 if (!card->pci_mmap1) {
2230 dev_err(adapter->dev, "iomap(2) error\n");
2231 ret = -EIO;
2232 goto err_iomap2;
2233 }
2234
2235 dev_dbg(adapter->dev,
2236 "PCI memory map Virt0: %p PCI memory map Virt2: %p\n",
2237 card->pci_mmap, card->pci_mmap1);
2238
2239 card->cmdrsp_buf = NULL;
2240 ret = mwifiex_pcie_create_txbd_ring(adapter);
2241 if (ret)
2242 goto err_cre_txbd;
2243 ret = mwifiex_pcie_create_rxbd_ring(adapter);
2244 if (ret)
2245 goto err_cre_rxbd;
2246 ret = mwifiex_pcie_create_evtbd_ring(adapter);
2247 if (ret)
2248 goto err_cre_evtbd;
2249 ret = mwifiex_pcie_alloc_cmdrsp_buf(adapter);
2250 if (ret)
2251 goto err_alloc_cmdbuf;
2252 if (reg->sleep_cookie) {
2253 ret = mwifiex_pcie_alloc_sleep_cookie_buf(adapter);
2254 if (ret)
2255 goto err_alloc_cookie;
2256 } else {
2257 card->sleep_cookie_vbase = NULL;
2258 }
2259 return ret;
2260
2261err_alloc_cookie:
2262 mwifiex_pcie_delete_cmdrsp_buf(adapter);
2263err_alloc_cmdbuf:
2264 mwifiex_pcie_delete_evtbd_ring(adapter);
2265err_cre_evtbd:
2266 mwifiex_pcie_delete_rxbd_ring(adapter);
2267err_cre_rxbd:
2268 mwifiex_pcie_delete_txbd_ring(adapter);
2269err_cre_txbd:
2270 pci_iounmap(pdev, card->pci_mmap1);
2271err_iomap2:
2272 pci_release_region(pdev, 2);
2273err_req_region2:
2274 pci_iounmap(pdev, card->pci_mmap);
2275err_iomap0:
2276 pci_release_region(pdev, 0);
2277err_req_region0:
2278err_set_dma_mask:
2279 pci_disable_device(pdev);
2280err_enable_dev:
2281 pci_set_drvdata(pdev, NULL);
2282 return ret;
2283}
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295static void mwifiex_pcie_cleanup(struct mwifiex_adapter *adapter)
2296{
2297 struct pcie_service_card *card = adapter->card;
2298 struct pci_dev *pdev = card->dev;
2299 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2300
2301 if (user_rmmod) {
2302 dev_dbg(adapter->dev, "Clearing driver ready signature\n");
2303 if (mwifiex_write_reg(adapter, reg->drv_rdy, 0x00000000))
2304 dev_err(adapter->dev,
2305 "Failed to write driver not-ready signature\n");
2306 }
2307
2308 if (pdev) {
2309 pci_iounmap(pdev, card->pci_mmap);
2310 pci_iounmap(pdev, card->pci_mmap1);
2311 pci_disable_device(pdev);
2312 pci_release_region(pdev, 2);
2313 pci_release_region(pdev, 0);
2314 pci_set_drvdata(pdev, NULL);
2315 }
2316}
2317
2318
2319
2320
2321
2322
2323static int mwifiex_register_dev(struct mwifiex_adapter *adapter)
2324{
2325 int ret;
2326 struct pcie_service_card *card = adapter->card;
2327 struct pci_dev *pdev = card->dev;
2328
2329
2330 card->adapter = adapter;
2331
2332 ret = request_irq(pdev->irq, mwifiex_pcie_interrupt, IRQF_SHARED,
2333 "MRVL_PCIE", pdev);
2334 if (ret) {
2335 pr_err("request_irq failed: ret=%d\n", ret);
2336 adapter->card = NULL;
2337 return -1;
2338 }
2339
2340 adapter->dev = &pdev->dev;
2341 strcpy(adapter->fw_name, card->pcie.firmware);
2342
2343 return 0;
2344}
2345
2346
2347
2348
2349
2350
2351
2352static void mwifiex_unregister_dev(struct mwifiex_adapter *adapter)
2353{
2354 struct pcie_service_card *card = adapter->card;
2355 const struct mwifiex_pcie_card_reg *reg;
2356
2357 if (card) {
2358 dev_dbg(adapter->dev, "%s(): calling free_irq()\n", __func__);
2359 free_irq(card->dev->irq, card->dev);
2360
2361 reg = card->pcie.reg;
2362 if (reg->sleep_cookie)
2363 mwifiex_pcie_delete_sleep_cookie_buf(adapter);
2364
2365 mwifiex_pcie_delete_cmdrsp_buf(adapter);
2366 mwifiex_pcie_delete_evtbd_ring(adapter);
2367 mwifiex_pcie_delete_rxbd_ring(adapter);
2368 mwifiex_pcie_delete_txbd_ring(adapter);
2369 card->cmdrsp_buf = NULL;
2370 }
2371}
2372
2373static struct mwifiex_if_ops pcie_ops = {
2374 .init_if = mwifiex_pcie_init,
2375 .cleanup_if = mwifiex_pcie_cleanup,
2376 .check_fw_status = mwifiex_check_fw_status,
2377 .prog_fw = mwifiex_prog_fw_w_helper,
2378 .register_dev = mwifiex_register_dev,
2379 .unregister_dev = mwifiex_unregister_dev,
2380 .enable_int = mwifiex_pcie_enable_host_int,
2381 .process_int_status = mwifiex_process_int_status,
2382 .host_to_card = mwifiex_pcie_host_to_card,
2383 .wakeup = mwifiex_pm_wakeup_card,
2384 .wakeup_complete = mwifiex_pm_wakeup_card_complete,
2385
2386
2387 .cmdrsp_complete = mwifiex_pcie_cmdrsp_complete,
2388 .event_complete = mwifiex_pcie_event_complete,
2389 .update_mp_end_port = NULL,
2390 .cleanup_mpa_buf = NULL,
2391 .init_fw_port = mwifiex_pcie_init_fw_port,
2392 .clean_pcie_ring = mwifiex_clean_pcie_ring_buf,
2393};
2394
2395
2396
2397
2398
2399
2400
2401static int mwifiex_pcie_init_module(void)
2402{
2403 int ret;
2404
2405 pr_debug("Marvell PCIe Driver\n");
2406
2407 sema_init(&add_remove_card_sem, 1);
2408
2409
2410 user_rmmod = 0;
2411
2412 ret = pci_register_driver(&mwifiex_pcie);
2413 if (ret)
2414 pr_err("Driver register failed!\n");
2415 else
2416 pr_debug("info: Driver registered successfully!\n");
2417
2418 return ret;
2419}
2420
2421
2422
2423
2424
2425
2426
2427
2428
2429
2430static void mwifiex_pcie_cleanup_module(void)
2431{
2432 if (!down_interruptible(&add_remove_card_sem))
2433 up(&add_remove_card_sem);
2434
2435
2436 user_rmmod = 1;
2437
2438 pci_unregister_driver(&mwifiex_pcie);
2439}
2440
2441module_init(mwifiex_pcie_init_module);
2442module_exit(mwifiex_pcie_cleanup_module);
2443
2444MODULE_AUTHOR("Marvell International Ltd.");
2445MODULE_DESCRIPTION("Marvell WiFi-Ex PCI-Express Driver version " PCIE_VERSION);
2446MODULE_VERSION(PCIE_VERSION);
2447MODULE_LICENSE("GPL v2");
2448MODULE_FIRMWARE(PCIE8766_DEFAULT_FW_NAME);
2449MODULE_FIRMWARE(PCIE8897_DEFAULT_FW_NAME);
2450