2 * Marvell Wireless LAN device driver: PCIE specific handling
4 * Copyright (C) 2011, 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 dev_err(adapter
->dev
, "failed to map pci memory!\n");
53 memcpy(skb
->cb
, &mapping
, sizeof(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_SKB_PACB(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 dev_dbg(adapter
->dev
, "info: ACCESS_HW: sleep cookie=0x%x\n",
83 if (*cookie_addr
== FW_AWAKE_COOKIE
)
90 #ifdef CONFIG_PM_SLEEP
92 * Kernel needs to suspend all functions separately. Therefore all
93 * registered functions must have drivers with suspend and resume
94 * methods. Failing that the kernel simply removes the whole card.
96 * If already not suspended, this function allocates and sends a host
97 * sleep activate request to the firmware and turns off the traffic.
99 static int mwifiex_pcie_suspend(struct device
*dev
)
101 struct mwifiex_adapter
*adapter
;
102 struct pcie_service_card
*card
;
104 struct pci_dev
*pdev
= to_pci_dev(dev
);
107 card
= pci_get_drvdata(pdev
);
108 if (!card
|| !card
->adapter
) {
109 pr_err("Card or adapter structure is not valid\n");
113 pr_err("PCIE device is not specified\n");
117 adapter
= card
->adapter
;
119 hs_actived
= mwifiex_enable_hs(adapter
);
121 /* Indicate device suspended */
122 adapter
->is_suspended
= true;
123 adapter
->hs_enabling
= false;
129 * Kernel needs to suspend all functions separately. Therefore all
130 * registered functions must have drivers with suspend and resume
131 * methods. Failing that the kernel simply removes the whole card.
133 * If already not resumed, this function turns on the traffic and
134 * sends a host sleep cancel request to the firmware.
136 static int mwifiex_pcie_resume(struct device
*dev
)
138 struct mwifiex_adapter
*adapter
;
139 struct pcie_service_card
*card
;
140 struct pci_dev
*pdev
= to_pci_dev(dev
);
143 card
= pci_get_drvdata(pdev
);
144 if (!card
|| !card
->adapter
) {
145 pr_err("Card or adapter structure is not valid\n");
149 pr_err("PCIE device is not specified\n");
153 adapter
= card
->adapter
;
155 if (!adapter
->is_suspended
) {
156 dev_warn(adapter
->dev
, "Device already resumed\n");
160 adapter
->is_suspended
= false;
162 mwifiex_cancel_hs(mwifiex_get_priv(adapter
, MWIFIEX_BSS_ROLE_STA
),
170 * This function probes an mwifiex device and registers it. It allocates
171 * the card structure, enables PCIE function number and initiates the
172 * device registration and initialization procedure by adding a logical
175 static int mwifiex_pcie_probe(struct pci_dev
*pdev
,
176 const struct pci_device_id
*ent
)
178 struct pcie_service_card
*card
;
180 pr_debug("info: vendor=0x%4.04X device=0x%4.04X rev=%d\n",
181 pdev
->vendor
, pdev
->device
, pdev
->revision
);
183 card
= kzalloc(sizeof(struct pcie_service_card
), GFP_KERNEL
);
189 if (ent
->driver_data
) {
190 struct mwifiex_pcie_device
*data
= (void *)ent
->driver_data
;
191 card
->pcie
.firmware
= data
->firmware
;
192 card
->pcie
.reg
= data
->reg
;
193 card
->pcie
.blksz_fw_dl
= data
->blksz_fw_dl
;
194 card
->pcie
.tx_buf_size
= data
->tx_buf_size
;
197 if (mwifiex_add_card(card
, &add_remove_card_sem
, &pcie_ops
,
199 pr_err("%s failed\n", __func__
);
208 * This function removes the interface and frees up the card structure.
210 static void mwifiex_pcie_remove(struct pci_dev
*pdev
)
212 struct pcie_service_card
*card
;
213 struct mwifiex_adapter
*adapter
;
214 struct mwifiex_private
*priv
;
216 card
= pci_get_drvdata(pdev
);
220 adapter
= card
->adapter
;
221 if (!adapter
|| !adapter
->priv_num
)
224 /* In case driver is removed when asynchronous FW load is in progress */
225 wait_for_completion(&adapter
->fw_load
);
228 #ifdef CONFIG_PM_SLEEP
229 if (adapter
->is_suspended
)
230 mwifiex_pcie_resume(&pdev
->dev
);
233 mwifiex_deauthenticate_all(adapter
);
235 priv
= mwifiex_get_priv(adapter
, MWIFIEX_BSS_ROLE_ANY
);
237 mwifiex_disable_auto_ds(priv
);
239 mwifiex_init_shutdown_fw(priv
, MWIFIEX_FUNC_SHUTDOWN
);
242 mwifiex_remove_card(card
->adapter
, &add_remove_card_sem
);
245 static void mwifiex_pcie_shutdown(struct pci_dev
*pdev
)
248 mwifiex_pcie_remove(pdev
);
253 static DEFINE_PCI_DEVICE_TABLE(mwifiex_ids
) = {
255 PCIE_VENDOR_ID_MARVELL
, PCIE_DEVICE_ID_MARVELL_88W8766P
,
256 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0,
257 .driver_data
= (unsigned long) &mwifiex_pcie8766
,
260 PCIE_VENDOR_ID_MARVELL
, PCIE_DEVICE_ID_MARVELL_88W8897
,
261 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0,
262 .driver_data
= (unsigned long) &mwifiex_pcie8897
,
267 MODULE_DEVICE_TABLE(pci
, mwifiex_ids
);
269 #ifdef CONFIG_PM_SLEEP
270 /* Power Management Hooks */
271 static SIMPLE_DEV_PM_OPS(mwifiex_pcie_pm_ops
, mwifiex_pcie_suspend
,
272 mwifiex_pcie_resume
);
275 /* PCI Device Driver */
276 static struct pci_driver __refdata mwifiex_pcie
= {
277 .name
= "mwifiex_pcie",
278 .id_table
= mwifiex_ids
,
279 .probe
= mwifiex_pcie_probe
,
280 .remove
= mwifiex_pcie_remove
,
281 #ifdef CONFIG_PM_SLEEP
283 .pm
= &mwifiex_pcie_pm_ops
,
286 .shutdown
= mwifiex_pcie_shutdown
,
290 * This function writes data into PCIE card register.
292 static int mwifiex_write_reg(struct mwifiex_adapter
*adapter
, int reg
, u32 data
)
294 struct pcie_service_card
*card
= adapter
->card
;
296 iowrite32(data
, card
->pci_mmap1
+ reg
);
302 * This function reads data from PCIE card register.
304 static int mwifiex_read_reg(struct mwifiex_adapter
*adapter
, int reg
, u32
*data
)
306 struct pcie_service_card
*card
= adapter
->card
;
308 *data
= ioread32(card
->pci_mmap1
+ reg
);
314 * This function adds delay loop to ensure FW is awake before proceeding.
316 static void mwifiex_pcie_dev_wakeup_delay(struct mwifiex_adapter
*adapter
)
320 while (mwifiex_pcie_ok_to_access_hw(adapter
)) {
322 usleep_range(10, 20);
331 static void mwifiex_delay_for_sleep_cookie(struct mwifiex_adapter
*adapter
,
332 u32 max_delay_loop_cnt
)
334 struct pcie_service_card
*card
= adapter
->card
;
336 u32 sleep_cookie
, count
;
338 for (count
= 0; count
< max_delay_loop_cnt
; count
++) {
339 buffer
= card
->cmdrsp_buf
->data
- INTF_HEADER_LEN
;
340 sleep_cookie
= *(u32
*)buffer
;
342 if (sleep_cookie
== MWIFIEX_DEF_SLEEP_COOKIE
) {
343 dev_dbg(adapter
->dev
,
344 "sleep cookie found at count %d\n", count
);
347 usleep_range(20, 30);
350 if (count
>= max_delay_loop_cnt
)
351 dev_dbg(adapter
->dev
,
352 "max count reached while accessing sleep cookie\n");
355 /* This function wakes up the card by reading fw_status register. */
356 static int mwifiex_pm_wakeup_card(struct mwifiex_adapter
*adapter
)
359 struct pcie_service_card
*card
= adapter
->card
;
360 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
362 dev_dbg(adapter
->dev
, "event: Wakeup device...\n");
364 if (reg
->sleep_cookie
)
365 mwifiex_pcie_dev_wakeup_delay(adapter
);
367 /* Reading fw_status register will wakeup device */
368 if (mwifiex_read_reg(adapter
, reg
->fw_status
, &fw_status
)) {
369 dev_warn(adapter
->dev
, "Reading fw_status register failed\n");
373 if (reg
->sleep_cookie
) {
374 mwifiex_pcie_dev_wakeup_delay(adapter
);
375 dev_dbg(adapter
->dev
, "PCIE wakeup: Setting PS_STATE_AWAKE\n");
376 adapter
->ps_state
= PS_STATE_AWAKE
;
383 * This function is called after the card has woken up.
385 * The card configuration register is reset.
387 static int mwifiex_pm_wakeup_card_complete(struct mwifiex_adapter
*adapter
)
389 dev_dbg(adapter
->dev
, "cmd: Wakeup device completed\n");
395 * This function disables the host interrupt.
397 * The host interrupt mask is read, the disable bit is reset and
398 * written back to the card host interrupt mask register.
400 static int mwifiex_pcie_disable_host_int(struct mwifiex_adapter
*adapter
)
402 if (mwifiex_pcie_ok_to_access_hw(adapter
)) {
403 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_MASK
,
405 dev_warn(adapter
->dev
, "Disable host interrupt failed\n");
414 * This function enables the host interrupt.
416 * The host interrupt enable mask is written to the card
417 * host interrupt mask register.
419 static int mwifiex_pcie_enable_host_int(struct mwifiex_adapter
*adapter
)
421 if (mwifiex_pcie_ok_to_access_hw(adapter
)) {
422 /* Simply write the mask to the register */
423 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_MASK
,
425 dev_warn(adapter
->dev
, "Enable host interrupt failed\n");
434 * This function initializes TX buffer ring descriptors
436 static int mwifiex_init_txq_ring(struct mwifiex_adapter
*adapter
)
438 struct pcie_service_card
*card
= adapter
->card
;
439 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
440 struct mwifiex_pcie_buf_desc
*desc
;
441 struct mwifiex_pfu_buf_desc
*desc2
;
444 for (i
= 0; i
< MWIFIEX_MAX_TXRX_BD
; i
++) {
445 card
->tx_buf_list
[i
] = NULL
;
446 if (reg
->pfu_enabled
) {
447 card
->txbd_ring
[i
] = (void *)card
->txbd_ring_vbase
+
448 (sizeof(*desc2
) * i
);
449 desc2
= card
->txbd_ring
[i
];
450 memset(desc2
, 0, sizeof(*desc2
));
452 card
->txbd_ring
[i
] = (void *)card
->txbd_ring_vbase
+
454 desc
= card
->txbd_ring
[i
];
455 memset(desc
, 0, sizeof(*desc
));
462 /* This function initializes RX buffer ring descriptors. Each SKB is allocated
463 * here and after mapping PCI memory, its physical address is assigned to
464 * PCIE Rx buffer descriptor's physical address.
466 static int mwifiex_init_rxq_ring(struct mwifiex_adapter
*adapter
)
468 struct pcie_service_card
*card
= adapter
->card
;
469 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
471 struct mwifiex_pcie_buf_desc
*desc
;
472 struct mwifiex_pfu_buf_desc
*desc2
;
476 for (i
= 0; i
< MWIFIEX_MAX_TXRX_BD
; i
++) {
477 /* Allocate skb here so that firmware can DMA data from it */
478 skb
= dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE
);
480 dev_err(adapter
->dev
,
481 "Unable to allocate skb for RX ring.\n");
482 kfree(card
->rxbd_ring_vbase
);
486 if (mwifiex_map_pci_memory(adapter
, skb
,
487 MWIFIEX_RX_DATA_BUF_SIZE
,
491 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb
);
493 dev_dbg(adapter
->dev
,
494 "info: RX ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
495 skb
, skb
->len
, skb
->data
, (u32
)buf_pa
,
496 (u32
)((u64
)buf_pa
>> 32));
498 card
->rx_buf_list
[i
] = skb
;
499 if (reg
->pfu_enabled
) {
500 card
->rxbd_ring
[i
] = (void *)card
->rxbd_ring_vbase
+
501 (sizeof(*desc2
) * i
);
502 desc2
= card
->rxbd_ring
[i
];
503 desc2
->paddr
= buf_pa
;
504 desc2
->len
= (u16
)skb
->len
;
505 desc2
->frag_len
= (u16
)skb
->len
;
506 desc2
->flags
= reg
->ring_flag_eop
| reg
->ring_flag_sop
;
509 card
->rxbd_ring
[i
] = (void *)(card
->rxbd_ring_vbase
+
510 (sizeof(*desc
) * i
));
511 desc
= card
->rxbd_ring
[i
];
512 desc
->paddr
= buf_pa
;
513 desc
->len
= (u16
)skb
->len
;
521 /* This function initializes event buffer ring descriptors. Each SKB is
522 * allocated here and after mapping PCI memory, its physical address is assigned
523 * to PCIE Rx buffer descriptor's physical address
525 static int mwifiex_pcie_init_evt_ring(struct mwifiex_adapter
*adapter
)
527 struct pcie_service_card
*card
= adapter
->card
;
528 struct mwifiex_evt_buf_desc
*desc
;
533 for (i
= 0; i
< MWIFIEX_MAX_EVT_BD
; i
++) {
534 /* Allocate skb here so that firmware can DMA data from it */
535 skb
= dev_alloc_skb(MAX_EVENT_SIZE
);
537 dev_err(adapter
->dev
,
538 "Unable to allocate skb for EVENT buf.\n");
539 kfree(card
->evtbd_ring_vbase
);
542 skb_put(skb
, MAX_EVENT_SIZE
);
544 if (mwifiex_map_pci_memory(adapter
, skb
, MAX_EVENT_SIZE
,
548 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb
);
550 dev_dbg(adapter
->dev
,
551 "info: EVT ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
552 skb
, skb
->len
, skb
->data
, (u32
)buf_pa
,
553 (u32
)((u64
)buf_pa
>> 32));
555 card
->evt_buf_list
[i
] = skb
;
556 card
->evtbd_ring
[i
] = (void *)(card
->evtbd_ring_vbase
+
557 (sizeof(*desc
) * i
));
558 desc
= card
->evtbd_ring
[i
];
559 desc
->paddr
= buf_pa
;
560 desc
->len
= (u16
)skb
->len
;
567 /* This function cleans up TX buffer rings. If any of the buffer list has valid
568 * SKB address, associated SKB is freed.
570 static void mwifiex_cleanup_txq_ring(struct mwifiex_adapter
*adapter
)
572 struct pcie_service_card
*card
= adapter
->card
;
573 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
575 struct mwifiex_pcie_buf_desc
*desc
;
576 struct mwifiex_pfu_buf_desc
*desc2
;
579 for (i
= 0; i
< MWIFIEX_MAX_TXRX_BD
; i
++) {
580 if (reg
->pfu_enabled
) {
581 desc2
= card
->txbd_ring
[i
];
582 if (card
->tx_buf_list
[i
]) {
583 skb
= card
->tx_buf_list
[i
];
584 mwifiex_unmap_pci_memory(adapter
, skb
,
586 dev_kfree_skb_any(skb
);
588 memset(desc2
, 0, sizeof(*desc2
));
590 desc
= card
->txbd_ring
[i
];
591 if (card
->tx_buf_list
[i
]) {
592 skb
= card
->tx_buf_list
[i
];
593 mwifiex_unmap_pci_memory(adapter
, skb
,
595 dev_kfree_skb_any(skb
);
597 memset(desc
, 0, sizeof(*desc
));
599 card
->tx_buf_list
[i
] = NULL
;
605 /* This function cleans up RX buffer rings. If any of the buffer list has valid
606 * SKB address, associated SKB is freed.
608 static void mwifiex_cleanup_rxq_ring(struct mwifiex_adapter
*adapter
)
610 struct pcie_service_card
*card
= adapter
->card
;
611 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
612 struct mwifiex_pcie_buf_desc
*desc
;
613 struct mwifiex_pfu_buf_desc
*desc2
;
617 for (i
= 0; i
< MWIFIEX_MAX_TXRX_BD
; i
++) {
618 if (reg
->pfu_enabled
) {
619 desc2
= card
->rxbd_ring
[i
];
620 if (card
->rx_buf_list
[i
]) {
621 skb
= card
->rx_buf_list
[i
];
622 mwifiex_unmap_pci_memory(adapter
, skb
,
624 dev_kfree_skb_any(skb
);
626 memset(desc2
, 0, sizeof(*desc2
));
628 desc
= card
->rxbd_ring
[i
];
629 if (card
->rx_buf_list
[i
]) {
630 skb
= card
->rx_buf_list
[i
];
631 mwifiex_unmap_pci_memory(adapter
, skb
,
633 dev_kfree_skb_any(skb
);
635 memset(desc
, 0, sizeof(*desc
));
637 card
->rx_buf_list
[i
] = NULL
;
643 /* This function cleans up event buffer rings. If any of the buffer list has
644 * valid SKB address, associated SKB is freed.
646 static void mwifiex_cleanup_evt_ring(struct mwifiex_adapter
*adapter
)
648 struct pcie_service_card
*card
= adapter
->card
;
649 struct mwifiex_evt_buf_desc
*desc
;
653 for (i
= 0; i
< MWIFIEX_MAX_EVT_BD
; i
++) {
654 desc
= card
->evtbd_ring
[i
];
655 if (card
->evt_buf_list
[i
]) {
656 skb
= card
->evt_buf_list
[i
];
657 mwifiex_unmap_pci_memory(adapter
, skb
,
659 dev_kfree_skb_any(skb
);
661 card
->evt_buf_list
[i
] = NULL
;
662 memset(desc
, 0, sizeof(*desc
));
668 /* This function creates buffer descriptor ring for TX
670 static int mwifiex_pcie_create_txbd_ring(struct mwifiex_adapter
*adapter
)
672 struct pcie_service_card
*card
= adapter
->card
;
673 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
676 * driver maintaines the write pointer and firmware maintaines the read
677 * pointer. The write pointer starts at 0 (zero) while the read pointer
678 * starts at zero with rollover bit set
680 card
->txbd_wrptr
= 0;
682 if (reg
->pfu_enabled
)
683 card
->txbd_rdptr
= 0;
685 card
->txbd_rdptr
|= reg
->tx_rollover_ind
;
687 /* allocate shared memory for the BD ring and divide the same in to
688 several descriptors */
689 if (reg
->pfu_enabled
)
690 card
->txbd_ring_size
= sizeof(struct mwifiex_pfu_buf_desc
) *
693 card
->txbd_ring_size
= sizeof(struct mwifiex_pcie_buf_desc
) *
696 dev_dbg(adapter
->dev
, "info: txbd_ring: Allocating %d bytes\n",
697 card
->txbd_ring_size
);
698 card
->txbd_ring_vbase
= pci_alloc_consistent(card
->dev
,
699 card
->txbd_ring_size
,
700 &card
->txbd_ring_pbase
);
701 if (!card
->txbd_ring_vbase
) {
702 dev_err(adapter
->dev
,
703 "allocate consistent memory (%d bytes) failed!\n",
704 card
->txbd_ring_size
);
707 dev_dbg(adapter
->dev
,
708 "info: txbd_ring - base: %p, pbase: %#x:%x, len: %x\n",
709 card
->txbd_ring_vbase
, (unsigned int)card
->txbd_ring_pbase
,
710 (u32
)((u64
)card
->txbd_ring_pbase
>> 32), card
->txbd_ring_size
);
712 return mwifiex_init_txq_ring(adapter
);
715 static int mwifiex_pcie_delete_txbd_ring(struct mwifiex_adapter
*adapter
)
717 struct pcie_service_card
*card
= adapter
->card
;
718 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
720 mwifiex_cleanup_txq_ring(adapter
);
722 if (card
->txbd_ring_vbase
)
723 pci_free_consistent(card
->dev
, card
->txbd_ring_size
,
724 card
->txbd_ring_vbase
,
725 card
->txbd_ring_pbase
);
726 card
->txbd_ring_size
= 0;
727 card
->txbd_wrptr
= 0;
728 card
->txbd_rdptr
= 0 | reg
->tx_rollover_ind
;
729 card
->txbd_ring_vbase
= NULL
;
730 card
->txbd_ring_pbase
= 0;
736 * This function creates buffer descriptor ring for RX
738 static int mwifiex_pcie_create_rxbd_ring(struct mwifiex_adapter
*adapter
)
740 struct pcie_service_card
*card
= adapter
->card
;
741 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
744 * driver maintaines the read pointer and firmware maintaines the write
745 * pointer. The write pointer starts at 0 (zero) while the read pointer
746 * starts at zero with rollover bit set
748 card
->rxbd_wrptr
= 0;
749 card
->rxbd_rdptr
= reg
->rx_rollover_ind
;
751 if (reg
->pfu_enabled
)
752 card
->rxbd_ring_size
= sizeof(struct mwifiex_pfu_buf_desc
) *
755 card
->rxbd_ring_size
= sizeof(struct mwifiex_pcie_buf_desc
) *
758 dev_dbg(adapter
->dev
, "info: rxbd_ring: Allocating %d bytes\n",
759 card
->rxbd_ring_size
);
760 card
->rxbd_ring_vbase
= pci_alloc_consistent(card
->dev
,
761 card
->rxbd_ring_size
,
762 &card
->rxbd_ring_pbase
);
763 if (!card
->rxbd_ring_vbase
) {
764 dev_err(adapter
->dev
,
765 "allocate consistent memory (%d bytes) failed!\n",
766 card
->rxbd_ring_size
);
770 dev_dbg(adapter
->dev
,
771 "info: rxbd_ring - base: %p, pbase: %#x:%x, len: %#x\n",
772 card
->rxbd_ring_vbase
, (u32
)card
->rxbd_ring_pbase
,
773 (u32
)((u64
)card
->rxbd_ring_pbase
>> 32),
774 card
->rxbd_ring_size
);
776 return mwifiex_init_rxq_ring(adapter
);
780 * This function deletes Buffer descriptor ring for RX
782 static int mwifiex_pcie_delete_rxbd_ring(struct mwifiex_adapter
*adapter
)
784 struct pcie_service_card
*card
= adapter
->card
;
785 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
787 mwifiex_cleanup_rxq_ring(adapter
);
789 if (card
->rxbd_ring_vbase
)
790 pci_free_consistent(card
->dev
, card
->rxbd_ring_size
,
791 card
->rxbd_ring_vbase
,
792 card
->rxbd_ring_pbase
);
793 card
->rxbd_ring_size
= 0;
794 card
->rxbd_wrptr
= 0;
795 card
->rxbd_rdptr
= 0 | reg
->rx_rollover_ind
;
796 card
->rxbd_ring_vbase
= NULL
;
797 card
->rxbd_ring_pbase
= 0;
803 * This function creates buffer descriptor ring for Events
805 static int mwifiex_pcie_create_evtbd_ring(struct mwifiex_adapter
*adapter
)
807 struct pcie_service_card
*card
= adapter
->card
;
808 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
811 * driver maintaines the read pointer and firmware maintaines the write
812 * pointer. The write pointer starts at 0 (zero) while the read pointer
813 * starts at zero with rollover bit set
815 card
->evtbd_wrptr
= 0;
816 card
->evtbd_rdptr
= reg
->evt_rollover_ind
;
818 card
->evtbd_ring_size
= sizeof(struct mwifiex_evt_buf_desc
) *
821 dev_dbg(adapter
->dev
, "info: evtbd_ring: Allocating %d bytes\n",
822 card
->evtbd_ring_size
);
823 card
->evtbd_ring_vbase
= pci_alloc_consistent(card
->dev
,
824 card
->evtbd_ring_size
,
825 &card
->evtbd_ring_pbase
);
826 if (!card
->evtbd_ring_vbase
) {
827 dev_err(adapter
->dev
,
828 "allocate consistent memory (%d bytes) failed!\n",
829 card
->evtbd_ring_size
);
833 dev_dbg(adapter
->dev
,
834 "info: CMDRSP/EVT bd_ring - base: %p pbase: %#x:%x len: %#x\n",
835 card
->evtbd_ring_vbase
, (u32
)card
->evtbd_ring_pbase
,
836 (u32
)((u64
)card
->evtbd_ring_pbase
>> 32),
837 card
->evtbd_ring_size
);
839 return mwifiex_pcie_init_evt_ring(adapter
);
843 * This function deletes Buffer descriptor ring for Events
845 static int mwifiex_pcie_delete_evtbd_ring(struct mwifiex_adapter
*adapter
)
847 struct pcie_service_card
*card
= adapter
->card
;
848 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
850 mwifiex_cleanup_evt_ring(adapter
);
852 if (card
->evtbd_ring_vbase
)
853 pci_free_consistent(card
->dev
, card
->evtbd_ring_size
,
854 card
->evtbd_ring_vbase
,
855 card
->evtbd_ring_pbase
);
856 card
->evtbd_wrptr
= 0;
857 card
->evtbd_rdptr
= 0 | reg
->evt_rollover_ind
;
858 card
->evtbd_ring_size
= 0;
859 card
->evtbd_ring_vbase
= NULL
;
860 card
->evtbd_ring_pbase
= 0;
866 * This function allocates a buffer for CMDRSP
868 static int mwifiex_pcie_alloc_cmdrsp_buf(struct mwifiex_adapter
*adapter
)
870 struct pcie_service_card
*card
= adapter
->card
;
873 /* Allocate memory for receiving command response data */
874 skb
= dev_alloc_skb(MWIFIEX_UPLD_SIZE
);
876 dev_err(adapter
->dev
,
877 "Unable to allocate skb for command response data.\n");
880 skb_put(skb
, MWIFIEX_UPLD_SIZE
);
881 if (mwifiex_map_pci_memory(adapter
, skb
, MWIFIEX_UPLD_SIZE
,
885 card
->cmdrsp_buf
= skb
;
891 * This function deletes a buffer for CMDRSP
893 static int mwifiex_pcie_delete_cmdrsp_buf(struct mwifiex_adapter
*adapter
)
895 struct pcie_service_card
*card
;
900 card
= adapter
->card
;
902 if (card
&& card
->cmdrsp_buf
) {
903 mwifiex_unmap_pci_memory(adapter
, card
->cmdrsp_buf
,
905 dev_kfree_skb_any(card
->cmdrsp_buf
);
908 if (card
&& card
->cmd_buf
) {
909 mwifiex_unmap_pci_memory(adapter
, card
->cmd_buf
,
916 * This function allocates a buffer for sleep cookie
918 static int mwifiex_pcie_alloc_sleep_cookie_buf(struct mwifiex_adapter
*adapter
)
920 struct pcie_service_card
*card
= adapter
->card
;
922 card
->sleep_cookie_vbase
= pci_alloc_consistent(card
->dev
, sizeof(u32
),
923 &card
->sleep_cookie_pbase
);
924 if (!card
->sleep_cookie_vbase
) {
925 dev_err(adapter
->dev
, "pci_alloc_consistent failed!\n");
928 /* Init val of Sleep Cookie */
929 *(u32
*)card
->sleep_cookie_vbase
= FW_AWAKE_COOKIE
;
931 dev_dbg(adapter
->dev
, "alloc_scook: sleep cookie=0x%x\n",
932 *((u32
*)card
->sleep_cookie_vbase
));
938 * This function deletes buffer for sleep cookie
940 static int mwifiex_pcie_delete_sleep_cookie_buf(struct mwifiex_adapter
*adapter
)
942 struct pcie_service_card
*card
;
947 card
= adapter
->card
;
949 if (card
&& card
->sleep_cookie_vbase
) {
950 pci_free_consistent(card
->dev
, sizeof(u32
),
951 card
->sleep_cookie_vbase
,
952 card
->sleep_cookie_pbase
);
953 card
->sleep_cookie_vbase
= NULL
;
959 /* This function flushes the TX buffer descriptor ring
960 * This function defined as handler is also called while cleaning TXRX
961 * during disconnect/ bss stop.
963 static int mwifiex_clean_pcie_ring_buf(struct mwifiex_adapter
*adapter
)
965 struct pcie_service_card
*card
= adapter
->card
;
967 if (!mwifiex_pcie_txbd_empty(card
, card
->txbd_rdptr
)) {
968 card
->txbd_flush
= 1;
969 /* write pointer already set at last send
970 * send dnld-rdy intr again, wait for completion.
972 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
973 CPU_INTR_DNLD_RDY
)) {
974 dev_err(adapter
->dev
,
975 "failed to assert dnld-rdy interrupt.\n");
983 * This function unmaps and frees downloaded data buffer
985 static int mwifiex_pcie_send_data_complete(struct mwifiex_adapter
*adapter
)
988 u32 wrdoneidx
, rdptr
, num_tx_buffs
, unmap_count
= 0;
989 struct mwifiex_pcie_buf_desc
*desc
;
990 struct mwifiex_pfu_buf_desc
*desc2
;
991 struct pcie_service_card
*card
= adapter
->card
;
992 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
994 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
995 mwifiex_pm_wakeup_card(adapter
);
997 /* Read the TX ring read pointer set by firmware */
998 if (mwifiex_read_reg(adapter
, reg
->tx_rdptr
, &rdptr
)) {
999 dev_err(adapter
->dev
,
1000 "SEND COMP: failed to read reg->tx_rdptr\n");
1004 dev_dbg(adapter
->dev
, "SEND COMP: rdptr_prev=0x%x, rdptr=0x%x\n",
1005 card
->txbd_rdptr
, rdptr
);
1007 num_tx_buffs
= MWIFIEX_MAX_TXRX_BD
<< reg
->tx_start_ptr
;
1008 /* free from previous txbd_rdptr to current txbd_rdptr */
1009 while (((card
->txbd_rdptr
& reg
->tx_mask
) !=
1010 (rdptr
& reg
->tx_mask
)) ||
1011 ((card
->txbd_rdptr
& reg
->tx_rollover_ind
) !=
1012 (rdptr
& reg
->tx_rollover_ind
))) {
1013 wrdoneidx
= (card
->txbd_rdptr
& reg
->tx_mask
) >>
1016 skb
= card
->tx_buf_list
[wrdoneidx
];
1019 dev_dbg(adapter
->dev
,
1020 "SEND COMP: Detach skb %p at txbd_rdidx=%d\n",
1022 mwifiex_unmap_pci_memory(adapter
, skb
,
1027 if (card
->txbd_flush
)
1028 mwifiex_write_data_complete(adapter
, skb
, 0,
1031 mwifiex_write_data_complete(adapter
, skb
, 0, 0);
1034 card
->tx_buf_list
[wrdoneidx
] = NULL
;
1036 if (reg
->pfu_enabled
) {
1037 desc2
= card
->txbd_ring
[wrdoneidx
];
1038 memset(desc2
, 0, sizeof(*desc2
));
1040 desc
= card
->txbd_ring
[wrdoneidx
];
1041 memset(desc
, 0, sizeof(*desc
));
1043 switch (card
->dev
->device
) {
1044 case PCIE_DEVICE_ID_MARVELL_88W8766P
:
1047 case PCIE_DEVICE_ID_MARVELL_88W8897
:
1048 card
->txbd_rdptr
+= reg
->ring_tx_start_ptr
;
1053 if ((card
->txbd_rdptr
& reg
->tx_mask
) == num_tx_buffs
)
1054 card
->txbd_rdptr
= ((card
->txbd_rdptr
&
1055 reg
->tx_rollover_ind
) ^
1056 reg
->tx_rollover_ind
);
1060 adapter
->data_sent
= false;
1062 if (card
->txbd_flush
) {
1063 if (mwifiex_pcie_txbd_empty(card
, card
->txbd_rdptr
))
1064 card
->txbd_flush
= 0;
1066 mwifiex_clean_pcie_ring_buf(adapter
);
1072 /* This function sends data buffer to device. First 4 bytes of payload
1073 * are filled with payload length and payload type. Then this payload
1074 * is mapped to PCI device memory. Tx ring pointers are advanced accordingly.
1075 * Download ready interrupt to FW is deffered if Tx ring is not full and
1076 * additional payload can be accomodated.
1079 mwifiex_pcie_send_data(struct mwifiex_adapter
*adapter
, struct sk_buff
*skb
,
1080 struct mwifiex_tx_param
*tx_param
)
1082 struct pcie_service_card
*card
= adapter
->card
;
1083 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1084 u32 wrindx
, num_tx_buffs
, rx_val
;
1087 struct mwifiex_pcie_buf_desc
*desc
= NULL
;
1088 struct mwifiex_pfu_buf_desc
*desc2
= NULL
;
1091 if (!(skb
->data
&& skb
->len
)) {
1092 dev_err(adapter
->dev
, "%s(): invalid parameter <%p, %#x>\n",
1093 __func__
, skb
->data
, skb
->len
);
1097 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1098 mwifiex_pm_wakeup_card(adapter
);
1100 num_tx_buffs
= MWIFIEX_MAX_TXRX_BD
<< reg
->tx_start_ptr
;
1101 dev_dbg(adapter
->dev
, "info: SEND DATA: <Rd: %#x, Wr: %#x>\n",
1102 card
->txbd_rdptr
, card
->txbd_wrptr
);
1103 if (mwifiex_pcie_txbd_not_full(card
)) {
1106 adapter
->data_sent
= true;
1107 payload
= skb
->data
;
1108 tmp
= (__le16
*)&payload
[0];
1109 *tmp
= cpu_to_le16((u16
)skb
->len
);
1110 tmp
= (__le16
*)&payload
[2];
1111 *tmp
= cpu_to_le16(MWIFIEX_TYPE_DATA
);
1113 if (mwifiex_map_pci_memory(adapter
, skb
, skb
->len
,
1117 wrindx
= (card
->txbd_wrptr
& reg
->tx_mask
) >> reg
->tx_start_ptr
;
1118 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb
);
1119 card
->tx_buf_list
[wrindx
] = skb
;
1121 if (reg
->pfu_enabled
) {
1122 desc2
= card
->txbd_ring
[wrindx
];
1123 desc2
->paddr
= buf_pa
;
1124 desc2
->len
= (u16
)skb
->len
;
1125 desc2
->frag_len
= (u16
)skb
->len
;
1127 desc2
->flags
= MWIFIEX_BD_FLAG_FIRST_DESC
|
1128 MWIFIEX_BD_FLAG_LAST_DESC
;
1130 desc
= card
->txbd_ring
[wrindx
];
1131 desc
->paddr
= buf_pa
;
1132 desc
->len
= (u16
)skb
->len
;
1133 desc
->flags
= MWIFIEX_BD_FLAG_FIRST_DESC
|
1134 MWIFIEX_BD_FLAG_LAST_DESC
;
1137 switch (card
->dev
->device
) {
1138 case PCIE_DEVICE_ID_MARVELL_88W8766P
:
1141 case PCIE_DEVICE_ID_MARVELL_88W8897
:
1142 card
->txbd_wrptr
+= reg
->ring_tx_start_ptr
;
1146 if ((card
->txbd_wrptr
& reg
->tx_mask
) == num_tx_buffs
)
1147 card
->txbd_wrptr
= ((card
->txbd_wrptr
&
1148 reg
->tx_rollover_ind
) ^
1149 reg
->tx_rollover_ind
);
1151 rx_val
= card
->rxbd_rdptr
& reg
->rx_wrap_mask
;
1152 /* Write the TX ring write pointer in to reg->tx_wrptr */
1153 if (mwifiex_write_reg(adapter
, reg
->tx_wrptr
,
1154 card
->txbd_wrptr
| rx_val
)) {
1155 dev_err(adapter
->dev
,
1156 "SEND DATA: failed to write reg->tx_wrptr\n");
1160 if ((mwifiex_pcie_txbd_not_full(card
)) &&
1161 tx_param
->next_pkt_len
) {
1162 /* have more packets and TxBD still can hold more */
1163 dev_dbg(adapter
->dev
,
1164 "SEND DATA: delay dnld-rdy interrupt.\n");
1165 adapter
->data_sent
= false;
1167 /* Send the TX ready interrupt */
1168 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1169 CPU_INTR_DNLD_RDY
)) {
1170 dev_err(adapter
->dev
,
1171 "SEND DATA: failed to assert dnld-rdy interrupt.\n");
1176 dev_dbg(adapter
->dev
, "info: SEND DATA: Updated <Rd: %#x, Wr: "
1177 "%#x> and sent packet to firmware successfully\n",
1178 card
->txbd_rdptr
, card
->txbd_wrptr
);
1180 dev_dbg(adapter
->dev
,
1181 "info: TX Ring full, can't send packets to fw\n");
1182 adapter
->data_sent
= true;
1183 /* Send the TX ready interrupt */
1184 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1186 dev_err(adapter
->dev
,
1187 "SEND DATA: failed to assert door-bell intr\n");
1191 return -EINPROGRESS
;
1193 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1194 card
->tx_buf_list
[wrindx
] = NULL
;
1195 if (reg
->pfu_enabled
)
1196 memset(desc2
, 0, sizeof(*desc2
));
1198 memset(desc
, 0, sizeof(*desc
));
1204 * This function handles received buffer ring and
1205 * dispatches packets to upper
1207 static int mwifiex_pcie_process_recv_data(struct mwifiex_adapter
*adapter
)
1209 struct pcie_service_card
*card
= adapter
->card
;
1210 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1211 u32 wrptr
, rd_index
, tx_val
;
1214 struct sk_buff
*skb_tmp
= NULL
;
1215 struct mwifiex_pcie_buf_desc
*desc
;
1216 struct mwifiex_pfu_buf_desc
*desc2
;
1218 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1219 mwifiex_pm_wakeup_card(adapter
);
1221 /* Read the RX ring Write pointer set by firmware */
1222 if (mwifiex_read_reg(adapter
, reg
->rx_wrptr
, &wrptr
)) {
1223 dev_err(adapter
->dev
,
1224 "RECV DATA: failed to read reg->rx_wrptr\n");
1228 card
->rxbd_wrptr
= wrptr
;
1230 while (((wrptr
& reg
->rx_mask
) !=
1231 (card
->rxbd_rdptr
& reg
->rx_mask
)) ||
1232 ((wrptr
& reg
->rx_rollover_ind
) ==
1233 (card
->rxbd_rdptr
& reg
->rx_rollover_ind
))) {
1234 struct sk_buff
*skb_data
;
1238 rd_index
= card
->rxbd_rdptr
& reg
->rx_mask
;
1239 skb_data
= card
->rx_buf_list
[rd_index
];
1241 /* If skb allocation was failed earlier for Rx packet,
1242 * rx_buf_list[rd_index] would have been left with a NULL.
1247 mwifiex_unmap_pci_memory(adapter
, skb_data
, PCI_DMA_FROMDEVICE
);
1248 card
->rx_buf_list
[rd_index
] = NULL
;
1250 /* Get data length from interface header -
1251 * first 2 bytes for len, next 2 bytes is for type
1253 pkt_len
= *((__le16
*)skb_data
->data
);
1254 rx_len
= le16_to_cpu(pkt_len
);
1255 skb_put(skb_data
, rx_len
);
1256 dev_dbg(adapter
->dev
,
1257 "info: RECV DATA: Rd=%#x, Wr=%#x, Len=%d\n",
1258 card
->rxbd_rdptr
, wrptr
, rx_len
);
1259 skb_pull(skb_data
, INTF_HEADER_LEN
);
1260 mwifiex_handle_rx_packet(adapter
, skb_data
);
1262 skb_tmp
= dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE
);
1264 dev_err(adapter
->dev
,
1265 "Unable to allocate skb.\n");
1269 if (mwifiex_map_pci_memory(adapter
, skb_tmp
,
1270 MWIFIEX_RX_DATA_BUF_SIZE
,
1271 PCI_DMA_FROMDEVICE
))
1274 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb_tmp
);
1276 dev_dbg(adapter
->dev
,
1277 "RECV DATA: Attach new sk_buff %p at rxbd_rdidx=%d\n",
1279 card
->rx_buf_list
[rd_index
] = skb_tmp
;
1281 if (reg
->pfu_enabled
) {
1282 desc2
= card
->rxbd_ring
[rd_index
];
1283 desc2
->paddr
= buf_pa
;
1284 desc2
->len
= skb_tmp
->len
;
1285 desc2
->frag_len
= skb_tmp
->len
;
1287 desc2
->flags
= reg
->ring_flag_sop
| reg
->ring_flag_eop
;
1289 desc
= card
->rxbd_ring
[rd_index
];
1290 desc
->paddr
= buf_pa
;
1291 desc
->len
= skb_tmp
->len
;
1295 if ((++card
->rxbd_rdptr
& reg
->rx_mask
) ==
1296 MWIFIEX_MAX_TXRX_BD
) {
1297 card
->rxbd_rdptr
= ((card
->rxbd_rdptr
&
1298 reg
->rx_rollover_ind
) ^
1299 reg
->rx_rollover_ind
);
1301 dev_dbg(adapter
->dev
, "info: RECV DATA: <Rd: %#x, Wr: %#x>\n",
1302 card
->rxbd_rdptr
, wrptr
);
1304 tx_val
= card
->txbd_wrptr
& reg
->tx_wrap_mask
;
1305 /* Write the RX ring read pointer in to reg->rx_rdptr */
1306 if (mwifiex_write_reg(adapter
, reg
->rx_rdptr
,
1307 card
->rxbd_rdptr
| tx_val
)) {
1308 dev_err(adapter
->dev
,
1309 "RECV DATA: failed to write reg->rx_rdptr\n");
1314 /* Read the RX ring Write pointer set by firmware */
1315 if (mwifiex_read_reg(adapter
, reg
->rx_wrptr
, &wrptr
)) {
1316 dev_err(adapter
->dev
,
1317 "RECV DATA: failed to read reg->rx_wrptr\n");
1321 dev_dbg(adapter
->dev
,
1322 "info: RECV DATA: Rcvd packet from fw successfully\n");
1323 card
->rxbd_wrptr
= wrptr
;
1331 * This function downloads the boot command to device
1334 mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter
*adapter
, struct sk_buff
*skb
)
1337 struct pcie_service_card
*card
= adapter
->card
;
1338 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1340 if (!(skb
->data
&& skb
->len
)) {
1341 dev_err(adapter
->dev
,
1342 "Invalid parameter in %s <%p. len %d>\n",
1343 __func__
, skb
->data
, skb
->len
);
1347 if (mwifiex_map_pci_memory(adapter
, skb
, skb
->len
, PCI_DMA_TODEVICE
))
1350 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb
);
1352 /* Write the lower 32bits of the physical address to low command
1353 * address scratch register
1355 if (mwifiex_write_reg(adapter
, reg
->cmd_addr_lo
, (u32
)buf_pa
)) {
1356 dev_err(adapter
->dev
,
1357 "%s: failed to write download command to boot code.\n",
1359 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1363 /* Write the upper 32bits of the physical address to high command
1364 * address scratch register
1366 if (mwifiex_write_reg(adapter
, reg
->cmd_addr_hi
,
1367 (u32
)((u64
)buf_pa
>> 32))) {
1368 dev_err(adapter
->dev
,
1369 "%s: failed to write download command to boot code.\n",
1371 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1375 /* Write the command length to cmd_size scratch register */
1376 if (mwifiex_write_reg(adapter
, reg
->cmd_size
, skb
->len
)) {
1377 dev_err(adapter
->dev
,
1378 "%s: failed to write command len to cmd_size scratch reg\n",
1380 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1384 /* Ring the door bell */
1385 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1386 CPU_INTR_DOOR_BELL
)) {
1387 dev_err(adapter
->dev
,
1388 "%s: failed to assert door-bell intr\n", __func__
);
1389 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1396 /* This function init rx port in firmware which in turn enables to receive data
1397 * from device before transmitting any packet.
1399 static int mwifiex_pcie_init_fw_port(struct mwifiex_adapter
*adapter
)
1401 struct pcie_service_card
*card
= adapter
->card
;
1402 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1403 int tx_wrap
= card
->txbd_wrptr
& reg
->tx_wrap_mask
;
1405 /* Write the RX ring read pointer in to reg->rx_rdptr */
1406 if (mwifiex_write_reg(adapter
, reg
->rx_rdptr
, card
->rxbd_rdptr
|
1408 dev_err(adapter
->dev
,
1409 "RECV DATA: failed to write reg->rx_rdptr\n");
1415 /* This function downloads commands to the device
1418 mwifiex_pcie_send_cmd(struct mwifiex_adapter
*adapter
, struct sk_buff
*skb
)
1420 struct pcie_service_card
*card
= adapter
->card
;
1421 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1423 dma_addr_t cmd_buf_pa
, cmdrsp_buf_pa
;
1424 u8
*payload
= (u8
*)skb
->data
;
1426 if (!(skb
->data
&& skb
->len
)) {
1427 dev_err(adapter
->dev
, "Invalid parameter in %s <%p, %#x>\n",
1428 __func__
, skb
->data
, skb
->len
);
1432 /* Make sure a command response buffer is available */
1433 if (!card
->cmdrsp_buf
) {
1434 dev_err(adapter
->dev
,
1435 "No response buffer available, send command failed\n");
1439 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1440 mwifiex_pm_wakeup_card(adapter
);
1442 adapter
->cmd_sent
= true;
1444 *(__le16
*)&payload
[0] = cpu_to_le16((u16
)skb
->len
);
1445 *(__le16
*)&payload
[2] = cpu_to_le16(MWIFIEX_TYPE_CMD
);
1447 if (mwifiex_map_pci_memory(adapter
, skb
, skb
->len
, PCI_DMA_TODEVICE
))
1450 card
->cmd_buf
= skb
;
1452 /* To send a command, the driver will:
1453 1. Write the 64bit physical address of the data buffer to
1454 cmd response address low + cmd response address high
1455 2. Ring the door bell (i.e. set the door bell interrupt)
1457 In response to door bell interrupt, the firmware will perform
1458 the DMA of the command packet (first header to obtain the total
1459 length and then rest of the command).
1462 if (card
->cmdrsp_buf
) {
1463 cmdrsp_buf_pa
= MWIFIEX_SKB_DMA_ADDR(card
->cmdrsp_buf
);
1464 /* Write the lower 32bits of the cmdrsp buffer physical
1466 if (mwifiex_write_reg(adapter
, reg
->cmdrsp_addr_lo
,
1467 (u32
)cmdrsp_buf_pa
)) {
1468 dev_err(adapter
->dev
,
1469 "Failed to write download cmd to boot code.\n");
1473 /* Write the upper 32bits of the cmdrsp buffer physical
1475 if (mwifiex_write_reg(adapter
, reg
->cmdrsp_addr_hi
,
1476 (u32
)((u64
)cmdrsp_buf_pa
>> 32))) {
1477 dev_err(adapter
->dev
,
1478 "Failed to write download cmd to boot code.\n");
1484 cmd_buf_pa
= MWIFIEX_SKB_DMA_ADDR(card
->cmd_buf
);
1485 /* Write the lower 32bits of the physical address to reg->cmd_addr_lo */
1486 if (mwifiex_write_reg(adapter
, reg
->cmd_addr_lo
,
1488 dev_err(adapter
->dev
,
1489 "Failed to write download cmd to boot code.\n");
1493 /* Write the upper 32bits of the physical address to reg->cmd_addr_hi */
1494 if (mwifiex_write_reg(adapter
, reg
->cmd_addr_hi
,
1495 (u32
)((u64
)cmd_buf_pa
>> 32))) {
1496 dev_err(adapter
->dev
,
1497 "Failed to write download cmd to boot code.\n");
1502 /* Write the command length to reg->cmd_size */
1503 if (mwifiex_write_reg(adapter
, reg
->cmd_size
,
1504 card
->cmd_buf
->len
)) {
1505 dev_err(adapter
->dev
,
1506 "Failed to write cmd len to reg->cmd_size\n");
1511 /* Ring the door bell */
1512 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1513 CPU_INTR_DOOR_BELL
)) {
1514 dev_err(adapter
->dev
,
1515 "Failed to assert door-bell intr\n");
1522 adapter
->cmd_sent
= false;
1528 * This function handles command complete interrupt
1530 static int mwifiex_pcie_process_cmd_complete(struct mwifiex_adapter
*adapter
)
1532 struct pcie_service_card
*card
= adapter
->card
;
1533 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1534 struct sk_buff
*skb
= card
->cmdrsp_buf
;
1539 dev_dbg(adapter
->dev
, "info: Rx CMD Response\n");
1541 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_FROMDEVICE
);
1543 /* Unmap the command as a response has been received. */
1544 if (card
->cmd_buf
) {
1545 mwifiex_unmap_pci_memory(adapter
, card
->cmd_buf
,
1547 card
->cmd_buf
= NULL
;
1550 pkt_len
= *((__le16
*)skb
->data
);
1551 rx_len
= le16_to_cpu(pkt_len
);
1552 skb_trim(skb
, rx_len
);
1553 skb_pull(skb
, INTF_HEADER_LEN
);
1555 if (!adapter
->curr_cmd
) {
1556 if (adapter
->ps_state
== PS_STATE_SLEEP_CFM
) {
1557 mwifiex_process_sleep_confirm_resp(adapter
, skb
->data
,
1559 mwifiex_pcie_enable_host_int(adapter
);
1560 if (mwifiex_write_reg(adapter
,
1562 CPU_INTR_SLEEP_CFM_DONE
)) {
1563 dev_warn(adapter
->dev
,
1564 "Write register failed\n");
1567 mwifiex_delay_for_sleep_cookie(adapter
,
1568 MWIFIEX_MAX_DELAY_COUNT
);
1569 while (reg
->sleep_cookie
&& (count
++ < 10) &&
1570 mwifiex_pcie_ok_to_access_hw(adapter
))
1571 usleep_range(50, 60);
1573 dev_err(adapter
->dev
,
1574 "There is no command but got cmdrsp\n");
1576 memcpy(adapter
->upld_buf
, skb
->data
,
1577 min_t(u32
, MWIFIEX_SIZE_OF_CMD_BUFFER
, skb
->len
));
1578 skb_push(skb
, INTF_HEADER_LEN
);
1579 if (mwifiex_map_pci_memory(adapter
, skb
, MWIFIEX_UPLD_SIZE
,
1580 PCI_DMA_FROMDEVICE
))
1582 } else if (mwifiex_pcie_ok_to_access_hw(adapter
)) {
1583 adapter
->curr_cmd
->resp_skb
= skb
;
1584 adapter
->cmd_resp_received
= true;
1585 /* Take the pointer and set it to CMD node and will
1586 return in the response complete callback */
1587 card
->cmdrsp_buf
= NULL
;
1589 /* Clear the cmd-rsp buffer address in scratch registers. This
1590 will prevent firmware from writing to the same response
1592 if (mwifiex_write_reg(adapter
, reg
->cmdrsp_addr_lo
, 0)) {
1593 dev_err(adapter
->dev
,
1594 "cmd_done: failed to clear cmd_rsp_addr_lo\n");
1597 /* Write the upper 32bits of the cmdrsp buffer physical
1599 if (mwifiex_write_reg(adapter
, reg
->cmdrsp_addr_hi
, 0)) {
1600 dev_err(adapter
->dev
,
1601 "cmd_done: failed to clear cmd_rsp_addr_hi\n");
1610 * Command Response processing complete handler
1612 static int mwifiex_pcie_cmdrsp_complete(struct mwifiex_adapter
*adapter
,
1613 struct sk_buff
*skb
)
1615 struct pcie_service_card
*card
= adapter
->card
;
1618 card
->cmdrsp_buf
= skb
;
1619 skb_push(card
->cmdrsp_buf
, INTF_HEADER_LEN
);
1620 if (mwifiex_map_pci_memory(adapter
, skb
, MWIFIEX_UPLD_SIZE
,
1621 PCI_DMA_FROMDEVICE
))
1629 * This function handles firmware event ready interrupt
1631 static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter
*adapter
)
1633 struct pcie_service_card
*card
= adapter
->card
;
1634 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1635 u32 rdptr
= card
->evtbd_rdptr
& MWIFIEX_EVTBD_MASK
;
1637 struct mwifiex_evt_buf_desc
*desc
;
1639 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1640 mwifiex_pm_wakeup_card(adapter
);
1642 if (adapter
->event_received
) {
1643 dev_dbg(adapter
->dev
, "info: Event being processed, "
1644 "do not process this interrupt just yet\n");
1648 if (rdptr
>= MWIFIEX_MAX_EVT_BD
) {
1649 dev_dbg(adapter
->dev
, "info: Invalid read pointer...\n");
1653 /* Read the event ring write pointer set by firmware */
1654 if (mwifiex_read_reg(adapter
, reg
->evt_wrptr
, &wrptr
)) {
1655 dev_err(adapter
->dev
,
1656 "EventReady: failed to read reg->evt_wrptr\n");
1660 dev_dbg(adapter
->dev
, "info: EventReady: Initial <Rd: 0x%x, Wr: 0x%x>",
1661 card
->evtbd_rdptr
, wrptr
);
1662 if (((wrptr
& MWIFIEX_EVTBD_MASK
) != (card
->evtbd_rdptr
1663 & MWIFIEX_EVTBD_MASK
)) ||
1664 ((wrptr
& reg
->evt_rollover_ind
) ==
1665 (card
->evtbd_rdptr
& reg
->evt_rollover_ind
))) {
1666 struct sk_buff
*skb_cmd
;
1667 __le16 data_len
= 0;
1670 dev_dbg(adapter
->dev
, "info: Read Index: %d\n", rdptr
);
1671 skb_cmd
= card
->evt_buf_list
[rdptr
];
1672 mwifiex_unmap_pci_memory(adapter
, skb_cmd
, PCI_DMA_FROMDEVICE
);
1674 /* Take the pointer and set it to event pointer in adapter
1675 and will return back after event handling callback */
1676 card
->evt_buf_list
[rdptr
] = NULL
;
1677 desc
= card
->evtbd_ring
[rdptr
];
1678 memset(desc
, 0, sizeof(*desc
));
1680 event
= *(u32
*) &skb_cmd
->data
[INTF_HEADER_LEN
];
1681 adapter
->event_cause
= event
;
1682 /* The first 4bytes will be the event transfer header
1683 len is 2 bytes followed by type which is 2 bytes */
1684 memcpy(&data_len
, skb_cmd
->data
, sizeof(__le16
));
1685 evt_len
= le16_to_cpu(data_len
);
1687 skb_pull(skb_cmd
, INTF_HEADER_LEN
);
1688 dev_dbg(adapter
->dev
, "info: Event length: %d\n", evt_len
);
1690 if ((evt_len
> 0) && (evt_len
< MAX_EVENT_SIZE
))
1691 memcpy(adapter
->event_body
, skb_cmd
->data
+
1692 MWIFIEX_EVENT_HEADER_LEN
, evt_len
-
1693 MWIFIEX_EVENT_HEADER_LEN
);
1695 adapter
->event_received
= true;
1696 adapter
->event_skb
= skb_cmd
;
1698 /* Do not update the event read pointer here, wait till the
1699 buffer is released. This is just to make things simpler,
1700 we need to find a better method of managing these buffers.
1708 * Event processing complete handler
1710 static int mwifiex_pcie_event_complete(struct mwifiex_adapter
*adapter
,
1711 struct sk_buff
*skb
)
1713 struct pcie_service_card
*card
= adapter
->card
;
1714 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1716 u32 rdptr
= card
->evtbd_rdptr
& MWIFIEX_EVTBD_MASK
;
1718 struct mwifiex_evt_buf_desc
*desc
;
1723 if (rdptr
>= MWIFIEX_MAX_EVT_BD
) {
1724 dev_err(adapter
->dev
, "event_complete: Invalid rdptr 0x%x\n",
1729 /* Read the event ring write pointer set by firmware */
1730 if (mwifiex_read_reg(adapter
, reg
->evt_wrptr
, &wrptr
)) {
1731 dev_err(adapter
->dev
,
1732 "event_complete: failed to read reg->evt_wrptr\n");
1736 if (!card
->evt_buf_list
[rdptr
]) {
1737 skb_push(skb
, INTF_HEADER_LEN
);
1738 if (mwifiex_map_pci_memory(adapter
, skb
,
1740 PCI_DMA_FROMDEVICE
))
1742 card
->evt_buf_list
[rdptr
] = skb
;
1743 desc
= card
->evtbd_ring
[rdptr
];
1744 desc
->paddr
= MWIFIEX_SKB_DMA_ADDR(skb
);
1745 desc
->len
= (u16
)skb
->len
;
1749 dev_dbg(adapter
->dev
,
1750 "info: ERROR: buf still valid at index %d, <%p, %p>\n",
1751 rdptr
, card
->evt_buf_list
[rdptr
], skb
);
1754 if ((++card
->evtbd_rdptr
& MWIFIEX_EVTBD_MASK
) == MWIFIEX_MAX_EVT_BD
) {
1755 card
->evtbd_rdptr
= ((card
->evtbd_rdptr
&
1756 reg
->evt_rollover_ind
) ^
1757 reg
->evt_rollover_ind
);
1760 dev_dbg(adapter
->dev
, "info: Updated <Rd: 0x%x, Wr: 0x%x>",
1761 card
->evtbd_rdptr
, wrptr
);
1763 /* Write the event ring read pointer in to reg->evt_rdptr */
1764 if (mwifiex_write_reg(adapter
, reg
->evt_rdptr
,
1765 card
->evtbd_rdptr
)) {
1766 dev_err(adapter
->dev
,
1767 "event_complete: failed to read reg->evt_rdptr\n");
1771 dev_dbg(adapter
->dev
, "info: Check Events Again\n");
1772 ret
= mwifiex_pcie_process_event_ready(adapter
);
1778 * This function downloads the firmware to the card.
1780 * Firmware is downloaded to the card in blocks. Every block download
1781 * is tested for CRC errors, and retried a number of times before
1782 * returning failure.
1784 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter
*adapter
,
1785 struct mwifiex_fw_image
*fw
)
1788 u8
*firmware
= fw
->fw_buf
;
1789 u32 firmware_len
= fw
->fw_len
;
1791 struct sk_buff
*skb
;
1792 u32 txlen
, tx_blocks
= 0, tries
, len
;
1793 u32 block_retry_cnt
= 0;
1794 struct pcie_service_card
*card
= adapter
->card
;
1795 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1797 if (!firmware
|| !firmware_len
) {
1798 dev_err(adapter
->dev
,
1799 "No firmware image found! Terminating download\n");
1803 dev_dbg(adapter
->dev
, "info: Downloading FW image (%d bytes)\n",
1806 if (mwifiex_pcie_disable_host_int(adapter
)) {
1807 dev_err(adapter
->dev
,
1808 "%s: Disabling interrupts failed.\n", __func__
);
1812 skb
= dev_alloc_skb(MWIFIEX_UPLD_SIZE
);
1818 /* Perform firmware data transfer */
1823 if (offset
>= firmware_len
)
1826 for (tries
= 0; tries
< MAX_POLL_TRIES
; tries
++) {
1827 ret
= mwifiex_read_reg(adapter
, reg
->cmd_size
,
1830 dev_warn(adapter
->dev
,
1831 "Failed reading len from boot code\n");
1836 usleep_range(10, 20);
1841 } else if (len
> MWIFIEX_UPLD_SIZE
) {
1842 pr_err("FW download failure @ %d, invalid length %d\n",
1852 if (block_retry_cnt
> MAX_WRITE_IOMEM_RETRY
) {
1853 pr_err("FW download failure @ %d, over max "
1854 "retry count\n", offset
);
1858 dev_err(adapter
->dev
, "FW CRC error indicated by the "
1859 "helper: len = 0x%04X, txlen = %d\n",
1862 /* Setting this to 0 to resend from same offset */
1865 block_retry_cnt
= 0;
1866 /* Set blocksize to transfer - checking for
1868 if (firmware_len
- offset
< txlen
)
1869 txlen
= firmware_len
- offset
;
1871 dev_dbg(adapter
->dev
, ".");
1873 tx_blocks
= (txlen
+ card
->pcie
.blksz_fw_dl
- 1) /
1874 card
->pcie
.blksz_fw_dl
;
1876 /* Copy payload to buffer */
1877 memmove(skb
->data
, &firmware
[offset
], txlen
);
1880 skb_put(skb
, MWIFIEX_UPLD_SIZE
- skb
->len
);
1881 skb_trim(skb
, tx_blocks
* card
->pcie
.blksz_fw_dl
);
1883 /* Send the boot command to device */
1884 if (mwifiex_pcie_send_boot_cmd(adapter
, skb
)) {
1885 dev_err(adapter
->dev
,
1886 "Failed to send firmware download command\n");
1891 /* Wait for the command done interrupt */
1893 if (mwifiex_read_reg(adapter
, PCIE_CPU_INT_STATUS
,
1895 dev_err(adapter
->dev
, "%s: Failed to read "
1896 "interrupt status during fw dnld.\n",
1898 mwifiex_unmap_pci_memory(adapter
, skb
,
1903 } while ((ireg_intr
& CPU_INTR_DOOR_BELL
) ==
1904 CPU_INTR_DOOR_BELL
);
1906 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1911 dev_dbg(adapter
->dev
, "info:\nFW download over, size %d bytes\n",
1917 dev_kfree_skb_any(skb
);
1922 * This function checks the firmware status in card.
1924 * The winner interface is also determined by this function.
1927 mwifiex_check_fw_status(struct mwifiex_adapter
*adapter
, u32 poll_num
)
1930 u32 firmware_stat
, winner_status
;
1931 struct pcie_service_card
*card
= adapter
->card
;
1932 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1935 /* Mask spurios interrupts */
1936 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_STATUS_MASK
,
1938 dev_warn(adapter
->dev
, "Write register failed\n");
1942 dev_dbg(adapter
->dev
, "Setting driver ready signature\n");
1943 if (mwifiex_write_reg(adapter
, reg
->drv_rdy
,
1944 FIRMWARE_READY_PCIE
)) {
1945 dev_err(adapter
->dev
,
1946 "Failed to write driver ready signature\n");
1950 /* Wait for firmware initialization event */
1951 for (tries
= 0; tries
< poll_num
; tries
++) {
1952 if (mwifiex_read_reg(adapter
, reg
->fw_status
,
1959 if (firmware_stat
== FIRMWARE_READY_PCIE
) {
1969 if (mwifiex_read_reg(adapter
, reg
->fw_status
,
1972 else if (!winner_status
) {
1973 dev_err(adapter
->dev
, "PCI-E is the winner\n");
1974 adapter
->winner
= 1;
1976 dev_err(adapter
->dev
,
1977 "PCI-E is not the winner <%#x,%d>, exit dnld\n",
1978 ret
, adapter
->winner
);
1986 * This function reads the interrupt status from card.
1988 static void mwifiex_interrupt_status(struct mwifiex_adapter
*adapter
)
1991 unsigned long flags
;
1993 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1996 if (mwifiex_read_reg(adapter
, PCIE_HOST_INT_STATUS
, &pcie_ireg
)) {
1997 dev_warn(adapter
->dev
, "Read register failed\n");
2001 if ((pcie_ireg
!= 0xFFFFFFFF) && (pcie_ireg
)) {
2003 mwifiex_pcie_disable_host_int(adapter
);
2005 /* Clear the pending interrupts */
2006 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_STATUS
,
2008 dev_warn(adapter
->dev
, "Write register failed\n");
2011 spin_lock_irqsave(&adapter
->int_lock
, flags
);
2012 adapter
->int_status
|= pcie_ireg
;
2013 spin_unlock_irqrestore(&adapter
->int_lock
, flags
);
2015 if (!adapter
->pps_uapsd_mode
&&
2016 adapter
->ps_state
== PS_STATE_SLEEP
&&
2017 mwifiex_pcie_ok_to_access_hw(adapter
)) {
2018 /* Potentially for PCIe we could get other
2019 * interrupts like shared. Don't change power
2020 * state until cookie is set */
2021 adapter
->ps_state
= PS_STATE_AWAKE
;
2022 adapter
->pm_wakeup_fw_try
= false;
2028 * Interrupt handler for PCIe root port
2030 * This function reads the interrupt status from firmware and assigns
2031 * the main process in workqueue which will handle the interrupt.
2033 static irqreturn_t
mwifiex_pcie_interrupt(int irq
, void *context
)
2035 struct pci_dev
*pdev
= (struct pci_dev
*)context
;
2036 struct pcie_service_card
*card
;
2037 struct mwifiex_adapter
*adapter
;
2040 pr_debug("info: %s: pdev is NULL\n", (u8
*)pdev
);
2044 card
= pci_get_drvdata(pdev
);
2045 if (!card
|| !card
->adapter
) {
2046 pr_debug("info: %s: card=%p adapter=%p\n", __func__
, card
,
2047 card
? card
->adapter
: NULL
);
2050 adapter
= card
->adapter
;
2052 if (adapter
->surprise_removed
)
2055 mwifiex_interrupt_status(adapter
);
2056 queue_work(adapter
->workqueue
, &adapter
->main_work
);
2063 * This function checks the current interrupt status.
2065 * The following interrupts are checked and handled by this function -
2068 * - Command received
2069 * - Packets received
2072 * In case of Rx packets received, the packets are uploaded from card to
2073 * host and processed accordingly.
2075 static int mwifiex_process_int_status(struct mwifiex_adapter
*adapter
)
2079 unsigned long flags
;
2081 spin_lock_irqsave(&adapter
->int_lock
, flags
);
2082 /* Clear out unused interrupts */
2083 pcie_ireg
= adapter
->int_status
;
2084 adapter
->int_status
= 0;
2085 spin_unlock_irqrestore(&adapter
->int_lock
, flags
);
2087 while (pcie_ireg
& HOST_INTR_MASK
) {
2088 if (pcie_ireg
& HOST_INTR_DNLD_DONE
) {
2089 pcie_ireg
&= ~HOST_INTR_DNLD_DONE
;
2090 dev_dbg(adapter
->dev
, "info: TX DNLD Done\n");
2091 ret
= mwifiex_pcie_send_data_complete(adapter
);
2095 if (pcie_ireg
& HOST_INTR_UPLD_RDY
) {
2096 pcie_ireg
&= ~HOST_INTR_UPLD_RDY
;
2097 dev_dbg(adapter
->dev
, "info: Rx DATA\n");
2098 ret
= mwifiex_pcie_process_recv_data(adapter
);
2102 if (pcie_ireg
& HOST_INTR_EVENT_RDY
) {
2103 pcie_ireg
&= ~HOST_INTR_EVENT_RDY
;
2104 dev_dbg(adapter
->dev
, "info: Rx EVENT\n");
2105 ret
= mwifiex_pcie_process_event_ready(adapter
);
2110 if (pcie_ireg
& HOST_INTR_CMD_DONE
) {
2111 pcie_ireg
&= ~HOST_INTR_CMD_DONE
;
2112 if (adapter
->cmd_sent
) {
2113 dev_dbg(adapter
->dev
,
2114 "info: CMD sent Interrupt\n");
2115 adapter
->cmd_sent
= false;
2117 /* Handle command response */
2118 ret
= mwifiex_pcie_process_cmd_complete(adapter
);
2123 if (mwifiex_pcie_ok_to_access_hw(adapter
)) {
2124 if (mwifiex_read_reg(adapter
, PCIE_HOST_INT_STATUS
,
2126 dev_warn(adapter
->dev
,
2127 "Read register failed\n");
2131 if ((pcie_ireg
!= 0xFFFFFFFF) && (pcie_ireg
)) {
2132 if (mwifiex_write_reg(adapter
,
2133 PCIE_HOST_INT_STATUS
,
2135 dev_warn(adapter
->dev
,
2136 "Write register failed\n");
2143 dev_dbg(adapter
->dev
, "info: cmd_sent=%d data_sent=%d\n",
2144 adapter
->cmd_sent
, adapter
->data_sent
);
2145 if (adapter
->ps_state
!= PS_STATE_SLEEP
)
2146 mwifiex_pcie_enable_host_int(adapter
);
2152 * This function downloads data from driver to card.
2154 * Both commands and data packets are transferred to the card by this
2157 * This function adds the PCIE specific header to the front of the buffer
2158 * before transferring. The header contains the length of the packet and
2159 * the type. The firmware handles the packets based upon this set type.
2161 static int mwifiex_pcie_host_to_card(struct mwifiex_adapter
*adapter
, u8 type
,
2162 struct sk_buff
*skb
,
2163 struct mwifiex_tx_param
*tx_param
)
2166 dev_err(adapter
->dev
, "Passed NULL skb to %s\n", __func__
);
2170 if (type
== MWIFIEX_TYPE_DATA
)
2171 return mwifiex_pcie_send_data(adapter
, skb
, tx_param
);
2172 else if (type
== MWIFIEX_TYPE_CMD
)
2173 return mwifiex_pcie_send_cmd(adapter
, skb
);
2179 * This function initializes the PCI-E host memory space, WCB rings, etc.
2181 * The following initializations steps are followed -
2182 * - Allocate TXBD ring buffers
2183 * - Allocate RXBD ring buffers
2184 * - Allocate event BD ring buffers
2185 * - Allocate command response ring buffer
2186 * - Allocate sleep cookie buffer
2188 static int mwifiex_pcie_init(struct mwifiex_adapter
*adapter
)
2190 struct pcie_service_card
*card
= adapter
->card
;
2192 struct pci_dev
*pdev
= card
->dev
;
2193 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
2195 pci_set_drvdata(pdev
, card
);
2197 ret
= pci_enable_device(pdev
);
2199 goto err_enable_dev
;
2201 pci_set_master(pdev
);
2203 dev_dbg(adapter
->dev
, "try set_consistent_dma_mask(32)\n");
2204 ret
= pci_set_dma_mask(pdev
, DMA_BIT_MASK(32));
2206 dev_err(adapter
->dev
, "set_dma_mask(32) failed\n");
2207 goto err_set_dma_mask
;
2210 ret
= pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(32));
2212 dev_err(adapter
->dev
, "set_consistent_dma_mask(64) failed\n");
2213 goto err_set_dma_mask
;
2216 ret
= pci_request_region(pdev
, 0, DRV_NAME
);
2218 dev_err(adapter
->dev
, "req_reg(0) error\n");
2219 goto err_req_region0
;
2221 card
->pci_mmap
= pci_iomap(pdev
, 0, 0);
2222 if (!card
->pci_mmap
) {
2223 dev_err(adapter
->dev
, "iomap(0) error\n");
2227 ret
= pci_request_region(pdev
, 2, DRV_NAME
);
2229 dev_err(adapter
->dev
, "req_reg(2) error\n");
2230 goto err_req_region2
;
2232 card
->pci_mmap1
= pci_iomap(pdev
, 2, 0);
2233 if (!card
->pci_mmap1
) {
2234 dev_err(adapter
->dev
, "iomap(2) error\n");
2239 dev_dbg(adapter
->dev
,
2240 "PCI memory map Virt0: %p PCI memory map Virt2: %p\n",
2241 card
->pci_mmap
, card
->pci_mmap1
);
2243 card
->cmdrsp_buf
= NULL
;
2244 ret
= mwifiex_pcie_create_txbd_ring(adapter
);
2247 ret
= mwifiex_pcie_create_rxbd_ring(adapter
);
2250 ret
= mwifiex_pcie_create_evtbd_ring(adapter
);
2253 ret
= mwifiex_pcie_alloc_cmdrsp_buf(adapter
);
2255 goto err_alloc_cmdbuf
;
2256 if (reg
->sleep_cookie
) {
2257 ret
= mwifiex_pcie_alloc_sleep_cookie_buf(adapter
);
2259 goto err_alloc_cookie
;
2261 card
->sleep_cookie_vbase
= NULL
;
2266 mwifiex_pcie_delete_cmdrsp_buf(adapter
);
2268 mwifiex_pcie_delete_evtbd_ring(adapter
);
2270 mwifiex_pcie_delete_rxbd_ring(adapter
);
2272 mwifiex_pcie_delete_txbd_ring(adapter
);
2274 pci_iounmap(pdev
, card
->pci_mmap1
);
2276 pci_release_region(pdev
, 2);
2278 pci_iounmap(pdev
, card
->pci_mmap
);
2280 pci_release_region(pdev
, 0);
2283 pci_disable_device(pdev
);
2285 pci_set_drvdata(pdev
, NULL
);
2290 * This function cleans up the allocated card buffers.
2292 * The following are freed by this function -
2293 * - TXBD ring buffers
2294 * - RXBD ring buffers
2295 * - Event BD ring buffers
2296 * - Command response ring buffer
2297 * - Sleep cookie buffer
2299 static void mwifiex_pcie_cleanup(struct mwifiex_adapter
*adapter
)
2301 struct pcie_service_card
*card
= adapter
->card
;
2302 struct pci_dev
*pdev
= card
->dev
;
2303 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
2306 dev_dbg(adapter
->dev
, "Clearing driver ready signature\n");
2307 if (mwifiex_write_reg(adapter
, reg
->drv_rdy
, 0x00000000))
2308 dev_err(adapter
->dev
,
2309 "Failed to write driver not-ready signature\n");
2313 pci_iounmap(pdev
, card
->pci_mmap
);
2314 pci_iounmap(pdev
, card
->pci_mmap1
);
2315 pci_disable_device(pdev
);
2316 pci_release_region(pdev
, 2);
2317 pci_release_region(pdev
, 0);
2318 pci_set_drvdata(pdev
, NULL
);
2324 * This function registers the PCIE device.
2326 * PCIE IRQ is claimed, block size is set and driver data is initialized.
2328 static int mwifiex_register_dev(struct mwifiex_adapter
*adapter
)
2331 struct pcie_service_card
*card
= adapter
->card
;
2332 struct pci_dev
*pdev
= card
->dev
;
2334 /* save adapter pointer in card */
2335 card
->adapter
= adapter
;
2337 ret
= request_irq(pdev
->irq
, mwifiex_pcie_interrupt
, IRQF_SHARED
,
2340 pr_err("request_irq failed: ret=%d\n", ret
);
2341 adapter
->card
= NULL
;
2345 adapter
->dev
= &pdev
->dev
;
2346 adapter
->tx_buf_size
= card
->pcie
.tx_buf_size
;
2347 strcpy(adapter
->fw_name
, card
->pcie
.firmware
);
2353 * This function unregisters the PCIE device.
2355 * The PCIE IRQ is released, the function is disabled and driver
2356 * data is set to null.
2358 static void mwifiex_unregister_dev(struct mwifiex_adapter
*adapter
)
2360 struct pcie_service_card
*card
= adapter
->card
;
2361 const struct mwifiex_pcie_card_reg
*reg
;
2364 dev_dbg(adapter
->dev
, "%s(): calling free_irq()\n", __func__
);
2365 free_irq(card
->dev
->irq
, card
->dev
);
2367 reg
= card
->pcie
.reg
;
2368 if (reg
->sleep_cookie
)
2369 mwifiex_pcie_delete_sleep_cookie_buf(adapter
);
2371 mwifiex_pcie_delete_cmdrsp_buf(adapter
);
2372 mwifiex_pcie_delete_evtbd_ring(adapter
);
2373 mwifiex_pcie_delete_rxbd_ring(adapter
);
2374 mwifiex_pcie_delete_txbd_ring(adapter
);
2375 card
->cmdrsp_buf
= NULL
;
2379 static struct mwifiex_if_ops pcie_ops
= {
2380 .init_if
= mwifiex_pcie_init
,
2381 .cleanup_if
= mwifiex_pcie_cleanup
,
2382 .check_fw_status
= mwifiex_check_fw_status
,
2383 .prog_fw
= mwifiex_prog_fw_w_helper
,
2384 .register_dev
= mwifiex_register_dev
,
2385 .unregister_dev
= mwifiex_unregister_dev
,
2386 .enable_int
= mwifiex_pcie_enable_host_int
,
2387 .process_int_status
= mwifiex_process_int_status
,
2388 .host_to_card
= mwifiex_pcie_host_to_card
,
2389 .wakeup
= mwifiex_pm_wakeup_card
,
2390 .wakeup_complete
= mwifiex_pm_wakeup_card_complete
,
2393 .cmdrsp_complete
= mwifiex_pcie_cmdrsp_complete
,
2394 .event_complete
= mwifiex_pcie_event_complete
,
2395 .update_mp_end_port
= NULL
,
2396 .cleanup_mpa_buf
= NULL
,
2397 .init_fw_port
= mwifiex_pcie_init_fw_port
,
2398 .clean_pcie_ring
= mwifiex_clean_pcie_ring_buf
,
2402 * This function initializes the PCIE driver module.
2404 * This initiates the semaphore and registers the device with
2407 static int mwifiex_pcie_init_module(void)
2411 pr_debug("Marvell PCIe Driver\n");
2413 sema_init(&add_remove_card_sem
, 1);
2415 /* Clear the flag in case user removes the card. */
2418 ret
= pci_register_driver(&mwifiex_pcie
);
2420 pr_err("Driver register failed!\n");
2422 pr_debug("info: Driver registered successfully!\n");
2428 * This function cleans up the PCIE driver.
2430 * The following major steps are followed for cleanup -
2431 * - Resume the device if its suspended
2432 * - Disconnect the device if connected
2433 * - Shutdown the firmware
2434 * - Unregister the device from PCIE bus.
2436 static void mwifiex_pcie_cleanup_module(void)
2438 if (!down_interruptible(&add_remove_card_sem
))
2439 up(&add_remove_card_sem
);
2441 /* Set the flag as user is removing this module. */
2444 pci_unregister_driver(&mwifiex_pcie
);
2447 module_init(mwifiex_pcie_init_module
);
2448 module_exit(mwifiex_pcie_cleanup_module
);
2450 MODULE_AUTHOR("Marvell International Ltd.");
2451 MODULE_DESCRIPTION("Marvell WiFi-Ex PCI-Express Driver version " PCIE_VERSION
);
2452 MODULE_VERSION(PCIE_VERSION
);
2453 MODULE_LICENSE("GPL v2");
2454 MODULE_FIRMWARE(PCIE8766_DEFAULT_FW_NAME
);
2455 MODULE_FIRMWARE(PCIE8897_DEFAULT_FW_NAME
);