2 * Marvell Wireless LAN device driver: PCIE specific handling
4 * Copyright (C) 2011-2014, Marvell International Ltd.
6 * This software file (the "File") is distributed by Marvell International
7 * Ltd. under the terms of the GNU General Public License Version 2, June 1991
8 * (the "License"). You may use, redistribute and/or modify this File in
9 * accordance with the terms and conditions of the License, a copy of which
10 * is available by writing to the Free Software Foundation, Inc.,
11 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
12 * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
14 * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
16 * ARE EXPRESSLY DISCLAIMED. The License provides additional details about
17 * this warranty disclaimer.
20 #include <linux/firmware.h>
31 #define PCIE_VERSION "1.0"
32 #define DRV_NAME "Marvell mwifiex PCIe"
36 static struct mwifiex_if_ops pcie_ops
;
38 static struct semaphore add_remove_card_sem
;
41 mwifiex_map_pci_memory(struct mwifiex_adapter
*adapter
, struct sk_buff
*skb
,
42 size_t size
, int flags
)
44 struct pcie_service_card
*card
= adapter
->card
;
45 struct mwifiex_dma_mapping mapping
;
47 mapping
.addr
= pci_map_single(card
->dev
, skb
->data
, size
, flags
);
48 if (pci_dma_mapping_error(card
->dev
, mapping
.addr
)) {
49 mwifiex_dbg(adapter
, ERROR
, "failed to map pci memory!\n");
53 mwifiex_store_mapping(skb
, &mapping
);
57 static void mwifiex_unmap_pci_memory(struct mwifiex_adapter
*adapter
,
58 struct sk_buff
*skb
, int flags
)
60 struct pcie_service_card
*card
= adapter
->card
;
61 struct mwifiex_dma_mapping mapping
;
63 mwifiex_get_mapping(skb
, &mapping
);
64 pci_unmap_single(card
->dev
, mapping
.addr
, mapping
.len
, flags
);
68 * This function reads sleep cookie and checks if FW is ready
70 static bool mwifiex_pcie_ok_to_access_hw(struct mwifiex_adapter
*adapter
)
73 struct pcie_service_card
*card
= adapter
->card
;
74 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
76 if (!reg
->sleep_cookie
)
79 if (card
->sleep_cookie_vbase
) {
80 cookie_addr
= (u32
*)card
->sleep_cookie_vbase
;
81 mwifiex_dbg(adapter
, INFO
,
82 "info: ACCESS_HW: sleep cookie=0x%x\n",
84 if (*cookie_addr
== FW_AWAKE_COOKIE
)
91 #ifdef CONFIG_PM_SLEEP
93 * Kernel needs to suspend all functions separately. Therefore all
94 * registered functions must have drivers with suspend and resume
95 * methods. Failing that the kernel simply removes the whole card.
97 * If already not suspended, this function allocates and sends a host
98 * sleep activate request to the firmware and turns off the traffic.
100 static int mwifiex_pcie_suspend(struct device
*dev
)
102 struct mwifiex_adapter
*adapter
;
103 struct pcie_service_card
*card
;
105 struct pci_dev
*pdev
= to_pci_dev(dev
);
108 card
= pci_get_drvdata(pdev
);
109 if (!card
|| !card
->adapter
) {
110 pr_err("Card or adapter structure is not valid\n");
114 pr_err("PCIE device is not specified\n");
118 adapter
= card
->adapter
;
120 hs_actived
= mwifiex_enable_hs(adapter
);
122 /* Indicate device suspended */
123 adapter
->is_suspended
= true;
124 adapter
->hs_enabling
= false;
130 * Kernel needs to suspend all functions separately. Therefore all
131 * registered functions must have drivers with suspend and resume
132 * methods. Failing that the kernel simply removes the whole card.
134 * If already not resumed, this function turns on the traffic and
135 * sends a host sleep cancel request to the firmware.
137 static int mwifiex_pcie_resume(struct device
*dev
)
139 struct mwifiex_adapter
*adapter
;
140 struct pcie_service_card
*card
;
141 struct pci_dev
*pdev
= to_pci_dev(dev
);
144 card
= pci_get_drvdata(pdev
);
145 if (!card
|| !card
->adapter
) {
146 pr_err("Card or adapter structure is not valid\n");
150 pr_err("PCIE device is not specified\n");
154 adapter
= card
->adapter
;
156 if (!adapter
->is_suspended
) {
157 mwifiex_dbg(adapter
, WARN
,
158 "Device already resumed\n");
162 adapter
->is_suspended
= false;
164 mwifiex_cancel_hs(mwifiex_get_priv(adapter
, MWIFIEX_BSS_ROLE_STA
),
172 * This function probes an mwifiex device and registers it. It allocates
173 * the card structure, enables PCIE function number and initiates the
174 * device registration and initialization procedure by adding a logical
177 static int mwifiex_pcie_probe(struct pci_dev
*pdev
,
178 const struct pci_device_id
*ent
)
180 struct pcie_service_card
*card
;
182 pr_debug("info: vendor=0x%4.04X device=0x%4.04X rev=%d\n",
183 pdev
->vendor
, pdev
->device
, pdev
->revision
);
185 card
= kzalloc(sizeof(struct pcie_service_card
), GFP_KERNEL
);
191 if (ent
->driver_data
) {
192 struct mwifiex_pcie_device
*data
= (void *)ent
->driver_data
;
193 card
->pcie
.firmware
= data
->firmware
;
194 card
->pcie
.reg
= data
->reg
;
195 card
->pcie
.blksz_fw_dl
= data
->blksz_fw_dl
;
196 card
->pcie
.tx_buf_size
= data
->tx_buf_size
;
197 card
->pcie
.can_dump_fw
= data
->can_dump_fw
;
198 card
->pcie
.mem_type_mapping_tbl
= data
->mem_type_mapping_tbl
;
199 card
->pcie
.num_mem_types
= data
->num_mem_types
;
200 card
->pcie
.can_ext_scan
= data
->can_ext_scan
;
203 if (mwifiex_add_card(card
, &add_remove_card_sem
, &pcie_ops
,
205 pr_err("%s failed\n", __func__
);
214 * This function removes the interface and frees up the card structure.
216 static void mwifiex_pcie_remove(struct pci_dev
*pdev
)
218 struct pcie_service_card
*card
;
219 struct mwifiex_adapter
*adapter
;
220 struct mwifiex_private
*priv
;
222 card
= pci_get_drvdata(pdev
);
226 adapter
= card
->adapter
;
227 if (!adapter
|| !adapter
->priv_num
)
231 #ifdef CONFIG_PM_SLEEP
232 if (adapter
->is_suspended
)
233 mwifiex_pcie_resume(&pdev
->dev
);
236 mwifiex_deauthenticate_all(adapter
);
238 priv
= mwifiex_get_priv(adapter
, MWIFIEX_BSS_ROLE_ANY
);
240 mwifiex_disable_auto_ds(priv
);
242 mwifiex_init_shutdown_fw(priv
, MWIFIEX_FUNC_SHUTDOWN
);
245 mwifiex_remove_card(card
->adapter
, &add_remove_card_sem
);
248 static void mwifiex_pcie_shutdown(struct pci_dev
*pdev
)
251 mwifiex_pcie_remove(pdev
);
256 static const struct pci_device_id mwifiex_ids
[] = {
258 PCIE_VENDOR_ID_MARVELL
, PCIE_DEVICE_ID_MARVELL_88W8766P
,
259 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0,
260 .driver_data
= (unsigned long)&mwifiex_pcie8766
,
263 PCIE_VENDOR_ID_MARVELL
, PCIE_DEVICE_ID_MARVELL_88W8897
,
264 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0,
265 .driver_data
= (unsigned long)&mwifiex_pcie8897
,
268 PCIE_VENDOR_ID_MARVELL
, PCIE_DEVICE_ID_MARVELL_88W8997
,
269 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0,
270 .driver_data
= (unsigned long)&mwifiex_pcie8997
,
275 MODULE_DEVICE_TABLE(pci
, mwifiex_ids
);
277 #ifdef CONFIG_PM_SLEEP
278 /* Power Management Hooks */
279 static SIMPLE_DEV_PM_OPS(mwifiex_pcie_pm_ops
, mwifiex_pcie_suspend
,
280 mwifiex_pcie_resume
);
283 /* PCI Device Driver */
284 static struct pci_driver __refdata mwifiex_pcie
= {
285 .name
= "mwifiex_pcie",
286 .id_table
= mwifiex_ids
,
287 .probe
= mwifiex_pcie_probe
,
288 .remove
= mwifiex_pcie_remove
,
289 #ifdef CONFIG_PM_SLEEP
291 .pm
= &mwifiex_pcie_pm_ops
,
294 .shutdown
= mwifiex_pcie_shutdown
,
298 * This function writes data into PCIE card register.
300 static int mwifiex_write_reg(struct mwifiex_adapter
*adapter
, int reg
, u32 data
)
302 struct pcie_service_card
*card
= adapter
->card
;
304 iowrite32(data
, card
->pci_mmap1
+ reg
);
310 * This function reads data from PCIE card register.
312 static int mwifiex_read_reg(struct mwifiex_adapter
*adapter
, int reg
, u32
*data
)
314 struct pcie_service_card
*card
= adapter
->card
;
316 *data
= ioread32(card
->pci_mmap1
+ reg
);
317 if (*data
== 0xffffffff)
323 /* This function reads u8 data from PCIE card register. */
324 static int mwifiex_read_reg_byte(struct mwifiex_adapter
*adapter
,
327 struct pcie_service_card
*card
= adapter
->card
;
329 *data
= ioread8(card
->pci_mmap1
+ reg
);
335 * This function adds delay loop to ensure FW is awake before proceeding.
337 static void mwifiex_pcie_dev_wakeup_delay(struct mwifiex_adapter
*adapter
)
341 while (mwifiex_pcie_ok_to_access_hw(adapter
)) {
343 usleep_range(10, 20);
352 static void mwifiex_delay_for_sleep_cookie(struct mwifiex_adapter
*adapter
,
353 u32 max_delay_loop_cnt
)
355 struct pcie_service_card
*card
= adapter
->card
;
357 u32 sleep_cookie
, count
;
359 for (count
= 0; count
< max_delay_loop_cnt
; count
++) {
360 buffer
= card
->cmdrsp_buf
->data
- INTF_HEADER_LEN
;
361 sleep_cookie
= *(u32
*)buffer
;
363 if (sleep_cookie
== MWIFIEX_DEF_SLEEP_COOKIE
) {
364 mwifiex_dbg(adapter
, INFO
,
365 "sleep cookie found at count %d\n", count
);
368 usleep_range(20, 30);
371 if (count
>= max_delay_loop_cnt
)
372 mwifiex_dbg(adapter
, INFO
,
373 "max count reached while accessing sleep cookie\n");
376 /* This function wakes up the card by reading fw_status register. */
377 static int mwifiex_pm_wakeup_card(struct mwifiex_adapter
*adapter
)
380 struct pcie_service_card
*card
= adapter
->card
;
381 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
383 mwifiex_dbg(adapter
, EVENT
,
384 "event: Wakeup device...\n");
386 if (reg
->sleep_cookie
)
387 mwifiex_pcie_dev_wakeup_delay(adapter
);
389 /* Reading fw_status register will wakeup device */
390 if (mwifiex_read_reg(adapter
, reg
->fw_status
, &fw_status
)) {
391 mwifiex_dbg(adapter
, ERROR
,
392 "Reading fw_status register failed\n");
396 if (reg
->sleep_cookie
) {
397 mwifiex_pcie_dev_wakeup_delay(adapter
);
398 mwifiex_dbg(adapter
, INFO
,
399 "PCIE wakeup: Setting PS_STATE_AWAKE\n");
400 adapter
->ps_state
= PS_STATE_AWAKE
;
407 * This function is called after the card has woken up.
409 * The card configuration register is reset.
411 static int mwifiex_pm_wakeup_card_complete(struct mwifiex_adapter
*adapter
)
413 mwifiex_dbg(adapter
, CMD
,
414 "cmd: Wakeup device completed\n");
420 * This function disables the host interrupt.
422 * The host interrupt mask is read, the disable bit is reset and
423 * written back to the card host interrupt mask register.
425 static int mwifiex_pcie_disable_host_int(struct mwifiex_adapter
*adapter
)
427 if (mwifiex_pcie_ok_to_access_hw(adapter
)) {
428 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_MASK
,
430 mwifiex_dbg(adapter
, ERROR
,
431 "Disable host interrupt failed\n");
440 * This function enables the host interrupt.
442 * The host interrupt enable mask is written to the card
443 * host interrupt mask register.
445 static int mwifiex_pcie_enable_host_int(struct mwifiex_adapter
*adapter
)
447 if (mwifiex_pcie_ok_to_access_hw(adapter
)) {
448 /* Simply write the mask to the register */
449 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_MASK
,
451 mwifiex_dbg(adapter
, ERROR
,
452 "Enable host interrupt failed\n");
461 * This function initializes TX buffer ring descriptors
463 static int mwifiex_init_txq_ring(struct mwifiex_adapter
*adapter
)
465 struct pcie_service_card
*card
= adapter
->card
;
466 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
467 struct mwifiex_pcie_buf_desc
*desc
;
468 struct mwifiex_pfu_buf_desc
*desc2
;
471 for (i
= 0; i
< MWIFIEX_MAX_TXRX_BD
; i
++) {
472 card
->tx_buf_list
[i
] = NULL
;
473 if (reg
->pfu_enabled
) {
474 card
->txbd_ring
[i
] = (void *)card
->txbd_ring_vbase
+
475 (sizeof(*desc2
) * i
);
476 desc2
= card
->txbd_ring
[i
];
477 memset(desc2
, 0, sizeof(*desc2
));
479 card
->txbd_ring
[i
] = (void *)card
->txbd_ring_vbase
+
481 desc
= card
->txbd_ring
[i
];
482 memset(desc
, 0, sizeof(*desc
));
489 /* This function initializes RX buffer ring descriptors. Each SKB is allocated
490 * here and after mapping PCI memory, its physical address is assigned to
491 * PCIE Rx buffer descriptor's physical address.
493 static int mwifiex_init_rxq_ring(struct mwifiex_adapter
*adapter
)
495 struct pcie_service_card
*card
= adapter
->card
;
496 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
498 struct mwifiex_pcie_buf_desc
*desc
;
499 struct mwifiex_pfu_buf_desc
*desc2
;
503 for (i
= 0; i
< MWIFIEX_MAX_TXRX_BD
; i
++) {
504 /* Allocate skb here so that firmware can DMA data from it */
505 skb
= mwifiex_alloc_dma_align_buf(MWIFIEX_RX_DATA_BUF_SIZE
,
506 GFP_KERNEL
| GFP_DMA
);
508 mwifiex_dbg(adapter
, ERROR
,
509 "Unable to allocate skb for RX ring.\n");
510 kfree(card
->rxbd_ring_vbase
);
514 if (mwifiex_map_pci_memory(adapter
, skb
,
515 MWIFIEX_RX_DATA_BUF_SIZE
,
519 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb
);
521 mwifiex_dbg(adapter
, INFO
,
522 "info: RX ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
523 skb
, skb
->len
, skb
->data
, (u32
)buf_pa
,
524 (u32
)((u64
)buf_pa
>> 32));
526 card
->rx_buf_list
[i
] = skb
;
527 if (reg
->pfu_enabled
) {
528 card
->rxbd_ring
[i
] = (void *)card
->rxbd_ring_vbase
+
529 (sizeof(*desc2
) * i
);
530 desc2
= card
->rxbd_ring
[i
];
531 desc2
->paddr
= buf_pa
;
532 desc2
->len
= (u16
)skb
->len
;
533 desc2
->frag_len
= (u16
)skb
->len
;
534 desc2
->flags
= reg
->ring_flag_eop
| reg
->ring_flag_sop
;
537 card
->rxbd_ring
[i
] = (void *)(card
->rxbd_ring_vbase
+
538 (sizeof(*desc
) * i
));
539 desc
= card
->rxbd_ring
[i
];
540 desc
->paddr
= buf_pa
;
541 desc
->len
= (u16
)skb
->len
;
549 /* This function initializes event buffer ring descriptors. Each SKB is
550 * allocated here and after mapping PCI memory, its physical address is assigned
551 * to PCIE Rx buffer descriptor's physical address
553 static int mwifiex_pcie_init_evt_ring(struct mwifiex_adapter
*adapter
)
555 struct pcie_service_card
*card
= adapter
->card
;
556 struct mwifiex_evt_buf_desc
*desc
;
561 for (i
= 0; i
< MWIFIEX_MAX_EVT_BD
; i
++) {
562 /* Allocate skb here so that firmware can DMA data from it */
563 skb
= dev_alloc_skb(MAX_EVENT_SIZE
);
565 mwifiex_dbg(adapter
, ERROR
,
566 "Unable to allocate skb for EVENT buf.\n");
567 kfree(card
->evtbd_ring_vbase
);
570 skb_put(skb
, MAX_EVENT_SIZE
);
572 if (mwifiex_map_pci_memory(adapter
, skb
, MAX_EVENT_SIZE
,
576 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb
);
578 mwifiex_dbg(adapter
, EVENT
,
579 "info: EVT ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
580 skb
, skb
->len
, skb
->data
, (u32
)buf_pa
,
581 (u32
)((u64
)buf_pa
>> 32));
583 card
->evt_buf_list
[i
] = skb
;
584 card
->evtbd_ring
[i
] = (void *)(card
->evtbd_ring_vbase
+
585 (sizeof(*desc
) * i
));
586 desc
= card
->evtbd_ring
[i
];
587 desc
->paddr
= buf_pa
;
588 desc
->len
= (u16
)skb
->len
;
595 /* This function cleans up TX buffer rings. If any of the buffer list has valid
596 * SKB address, associated SKB is freed.
598 static void mwifiex_cleanup_txq_ring(struct mwifiex_adapter
*adapter
)
600 struct pcie_service_card
*card
= adapter
->card
;
601 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
603 struct mwifiex_pcie_buf_desc
*desc
;
604 struct mwifiex_pfu_buf_desc
*desc2
;
607 for (i
= 0; i
< MWIFIEX_MAX_TXRX_BD
; i
++) {
608 if (reg
->pfu_enabled
) {
609 desc2
= card
->txbd_ring
[i
];
610 if (card
->tx_buf_list
[i
]) {
611 skb
= card
->tx_buf_list
[i
];
612 mwifiex_unmap_pci_memory(adapter
, skb
,
614 dev_kfree_skb_any(skb
);
616 memset(desc2
, 0, sizeof(*desc2
));
618 desc
= card
->txbd_ring
[i
];
619 if (card
->tx_buf_list
[i
]) {
620 skb
= card
->tx_buf_list
[i
];
621 mwifiex_unmap_pci_memory(adapter
, skb
,
623 dev_kfree_skb_any(skb
);
625 memset(desc
, 0, sizeof(*desc
));
627 card
->tx_buf_list
[i
] = NULL
;
633 /* This function cleans up RX buffer rings. If any of the buffer list has valid
634 * SKB address, associated SKB is freed.
636 static void mwifiex_cleanup_rxq_ring(struct mwifiex_adapter
*adapter
)
638 struct pcie_service_card
*card
= adapter
->card
;
639 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
640 struct mwifiex_pcie_buf_desc
*desc
;
641 struct mwifiex_pfu_buf_desc
*desc2
;
645 for (i
= 0; i
< MWIFIEX_MAX_TXRX_BD
; i
++) {
646 if (reg
->pfu_enabled
) {
647 desc2
= card
->rxbd_ring
[i
];
648 if (card
->rx_buf_list
[i
]) {
649 skb
= card
->rx_buf_list
[i
];
650 mwifiex_unmap_pci_memory(adapter
, skb
,
652 dev_kfree_skb_any(skb
);
654 memset(desc2
, 0, sizeof(*desc2
));
656 desc
= card
->rxbd_ring
[i
];
657 if (card
->rx_buf_list
[i
]) {
658 skb
= card
->rx_buf_list
[i
];
659 mwifiex_unmap_pci_memory(adapter
, skb
,
661 dev_kfree_skb_any(skb
);
663 memset(desc
, 0, sizeof(*desc
));
665 card
->rx_buf_list
[i
] = NULL
;
671 /* This function cleans up event buffer rings. If any of the buffer list has
672 * valid SKB address, associated SKB is freed.
674 static void mwifiex_cleanup_evt_ring(struct mwifiex_adapter
*adapter
)
676 struct pcie_service_card
*card
= adapter
->card
;
677 struct mwifiex_evt_buf_desc
*desc
;
681 for (i
= 0; i
< MWIFIEX_MAX_EVT_BD
; i
++) {
682 desc
= card
->evtbd_ring
[i
];
683 if (card
->evt_buf_list
[i
]) {
684 skb
= card
->evt_buf_list
[i
];
685 mwifiex_unmap_pci_memory(adapter
, skb
,
687 dev_kfree_skb_any(skb
);
689 card
->evt_buf_list
[i
] = NULL
;
690 memset(desc
, 0, sizeof(*desc
));
696 /* This function creates buffer descriptor ring for TX
698 static int mwifiex_pcie_create_txbd_ring(struct mwifiex_adapter
*adapter
)
700 struct pcie_service_card
*card
= adapter
->card
;
701 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
704 * driver maintaines the write pointer and firmware maintaines the read
705 * pointer. The write pointer starts at 0 (zero) while the read pointer
706 * starts at zero with rollover bit set
708 card
->txbd_wrptr
= 0;
710 if (reg
->pfu_enabled
)
711 card
->txbd_rdptr
= 0;
713 card
->txbd_rdptr
|= reg
->tx_rollover_ind
;
715 /* allocate shared memory for the BD ring and divide the same in to
716 several descriptors */
717 if (reg
->pfu_enabled
)
718 card
->txbd_ring_size
= sizeof(struct mwifiex_pfu_buf_desc
) *
721 card
->txbd_ring_size
= sizeof(struct mwifiex_pcie_buf_desc
) *
724 mwifiex_dbg(adapter
, INFO
,
725 "info: txbd_ring: Allocating %d bytes\n",
726 card
->txbd_ring_size
);
727 card
->txbd_ring_vbase
= pci_alloc_consistent(card
->dev
,
728 card
->txbd_ring_size
,
729 &card
->txbd_ring_pbase
);
730 if (!card
->txbd_ring_vbase
) {
731 mwifiex_dbg(adapter
, ERROR
,
732 "allocate consistent memory (%d bytes) failed!\n",
733 card
->txbd_ring_size
);
736 mwifiex_dbg(adapter
, DATA
,
737 "info: txbd_ring - base: %p, pbase: %#x:%x, len: %x\n",
738 card
->txbd_ring_vbase
, (unsigned int)card
->txbd_ring_pbase
,
739 (u32
)((u64
)card
->txbd_ring_pbase
>> 32),
740 card
->txbd_ring_size
);
742 return mwifiex_init_txq_ring(adapter
);
745 static int mwifiex_pcie_delete_txbd_ring(struct mwifiex_adapter
*adapter
)
747 struct pcie_service_card
*card
= adapter
->card
;
748 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
750 mwifiex_cleanup_txq_ring(adapter
);
752 if (card
->txbd_ring_vbase
)
753 pci_free_consistent(card
->dev
, card
->txbd_ring_size
,
754 card
->txbd_ring_vbase
,
755 card
->txbd_ring_pbase
);
756 card
->txbd_ring_size
= 0;
757 card
->txbd_wrptr
= 0;
758 card
->txbd_rdptr
= 0 | reg
->tx_rollover_ind
;
759 card
->txbd_ring_vbase
= NULL
;
760 card
->txbd_ring_pbase
= 0;
766 * This function creates buffer descriptor ring for RX
768 static int mwifiex_pcie_create_rxbd_ring(struct mwifiex_adapter
*adapter
)
770 struct pcie_service_card
*card
= adapter
->card
;
771 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
774 * driver maintaines the read pointer and firmware maintaines the write
775 * pointer. The write pointer starts at 0 (zero) while the read pointer
776 * starts at zero with rollover bit set
778 card
->rxbd_wrptr
= 0;
779 card
->rxbd_rdptr
= reg
->rx_rollover_ind
;
781 if (reg
->pfu_enabled
)
782 card
->rxbd_ring_size
= sizeof(struct mwifiex_pfu_buf_desc
) *
785 card
->rxbd_ring_size
= sizeof(struct mwifiex_pcie_buf_desc
) *
788 mwifiex_dbg(adapter
, INFO
,
789 "info: rxbd_ring: Allocating %d bytes\n",
790 card
->rxbd_ring_size
);
791 card
->rxbd_ring_vbase
= pci_alloc_consistent(card
->dev
,
792 card
->rxbd_ring_size
,
793 &card
->rxbd_ring_pbase
);
794 if (!card
->rxbd_ring_vbase
) {
795 mwifiex_dbg(adapter
, ERROR
,
796 "allocate consistent memory (%d bytes) failed!\n",
797 card
->rxbd_ring_size
);
801 mwifiex_dbg(adapter
, DATA
,
802 "info: rxbd_ring - base: %p, pbase: %#x:%x, len: %#x\n",
803 card
->rxbd_ring_vbase
, (u32
)card
->rxbd_ring_pbase
,
804 (u32
)((u64
)card
->rxbd_ring_pbase
>> 32),
805 card
->rxbd_ring_size
);
807 return mwifiex_init_rxq_ring(adapter
);
811 * This function deletes Buffer descriptor ring for RX
813 static int mwifiex_pcie_delete_rxbd_ring(struct mwifiex_adapter
*adapter
)
815 struct pcie_service_card
*card
= adapter
->card
;
816 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
818 mwifiex_cleanup_rxq_ring(adapter
);
820 if (card
->rxbd_ring_vbase
)
821 pci_free_consistent(card
->dev
, card
->rxbd_ring_size
,
822 card
->rxbd_ring_vbase
,
823 card
->rxbd_ring_pbase
);
824 card
->rxbd_ring_size
= 0;
825 card
->rxbd_wrptr
= 0;
826 card
->rxbd_rdptr
= 0 | reg
->rx_rollover_ind
;
827 card
->rxbd_ring_vbase
= NULL
;
828 card
->rxbd_ring_pbase
= 0;
834 * This function creates buffer descriptor ring for Events
836 static int mwifiex_pcie_create_evtbd_ring(struct mwifiex_adapter
*adapter
)
838 struct pcie_service_card
*card
= adapter
->card
;
839 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
842 * driver maintaines the read pointer and firmware maintaines the write
843 * pointer. The write pointer starts at 0 (zero) while the read pointer
844 * starts at zero with rollover bit set
846 card
->evtbd_wrptr
= 0;
847 card
->evtbd_rdptr
= reg
->evt_rollover_ind
;
849 card
->evtbd_ring_size
= sizeof(struct mwifiex_evt_buf_desc
) *
852 mwifiex_dbg(adapter
, INFO
,
853 "info: evtbd_ring: Allocating %d bytes\n",
854 card
->evtbd_ring_size
);
855 card
->evtbd_ring_vbase
= pci_alloc_consistent(card
->dev
,
856 card
->evtbd_ring_size
,
857 &card
->evtbd_ring_pbase
);
858 if (!card
->evtbd_ring_vbase
) {
859 mwifiex_dbg(adapter
, ERROR
,
860 "allocate consistent memory (%d bytes) failed!\n",
861 card
->evtbd_ring_size
);
865 mwifiex_dbg(adapter
, EVENT
,
866 "info: CMDRSP/EVT bd_ring - base: %p pbase: %#x:%x len: %#x\n",
867 card
->evtbd_ring_vbase
, (u32
)card
->evtbd_ring_pbase
,
868 (u32
)((u64
)card
->evtbd_ring_pbase
>> 32),
869 card
->evtbd_ring_size
);
871 return mwifiex_pcie_init_evt_ring(adapter
);
875 * This function deletes Buffer descriptor ring for Events
877 static int mwifiex_pcie_delete_evtbd_ring(struct mwifiex_adapter
*adapter
)
879 struct pcie_service_card
*card
= adapter
->card
;
880 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
882 mwifiex_cleanup_evt_ring(adapter
);
884 if (card
->evtbd_ring_vbase
)
885 pci_free_consistent(card
->dev
, card
->evtbd_ring_size
,
886 card
->evtbd_ring_vbase
,
887 card
->evtbd_ring_pbase
);
888 card
->evtbd_wrptr
= 0;
889 card
->evtbd_rdptr
= 0 | reg
->evt_rollover_ind
;
890 card
->evtbd_ring_size
= 0;
891 card
->evtbd_ring_vbase
= NULL
;
892 card
->evtbd_ring_pbase
= 0;
898 * This function allocates a buffer for CMDRSP
900 static int mwifiex_pcie_alloc_cmdrsp_buf(struct mwifiex_adapter
*adapter
)
902 struct pcie_service_card
*card
= adapter
->card
;
905 /* Allocate memory for receiving command response data */
906 skb
= dev_alloc_skb(MWIFIEX_UPLD_SIZE
);
908 mwifiex_dbg(adapter
, ERROR
,
909 "Unable to allocate skb for command response data.\n");
912 skb_put(skb
, MWIFIEX_UPLD_SIZE
);
913 if (mwifiex_map_pci_memory(adapter
, skb
, MWIFIEX_UPLD_SIZE
,
917 card
->cmdrsp_buf
= skb
;
923 * This function deletes a buffer for CMDRSP
925 static int mwifiex_pcie_delete_cmdrsp_buf(struct mwifiex_adapter
*adapter
)
927 struct pcie_service_card
*card
;
932 card
= adapter
->card
;
934 if (card
&& card
->cmdrsp_buf
) {
935 mwifiex_unmap_pci_memory(adapter
, card
->cmdrsp_buf
,
937 dev_kfree_skb_any(card
->cmdrsp_buf
);
940 if (card
&& card
->cmd_buf
) {
941 mwifiex_unmap_pci_memory(adapter
, card
->cmd_buf
,
948 * This function allocates a buffer for sleep cookie
950 static int mwifiex_pcie_alloc_sleep_cookie_buf(struct mwifiex_adapter
*adapter
)
952 struct pcie_service_card
*card
= adapter
->card
;
954 card
->sleep_cookie_vbase
= pci_alloc_consistent(card
->dev
, sizeof(u32
),
955 &card
->sleep_cookie_pbase
);
956 if (!card
->sleep_cookie_vbase
) {
957 mwifiex_dbg(adapter
, ERROR
,
958 "pci_alloc_consistent failed!\n");
961 /* Init val of Sleep Cookie */
962 *(u32
*)card
->sleep_cookie_vbase
= FW_AWAKE_COOKIE
;
964 mwifiex_dbg(adapter
, INFO
,
965 "alloc_scook: sleep cookie=0x%x\n",
966 *((u32
*)card
->sleep_cookie_vbase
));
972 * This function deletes buffer for sleep cookie
974 static int mwifiex_pcie_delete_sleep_cookie_buf(struct mwifiex_adapter
*adapter
)
976 struct pcie_service_card
*card
;
981 card
= adapter
->card
;
983 if (card
&& card
->sleep_cookie_vbase
) {
984 pci_free_consistent(card
->dev
, sizeof(u32
),
985 card
->sleep_cookie_vbase
,
986 card
->sleep_cookie_pbase
);
987 card
->sleep_cookie_vbase
= NULL
;
993 /* This function flushes the TX buffer descriptor ring
994 * This function defined as handler is also called while cleaning TXRX
995 * during disconnect/ bss stop.
997 static int mwifiex_clean_pcie_ring_buf(struct mwifiex_adapter
*adapter
)
999 struct pcie_service_card
*card
= adapter
->card
;
1001 if (!mwifiex_pcie_txbd_empty(card
, card
->txbd_rdptr
)) {
1002 card
->txbd_flush
= 1;
1003 /* write pointer already set at last send
1004 * send dnld-rdy intr again, wait for completion.
1006 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1007 CPU_INTR_DNLD_RDY
)) {
1008 mwifiex_dbg(adapter
, ERROR
,
1009 "failed to assert dnld-rdy interrupt.\n");
1017 * This function unmaps and frees downloaded data buffer
1019 static int mwifiex_pcie_send_data_complete(struct mwifiex_adapter
*adapter
)
1021 struct sk_buff
*skb
;
1022 u32 wrdoneidx
, rdptr
, num_tx_buffs
, unmap_count
= 0;
1023 struct mwifiex_pcie_buf_desc
*desc
;
1024 struct mwifiex_pfu_buf_desc
*desc2
;
1025 struct pcie_service_card
*card
= adapter
->card
;
1026 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1028 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1029 mwifiex_pm_wakeup_card(adapter
);
1031 /* Read the TX ring read pointer set by firmware */
1032 if (mwifiex_read_reg(adapter
, reg
->tx_rdptr
, &rdptr
)) {
1033 mwifiex_dbg(adapter
, ERROR
,
1034 "SEND COMP: failed to read reg->tx_rdptr\n");
1038 mwifiex_dbg(adapter
, DATA
,
1039 "SEND COMP: rdptr_prev=0x%x, rdptr=0x%x\n",
1040 card
->txbd_rdptr
, rdptr
);
1042 num_tx_buffs
= MWIFIEX_MAX_TXRX_BD
<< reg
->tx_start_ptr
;
1043 /* free from previous txbd_rdptr to current txbd_rdptr */
1044 while (((card
->txbd_rdptr
& reg
->tx_mask
) !=
1045 (rdptr
& reg
->tx_mask
)) ||
1046 ((card
->txbd_rdptr
& reg
->tx_rollover_ind
) !=
1047 (rdptr
& reg
->tx_rollover_ind
))) {
1048 wrdoneidx
= (card
->txbd_rdptr
& reg
->tx_mask
) >>
1051 skb
= card
->tx_buf_list
[wrdoneidx
];
1054 mwifiex_dbg(adapter
, DATA
,
1055 "SEND COMP: Detach skb %p at txbd_rdidx=%d\n",
1057 mwifiex_unmap_pci_memory(adapter
, skb
,
1062 if (card
->txbd_flush
)
1063 mwifiex_write_data_complete(adapter
, skb
, 0,
1066 mwifiex_write_data_complete(adapter
, skb
, 0, 0);
1069 card
->tx_buf_list
[wrdoneidx
] = NULL
;
1071 if (reg
->pfu_enabled
) {
1072 desc2
= card
->txbd_ring
[wrdoneidx
];
1073 memset(desc2
, 0, sizeof(*desc2
));
1075 desc
= card
->txbd_ring
[wrdoneidx
];
1076 memset(desc
, 0, sizeof(*desc
));
1078 switch (card
->dev
->device
) {
1079 case PCIE_DEVICE_ID_MARVELL_88W8766P
:
1082 case PCIE_DEVICE_ID_MARVELL_88W8897
:
1083 case PCIE_DEVICE_ID_MARVELL_88W8997
:
1084 card
->txbd_rdptr
+= reg
->ring_tx_start_ptr
;
1089 if ((card
->txbd_rdptr
& reg
->tx_mask
) == num_tx_buffs
)
1090 card
->txbd_rdptr
= ((card
->txbd_rdptr
&
1091 reg
->tx_rollover_ind
) ^
1092 reg
->tx_rollover_ind
);
1096 adapter
->data_sent
= false;
1098 if (card
->txbd_flush
) {
1099 if (mwifiex_pcie_txbd_empty(card
, card
->txbd_rdptr
))
1100 card
->txbd_flush
= 0;
1102 mwifiex_clean_pcie_ring_buf(adapter
);
1108 /* This function sends data buffer to device. First 4 bytes of payload
1109 * are filled with payload length and payload type. Then this payload
1110 * is mapped to PCI device memory. Tx ring pointers are advanced accordingly.
1111 * Download ready interrupt to FW is deffered if Tx ring is not full and
1112 * additional payload can be accomodated.
1113 * Caller must ensure tx_param parameter to this function is not NULL.
1116 mwifiex_pcie_send_data(struct mwifiex_adapter
*adapter
, struct sk_buff
*skb
,
1117 struct mwifiex_tx_param
*tx_param
)
1119 struct pcie_service_card
*card
= adapter
->card
;
1120 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1121 u32 wrindx
, num_tx_buffs
, rx_val
;
1124 struct mwifiex_pcie_buf_desc
*desc
= NULL
;
1125 struct mwifiex_pfu_buf_desc
*desc2
= NULL
;
1128 if (!(skb
->data
&& skb
->len
)) {
1129 mwifiex_dbg(adapter
, ERROR
,
1130 "%s(): invalid parameter <%p, %#x>\n",
1131 __func__
, skb
->data
, skb
->len
);
1135 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1136 mwifiex_pm_wakeup_card(adapter
);
1138 num_tx_buffs
= MWIFIEX_MAX_TXRX_BD
<< reg
->tx_start_ptr
;
1139 mwifiex_dbg(adapter
, DATA
,
1140 "info: SEND DATA: <Rd: %#x, Wr: %#x>\n",
1141 card
->txbd_rdptr
, card
->txbd_wrptr
);
1142 if (mwifiex_pcie_txbd_not_full(card
)) {
1145 adapter
->data_sent
= true;
1146 payload
= skb
->data
;
1147 tmp
= (__le16
*)&payload
[0];
1148 *tmp
= cpu_to_le16((u16
)skb
->len
);
1149 tmp
= (__le16
*)&payload
[2];
1150 *tmp
= cpu_to_le16(MWIFIEX_TYPE_DATA
);
1152 if (mwifiex_map_pci_memory(adapter
, skb
, skb
->len
,
1156 wrindx
= (card
->txbd_wrptr
& reg
->tx_mask
) >> reg
->tx_start_ptr
;
1157 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb
);
1158 card
->tx_buf_list
[wrindx
] = skb
;
1160 if (reg
->pfu_enabled
) {
1161 desc2
= card
->txbd_ring
[wrindx
];
1162 desc2
->paddr
= buf_pa
;
1163 desc2
->len
= (u16
)skb
->len
;
1164 desc2
->frag_len
= (u16
)skb
->len
;
1166 desc2
->flags
= MWIFIEX_BD_FLAG_FIRST_DESC
|
1167 MWIFIEX_BD_FLAG_LAST_DESC
;
1169 desc
= card
->txbd_ring
[wrindx
];
1170 desc
->paddr
= buf_pa
;
1171 desc
->len
= (u16
)skb
->len
;
1172 desc
->flags
= MWIFIEX_BD_FLAG_FIRST_DESC
|
1173 MWIFIEX_BD_FLAG_LAST_DESC
;
1176 switch (card
->dev
->device
) {
1177 case PCIE_DEVICE_ID_MARVELL_88W8766P
:
1180 case PCIE_DEVICE_ID_MARVELL_88W8897
:
1181 case PCIE_DEVICE_ID_MARVELL_88W8997
:
1182 card
->txbd_wrptr
+= reg
->ring_tx_start_ptr
;
1186 if ((card
->txbd_wrptr
& reg
->tx_mask
) == num_tx_buffs
)
1187 card
->txbd_wrptr
= ((card
->txbd_wrptr
&
1188 reg
->tx_rollover_ind
) ^
1189 reg
->tx_rollover_ind
);
1191 rx_val
= card
->rxbd_rdptr
& reg
->rx_wrap_mask
;
1192 /* Write the TX ring write pointer in to reg->tx_wrptr */
1193 if (mwifiex_write_reg(adapter
, reg
->tx_wrptr
,
1194 card
->txbd_wrptr
| rx_val
)) {
1195 mwifiex_dbg(adapter
, ERROR
,
1196 "SEND DATA: failed to write reg->tx_wrptr\n");
1200 if ((mwifiex_pcie_txbd_not_full(card
)) &&
1201 tx_param
->next_pkt_len
) {
1202 /* have more packets and TxBD still can hold more */
1203 mwifiex_dbg(adapter
, DATA
,
1204 "SEND DATA: delay dnld-rdy interrupt.\n");
1205 adapter
->data_sent
= false;
1207 /* Send the TX ready interrupt */
1208 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1209 CPU_INTR_DNLD_RDY
)) {
1210 mwifiex_dbg(adapter
, ERROR
,
1211 "SEND DATA: failed to assert dnld-rdy interrupt.\n");
1216 mwifiex_dbg(adapter
, DATA
,
1217 "info: SEND DATA: Updated <Rd: %#x, Wr:\t"
1218 "%#x> and sent packet to firmware successfully\n",
1219 card
->txbd_rdptr
, card
->txbd_wrptr
);
1221 mwifiex_dbg(adapter
, DATA
,
1222 "info: TX Ring full, can't send packets to fw\n");
1223 adapter
->data_sent
= true;
1224 /* Send the TX ready interrupt */
1225 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1227 mwifiex_dbg(adapter
, ERROR
,
1228 "SEND DATA: failed to assert door-bell intr\n");
1232 return -EINPROGRESS
;
1234 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1235 card
->tx_buf_list
[wrindx
] = NULL
;
1236 if (reg
->pfu_enabled
)
1237 memset(desc2
, 0, sizeof(*desc2
));
1239 memset(desc
, 0, sizeof(*desc
));
1245 * This function handles received buffer ring and
1246 * dispatches packets to upper
1248 static int mwifiex_pcie_process_recv_data(struct mwifiex_adapter
*adapter
)
1250 struct pcie_service_card
*card
= adapter
->card
;
1251 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1252 u32 wrptr
, rd_index
, tx_val
;
1255 struct sk_buff
*skb_tmp
= NULL
;
1256 struct mwifiex_pcie_buf_desc
*desc
;
1257 struct mwifiex_pfu_buf_desc
*desc2
;
1259 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1260 mwifiex_pm_wakeup_card(adapter
);
1262 /* Read the RX ring Write pointer set by firmware */
1263 if (mwifiex_read_reg(adapter
, reg
->rx_wrptr
, &wrptr
)) {
1264 mwifiex_dbg(adapter
, ERROR
,
1265 "RECV DATA: failed to read reg->rx_wrptr\n");
1269 card
->rxbd_wrptr
= wrptr
;
1271 while (((wrptr
& reg
->rx_mask
) !=
1272 (card
->rxbd_rdptr
& reg
->rx_mask
)) ||
1273 ((wrptr
& reg
->rx_rollover_ind
) ==
1274 (card
->rxbd_rdptr
& reg
->rx_rollover_ind
))) {
1275 struct sk_buff
*skb_data
;
1279 rd_index
= card
->rxbd_rdptr
& reg
->rx_mask
;
1280 skb_data
= card
->rx_buf_list
[rd_index
];
1282 /* If skb allocation was failed earlier for Rx packet,
1283 * rx_buf_list[rd_index] would have been left with a NULL.
1288 mwifiex_unmap_pci_memory(adapter
, skb_data
, PCI_DMA_FROMDEVICE
);
1289 card
->rx_buf_list
[rd_index
] = NULL
;
1291 /* Get data length from interface header -
1292 * first 2 bytes for len, next 2 bytes is for type
1294 pkt_len
= *((__le16
*)skb_data
->data
);
1295 rx_len
= le16_to_cpu(pkt_len
);
1296 if (WARN_ON(rx_len
<= INTF_HEADER_LEN
||
1297 rx_len
> MWIFIEX_RX_DATA_BUF_SIZE
)) {
1298 mwifiex_dbg(adapter
, ERROR
,
1299 "Invalid RX len %d, Rd=%#x, Wr=%#x\n",
1300 rx_len
, card
->rxbd_rdptr
, wrptr
);
1301 dev_kfree_skb_any(skb_data
);
1303 skb_put(skb_data
, rx_len
);
1304 mwifiex_dbg(adapter
, DATA
,
1305 "info: RECV DATA: Rd=%#x, Wr=%#x, Len=%d\n",
1306 card
->rxbd_rdptr
, wrptr
, rx_len
);
1307 skb_pull(skb_data
, INTF_HEADER_LEN
);
1308 if (adapter
->rx_work_enabled
) {
1309 skb_queue_tail(&adapter
->rx_data_q
, skb_data
);
1310 adapter
->data_received
= true;
1311 atomic_inc(&adapter
->rx_pending
);
1313 mwifiex_handle_rx_packet(adapter
, skb_data
);
1317 skb_tmp
= mwifiex_alloc_dma_align_buf(MWIFIEX_RX_DATA_BUF_SIZE
,
1318 GFP_KERNEL
| GFP_DMA
);
1320 mwifiex_dbg(adapter
, ERROR
,
1321 "Unable to allocate skb.\n");
1325 if (mwifiex_map_pci_memory(adapter
, skb_tmp
,
1326 MWIFIEX_RX_DATA_BUF_SIZE
,
1327 PCI_DMA_FROMDEVICE
))
1330 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb_tmp
);
1332 mwifiex_dbg(adapter
, INFO
,
1333 "RECV DATA: Attach new sk_buff %p at rxbd_rdidx=%d\n",
1335 card
->rx_buf_list
[rd_index
] = skb_tmp
;
1337 if (reg
->pfu_enabled
) {
1338 desc2
= card
->rxbd_ring
[rd_index
];
1339 desc2
->paddr
= buf_pa
;
1340 desc2
->len
= skb_tmp
->len
;
1341 desc2
->frag_len
= skb_tmp
->len
;
1343 desc2
->flags
= reg
->ring_flag_sop
| reg
->ring_flag_eop
;
1345 desc
= card
->rxbd_ring
[rd_index
];
1346 desc
->paddr
= buf_pa
;
1347 desc
->len
= skb_tmp
->len
;
1351 if ((++card
->rxbd_rdptr
& reg
->rx_mask
) ==
1352 MWIFIEX_MAX_TXRX_BD
) {
1353 card
->rxbd_rdptr
= ((card
->rxbd_rdptr
&
1354 reg
->rx_rollover_ind
) ^
1355 reg
->rx_rollover_ind
);
1357 mwifiex_dbg(adapter
, DATA
,
1358 "info: RECV DATA: <Rd: %#x, Wr: %#x>\n",
1359 card
->rxbd_rdptr
, wrptr
);
1361 tx_val
= card
->txbd_wrptr
& reg
->tx_wrap_mask
;
1362 /* Write the RX ring read pointer in to reg->rx_rdptr */
1363 if (mwifiex_write_reg(adapter
, reg
->rx_rdptr
,
1364 card
->rxbd_rdptr
| tx_val
)) {
1365 mwifiex_dbg(adapter
, DATA
,
1366 "RECV DATA: failed to write reg->rx_rdptr\n");
1371 /* Read the RX ring Write pointer set by firmware */
1372 if (mwifiex_read_reg(adapter
, reg
->rx_wrptr
, &wrptr
)) {
1373 mwifiex_dbg(adapter
, ERROR
,
1374 "RECV DATA: failed to read reg->rx_wrptr\n");
1378 mwifiex_dbg(adapter
, DATA
,
1379 "info: RECV DATA: Rcvd packet from fw successfully\n");
1380 card
->rxbd_wrptr
= wrptr
;
1388 * This function downloads the boot command to device
1391 mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter
*adapter
, struct sk_buff
*skb
)
1394 struct pcie_service_card
*card
= adapter
->card
;
1395 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1397 if (!(skb
->data
&& skb
->len
)) {
1398 mwifiex_dbg(adapter
, ERROR
,
1399 "Invalid parameter in %s <%p. len %d>\n",
1400 __func__
, skb
->data
, skb
->len
);
1404 if (mwifiex_map_pci_memory(adapter
, skb
, skb
->len
, PCI_DMA_TODEVICE
))
1407 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb
);
1409 /* Write the lower 32bits of the physical address to low command
1410 * address scratch register
1412 if (mwifiex_write_reg(adapter
, reg
->cmd_addr_lo
, (u32
)buf_pa
)) {
1413 mwifiex_dbg(adapter
, ERROR
,
1414 "%s: failed to write download command to boot code.\n",
1416 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1420 /* Write the upper 32bits of the physical address to high command
1421 * address scratch register
1423 if (mwifiex_write_reg(adapter
, reg
->cmd_addr_hi
,
1424 (u32
)((u64
)buf_pa
>> 32))) {
1425 mwifiex_dbg(adapter
, ERROR
,
1426 "%s: failed to write download command to boot code.\n",
1428 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1432 /* Write the command length to cmd_size scratch register */
1433 if (mwifiex_write_reg(adapter
, reg
->cmd_size
, skb
->len
)) {
1434 mwifiex_dbg(adapter
, ERROR
,
1435 "%s: failed to write command len to cmd_size scratch reg\n",
1437 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1441 /* Ring the door bell */
1442 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1443 CPU_INTR_DOOR_BELL
)) {
1444 mwifiex_dbg(adapter
, ERROR
,
1445 "%s: failed to assert door-bell intr\n", __func__
);
1446 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1453 /* This function init rx port in firmware which in turn enables to receive data
1454 * from device before transmitting any packet.
1456 static int mwifiex_pcie_init_fw_port(struct mwifiex_adapter
*adapter
)
1458 struct pcie_service_card
*card
= adapter
->card
;
1459 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1460 int tx_wrap
= card
->txbd_wrptr
& reg
->tx_wrap_mask
;
1462 /* Write the RX ring read pointer in to reg->rx_rdptr */
1463 if (mwifiex_write_reg(adapter
, reg
->rx_rdptr
, card
->rxbd_rdptr
|
1465 mwifiex_dbg(adapter
, ERROR
,
1466 "RECV DATA: failed to write reg->rx_rdptr\n");
1472 /* This function downloads commands to the device
1475 mwifiex_pcie_send_cmd(struct mwifiex_adapter
*adapter
, struct sk_buff
*skb
)
1477 struct pcie_service_card
*card
= adapter
->card
;
1478 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1480 dma_addr_t cmd_buf_pa
, cmdrsp_buf_pa
;
1481 u8
*payload
= (u8
*)skb
->data
;
1483 if (!(skb
->data
&& skb
->len
)) {
1484 mwifiex_dbg(adapter
, ERROR
,
1485 "Invalid parameter in %s <%p, %#x>\n",
1486 __func__
, skb
->data
, skb
->len
);
1490 /* Make sure a command response buffer is available */
1491 if (!card
->cmdrsp_buf
) {
1492 mwifiex_dbg(adapter
, ERROR
,
1493 "No response buffer available, send command failed\n");
1497 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1498 mwifiex_pm_wakeup_card(adapter
);
1500 adapter
->cmd_sent
= true;
1502 *(__le16
*)&payload
[0] = cpu_to_le16((u16
)skb
->len
);
1503 *(__le16
*)&payload
[2] = cpu_to_le16(MWIFIEX_TYPE_CMD
);
1505 if (mwifiex_map_pci_memory(adapter
, skb
, skb
->len
, PCI_DMA_TODEVICE
))
1508 card
->cmd_buf
= skb
;
1510 /* To send a command, the driver will:
1511 1. Write the 64bit physical address of the data buffer to
1512 cmd response address low + cmd response address high
1513 2. Ring the door bell (i.e. set the door bell interrupt)
1515 In response to door bell interrupt, the firmware will perform
1516 the DMA of the command packet (first header to obtain the total
1517 length and then rest of the command).
1520 if (card
->cmdrsp_buf
) {
1521 cmdrsp_buf_pa
= MWIFIEX_SKB_DMA_ADDR(card
->cmdrsp_buf
);
1522 /* Write the lower 32bits of the cmdrsp buffer physical
1524 if (mwifiex_write_reg(adapter
, reg
->cmdrsp_addr_lo
,
1525 (u32
)cmdrsp_buf_pa
)) {
1526 mwifiex_dbg(adapter
, ERROR
,
1527 "Failed to write download cmd to boot code.\n");
1531 /* Write the upper 32bits of the cmdrsp buffer physical
1533 if (mwifiex_write_reg(adapter
, reg
->cmdrsp_addr_hi
,
1534 (u32
)((u64
)cmdrsp_buf_pa
>> 32))) {
1535 mwifiex_dbg(adapter
, ERROR
,
1536 "Failed to write download cmd to boot code.\n");
1542 cmd_buf_pa
= MWIFIEX_SKB_DMA_ADDR(card
->cmd_buf
);
1543 /* Write the lower 32bits of the physical address to reg->cmd_addr_lo */
1544 if (mwifiex_write_reg(adapter
, reg
->cmd_addr_lo
,
1546 mwifiex_dbg(adapter
, ERROR
,
1547 "Failed to write download cmd to boot code.\n");
1551 /* Write the upper 32bits of the physical address to reg->cmd_addr_hi */
1552 if (mwifiex_write_reg(adapter
, reg
->cmd_addr_hi
,
1553 (u32
)((u64
)cmd_buf_pa
>> 32))) {
1554 mwifiex_dbg(adapter
, ERROR
,
1555 "Failed to write download cmd to boot code.\n");
1560 /* Write the command length to reg->cmd_size */
1561 if (mwifiex_write_reg(adapter
, reg
->cmd_size
,
1562 card
->cmd_buf
->len
)) {
1563 mwifiex_dbg(adapter
, ERROR
,
1564 "Failed to write cmd len to reg->cmd_size\n");
1569 /* Ring the door bell */
1570 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1571 CPU_INTR_DOOR_BELL
)) {
1572 mwifiex_dbg(adapter
, ERROR
,
1573 "Failed to assert door-bell intr\n");
1580 adapter
->cmd_sent
= false;
1586 * This function handles command complete interrupt
1588 static int mwifiex_pcie_process_cmd_complete(struct mwifiex_adapter
*adapter
)
1590 struct pcie_service_card
*card
= adapter
->card
;
1591 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1592 struct sk_buff
*skb
= card
->cmdrsp_buf
;
1597 mwifiex_dbg(adapter
, CMD
,
1598 "info: Rx CMD Response\n");
1600 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_FROMDEVICE
);
1602 /* Unmap the command as a response has been received. */
1603 if (card
->cmd_buf
) {
1604 mwifiex_unmap_pci_memory(adapter
, card
->cmd_buf
,
1606 card
->cmd_buf
= NULL
;
1609 pkt_len
= *((__le16
*)skb
->data
);
1610 rx_len
= le16_to_cpu(pkt_len
);
1611 skb_trim(skb
, rx_len
);
1612 skb_pull(skb
, INTF_HEADER_LEN
);
1614 if (!adapter
->curr_cmd
) {
1615 if (adapter
->ps_state
== PS_STATE_SLEEP_CFM
) {
1616 mwifiex_process_sleep_confirm_resp(adapter
, skb
->data
,
1618 mwifiex_pcie_enable_host_int(adapter
);
1619 if (mwifiex_write_reg(adapter
,
1621 CPU_INTR_SLEEP_CFM_DONE
)) {
1622 mwifiex_dbg(adapter
, ERROR
,
1623 "Write register failed\n");
1626 mwifiex_delay_for_sleep_cookie(adapter
,
1627 MWIFIEX_MAX_DELAY_COUNT
);
1628 while (reg
->sleep_cookie
&& (count
++ < 10) &&
1629 mwifiex_pcie_ok_to_access_hw(adapter
))
1630 usleep_range(50, 60);
1632 mwifiex_dbg(adapter
, ERROR
,
1633 "There is no command but got cmdrsp\n");
1635 memcpy(adapter
->upld_buf
, skb
->data
,
1636 min_t(u32
, MWIFIEX_SIZE_OF_CMD_BUFFER
, skb
->len
));
1637 skb_push(skb
, INTF_HEADER_LEN
);
1638 if (mwifiex_map_pci_memory(adapter
, skb
, MWIFIEX_UPLD_SIZE
,
1639 PCI_DMA_FROMDEVICE
))
1641 } else if (mwifiex_pcie_ok_to_access_hw(adapter
)) {
1642 adapter
->curr_cmd
->resp_skb
= skb
;
1643 adapter
->cmd_resp_received
= true;
1644 /* Take the pointer and set it to CMD node and will
1645 return in the response complete callback */
1646 card
->cmdrsp_buf
= NULL
;
1648 /* Clear the cmd-rsp buffer address in scratch registers. This
1649 will prevent firmware from writing to the same response
1651 if (mwifiex_write_reg(adapter
, reg
->cmdrsp_addr_lo
, 0)) {
1652 mwifiex_dbg(adapter
, ERROR
,
1653 "cmd_done: failed to clear cmd_rsp_addr_lo\n");
1656 /* Write the upper 32bits of the cmdrsp buffer physical
1658 if (mwifiex_write_reg(adapter
, reg
->cmdrsp_addr_hi
, 0)) {
1659 mwifiex_dbg(adapter
, ERROR
,
1660 "cmd_done: failed to clear cmd_rsp_addr_hi\n");
1669 * Command Response processing complete handler
1671 static int mwifiex_pcie_cmdrsp_complete(struct mwifiex_adapter
*adapter
,
1672 struct sk_buff
*skb
)
1674 struct pcie_service_card
*card
= adapter
->card
;
1677 card
->cmdrsp_buf
= skb
;
1678 skb_push(card
->cmdrsp_buf
, INTF_HEADER_LEN
);
1679 if (mwifiex_map_pci_memory(adapter
, skb
, MWIFIEX_UPLD_SIZE
,
1680 PCI_DMA_FROMDEVICE
))
1688 * This function handles firmware event ready interrupt
1690 static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter
*adapter
)
1692 struct pcie_service_card
*card
= adapter
->card
;
1693 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1694 u32 rdptr
= card
->evtbd_rdptr
& MWIFIEX_EVTBD_MASK
;
1696 struct mwifiex_evt_buf_desc
*desc
;
1698 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1699 mwifiex_pm_wakeup_card(adapter
);
1701 if (adapter
->event_received
) {
1702 mwifiex_dbg(adapter
, EVENT
,
1703 "info: Event being processed,\t"
1704 "do not process this interrupt just yet\n");
1708 if (rdptr
>= MWIFIEX_MAX_EVT_BD
) {
1709 mwifiex_dbg(adapter
, ERROR
,
1710 "info: Invalid read pointer...\n");
1714 /* Read the event ring write pointer set by firmware */
1715 if (mwifiex_read_reg(adapter
, reg
->evt_wrptr
, &wrptr
)) {
1716 mwifiex_dbg(adapter
, ERROR
,
1717 "EventReady: failed to read reg->evt_wrptr\n");
1721 mwifiex_dbg(adapter
, EVENT
,
1722 "info: EventReady: Initial <Rd: 0x%x, Wr: 0x%x>",
1723 card
->evtbd_rdptr
, wrptr
);
1724 if (((wrptr
& MWIFIEX_EVTBD_MASK
) != (card
->evtbd_rdptr
1725 & MWIFIEX_EVTBD_MASK
)) ||
1726 ((wrptr
& reg
->evt_rollover_ind
) ==
1727 (card
->evtbd_rdptr
& reg
->evt_rollover_ind
))) {
1728 struct sk_buff
*skb_cmd
;
1729 __le16 data_len
= 0;
1732 mwifiex_dbg(adapter
, INFO
,
1733 "info: Read Index: %d\n", rdptr
);
1734 skb_cmd
= card
->evt_buf_list
[rdptr
];
1735 mwifiex_unmap_pci_memory(adapter
, skb_cmd
, PCI_DMA_FROMDEVICE
);
1737 /* Take the pointer and set it to event pointer in adapter
1738 and will return back after event handling callback */
1739 card
->evt_buf_list
[rdptr
] = NULL
;
1740 desc
= card
->evtbd_ring
[rdptr
];
1741 memset(desc
, 0, sizeof(*desc
));
1743 event
= *(u32
*) &skb_cmd
->data
[INTF_HEADER_LEN
];
1744 adapter
->event_cause
= event
;
1745 /* The first 4bytes will be the event transfer header
1746 len is 2 bytes followed by type which is 2 bytes */
1747 memcpy(&data_len
, skb_cmd
->data
, sizeof(__le16
));
1748 evt_len
= le16_to_cpu(data_len
);
1749 skb_trim(skb_cmd
, evt_len
);
1750 skb_pull(skb_cmd
, INTF_HEADER_LEN
);
1751 mwifiex_dbg(adapter
, EVENT
,
1752 "info: Event length: %d\n", evt_len
);
1754 if ((evt_len
> 0) && (evt_len
< MAX_EVENT_SIZE
))
1755 memcpy(adapter
->event_body
, skb_cmd
->data
+
1756 MWIFIEX_EVENT_HEADER_LEN
, evt_len
-
1757 MWIFIEX_EVENT_HEADER_LEN
);
1759 adapter
->event_received
= true;
1760 adapter
->event_skb
= skb_cmd
;
1762 /* Do not update the event read pointer here, wait till the
1763 buffer is released. This is just to make things simpler,
1764 we need to find a better method of managing these buffers.
1767 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1768 CPU_INTR_EVENT_DONE
)) {
1769 mwifiex_dbg(adapter
, ERROR
,
1770 "Write register failed\n");
1779 * Event processing complete handler
1781 static int mwifiex_pcie_event_complete(struct mwifiex_adapter
*adapter
,
1782 struct sk_buff
*skb
)
1784 struct pcie_service_card
*card
= adapter
->card
;
1785 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1787 u32 rdptr
= card
->evtbd_rdptr
& MWIFIEX_EVTBD_MASK
;
1789 struct mwifiex_evt_buf_desc
*desc
;
1794 if (rdptr
>= MWIFIEX_MAX_EVT_BD
) {
1795 mwifiex_dbg(adapter
, ERROR
,
1796 "event_complete: Invalid rdptr 0x%x\n",
1801 /* Read the event ring write pointer set by firmware */
1802 if (mwifiex_read_reg(adapter
, reg
->evt_wrptr
, &wrptr
)) {
1803 mwifiex_dbg(adapter
, ERROR
,
1804 "event_complete: failed to read reg->evt_wrptr\n");
1808 if (!card
->evt_buf_list
[rdptr
]) {
1809 skb_push(skb
, INTF_HEADER_LEN
);
1810 skb_put(skb
, MAX_EVENT_SIZE
- skb
->len
);
1811 if (mwifiex_map_pci_memory(adapter
, skb
,
1813 PCI_DMA_FROMDEVICE
))
1815 card
->evt_buf_list
[rdptr
] = skb
;
1816 desc
= card
->evtbd_ring
[rdptr
];
1817 desc
->paddr
= MWIFIEX_SKB_DMA_ADDR(skb
);
1818 desc
->len
= (u16
)skb
->len
;
1822 mwifiex_dbg(adapter
, ERROR
,
1823 "info: ERROR: buf still valid at index %d, <%p, %p>\n",
1824 rdptr
, card
->evt_buf_list
[rdptr
], skb
);
1827 if ((++card
->evtbd_rdptr
& MWIFIEX_EVTBD_MASK
) == MWIFIEX_MAX_EVT_BD
) {
1828 card
->evtbd_rdptr
= ((card
->evtbd_rdptr
&
1829 reg
->evt_rollover_ind
) ^
1830 reg
->evt_rollover_ind
);
1833 mwifiex_dbg(adapter
, EVENT
,
1834 "info: Updated <Rd: 0x%x, Wr: 0x%x>",
1835 card
->evtbd_rdptr
, wrptr
);
1837 /* Write the event ring read pointer in to reg->evt_rdptr */
1838 if (mwifiex_write_reg(adapter
, reg
->evt_rdptr
,
1839 card
->evtbd_rdptr
)) {
1840 mwifiex_dbg(adapter
, ERROR
,
1841 "event_complete: failed to read reg->evt_rdptr\n");
1845 mwifiex_dbg(adapter
, EVENT
,
1846 "info: Check Events Again\n");
1847 ret
= mwifiex_pcie_process_event_ready(adapter
);
1853 * This function downloads the firmware to the card.
1855 * Firmware is downloaded to the card in blocks. Every block download
1856 * is tested for CRC errors, and retried a number of times before
1857 * returning failure.
1859 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter
*adapter
,
1860 struct mwifiex_fw_image
*fw
)
1863 u8
*firmware
= fw
->fw_buf
;
1864 u32 firmware_len
= fw
->fw_len
;
1866 struct sk_buff
*skb
;
1867 u32 txlen
, tx_blocks
= 0, tries
, len
;
1868 u32 block_retry_cnt
= 0;
1869 struct pcie_service_card
*card
= adapter
->card
;
1870 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1872 if (!firmware
|| !firmware_len
) {
1873 mwifiex_dbg(adapter
, ERROR
,
1874 "No firmware image found! Terminating download\n");
1878 mwifiex_dbg(adapter
, INFO
,
1879 "info: Downloading FW image (%d bytes)\n",
1882 if (mwifiex_pcie_disable_host_int(adapter
)) {
1883 mwifiex_dbg(adapter
, ERROR
,
1884 "%s: Disabling interrupts failed.\n", __func__
);
1888 skb
= dev_alloc_skb(MWIFIEX_UPLD_SIZE
);
1894 /* Perform firmware data transfer */
1899 if (offset
>= firmware_len
)
1902 for (tries
= 0; tries
< MAX_POLL_TRIES
; tries
++) {
1903 ret
= mwifiex_read_reg(adapter
, reg
->cmd_size
,
1906 mwifiex_dbg(adapter
, FATAL
,
1907 "Failed reading len from boot code\n");
1912 usleep_range(10, 20);
1917 } else if (len
> MWIFIEX_UPLD_SIZE
) {
1918 mwifiex_dbg(adapter
, ERROR
,
1919 "FW download failure @ %d, invalid length %d\n",
1929 if (block_retry_cnt
> MAX_WRITE_IOMEM_RETRY
) {
1930 mwifiex_dbg(adapter
, ERROR
,
1931 "FW download failure @ %d, over max\t"
1932 "retry count\n", offset
);
1936 mwifiex_dbg(adapter
, ERROR
,
1937 "FW CRC error indicated by the\t"
1938 "helper: len = 0x%04X, txlen = %d\n",
1941 /* Setting this to 0 to resend from same offset */
1944 block_retry_cnt
= 0;
1945 /* Set blocksize to transfer - checking for
1947 if (firmware_len
- offset
< txlen
)
1948 txlen
= firmware_len
- offset
;
1950 mwifiex_dbg(adapter
, INFO
, ".");
1952 tx_blocks
= (txlen
+ card
->pcie
.blksz_fw_dl
- 1) /
1953 card
->pcie
.blksz_fw_dl
;
1955 /* Copy payload to buffer */
1956 memmove(skb
->data
, &firmware
[offset
], txlen
);
1959 skb_put(skb
, MWIFIEX_UPLD_SIZE
- skb
->len
);
1960 skb_trim(skb
, tx_blocks
* card
->pcie
.blksz_fw_dl
);
1962 /* Send the boot command to device */
1963 if (mwifiex_pcie_send_boot_cmd(adapter
, skb
)) {
1964 mwifiex_dbg(adapter
, ERROR
,
1965 "Failed to send firmware download command\n");
1970 /* Wait for the command done interrupt */
1972 if (mwifiex_read_reg(adapter
, PCIE_CPU_INT_STATUS
,
1974 mwifiex_dbg(adapter
, ERROR
,
1975 "%s: Failed to read\t"
1976 "interrupt status during fw dnld.\n",
1978 mwifiex_unmap_pci_memory(adapter
, skb
,
1983 } while ((ireg_intr
& CPU_INTR_DOOR_BELL
) ==
1984 CPU_INTR_DOOR_BELL
);
1986 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1991 mwifiex_dbg(adapter
, MSG
,
1992 "info: FW download over, size %d bytes\n", offset
);
1997 dev_kfree_skb_any(skb
);
2002 * This function checks the firmware status in card.
2005 mwifiex_check_fw_status(struct mwifiex_adapter
*adapter
, u32 poll_num
)
2009 struct pcie_service_card
*card
= adapter
->card
;
2010 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
2013 /* Mask spurios interrupts */
2014 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_STATUS_MASK
,
2016 mwifiex_dbg(adapter
, ERROR
,
2017 "Write register failed\n");
2021 mwifiex_dbg(adapter
, INFO
,
2022 "Setting driver ready signature\n");
2023 if (mwifiex_write_reg(adapter
, reg
->drv_rdy
,
2024 FIRMWARE_READY_PCIE
)) {
2025 mwifiex_dbg(adapter
, ERROR
,
2026 "Failed to write driver ready signature\n");
2030 /* Wait for firmware initialization event */
2031 for (tries
= 0; tries
< poll_num
; tries
++) {
2032 if (mwifiex_read_reg(adapter
, reg
->fw_status
,
2039 if (firmware_stat
== FIRMWARE_READY_PCIE
) {
2051 /* This function checks if WLAN is the winner.
2054 mwifiex_check_winner_status(struct mwifiex_adapter
*adapter
)
2058 struct pcie_service_card
*card
= adapter
->card
;
2059 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
2061 if (mwifiex_read_reg(adapter
, reg
->fw_status
, &winner
)) {
2063 } else if (!winner
) {
2064 mwifiex_dbg(adapter
, INFO
, "PCI-E is the winner\n");
2065 adapter
->winner
= 1;
2067 mwifiex_dbg(adapter
, ERROR
,
2068 "PCI-E is not the winner <%#x,%d>, exit dnld\n",
2069 ret
, adapter
->winner
);
2076 * This function reads the interrupt status from card.
2078 static void mwifiex_interrupt_status(struct mwifiex_adapter
*adapter
,
2082 unsigned long flags
;
2083 struct pcie_service_card
*card
= adapter
->card
;
2085 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
2088 if (card
->msix_enable
&& msg_id
>= 0) {
2089 pcie_ireg
= BIT(msg_id
);
2091 if (mwifiex_read_reg(adapter
, PCIE_HOST_INT_STATUS
,
2093 mwifiex_dbg(adapter
, ERROR
, "Read register failed\n");
2097 if ((pcie_ireg
== 0xFFFFFFFF) || !pcie_ireg
)
2101 mwifiex_pcie_disable_host_int(adapter
);
2103 /* Clear the pending interrupts */
2104 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_STATUS
,
2106 mwifiex_dbg(adapter
, ERROR
,
2107 "Write register failed\n");
2112 if (!adapter
->pps_uapsd_mode
&&
2113 adapter
->ps_state
== PS_STATE_SLEEP
&&
2114 mwifiex_pcie_ok_to_access_hw(adapter
)) {
2115 /* Potentially for PCIe we could get other
2116 * interrupts like shared. Don't change power
2117 * state until cookie is set
2119 adapter
->ps_state
= PS_STATE_AWAKE
;
2120 adapter
->pm_wakeup_fw_try
= false;
2121 del_timer(&adapter
->wakeup_timer
);
2124 spin_lock_irqsave(&adapter
->int_lock
, flags
);
2125 adapter
->int_status
|= pcie_ireg
;
2126 spin_unlock_irqrestore(&adapter
->int_lock
, flags
);
2127 mwifiex_dbg(adapter
, INTR
, "ireg: 0x%08x\n", pcie_ireg
);
2131 * Interrupt handler for PCIe root port
2133 * This function reads the interrupt status from firmware and assigns
2134 * the main process in workqueue which will handle the interrupt.
2136 static irqreturn_t
mwifiex_pcie_interrupt(int irq
, void *context
)
2138 struct mwifiex_msix_context
*ctx
= context
;
2139 struct pci_dev
*pdev
= ctx
->dev
;
2140 struct pcie_service_card
*card
;
2141 struct mwifiex_adapter
*adapter
;
2144 pr_err("info: %s: pdev is NULL\n", __func__
);
2148 card
= pci_get_drvdata(pdev
);
2149 if (!card
|| !card
->adapter
) {
2150 pr_err("info: %s: card=%p adapter=%p\n", __func__
, card
,
2151 card
? card
->adapter
: NULL
);
2154 adapter
= card
->adapter
;
2156 if (adapter
->surprise_removed
)
2159 if (card
->msix_enable
)
2160 mwifiex_interrupt_status(adapter
, ctx
->msg_id
);
2162 mwifiex_interrupt_status(adapter
, -1);
2164 mwifiex_queue_main_work(adapter
);
2171 * This function checks the current interrupt status.
2173 * The following interrupts are checked and handled by this function -
2176 * - Command received
2177 * - Packets received
2180 * In case of Rx packets received, the packets are uploaded from card to
2181 * host and processed accordingly.
2183 static int mwifiex_process_pcie_int(struct mwifiex_adapter
*adapter
)
2187 unsigned long flags
;
2189 spin_lock_irqsave(&adapter
->int_lock
, flags
);
2190 /* Clear out unused interrupts */
2191 pcie_ireg
= adapter
->int_status
;
2192 adapter
->int_status
= 0;
2193 spin_unlock_irqrestore(&adapter
->int_lock
, flags
);
2195 while (pcie_ireg
& HOST_INTR_MASK
) {
2196 if (pcie_ireg
& HOST_INTR_DNLD_DONE
) {
2197 pcie_ireg
&= ~HOST_INTR_DNLD_DONE
;
2198 mwifiex_dbg(adapter
, INTR
,
2199 "info: TX DNLD Done\n");
2200 ret
= mwifiex_pcie_send_data_complete(adapter
);
2204 if (pcie_ireg
& HOST_INTR_UPLD_RDY
) {
2205 pcie_ireg
&= ~HOST_INTR_UPLD_RDY
;
2206 mwifiex_dbg(adapter
, INTR
,
2208 ret
= mwifiex_pcie_process_recv_data(adapter
);
2212 if (pcie_ireg
& HOST_INTR_EVENT_RDY
) {
2213 pcie_ireg
&= ~HOST_INTR_EVENT_RDY
;
2214 mwifiex_dbg(adapter
, INTR
,
2215 "info: Rx EVENT\n");
2216 ret
= mwifiex_pcie_process_event_ready(adapter
);
2221 if (pcie_ireg
& HOST_INTR_CMD_DONE
) {
2222 pcie_ireg
&= ~HOST_INTR_CMD_DONE
;
2223 if (adapter
->cmd_sent
) {
2224 mwifiex_dbg(adapter
, INTR
,
2225 "info: CMD sent Interrupt\n");
2226 adapter
->cmd_sent
= false;
2228 /* Handle command response */
2229 ret
= mwifiex_pcie_process_cmd_complete(adapter
);
2234 if (mwifiex_pcie_ok_to_access_hw(adapter
)) {
2235 if (mwifiex_read_reg(adapter
, PCIE_HOST_INT_STATUS
,
2237 mwifiex_dbg(adapter
, ERROR
,
2238 "Read register failed\n");
2242 if ((pcie_ireg
!= 0xFFFFFFFF) && (pcie_ireg
)) {
2243 if (mwifiex_write_reg(adapter
,
2244 PCIE_HOST_INT_STATUS
,
2246 mwifiex_dbg(adapter
, ERROR
,
2247 "Write register failed\n");
2254 mwifiex_dbg(adapter
, INTR
,
2255 "info: cmd_sent=%d data_sent=%d\n",
2256 adapter
->cmd_sent
, adapter
->data_sent
);
2257 if (adapter
->ps_state
!= PS_STATE_SLEEP
)
2258 mwifiex_pcie_enable_host_int(adapter
);
2263 static int mwifiex_process_msix_int(struct mwifiex_adapter
*adapter
)
2267 unsigned long flags
;
2269 spin_lock_irqsave(&adapter
->int_lock
, flags
);
2270 /* Clear out unused interrupts */
2271 pcie_ireg
= adapter
->int_status
;
2272 adapter
->int_status
= 0;
2273 spin_unlock_irqrestore(&adapter
->int_lock
, flags
);
2275 if (pcie_ireg
& HOST_INTR_DNLD_DONE
) {
2276 mwifiex_dbg(adapter
, INTR
,
2277 "info: TX DNLD Done\n");
2278 ret
= mwifiex_pcie_send_data_complete(adapter
);
2282 if (pcie_ireg
& HOST_INTR_UPLD_RDY
) {
2283 mwifiex_dbg(adapter
, INTR
,
2285 ret
= mwifiex_pcie_process_recv_data(adapter
);
2289 if (pcie_ireg
& HOST_INTR_EVENT_RDY
) {
2290 mwifiex_dbg(adapter
, INTR
,
2291 "info: Rx EVENT\n");
2292 ret
= mwifiex_pcie_process_event_ready(adapter
);
2297 if (pcie_ireg
& HOST_INTR_CMD_DONE
) {
2298 if (adapter
->cmd_sent
) {
2299 mwifiex_dbg(adapter
, INTR
,
2300 "info: CMD sent Interrupt\n");
2301 adapter
->cmd_sent
= false;
2303 /* Handle command response */
2304 ret
= mwifiex_pcie_process_cmd_complete(adapter
);
2309 mwifiex_dbg(adapter
, INTR
,
2310 "info: cmd_sent=%d data_sent=%d\n",
2311 adapter
->cmd_sent
, adapter
->data_sent
);
2316 static int mwifiex_process_int_status(struct mwifiex_adapter
*adapter
)
2318 struct pcie_service_card
*card
= adapter
->card
;
2320 if (card
->msix_enable
)
2321 return mwifiex_process_msix_int(adapter
);
2323 return mwifiex_process_pcie_int(adapter
);
2327 * This function downloads data from driver to card.
2329 * Both commands and data packets are transferred to the card by this
2332 * This function adds the PCIE specific header to the front of the buffer
2333 * before transferring. The header contains the length of the packet and
2334 * the type. The firmware handles the packets based upon this set type.
2336 static int mwifiex_pcie_host_to_card(struct mwifiex_adapter
*adapter
, u8 type
,
2337 struct sk_buff
*skb
,
2338 struct mwifiex_tx_param
*tx_param
)
2341 mwifiex_dbg(adapter
, ERROR
,
2342 "Passed NULL skb to %s\n", __func__
);
2346 if (type
== MWIFIEX_TYPE_DATA
)
2347 return mwifiex_pcie_send_data(adapter
, skb
, tx_param
);
2348 else if (type
== MWIFIEX_TYPE_CMD
)
2349 return mwifiex_pcie_send_cmd(adapter
, skb
);
2354 /* This function read/write firmware */
2355 static enum rdwr_status
2356 mwifiex_pcie_rdwr_firmware(struct mwifiex_adapter
*adapter
, u8 doneflag
)
2361 struct pcie_service_card
*card
= adapter
->card
;
2362 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
2364 if (mwifiex_read_reg(adapter
, reg
->fw_status
, &fw_status
))
2365 return RDWR_STATUS_FAILURE
;
2367 ret
= mwifiex_write_reg(adapter
, reg
->fw_dump_ctrl
,
2368 reg
->fw_dump_host_ready
);
2370 mwifiex_dbg(adapter
, ERROR
,
2371 "PCIE write err\n");
2372 return RDWR_STATUS_FAILURE
;
2375 for (tries
= 0; tries
< MAX_POLL_TRIES
; tries
++) {
2376 mwifiex_read_reg_byte(adapter
, reg
->fw_dump_ctrl
, &ctrl_data
);
2377 if (ctrl_data
== FW_DUMP_DONE
)
2378 return RDWR_STATUS_SUCCESS
;
2379 if (doneflag
&& ctrl_data
== doneflag
)
2380 return RDWR_STATUS_DONE
;
2381 if (ctrl_data
!= reg
->fw_dump_host_ready
) {
2382 mwifiex_dbg(adapter
, WARN
,
2383 "The ctrl reg was changed, re-try again!\n");
2384 ret
= mwifiex_write_reg(adapter
, reg
->fw_dump_ctrl
,
2385 reg
->fw_dump_host_ready
);
2387 mwifiex_dbg(adapter
, ERROR
,
2388 "PCIE write err\n");
2389 return RDWR_STATUS_FAILURE
;
2392 usleep_range(100, 200);
2395 mwifiex_dbg(adapter
, ERROR
, "Fail to pull ctrl_data\n");
2396 return RDWR_STATUS_FAILURE
;
2399 /* This function dump firmware memory to file */
2400 static void mwifiex_pcie_fw_dump(struct mwifiex_adapter
*adapter
)
2402 struct pcie_service_card
*card
= adapter
->card
;
2403 const struct mwifiex_pcie_card_reg
*creg
= card
->pcie
.reg
;
2404 unsigned int reg
, reg_start
, reg_end
;
2405 u8
*dbg_ptr
, *end_ptr
, *tmp_ptr
, fw_dump_num
, dump_num
;
2406 u8 idx
, i
, read_reg
, doneflag
= 0;
2407 enum rdwr_status stat
;
2411 if (!card
->pcie
.can_dump_fw
)
2414 for (idx
= 0; idx
< adapter
->num_mem_types
; idx
++) {
2415 struct memory_type_mapping
*entry
=
2416 &adapter
->mem_type_mapping_tbl
[idx
];
2418 if (entry
->mem_ptr
) {
2419 vfree(entry
->mem_ptr
);
2420 entry
->mem_ptr
= NULL
;
2422 entry
->mem_size
= 0;
2425 mwifiex_dbg(adapter
, MSG
, "== mwifiex firmware dump start ==\n");
2427 /* Read the number of the memories which will dump */
2428 stat
= mwifiex_pcie_rdwr_firmware(adapter
, doneflag
);
2429 if (stat
== RDWR_STATUS_FAILURE
)
2432 reg
= creg
->fw_dump_start
;
2433 mwifiex_read_reg_byte(adapter
, reg
, &fw_dump_num
);
2435 /* W8997 chipset firmware dump will be restore in single region*/
2436 if (fw_dump_num
== 0)
2439 dump_num
= fw_dump_num
;
2441 /* Read the length of every memory which will dump */
2442 for (idx
= 0; idx
< dump_num
; idx
++) {
2443 struct memory_type_mapping
*entry
=
2444 &adapter
->mem_type_mapping_tbl
[idx
];
2446 if (fw_dump_num
!= 0) {
2447 stat
= mwifiex_pcie_rdwr_firmware(adapter
, doneflag
);
2448 if (stat
== RDWR_STATUS_FAILURE
)
2451 reg
= creg
->fw_dump_start
;
2452 for (i
= 0; i
< 4; i
++) {
2453 mwifiex_read_reg_byte(adapter
, reg
, &read_reg
);
2454 memory_size
|= (read_reg
<< (i
* 8));
2458 memory_size
= MWIFIEX_FW_DUMP_MAX_MEMSIZE
;
2461 if (memory_size
== 0) {
2462 mwifiex_dbg(adapter
, MSG
, "Firmware dump Finished!\n");
2463 ret
= mwifiex_write_reg(adapter
, creg
->fw_dump_ctrl
,
2464 creg
->fw_dump_read_done
);
2466 mwifiex_dbg(adapter
, ERROR
, "PCIE write err\n");
2472 mwifiex_dbg(adapter
, DUMP
,
2473 "%s_SIZE=0x%x\n", entry
->mem_name
, memory_size
);
2474 entry
->mem_ptr
= vmalloc(memory_size
+ 1);
2475 entry
->mem_size
= memory_size
;
2476 if (!entry
->mem_ptr
) {
2477 mwifiex_dbg(adapter
, ERROR
,
2478 "Vmalloc %s failed\n", entry
->mem_name
);
2481 dbg_ptr
= entry
->mem_ptr
;
2482 end_ptr
= dbg_ptr
+ memory_size
;
2484 doneflag
= entry
->done_flag
;
2485 mwifiex_dbg(adapter
, DUMP
, "Start %s output, please wait...\n",
2489 stat
= mwifiex_pcie_rdwr_firmware(adapter
, doneflag
);
2490 if (RDWR_STATUS_FAILURE
== stat
)
2493 reg_start
= creg
->fw_dump_start
;
2494 reg_end
= creg
->fw_dump_end
;
2495 for (reg
= reg_start
; reg
<= reg_end
; reg
++) {
2496 mwifiex_read_reg_byte(adapter
, reg
, dbg_ptr
);
2497 if (dbg_ptr
< end_ptr
) {
2501 mwifiex_dbg(adapter
, ERROR
,
2502 "pre-allocated buf not enough\n");
2504 vzalloc(memory_size
+ MWIFIEX_SIZE_4K
);
2507 memcpy(tmp_ptr
, entry
->mem_ptr
, memory_size
);
2508 vfree(entry
->mem_ptr
);
2509 entry
->mem_ptr
= tmp_ptr
;
2511 dbg_ptr
= entry
->mem_ptr
+ memory_size
;
2512 memory_size
+= MWIFIEX_SIZE_4K
;
2513 end_ptr
= entry
->mem_ptr
+ memory_size
;
2516 if (stat
!= RDWR_STATUS_DONE
)
2519 mwifiex_dbg(adapter
, DUMP
,
2520 "%s done: size=0x%tx\n",
2521 entry
->mem_name
, dbg_ptr
- entry
->mem_ptr
);
2525 mwifiex_dbg(adapter
, MSG
, "== mwifiex firmware dump end ==\n");
2528 static void mwifiex_pcie_device_dump_work(struct mwifiex_adapter
*adapter
)
2530 mwifiex_drv_info_dump(adapter
);
2531 mwifiex_pcie_fw_dump(adapter
);
2532 mwifiex_upload_device_dump(adapter
);
2535 static unsigned long iface_work_flags
;
2536 static struct mwifiex_adapter
*save_adapter
;
2537 static void mwifiex_pcie_work(struct work_struct
*work
)
2539 if (test_and_clear_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP
,
2541 mwifiex_pcie_device_dump_work(save_adapter
);
2544 static DECLARE_WORK(pcie_work
, mwifiex_pcie_work
);
2545 /* This function dumps FW information */
2546 static void mwifiex_pcie_device_dump(struct mwifiex_adapter
*adapter
)
2548 save_adapter
= adapter
;
2549 if (test_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP
, &iface_work_flags
))
2552 set_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP
, &iface_work_flags
);
2554 schedule_work(&pcie_work
);
2558 * This function initializes the PCI-E host memory space, WCB rings, etc.
2560 * The following initializations steps are followed -
2561 * - Allocate TXBD ring buffers
2562 * - Allocate RXBD ring buffers
2563 * - Allocate event BD ring buffers
2564 * - Allocate command response ring buffer
2565 * - Allocate sleep cookie buffer
2567 static int mwifiex_pcie_init(struct mwifiex_adapter
*adapter
)
2569 struct pcie_service_card
*card
= adapter
->card
;
2571 struct pci_dev
*pdev
= card
->dev
;
2572 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
2574 pci_set_drvdata(pdev
, card
);
2576 ret
= pci_enable_device(pdev
);
2578 goto err_enable_dev
;
2580 pci_set_master(pdev
);
2582 pr_notice("try set_consistent_dma_mask(32)\n");
2583 ret
= pci_set_dma_mask(pdev
, DMA_BIT_MASK(32));
2585 pr_err("set_dma_mask(32) failed\n");
2586 goto err_set_dma_mask
;
2589 ret
= pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(32));
2591 pr_err("set_consistent_dma_mask(64) failed\n");
2592 goto err_set_dma_mask
;
2595 ret
= pci_request_region(pdev
, 0, DRV_NAME
);
2597 pr_err("req_reg(0) error\n");
2598 goto err_req_region0
;
2600 card
->pci_mmap
= pci_iomap(pdev
, 0, 0);
2601 if (!card
->pci_mmap
) {
2602 pr_err("iomap(0) error\n");
2606 ret
= pci_request_region(pdev
, 2, DRV_NAME
);
2608 pr_err("req_reg(2) error\n");
2609 goto err_req_region2
;
2611 card
->pci_mmap1
= pci_iomap(pdev
, 2, 0);
2612 if (!card
->pci_mmap1
) {
2613 pr_err("iomap(2) error\n");
2618 pr_notice("PCI memory map Virt0: %p PCI memory map Virt2: %p\n",
2619 card
->pci_mmap
, card
->pci_mmap1
);
2621 card
->cmdrsp_buf
= NULL
;
2622 ret
= mwifiex_pcie_create_txbd_ring(adapter
);
2625 ret
= mwifiex_pcie_create_rxbd_ring(adapter
);
2628 ret
= mwifiex_pcie_create_evtbd_ring(adapter
);
2631 ret
= mwifiex_pcie_alloc_cmdrsp_buf(adapter
);
2633 goto err_alloc_cmdbuf
;
2634 if (reg
->sleep_cookie
) {
2635 ret
= mwifiex_pcie_alloc_sleep_cookie_buf(adapter
);
2637 goto err_alloc_cookie
;
2639 card
->sleep_cookie_vbase
= NULL
;
2644 mwifiex_pcie_delete_cmdrsp_buf(adapter
);
2646 mwifiex_pcie_delete_evtbd_ring(adapter
);
2648 mwifiex_pcie_delete_rxbd_ring(adapter
);
2650 mwifiex_pcie_delete_txbd_ring(adapter
);
2652 pci_iounmap(pdev
, card
->pci_mmap1
);
2654 pci_release_region(pdev
, 2);
2656 pci_iounmap(pdev
, card
->pci_mmap
);
2658 pci_release_region(pdev
, 0);
2661 pci_disable_device(pdev
);
2663 pci_set_drvdata(pdev
, NULL
);
2668 * This function cleans up the allocated card buffers.
2670 * The following are freed by this function -
2671 * - TXBD ring buffers
2672 * - RXBD ring buffers
2673 * - Event BD ring buffers
2674 * - Command response ring buffer
2675 * - Sleep cookie buffer
2677 static void mwifiex_pcie_cleanup(struct mwifiex_adapter
*adapter
)
2679 struct pcie_service_card
*card
= adapter
->card
;
2680 struct pci_dev
*pdev
= card
->dev
;
2681 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
2684 mwifiex_dbg(adapter
, INFO
,
2685 "Clearing driver ready signature\n");
2686 if (mwifiex_write_reg(adapter
, reg
->drv_rdy
, 0x00000000))
2687 mwifiex_dbg(adapter
, ERROR
,
2688 "Failed to write driver not-ready signature\n");
2692 pci_iounmap(pdev
, card
->pci_mmap
);
2693 pci_iounmap(pdev
, card
->pci_mmap1
);
2694 pci_disable_device(pdev
);
2695 pci_release_region(pdev
, 2);
2696 pci_release_region(pdev
, 0);
2697 pci_set_drvdata(pdev
, NULL
);
2702 static int mwifiex_pcie_request_irq(struct mwifiex_adapter
*adapter
)
2705 struct pcie_service_card
*card
= adapter
->card
;
2706 struct pci_dev
*pdev
= card
->dev
;
2708 if (card
->pcie
.reg
->msix_support
) {
2709 for (i
= 0; i
< MWIFIEX_NUM_MSIX_VECTORS
; i
++)
2710 card
->msix_entries
[i
].entry
= i
;
2711 ret
= pci_enable_msix_exact(pdev
, card
->msix_entries
,
2712 MWIFIEX_NUM_MSIX_VECTORS
);
2714 for (i
= 0; i
< MWIFIEX_NUM_MSIX_VECTORS
; i
++) {
2715 card
->msix_ctx
[i
].dev
= pdev
;
2716 card
->msix_ctx
[i
].msg_id
= i
;
2718 ret
= request_irq(card
->msix_entries
[i
].vector
,
2719 mwifiex_pcie_interrupt
, 0,
2720 "MWIFIEX_PCIE_MSIX",
2721 &card
->msix_ctx
[i
]);
2727 mwifiex_dbg(adapter
, INFO
, "request_irq fail: %d\n",
2729 for (j
= 0; j
< i
; j
++)
2730 free_irq(card
->msix_entries
[j
].vector
,
2731 &card
->msix_ctx
[i
]);
2732 pci_disable_msix(pdev
);
2734 mwifiex_dbg(adapter
, MSG
, "MSIx enabled!");
2735 card
->msix_enable
= 1;
2741 if (pci_enable_msi(pdev
) != 0)
2742 pci_disable_msi(pdev
);
2744 card
->msi_enable
= 1;
2746 mwifiex_dbg(adapter
, INFO
, "msi_enable = %d\n", card
->msi_enable
);
2748 card
->share_irq_ctx
.dev
= pdev
;
2749 card
->share_irq_ctx
.msg_id
= -1;
2750 ret
= request_irq(pdev
->irq
, mwifiex_pcie_interrupt
, IRQF_SHARED
,
2751 "MRVL_PCIE", &card
->share_irq_ctx
);
2753 pr_err("request_irq failed: ret=%d\n", ret
);
2754 adapter
->card
= NULL
;
2762 * This function registers the PCIE device.
2764 * PCIE IRQ is claimed, block size is set and driver data is initialized.
2766 static int mwifiex_register_dev(struct mwifiex_adapter
*adapter
)
2768 struct pcie_service_card
*card
= adapter
->card
;
2769 struct pci_dev
*pdev
= card
->dev
;
2771 /* save adapter pointer in card */
2772 card
->adapter
= adapter
;
2773 adapter
->dev
= &pdev
->dev
;
2775 if (mwifiex_pcie_request_irq(adapter
))
2778 adapter
->tx_buf_size
= card
->pcie
.tx_buf_size
;
2779 adapter
->mem_type_mapping_tbl
= card
->pcie
.mem_type_mapping_tbl
;
2780 adapter
->num_mem_types
= card
->pcie
.num_mem_types
;
2781 strcpy(adapter
->fw_name
, card
->pcie
.firmware
);
2782 adapter
->ext_scan
= card
->pcie
.can_ext_scan
;
2788 * This function unregisters the PCIE device.
2790 * The PCIE IRQ is released, the function is disabled and driver
2791 * data is set to null.
2793 static void mwifiex_unregister_dev(struct mwifiex_adapter
*adapter
)
2795 struct pcie_service_card
*card
= adapter
->card
;
2796 const struct mwifiex_pcie_card_reg
*reg
;
2797 struct pci_dev
*pdev
= card
->dev
;
2801 if (card
->msix_enable
) {
2802 for (i
= 0; i
< MWIFIEX_NUM_MSIX_VECTORS
; i
++)
2803 synchronize_irq(card
->msix_entries
[i
].vector
);
2805 for (i
= 0; i
< MWIFIEX_NUM_MSIX_VECTORS
; i
++)
2806 free_irq(card
->msix_entries
[i
].vector
,
2807 &card
->msix_ctx
[i
]);
2809 card
->msix_enable
= 0;
2810 pci_disable_msix(pdev
);
2812 mwifiex_dbg(adapter
, INFO
,
2813 "%s(): calling free_irq()\n", __func__
);
2814 free_irq(card
->dev
->irq
, &card
->share_irq_ctx
);
2816 if (card
->msi_enable
)
2817 pci_disable_msi(pdev
);
2820 reg
= card
->pcie
.reg
;
2821 if (reg
->sleep_cookie
)
2822 mwifiex_pcie_delete_sleep_cookie_buf(adapter
);
2824 mwifiex_pcie_delete_cmdrsp_buf(adapter
);
2825 mwifiex_pcie_delete_evtbd_ring(adapter
);
2826 mwifiex_pcie_delete_rxbd_ring(adapter
);
2827 mwifiex_pcie_delete_txbd_ring(adapter
);
2828 card
->cmdrsp_buf
= NULL
;
2832 static struct mwifiex_if_ops pcie_ops
= {
2833 .init_if
= mwifiex_pcie_init
,
2834 .cleanup_if
= mwifiex_pcie_cleanup
,
2835 .check_fw_status
= mwifiex_check_fw_status
,
2836 .check_winner_status
= mwifiex_check_winner_status
,
2837 .prog_fw
= mwifiex_prog_fw_w_helper
,
2838 .register_dev
= mwifiex_register_dev
,
2839 .unregister_dev
= mwifiex_unregister_dev
,
2840 .enable_int
= mwifiex_pcie_enable_host_int
,
2841 .process_int_status
= mwifiex_process_int_status
,
2842 .host_to_card
= mwifiex_pcie_host_to_card
,
2843 .wakeup
= mwifiex_pm_wakeup_card
,
2844 .wakeup_complete
= mwifiex_pm_wakeup_card_complete
,
2847 .cmdrsp_complete
= mwifiex_pcie_cmdrsp_complete
,
2848 .event_complete
= mwifiex_pcie_event_complete
,
2849 .update_mp_end_port
= NULL
,
2850 .cleanup_mpa_buf
= NULL
,
2851 .init_fw_port
= mwifiex_pcie_init_fw_port
,
2852 .clean_pcie_ring
= mwifiex_clean_pcie_ring_buf
,
2853 .device_dump
= mwifiex_pcie_device_dump
,
2857 * This function initializes the PCIE driver module.
2859 * This initiates the semaphore and registers the device with
2862 static int mwifiex_pcie_init_module(void)
2866 pr_debug("Marvell PCIe Driver\n");
2868 sema_init(&add_remove_card_sem
, 1);
2870 /* Clear the flag in case user removes the card. */
2873 ret
= pci_register_driver(&mwifiex_pcie
);
2875 pr_err("Driver register failed!\n");
2877 pr_debug("info: Driver registered successfully!\n");
2883 * This function cleans up the PCIE driver.
2885 * The following major steps are followed for cleanup -
2886 * - Resume the device if its suspended
2887 * - Disconnect the device if connected
2888 * - Shutdown the firmware
2889 * - Unregister the device from PCIE bus.
2891 static void mwifiex_pcie_cleanup_module(void)
2893 if (!down_interruptible(&add_remove_card_sem
))
2894 up(&add_remove_card_sem
);
2896 /* Set the flag as user is removing this module. */
2899 cancel_work_sync(&pcie_work
);
2900 pci_unregister_driver(&mwifiex_pcie
);
2903 module_init(mwifiex_pcie_init_module
);
2904 module_exit(mwifiex_pcie_cleanup_module
);
2906 MODULE_AUTHOR("Marvell International Ltd.");
2907 MODULE_DESCRIPTION("Marvell WiFi-Ex PCI-Express Driver version " PCIE_VERSION
);
2908 MODULE_VERSION(PCIE_VERSION
);
2909 MODULE_LICENSE("GPL v2");
2910 MODULE_FIRMWARE(PCIE8766_DEFAULT_FW_NAME
);
2911 MODULE_FIRMWARE(PCIE8897_DEFAULT_FW_NAME
);
2912 MODULE_FIRMWARE(PCIE8997_DEFAULT_FW_NAME
);