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"
34 static struct mwifiex_if_ops pcie_ops;
36 static const struct of_device_id mwifiex_pcie_of_match_table[] = {
37 { .compatible = "pci11ab,2b42" },
38 { .compatible = "pci1b4b,2b42" },
42 static int mwifiex_pcie_probe_of(struct device *dev)
44 if (!of_match_node(mwifiex_pcie_of_match_table, dev->of_node)) {
45 dev_err(dev, "required compatible string missing\n");
52 static void mwifiex_pcie_work(struct work_struct *work);
55 mwifiex_map_pci_memory(struct mwifiex_adapter *adapter, struct sk_buff *skb,
56 size_t size, int flags)
58 struct pcie_service_card *card = adapter->card;
59 struct mwifiex_dma_mapping mapping;
61 mapping.addr = pci_map_single(card->dev, skb->data, size, flags);
62 if (pci_dma_mapping_error(card->dev, mapping.addr)) {
63 mwifiex_dbg(adapter, ERROR, "failed to map pci memory!\n");
67 mwifiex_store_mapping(skb, &mapping);
71 static void mwifiex_unmap_pci_memory(struct mwifiex_adapter *adapter,
72 struct sk_buff *skb, int flags)
74 struct pcie_service_card *card = adapter->card;
75 struct mwifiex_dma_mapping mapping;
77 mwifiex_get_mapping(skb, &mapping);
78 pci_unmap_single(card->dev, mapping.addr, mapping.len, flags);
82 * This function writes data into PCIE card register.
84 static int mwifiex_write_reg(struct mwifiex_adapter *adapter, int reg, u32 data)
86 struct pcie_service_card *card = adapter->card;
88 iowrite32(data, card->pci_mmap1 + reg);
93 /* This function reads data from PCIE card register.
95 static int mwifiex_read_reg(struct mwifiex_adapter *adapter, int reg, u32 *data)
97 struct pcie_service_card *card = adapter->card;
99 *data = ioread32(card->pci_mmap1 + reg);
100 if (*data == 0xffffffff)
106 /* This function reads u8 data from PCIE card register. */
107 static int mwifiex_read_reg_byte(struct mwifiex_adapter *adapter,
110 struct pcie_service_card *card = adapter->card;
112 *data = ioread8(card->pci_mmap1 + reg);
118 * This function reads sleep cookie and checks if FW is ready
120 static bool mwifiex_pcie_ok_to_access_hw(struct mwifiex_adapter *adapter)
123 struct pcie_service_card *card = adapter->card;
124 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
126 if (!reg->sleep_cookie)
129 if (card->sleep_cookie_vbase) {
130 cookie_value = get_unaligned_le32(card->sleep_cookie_vbase);
131 mwifiex_dbg(adapter, INFO,
132 "info: ACCESS_HW: sleep cookie=0x%x\n",
134 if (cookie_value == FW_AWAKE_COOKIE)
141 #ifdef CONFIG_PM_SLEEP
143 * Kernel needs to suspend all functions separately. Therefore all
144 * registered functions must have drivers with suspend and resume
145 * methods. Failing that the kernel simply removes the whole card.
147 * If already not suspended, this function allocates and sends a host
148 * sleep activate request to the firmware and turns off the traffic.
150 static int mwifiex_pcie_suspend(struct device *dev)
152 struct mwifiex_adapter *adapter;
153 struct pcie_service_card *card;
154 struct pci_dev *pdev = to_pci_dev(dev);
156 card = pci_get_drvdata(pdev);
158 /* Might still be loading firmware */
159 wait_for_completion(&card->fw_done);
161 adapter = card->adapter;
163 dev_err(dev, "adapter is not valid\n");
167 mwifiex_enable_wake(adapter);
169 /* Enable the Host Sleep */
170 if (!mwifiex_enable_hs(adapter)) {
171 mwifiex_dbg(adapter, ERROR,
172 "cmd: failed to suspend\n");
173 adapter->hs_enabling = false;
174 mwifiex_disable_wake(adapter);
178 flush_workqueue(adapter->workqueue);
180 /* Indicate device suspended */
181 adapter->is_suspended = true;
182 adapter->hs_enabling = false;
188 * Kernel needs to suspend all functions separately. Therefore all
189 * registered functions must have drivers with suspend and resume
190 * methods. Failing that the kernel simply removes the whole card.
192 * If already not resumed, this function turns on the traffic and
193 * sends a host sleep cancel request to the firmware.
195 static int mwifiex_pcie_resume(struct device *dev)
197 struct mwifiex_adapter *adapter;
198 struct pcie_service_card *card;
199 struct pci_dev *pdev = to_pci_dev(dev);
201 card = pci_get_drvdata(pdev);
203 if (!card->adapter) {
204 dev_err(dev, "adapter structure is not valid\n");
208 adapter = card->adapter;
210 if (!adapter->is_suspended) {
211 mwifiex_dbg(adapter, WARN,
212 "Device already resumed\n");
216 adapter->is_suspended = false;
218 mwifiex_cancel_hs(mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA),
220 mwifiex_disable_wake(adapter);
227 * This function probes an mwifiex device and registers it. It allocates
228 * the card structure, enables PCIE function number and initiates the
229 * device registration and initialization procedure by adding a logical
232 static int mwifiex_pcie_probe(struct pci_dev *pdev,
233 const struct pci_device_id *ent)
235 struct pcie_service_card *card;
238 pr_debug("info: vendor=0x%4.04X device=0x%4.04X rev=%d\n",
239 pdev->vendor, pdev->device, pdev->revision);
241 card = devm_kzalloc(&pdev->dev, sizeof(*card), GFP_KERNEL);
245 init_completion(&card->fw_done);
249 if (ent->driver_data) {
250 struct mwifiex_pcie_device *data = (void *)ent->driver_data;
251 card->pcie.reg = data->reg;
252 card->pcie.blksz_fw_dl = data->blksz_fw_dl;
253 card->pcie.tx_buf_size = data->tx_buf_size;
254 card->pcie.can_dump_fw = data->can_dump_fw;
255 card->pcie.mem_type_mapping_tbl = data->mem_type_mapping_tbl;
256 card->pcie.num_mem_types = data->num_mem_types;
257 card->pcie.can_ext_scan = data->can_ext_scan;
258 INIT_WORK(&card->work, mwifiex_pcie_work);
261 /* device tree node parsing and platform specific configuration*/
262 if (pdev->dev.of_node) {
263 ret = mwifiex_pcie_probe_of(&pdev->dev);
268 if (mwifiex_add_card(card, &card->fw_done, &pcie_ops,
269 MWIFIEX_PCIE, &pdev->dev)) {
270 pr_err("%s failed\n", __func__);
278 * This function removes the interface and frees up the card structure.
280 static void mwifiex_pcie_remove(struct pci_dev *pdev)
282 struct pcie_service_card *card;
283 struct mwifiex_adapter *adapter;
284 struct mwifiex_private *priv;
285 const struct mwifiex_pcie_card_reg *reg;
289 card = pci_get_drvdata(pdev);
291 wait_for_completion(&card->fw_done);
293 adapter = card->adapter;
294 if (!adapter || !adapter->priv_num)
297 reg = card->pcie.reg;
299 ret = mwifiex_read_reg(adapter, reg->fw_status, &fw_status);
303 if (fw_status == FIRMWARE_READY_PCIE && !adapter->mfg_mode) {
304 mwifiex_deauthenticate_all(adapter);
306 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
308 mwifiex_disable_auto_ds(priv);
310 mwifiex_init_shutdown_fw(priv, MWIFIEX_FUNC_SHUTDOWN);
313 mwifiex_remove_card(adapter);
316 static void mwifiex_pcie_shutdown(struct pci_dev *pdev)
318 mwifiex_pcie_remove(pdev);
323 static const struct pci_device_id mwifiex_ids[] = {
325 PCIE_VENDOR_ID_MARVELL, PCIE_DEVICE_ID_MARVELL_88W8766P,
326 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
327 .driver_data = (unsigned long)&mwifiex_pcie8766,
330 PCIE_VENDOR_ID_MARVELL, PCIE_DEVICE_ID_MARVELL_88W8897,
331 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
332 .driver_data = (unsigned long)&mwifiex_pcie8897,
335 PCIE_VENDOR_ID_MARVELL, PCIE_DEVICE_ID_MARVELL_88W8997,
336 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
337 .driver_data = (unsigned long)&mwifiex_pcie8997,
340 PCIE_VENDOR_ID_V2_MARVELL, PCIE_DEVICE_ID_MARVELL_88W8997,
341 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
342 .driver_data = (unsigned long)&mwifiex_pcie8997,
347 MODULE_DEVICE_TABLE(pci, mwifiex_ids);
349 static void mwifiex_pcie_reset_notify(struct pci_dev *pdev, bool prepare)
351 struct pcie_service_card *card = pci_get_drvdata(pdev);
352 struct mwifiex_adapter *adapter = card->adapter;
356 dev_err(&pdev->dev, "%s: adapter structure is not valid\n",
361 mwifiex_dbg(adapter, INFO,
362 "%s: vendor=0x%4.04x device=0x%4.04x rev=%d %s\n",
363 __func__, pdev->vendor, pdev->device,
365 prepare ? "Pre-FLR" : "Post-FLR");
368 /* Kernel would be performing FLR after this notification.
369 * Cleanup all software without cleaning anything related to
372 mwifiex_shutdown_sw(adapter);
373 adapter->surprise_removed = true;
374 clear_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP, &card->work_flags);
375 clear_bit(MWIFIEX_IFACE_WORK_CARD_RESET, &card->work_flags);
377 /* Kernel stores and restores PCIe function context before and
378 * after performing FLR respectively. Reconfigure the software
379 * and firmware including firmware redownload
381 adapter->surprise_removed = false;
382 ret = mwifiex_reinit_sw(adapter);
384 dev_err(&pdev->dev, "reinit failed: %d\n", ret);
388 mwifiex_dbg(adapter, INFO, "%s, successful\n", __func__);
391 static const struct pci_error_handlers mwifiex_pcie_err_handler[] = {
392 { .reset_notify = mwifiex_pcie_reset_notify, },
395 #ifdef CONFIG_PM_SLEEP
396 /* Power Management Hooks */
397 static SIMPLE_DEV_PM_OPS(mwifiex_pcie_pm_ops, mwifiex_pcie_suspend,
398 mwifiex_pcie_resume);
401 /* PCI Device Driver */
402 static struct pci_driver __refdata mwifiex_pcie = {
403 .name = "mwifiex_pcie",
404 .id_table = mwifiex_ids,
405 .probe = mwifiex_pcie_probe,
406 .remove = mwifiex_pcie_remove,
407 #ifdef CONFIG_PM_SLEEP
409 .pm = &mwifiex_pcie_pm_ops,
412 .shutdown = mwifiex_pcie_shutdown,
413 .err_handler = mwifiex_pcie_err_handler,
417 * This function adds delay loop to ensure FW is awake before proceeding.
419 static void mwifiex_pcie_dev_wakeup_delay(struct mwifiex_adapter *adapter)
423 while (mwifiex_pcie_ok_to_access_hw(adapter)) {
425 usleep_range(10, 20);
434 static void mwifiex_delay_for_sleep_cookie(struct mwifiex_adapter *adapter,
435 u32 max_delay_loop_cnt)
437 struct pcie_service_card *card = adapter->card;
439 u32 sleep_cookie, count;
440 struct sk_buff *cmdrsp = card->cmdrsp_buf;
442 for (count = 0; count < max_delay_loop_cnt; count++) {
443 pci_dma_sync_single_for_cpu(card->dev,
444 MWIFIEX_SKB_DMA_ADDR(cmdrsp),
445 sizeof(sleep_cookie),
447 buffer = cmdrsp->data;
448 sleep_cookie = get_unaligned_le32(buffer);
450 if (sleep_cookie == MWIFIEX_DEF_SLEEP_COOKIE) {
451 mwifiex_dbg(adapter, INFO,
452 "sleep cookie found at count %d\n", count);
455 pci_dma_sync_single_for_device(card->dev,
456 MWIFIEX_SKB_DMA_ADDR(cmdrsp),
457 sizeof(sleep_cookie),
459 usleep_range(20, 30);
462 if (count >= max_delay_loop_cnt)
463 mwifiex_dbg(adapter, INFO,
464 "max count reached while accessing sleep cookie\n");
467 /* This function wakes up the card by reading fw_status register. */
468 static int mwifiex_pm_wakeup_card(struct mwifiex_adapter *adapter)
470 struct pcie_service_card *card = adapter->card;
471 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
473 mwifiex_dbg(adapter, EVENT,
474 "event: Wakeup device...\n");
476 if (reg->sleep_cookie)
477 mwifiex_pcie_dev_wakeup_delay(adapter);
479 /* Accessing fw_status register will wakeup device */
480 if (mwifiex_write_reg(adapter, reg->fw_status, FIRMWARE_READY_PCIE)) {
481 mwifiex_dbg(adapter, ERROR,
482 "Writing fw_status register failed\n");
486 if (reg->sleep_cookie) {
487 mwifiex_pcie_dev_wakeup_delay(adapter);
488 mwifiex_dbg(adapter, INFO,
489 "PCIE wakeup: Setting PS_STATE_AWAKE\n");
490 adapter->ps_state = PS_STATE_AWAKE;
497 * This function is called after the card has woken up.
499 * The card configuration register is reset.
501 static int mwifiex_pm_wakeup_card_complete(struct mwifiex_adapter *adapter)
503 mwifiex_dbg(adapter, CMD,
504 "cmd: Wakeup device completed\n");
510 * This function disables the host interrupt.
512 * The host interrupt mask is read, the disable bit is reset and
513 * written back to the card host interrupt mask register.
515 static int mwifiex_pcie_disable_host_int(struct mwifiex_adapter *adapter)
517 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
518 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK,
520 mwifiex_dbg(adapter, ERROR,
521 "Disable host interrupt failed\n");
526 atomic_set(&adapter->tx_hw_pending, 0);
530 static void mwifiex_pcie_disable_host_int_noerr(struct mwifiex_adapter *adapter)
532 WARN_ON(mwifiex_pcie_disable_host_int(adapter));
536 * This function enables the host interrupt.
538 * The host interrupt enable mask is written to the card
539 * host interrupt mask register.
541 static int mwifiex_pcie_enable_host_int(struct mwifiex_adapter *adapter)
543 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
544 /* Simply write the mask to the register */
545 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK,
547 mwifiex_dbg(adapter, ERROR,
548 "Enable host interrupt failed\n");
557 * This function initializes TX buffer ring descriptors
559 static int mwifiex_init_txq_ring(struct mwifiex_adapter *adapter)
561 struct pcie_service_card *card = adapter->card;
562 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
563 struct mwifiex_pcie_buf_desc *desc;
564 struct mwifiex_pfu_buf_desc *desc2;
567 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
568 card->tx_buf_list[i] = NULL;
569 if (reg->pfu_enabled) {
570 card->txbd_ring[i] = (void *)card->txbd_ring_vbase +
571 (sizeof(*desc2) * i);
572 desc2 = card->txbd_ring[i];
573 memset(desc2, 0, sizeof(*desc2));
575 card->txbd_ring[i] = (void *)card->txbd_ring_vbase +
577 desc = card->txbd_ring[i];
578 memset(desc, 0, sizeof(*desc));
585 /* This function initializes RX buffer ring descriptors. Each SKB is allocated
586 * here and after mapping PCI memory, its physical address is assigned to
587 * PCIE Rx buffer descriptor's physical address.
589 static int mwifiex_init_rxq_ring(struct mwifiex_adapter *adapter)
591 struct pcie_service_card *card = adapter->card;
592 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
594 struct mwifiex_pcie_buf_desc *desc;
595 struct mwifiex_pfu_buf_desc *desc2;
599 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
600 /* Allocate skb here so that firmware can DMA data from it */
601 skb = mwifiex_alloc_dma_align_buf(MWIFIEX_RX_DATA_BUF_SIZE,
604 mwifiex_dbg(adapter, ERROR,
605 "Unable to allocate skb for RX ring.\n");
606 kfree(card->rxbd_ring_vbase);
610 if (mwifiex_map_pci_memory(adapter, skb,
611 MWIFIEX_RX_DATA_BUF_SIZE,
615 buf_pa = MWIFIEX_SKB_DMA_ADDR(skb);
617 mwifiex_dbg(adapter, INFO,
618 "info: RX ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
619 skb, skb->len, skb->data, (u32)buf_pa,
620 (u32)((u64)buf_pa >> 32));
622 card->rx_buf_list[i] = skb;
623 if (reg->pfu_enabled) {
624 card->rxbd_ring[i] = (void *)card->rxbd_ring_vbase +
625 (sizeof(*desc2) * i);
626 desc2 = card->rxbd_ring[i];
627 desc2->paddr = buf_pa;
628 desc2->len = (u16)skb->len;
629 desc2->frag_len = (u16)skb->len;
630 desc2->flags = reg->ring_flag_eop | reg->ring_flag_sop;
633 card->rxbd_ring[i] = (void *)(card->rxbd_ring_vbase +
634 (sizeof(*desc) * i));
635 desc = card->rxbd_ring[i];
636 desc->paddr = buf_pa;
637 desc->len = (u16)skb->len;
645 /* This function initializes event buffer ring descriptors. Each SKB is
646 * allocated here and after mapping PCI memory, its physical address is assigned
647 * to PCIE Rx buffer descriptor's physical address
649 static int mwifiex_pcie_init_evt_ring(struct mwifiex_adapter *adapter)
651 struct pcie_service_card *card = adapter->card;
652 struct mwifiex_evt_buf_desc *desc;
657 for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) {
658 /* Allocate skb here so that firmware can DMA data from it */
659 skb = dev_alloc_skb(MAX_EVENT_SIZE);
661 mwifiex_dbg(adapter, ERROR,
662 "Unable to allocate skb for EVENT buf.\n");
663 kfree(card->evtbd_ring_vbase);
666 skb_put(skb, MAX_EVENT_SIZE);
668 if (mwifiex_map_pci_memory(adapter, skb, MAX_EVENT_SIZE,
672 buf_pa = MWIFIEX_SKB_DMA_ADDR(skb);
674 mwifiex_dbg(adapter, EVENT,
675 "info: EVT ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
676 skb, skb->len, skb->data, (u32)buf_pa,
677 (u32)((u64)buf_pa >> 32));
679 card->evt_buf_list[i] = skb;
680 card->evtbd_ring[i] = (void *)(card->evtbd_ring_vbase +
681 (sizeof(*desc) * i));
682 desc = card->evtbd_ring[i];
683 desc->paddr = buf_pa;
684 desc->len = (u16)skb->len;
691 /* This function cleans up TX buffer rings. If any of the buffer list has valid
692 * SKB address, associated SKB is freed.
694 static void mwifiex_cleanup_txq_ring(struct mwifiex_adapter *adapter)
696 struct pcie_service_card *card = adapter->card;
697 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
699 struct mwifiex_pcie_buf_desc *desc;
700 struct mwifiex_pfu_buf_desc *desc2;
703 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
704 if (reg->pfu_enabled) {
705 desc2 = card->txbd_ring[i];
706 if (card->tx_buf_list[i]) {
707 skb = card->tx_buf_list[i];
708 mwifiex_unmap_pci_memory(adapter, skb,
710 dev_kfree_skb_any(skb);
712 memset(desc2, 0, sizeof(*desc2));
714 desc = card->txbd_ring[i];
715 if (card->tx_buf_list[i]) {
716 skb = card->tx_buf_list[i];
717 mwifiex_unmap_pci_memory(adapter, skb,
719 dev_kfree_skb_any(skb);
721 memset(desc, 0, sizeof(*desc));
723 card->tx_buf_list[i] = NULL;
726 atomic_set(&adapter->tx_hw_pending, 0);
730 /* This function cleans up RX buffer rings. If any of the buffer list has valid
731 * SKB address, associated SKB is freed.
733 static void mwifiex_cleanup_rxq_ring(struct mwifiex_adapter *adapter)
735 struct pcie_service_card *card = adapter->card;
736 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
737 struct mwifiex_pcie_buf_desc *desc;
738 struct mwifiex_pfu_buf_desc *desc2;
742 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
743 if (reg->pfu_enabled) {
744 desc2 = card->rxbd_ring[i];
745 if (card->rx_buf_list[i]) {
746 skb = card->rx_buf_list[i];
747 mwifiex_unmap_pci_memory(adapter, skb,
749 dev_kfree_skb_any(skb);
751 memset(desc2, 0, sizeof(*desc2));
753 desc = card->rxbd_ring[i];
754 if (card->rx_buf_list[i]) {
755 skb = card->rx_buf_list[i];
756 mwifiex_unmap_pci_memory(adapter, skb,
758 dev_kfree_skb_any(skb);
760 memset(desc, 0, sizeof(*desc));
762 card->rx_buf_list[i] = NULL;
768 /* This function cleans up event buffer rings. If any of the buffer list has
769 * valid SKB address, associated SKB is freed.
771 static void mwifiex_cleanup_evt_ring(struct mwifiex_adapter *adapter)
773 struct pcie_service_card *card = adapter->card;
774 struct mwifiex_evt_buf_desc *desc;
778 for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) {
779 desc = card->evtbd_ring[i];
780 if (card->evt_buf_list[i]) {
781 skb = card->evt_buf_list[i];
782 mwifiex_unmap_pci_memory(adapter, skb,
784 dev_kfree_skb_any(skb);
786 card->evt_buf_list[i] = NULL;
787 memset(desc, 0, sizeof(*desc));
793 /* This function creates buffer descriptor ring for TX
795 static int mwifiex_pcie_create_txbd_ring(struct mwifiex_adapter *adapter)
797 struct pcie_service_card *card = adapter->card;
798 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
801 * driver maintaines the write pointer and firmware maintaines the read
802 * pointer. The write pointer starts at 0 (zero) while the read pointer
803 * starts at zero with rollover bit set
805 card->txbd_wrptr = 0;
807 if (reg->pfu_enabled)
808 card->txbd_rdptr = 0;
810 card->txbd_rdptr |= reg->tx_rollover_ind;
812 /* allocate shared memory for the BD ring and divide the same in to
813 several descriptors */
814 if (reg->pfu_enabled)
815 card->txbd_ring_size = sizeof(struct mwifiex_pfu_buf_desc) *
818 card->txbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
821 mwifiex_dbg(adapter, INFO,
822 "info: txbd_ring: Allocating %d bytes\n",
823 card->txbd_ring_size);
824 card->txbd_ring_vbase = pci_alloc_consistent(card->dev,
825 card->txbd_ring_size,
826 &card->txbd_ring_pbase);
827 if (!card->txbd_ring_vbase) {
828 mwifiex_dbg(adapter, ERROR,
829 "allocate consistent memory (%d bytes) failed!\n",
830 card->txbd_ring_size);
833 mwifiex_dbg(adapter, DATA,
834 "info: txbd_ring - base: %p, pbase: %#x:%x, len: %x\n",
835 card->txbd_ring_vbase, (unsigned int)card->txbd_ring_pbase,
836 (u32)((u64)card->txbd_ring_pbase >> 32),
837 card->txbd_ring_size);
839 return mwifiex_init_txq_ring(adapter);
842 static int mwifiex_pcie_delete_txbd_ring(struct mwifiex_adapter *adapter)
844 struct pcie_service_card *card = adapter->card;
845 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
847 mwifiex_cleanup_txq_ring(adapter);
849 if (card->txbd_ring_vbase)
850 pci_free_consistent(card->dev, card->txbd_ring_size,
851 card->txbd_ring_vbase,
852 card->txbd_ring_pbase);
853 card->txbd_ring_size = 0;
854 card->txbd_wrptr = 0;
855 card->txbd_rdptr = 0 | reg->tx_rollover_ind;
856 card->txbd_ring_vbase = NULL;
857 card->txbd_ring_pbase = 0;
863 * This function creates buffer descriptor ring for RX
865 static int mwifiex_pcie_create_rxbd_ring(struct mwifiex_adapter *adapter)
867 struct pcie_service_card *card = adapter->card;
868 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
871 * driver maintaines the read pointer and firmware maintaines the write
872 * pointer. The write pointer starts at 0 (zero) while the read pointer
873 * starts at zero with rollover bit set
875 card->rxbd_wrptr = 0;
876 card->rxbd_rdptr = reg->rx_rollover_ind;
878 if (reg->pfu_enabled)
879 card->rxbd_ring_size = sizeof(struct mwifiex_pfu_buf_desc) *
882 card->rxbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
885 mwifiex_dbg(adapter, INFO,
886 "info: rxbd_ring: Allocating %d bytes\n",
887 card->rxbd_ring_size);
888 card->rxbd_ring_vbase = pci_alloc_consistent(card->dev,
889 card->rxbd_ring_size,
890 &card->rxbd_ring_pbase);
891 if (!card->rxbd_ring_vbase) {
892 mwifiex_dbg(adapter, ERROR,
893 "allocate consistent memory (%d bytes) failed!\n",
894 card->rxbd_ring_size);
898 mwifiex_dbg(adapter, DATA,
899 "info: rxbd_ring - base: %p, pbase: %#x:%x, len: %#x\n",
900 card->rxbd_ring_vbase, (u32)card->rxbd_ring_pbase,
901 (u32)((u64)card->rxbd_ring_pbase >> 32),
902 card->rxbd_ring_size);
904 return mwifiex_init_rxq_ring(adapter);
908 * This function deletes Buffer descriptor ring for RX
910 static int mwifiex_pcie_delete_rxbd_ring(struct mwifiex_adapter *adapter)
912 struct pcie_service_card *card = adapter->card;
913 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
915 mwifiex_cleanup_rxq_ring(adapter);
917 if (card->rxbd_ring_vbase)
918 pci_free_consistent(card->dev, card->rxbd_ring_size,
919 card->rxbd_ring_vbase,
920 card->rxbd_ring_pbase);
921 card->rxbd_ring_size = 0;
922 card->rxbd_wrptr = 0;
923 card->rxbd_rdptr = 0 | reg->rx_rollover_ind;
924 card->rxbd_ring_vbase = NULL;
925 card->rxbd_ring_pbase = 0;
931 * This function creates buffer descriptor ring for Events
933 static int mwifiex_pcie_create_evtbd_ring(struct mwifiex_adapter *adapter)
935 struct pcie_service_card *card = adapter->card;
936 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
939 * driver maintaines the read pointer and firmware maintaines the write
940 * pointer. The write pointer starts at 0 (zero) while the read pointer
941 * starts at zero with rollover bit set
943 card->evtbd_wrptr = 0;
944 card->evtbd_rdptr = reg->evt_rollover_ind;
946 card->evtbd_ring_size = sizeof(struct mwifiex_evt_buf_desc) *
949 mwifiex_dbg(adapter, INFO,
950 "info: evtbd_ring: Allocating %d bytes\n",
951 card->evtbd_ring_size);
952 card->evtbd_ring_vbase = pci_alloc_consistent(card->dev,
953 card->evtbd_ring_size,
954 &card->evtbd_ring_pbase);
955 if (!card->evtbd_ring_vbase) {
956 mwifiex_dbg(adapter, ERROR,
957 "allocate consistent memory (%d bytes) failed!\n",
958 card->evtbd_ring_size);
962 mwifiex_dbg(adapter, EVENT,
963 "info: CMDRSP/EVT bd_ring - base: %p pbase: %#x:%x len: %#x\n",
964 card->evtbd_ring_vbase, (u32)card->evtbd_ring_pbase,
965 (u32)((u64)card->evtbd_ring_pbase >> 32),
966 card->evtbd_ring_size);
968 return mwifiex_pcie_init_evt_ring(adapter);
972 * This function deletes Buffer descriptor ring for Events
974 static int mwifiex_pcie_delete_evtbd_ring(struct mwifiex_adapter *adapter)
976 struct pcie_service_card *card = adapter->card;
977 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
979 mwifiex_cleanup_evt_ring(adapter);
981 if (card->evtbd_ring_vbase)
982 pci_free_consistent(card->dev, card->evtbd_ring_size,
983 card->evtbd_ring_vbase,
984 card->evtbd_ring_pbase);
985 card->evtbd_wrptr = 0;
986 card->evtbd_rdptr = 0 | reg->evt_rollover_ind;
987 card->evtbd_ring_size = 0;
988 card->evtbd_ring_vbase = NULL;
989 card->evtbd_ring_pbase = 0;
995 * This function allocates a buffer for CMDRSP
997 static int mwifiex_pcie_alloc_cmdrsp_buf(struct mwifiex_adapter *adapter)
999 struct pcie_service_card *card = adapter->card;
1000 struct sk_buff *skb;
1002 /* Allocate memory for receiving command response data */
1003 skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
1005 mwifiex_dbg(adapter, ERROR,
1006 "Unable to allocate skb for command response data.\n");
1009 skb_put(skb, MWIFIEX_UPLD_SIZE);
1010 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1011 PCI_DMA_FROMDEVICE))
1014 card->cmdrsp_buf = skb;
1020 * This function deletes a buffer for CMDRSP
1022 static int mwifiex_pcie_delete_cmdrsp_buf(struct mwifiex_adapter *adapter)
1024 struct pcie_service_card *card;
1029 card = adapter->card;
1031 if (card && card->cmdrsp_buf) {
1032 mwifiex_unmap_pci_memory(adapter, card->cmdrsp_buf,
1033 PCI_DMA_FROMDEVICE);
1034 dev_kfree_skb_any(card->cmdrsp_buf);
1037 if (card && card->cmd_buf) {
1038 mwifiex_unmap_pci_memory(adapter, card->cmd_buf,
1040 dev_kfree_skb_any(card->cmd_buf);
1046 * This function allocates a buffer for sleep cookie
1048 static int mwifiex_pcie_alloc_sleep_cookie_buf(struct mwifiex_adapter *adapter)
1050 struct pcie_service_card *card = adapter->card;
1053 card->sleep_cookie_vbase = pci_alloc_consistent(card->dev, sizeof(u32),
1054 &card->sleep_cookie_pbase);
1055 if (!card->sleep_cookie_vbase) {
1056 mwifiex_dbg(adapter, ERROR,
1057 "pci_alloc_consistent failed!\n");
1060 /* Init val of Sleep Cookie */
1061 tmp = FW_AWAKE_COOKIE;
1062 put_unaligned(tmp, card->sleep_cookie_vbase);
1064 mwifiex_dbg(adapter, INFO,
1065 "alloc_scook: sleep cookie=0x%x\n",
1066 get_unaligned(card->sleep_cookie_vbase));
1072 * This function deletes buffer for sleep cookie
1074 static int mwifiex_pcie_delete_sleep_cookie_buf(struct mwifiex_adapter *adapter)
1076 struct pcie_service_card *card;
1081 card = adapter->card;
1083 if (card && card->sleep_cookie_vbase) {
1084 pci_free_consistent(card->dev, sizeof(u32),
1085 card->sleep_cookie_vbase,
1086 card->sleep_cookie_pbase);
1087 card->sleep_cookie_vbase = NULL;
1093 /* This function flushes the TX buffer descriptor ring
1094 * This function defined as handler is also called while cleaning TXRX
1095 * during disconnect/ bss stop.
1097 static int mwifiex_clean_pcie_ring_buf(struct mwifiex_adapter *adapter)
1099 struct pcie_service_card *card = adapter->card;
1101 if (!mwifiex_pcie_txbd_empty(card, card->txbd_rdptr)) {
1102 card->txbd_flush = 1;
1103 /* write pointer already set at last send
1104 * send dnld-rdy intr again, wait for completion.
1106 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1107 CPU_INTR_DNLD_RDY)) {
1108 mwifiex_dbg(adapter, ERROR,
1109 "failed to assert dnld-rdy interrupt.\n");
1117 * This function unmaps and frees downloaded data buffer
1119 static int mwifiex_pcie_send_data_complete(struct mwifiex_adapter *adapter)
1121 struct sk_buff *skb;
1122 u32 wrdoneidx, rdptr, num_tx_buffs, unmap_count = 0;
1123 struct mwifiex_pcie_buf_desc *desc;
1124 struct mwifiex_pfu_buf_desc *desc2;
1125 struct pcie_service_card *card = adapter->card;
1126 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1128 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1129 mwifiex_pm_wakeup_card(adapter);
1131 /* Read the TX ring read pointer set by firmware */
1132 if (mwifiex_read_reg(adapter, reg->tx_rdptr, &rdptr)) {
1133 mwifiex_dbg(adapter, ERROR,
1134 "SEND COMP: failed to read reg->tx_rdptr\n");
1138 mwifiex_dbg(adapter, DATA,
1139 "SEND COMP: rdptr_prev=0x%x, rdptr=0x%x\n",
1140 card->txbd_rdptr, rdptr);
1142 num_tx_buffs = MWIFIEX_MAX_TXRX_BD << reg->tx_start_ptr;
1143 /* free from previous txbd_rdptr to current txbd_rdptr */
1144 while (((card->txbd_rdptr & reg->tx_mask) !=
1145 (rdptr & reg->tx_mask)) ||
1146 ((card->txbd_rdptr & reg->tx_rollover_ind) !=
1147 (rdptr & reg->tx_rollover_ind))) {
1148 wrdoneidx = (card->txbd_rdptr & reg->tx_mask) >>
1151 skb = card->tx_buf_list[wrdoneidx];
1154 mwifiex_dbg(adapter, DATA,
1155 "SEND COMP: Detach skb %p at txbd_rdidx=%d\n",
1157 mwifiex_unmap_pci_memory(adapter, skb,
1162 if (card->txbd_flush)
1163 mwifiex_write_data_complete(adapter, skb, 0,
1166 mwifiex_write_data_complete(adapter, skb, 0, 0);
1167 atomic_dec(&adapter->tx_hw_pending);
1170 card->tx_buf_list[wrdoneidx] = NULL;
1172 if (reg->pfu_enabled) {
1173 desc2 = card->txbd_ring[wrdoneidx];
1174 memset(desc2, 0, sizeof(*desc2));
1176 desc = card->txbd_ring[wrdoneidx];
1177 memset(desc, 0, sizeof(*desc));
1179 switch (card->dev->device) {
1180 case PCIE_DEVICE_ID_MARVELL_88W8766P:
1183 case PCIE_DEVICE_ID_MARVELL_88W8897:
1184 case PCIE_DEVICE_ID_MARVELL_88W8997:
1185 card->txbd_rdptr += reg->ring_tx_start_ptr;
1190 if ((card->txbd_rdptr & reg->tx_mask) == num_tx_buffs)
1191 card->txbd_rdptr = ((card->txbd_rdptr &
1192 reg->tx_rollover_ind) ^
1193 reg->tx_rollover_ind);
1197 adapter->data_sent = false;
1199 if (card->txbd_flush) {
1200 if (mwifiex_pcie_txbd_empty(card, card->txbd_rdptr))
1201 card->txbd_flush = 0;
1203 mwifiex_clean_pcie_ring_buf(adapter);
1209 /* This function sends data buffer to device. First 4 bytes of payload
1210 * are filled with payload length and payload type. Then this payload
1211 * is mapped to PCI device memory. Tx ring pointers are advanced accordingly.
1212 * Download ready interrupt to FW is deffered if Tx ring is not full and
1213 * additional payload can be accomodated.
1214 * Caller must ensure tx_param parameter to this function is not NULL.
1217 mwifiex_pcie_send_data(struct mwifiex_adapter *adapter, struct sk_buff *skb,
1218 struct mwifiex_tx_param *tx_param)
1220 struct pcie_service_card *card = adapter->card;
1221 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1222 u32 wrindx, num_tx_buffs, rx_val;
1225 struct mwifiex_pcie_buf_desc *desc = NULL;
1226 struct mwifiex_pfu_buf_desc *desc2 = NULL;
1228 if (!(skb->data && skb->len)) {
1229 mwifiex_dbg(adapter, ERROR,
1230 "%s(): invalid parameter <%p, %#x>\n",
1231 __func__, skb->data, skb->len);
1235 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1236 mwifiex_pm_wakeup_card(adapter);
1238 num_tx_buffs = MWIFIEX_MAX_TXRX_BD << reg->tx_start_ptr;
1239 mwifiex_dbg(adapter, DATA,
1240 "info: SEND DATA: <Rd: %#x, Wr: %#x>\n",
1241 card->txbd_rdptr, card->txbd_wrptr);
1242 if (mwifiex_pcie_txbd_not_full(card)) {
1245 adapter->data_sent = true;
1246 payload = skb->data;
1247 put_unaligned_le16((u16)skb->len, payload + 0);
1248 put_unaligned_le16(MWIFIEX_TYPE_DATA, payload + 2);
1250 if (mwifiex_map_pci_memory(adapter, skb, skb->len,
1254 wrindx = (card->txbd_wrptr & reg->tx_mask) >> reg->tx_start_ptr;
1255 buf_pa = MWIFIEX_SKB_DMA_ADDR(skb);
1256 card->tx_buf_list[wrindx] = skb;
1257 atomic_inc(&adapter->tx_hw_pending);
1259 if (reg->pfu_enabled) {
1260 desc2 = card->txbd_ring[wrindx];
1261 desc2->paddr = buf_pa;
1262 desc2->len = (u16)skb->len;
1263 desc2->frag_len = (u16)skb->len;
1265 desc2->flags = MWIFIEX_BD_FLAG_FIRST_DESC |
1266 MWIFIEX_BD_FLAG_LAST_DESC;
1268 desc = card->txbd_ring[wrindx];
1269 desc->paddr = buf_pa;
1270 desc->len = (u16)skb->len;
1271 desc->flags = MWIFIEX_BD_FLAG_FIRST_DESC |
1272 MWIFIEX_BD_FLAG_LAST_DESC;
1275 switch (card->dev->device) {
1276 case PCIE_DEVICE_ID_MARVELL_88W8766P:
1279 case PCIE_DEVICE_ID_MARVELL_88W8897:
1280 case PCIE_DEVICE_ID_MARVELL_88W8997:
1281 card->txbd_wrptr += reg->ring_tx_start_ptr;
1285 if ((card->txbd_wrptr & reg->tx_mask) == num_tx_buffs)
1286 card->txbd_wrptr = ((card->txbd_wrptr &
1287 reg->tx_rollover_ind) ^
1288 reg->tx_rollover_ind);
1290 rx_val = card->rxbd_rdptr & reg->rx_wrap_mask;
1291 /* Write the TX ring write pointer in to reg->tx_wrptr */
1292 if (mwifiex_write_reg(adapter, reg->tx_wrptr,
1293 card->txbd_wrptr | rx_val)) {
1294 mwifiex_dbg(adapter, ERROR,
1295 "SEND DATA: failed to write reg->tx_wrptr\n");
1299 if ((mwifiex_pcie_txbd_not_full(card)) &&
1300 tx_param->next_pkt_len) {
1301 /* have more packets and TxBD still can hold more */
1302 mwifiex_dbg(adapter, DATA,
1303 "SEND DATA: delay dnld-rdy interrupt.\n");
1304 adapter->data_sent = false;
1306 /* Send the TX ready interrupt */
1307 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1308 CPU_INTR_DNLD_RDY)) {
1309 mwifiex_dbg(adapter, ERROR,
1310 "SEND DATA: failed to assert dnld-rdy interrupt.\n");
1315 mwifiex_dbg(adapter, DATA,
1316 "info: SEND DATA: Updated <Rd: %#x, Wr:\t"
1317 "%#x> and sent packet to firmware successfully\n",
1318 card->txbd_rdptr, card->txbd_wrptr);
1320 mwifiex_dbg(adapter, DATA,
1321 "info: TX Ring full, can't send packets to fw\n");
1322 adapter->data_sent = true;
1323 /* Send the TX ready interrupt */
1324 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1326 mwifiex_dbg(adapter, ERROR,
1327 "SEND DATA: failed to assert door-bell intr\n");
1331 return -EINPROGRESS;
1333 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1334 card->tx_buf_list[wrindx] = NULL;
1335 atomic_dec(&adapter->tx_hw_pending);
1336 if (reg->pfu_enabled)
1337 memset(desc2, 0, sizeof(*desc2));
1339 memset(desc, 0, sizeof(*desc));
1345 * This function handles received buffer ring and
1346 * dispatches packets to upper
1348 static int mwifiex_pcie_process_recv_data(struct mwifiex_adapter *adapter)
1350 struct pcie_service_card *card = adapter->card;
1351 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1352 u32 wrptr, rd_index, tx_val;
1355 struct sk_buff *skb_tmp = NULL;
1356 struct mwifiex_pcie_buf_desc *desc;
1357 struct mwifiex_pfu_buf_desc *desc2;
1359 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1360 mwifiex_pm_wakeup_card(adapter);
1362 /* Read the RX ring Write pointer set by firmware */
1363 if (mwifiex_read_reg(adapter, reg->rx_wrptr, &wrptr)) {
1364 mwifiex_dbg(adapter, ERROR,
1365 "RECV DATA: failed to read reg->rx_wrptr\n");
1369 card->rxbd_wrptr = wrptr;
1371 while (((wrptr & reg->rx_mask) !=
1372 (card->rxbd_rdptr & reg->rx_mask)) ||
1373 ((wrptr & reg->rx_rollover_ind) ==
1374 (card->rxbd_rdptr & reg->rx_rollover_ind))) {
1375 struct sk_buff *skb_data;
1378 rd_index = card->rxbd_rdptr & reg->rx_mask;
1379 skb_data = card->rx_buf_list[rd_index];
1381 /* If skb allocation was failed earlier for Rx packet,
1382 * rx_buf_list[rd_index] would have been left with a NULL.
1387 mwifiex_unmap_pci_memory(adapter, skb_data, PCI_DMA_FROMDEVICE);
1388 card->rx_buf_list[rd_index] = NULL;
1390 /* Get data length from interface header -
1391 * first 2 bytes for len, next 2 bytes is for type
1393 rx_len = get_unaligned_le16(skb_data->data);
1394 if (WARN_ON(rx_len <= INTF_HEADER_LEN ||
1395 rx_len > MWIFIEX_RX_DATA_BUF_SIZE)) {
1396 mwifiex_dbg(adapter, ERROR,
1397 "Invalid RX len %d, Rd=%#x, Wr=%#x\n",
1398 rx_len, card->rxbd_rdptr, wrptr);
1399 dev_kfree_skb_any(skb_data);
1401 skb_put(skb_data, rx_len);
1402 mwifiex_dbg(adapter, DATA,
1403 "info: RECV DATA: Rd=%#x, Wr=%#x, Len=%d\n",
1404 card->rxbd_rdptr, wrptr, rx_len);
1405 skb_pull(skb_data, INTF_HEADER_LEN);
1406 if (adapter->rx_work_enabled) {
1407 skb_queue_tail(&adapter->rx_data_q, skb_data);
1408 adapter->data_received = true;
1409 atomic_inc(&adapter->rx_pending);
1411 mwifiex_handle_rx_packet(adapter, skb_data);
1415 skb_tmp = mwifiex_alloc_dma_align_buf(MWIFIEX_RX_DATA_BUF_SIZE,
1418 mwifiex_dbg(adapter, ERROR,
1419 "Unable to allocate skb.\n");
1423 if (mwifiex_map_pci_memory(adapter, skb_tmp,
1424 MWIFIEX_RX_DATA_BUF_SIZE,
1425 PCI_DMA_FROMDEVICE))
1428 buf_pa = MWIFIEX_SKB_DMA_ADDR(skb_tmp);
1430 mwifiex_dbg(adapter, INFO,
1431 "RECV DATA: Attach new sk_buff %p at rxbd_rdidx=%d\n",
1433 card->rx_buf_list[rd_index] = skb_tmp;
1435 if (reg->pfu_enabled) {
1436 desc2 = card->rxbd_ring[rd_index];
1437 desc2->paddr = buf_pa;
1438 desc2->len = skb_tmp->len;
1439 desc2->frag_len = skb_tmp->len;
1441 desc2->flags = reg->ring_flag_sop | reg->ring_flag_eop;
1443 desc = card->rxbd_ring[rd_index];
1444 desc->paddr = buf_pa;
1445 desc->len = skb_tmp->len;
1449 if ((++card->rxbd_rdptr & reg->rx_mask) ==
1450 MWIFIEX_MAX_TXRX_BD) {
1451 card->rxbd_rdptr = ((card->rxbd_rdptr &
1452 reg->rx_rollover_ind) ^
1453 reg->rx_rollover_ind);
1455 mwifiex_dbg(adapter, DATA,
1456 "info: RECV DATA: <Rd: %#x, Wr: %#x>\n",
1457 card->rxbd_rdptr, wrptr);
1459 tx_val = card->txbd_wrptr & reg->tx_wrap_mask;
1460 /* Write the RX ring read pointer in to reg->rx_rdptr */
1461 if (mwifiex_write_reg(adapter, reg->rx_rdptr,
1462 card->rxbd_rdptr | tx_val)) {
1463 mwifiex_dbg(adapter, DATA,
1464 "RECV DATA: failed to write reg->rx_rdptr\n");
1469 /* Read the RX ring Write pointer set by firmware */
1470 if (mwifiex_read_reg(adapter, reg->rx_wrptr, &wrptr)) {
1471 mwifiex_dbg(adapter, ERROR,
1472 "RECV DATA: failed to read reg->rx_wrptr\n");
1476 mwifiex_dbg(adapter, DATA,
1477 "info: RECV DATA: Rcvd packet from fw successfully\n");
1478 card->rxbd_wrptr = wrptr;
1486 * This function downloads the boot command to device
1489 mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
1492 struct pcie_service_card *card = adapter->card;
1493 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1495 if (!(skb->data && skb->len)) {
1496 mwifiex_dbg(adapter, ERROR,
1497 "Invalid parameter in %s <%p. len %d>\n",
1498 __func__, skb->data, skb->len);
1502 if (mwifiex_map_pci_memory(adapter, skb, skb->len, PCI_DMA_TODEVICE))
1505 buf_pa = MWIFIEX_SKB_DMA_ADDR(skb);
1507 /* Write the lower 32bits of the physical address to low command
1508 * address scratch register
1510 if (mwifiex_write_reg(adapter, reg->cmd_addr_lo, (u32)buf_pa)) {
1511 mwifiex_dbg(adapter, ERROR,
1512 "%s: failed to write download command to boot code.\n",
1514 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1518 /* Write the upper 32bits of the physical address to high command
1519 * address scratch register
1521 if (mwifiex_write_reg(adapter, reg->cmd_addr_hi,
1522 (u32)((u64)buf_pa >> 32))) {
1523 mwifiex_dbg(adapter, ERROR,
1524 "%s: failed to write download command to boot code.\n",
1526 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1530 /* Write the command length to cmd_size scratch register */
1531 if (mwifiex_write_reg(adapter, reg->cmd_size, skb->len)) {
1532 mwifiex_dbg(adapter, ERROR,
1533 "%s: failed to write command len to cmd_size scratch reg\n",
1535 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1539 /* Ring the door bell */
1540 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1541 CPU_INTR_DOOR_BELL)) {
1542 mwifiex_dbg(adapter, ERROR,
1543 "%s: failed to assert door-bell intr\n", __func__);
1544 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1551 /* This function init rx port in firmware which in turn enables to receive data
1552 * from device before transmitting any packet.
1554 static int mwifiex_pcie_init_fw_port(struct mwifiex_adapter *adapter)
1556 struct pcie_service_card *card = adapter->card;
1557 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1558 int tx_wrap = card->txbd_wrptr & reg->tx_wrap_mask;
1560 /* Write the RX ring read pointer in to reg->rx_rdptr */
1561 if (mwifiex_write_reg(adapter, reg->rx_rdptr, card->rxbd_rdptr |
1563 mwifiex_dbg(adapter, ERROR,
1564 "RECV DATA: failed to write reg->rx_rdptr\n");
1570 /* This function downloads commands to the device
1573 mwifiex_pcie_send_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
1575 struct pcie_service_card *card = adapter->card;
1576 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1578 dma_addr_t cmd_buf_pa, cmdrsp_buf_pa;
1579 u8 *payload = (u8 *)skb->data;
1581 if (!(skb->data && skb->len)) {
1582 mwifiex_dbg(adapter, ERROR,
1583 "Invalid parameter in %s <%p, %#x>\n",
1584 __func__, skb->data, skb->len);
1588 /* Make sure a command response buffer is available */
1589 if (!card->cmdrsp_buf) {
1590 mwifiex_dbg(adapter, ERROR,
1591 "No response buffer available, send command failed\n");
1595 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1596 mwifiex_pm_wakeup_card(adapter);
1598 adapter->cmd_sent = true;
1600 put_unaligned_le16((u16)skb->len, &payload[0]);
1601 put_unaligned_le16(MWIFIEX_TYPE_CMD, &payload[2]);
1603 if (mwifiex_map_pci_memory(adapter, skb, skb->len, PCI_DMA_TODEVICE))
1606 card->cmd_buf = skb;
1608 * Need to keep a reference, since core driver might free up this
1609 * buffer before we've unmapped it.
1613 /* To send a command, the driver will:
1614 1. Write the 64bit physical address of the data buffer to
1615 cmd response address low + cmd response address high
1616 2. Ring the door bell (i.e. set the door bell interrupt)
1618 In response to door bell interrupt, the firmware will perform
1619 the DMA of the command packet (first header to obtain the total
1620 length and then rest of the command).
1623 if (card->cmdrsp_buf) {
1624 cmdrsp_buf_pa = MWIFIEX_SKB_DMA_ADDR(card->cmdrsp_buf);
1625 /* Write the lower 32bits of the cmdrsp buffer physical
1627 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo,
1628 (u32)cmdrsp_buf_pa)) {
1629 mwifiex_dbg(adapter, ERROR,
1630 "Failed to write download cmd to boot code.\n");
1634 /* Write the upper 32bits of the cmdrsp buffer physical
1636 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi,
1637 (u32)((u64)cmdrsp_buf_pa >> 32))) {
1638 mwifiex_dbg(adapter, ERROR,
1639 "Failed to write download cmd to boot code.\n");
1645 cmd_buf_pa = MWIFIEX_SKB_DMA_ADDR(card->cmd_buf);
1646 /* Write the lower 32bits of the physical address to reg->cmd_addr_lo */
1647 if (mwifiex_write_reg(adapter, reg->cmd_addr_lo,
1649 mwifiex_dbg(adapter, ERROR,
1650 "Failed to write download cmd to boot code.\n");
1654 /* Write the upper 32bits of the physical address to reg->cmd_addr_hi */
1655 if (mwifiex_write_reg(adapter, reg->cmd_addr_hi,
1656 (u32)((u64)cmd_buf_pa >> 32))) {
1657 mwifiex_dbg(adapter, ERROR,
1658 "Failed to write download cmd to boot code.\n");
1663 /* Write the command length to reg->cmd_size */
1664 if (mwifiex_write_reg(adapter, reg->cmd_size,
1665 card->cmd_buf->len)) {
1666 mwifiex_dbg(adapter, ERROR,
1667 "Failed to write cmd len to reg->cmd_size\n");
1672 /* Ring the door bell */
1673 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1674 CPU_INTR_DOOR_BELL)) {
1675 mwifiex_dbg(adapter, ERROR,
1676 "Failed to assert door-bell intr\n");
1683 adapter->cmd_sent = false;
1689 * This function handles command complete interrupt
1691 static int mwifiex_pcie_process_cmd_complete(struct mwifiex_adapter *adapter)
1693 struct pcie_service_card *card = adapter->card;
1694 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1695 struct sk_buff *skb = card->cmdrsp_buf;
1699 mwifiex_dbg(adapter, CMD,
1700 "info: Rx CMD Response\n");
1702 if (adapter->curr_cmd)
1703 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_FROMDEVICE);
1705 pci_dma_sync_single_for_cpu(card->dev,
1706 MWIFIEX_SKB_DMA_ADDR(skb),
1708 PCI_DMA_FROMDEVICE);
1710 /* Unmap the command as a response has been received. */
1711 if (card->cmd_buf) {
1712 mwifiex_unmap_pci_memory(adapter, card->cmd_buf,
1714 dev_kfree_skb_any(card->cmd_buf);
1715 card->cmd_buf = NULL;
1718 rx_len = get_unaligned_le16(skb->data);
1719 skb_put(skb, MWIFIEX_UPLD_SIZE - skb->len);
1720 skb_trim(skb, rx_len);
1722 if (!adapter->curr_cmd) {
1723 if (adapter->ps_state == PS_STATE_SLEEP_CFM) {
1724 pci_dma_sync_single_for_device(card->dev,
1725 MWIFIEX_SKB_DMA_ADDR(skb),
1726 MWIFIEX_SLEEP_COOKIE_SIZE,
1727 PCI_DMA_FROMDEVICE);
1728 if (mwifiex_write_reg(adapter,
1730 CPU_INTR_SLEEP_CFM_DONE)) {
1731 mwifiex_dbg(adapter, ERROR,
1732 "Write register failed\n");
1735 mwifiex_delay_for_sleep_cookie(adapter,
1736 MWIFIEX_MAX_DELAY_COUNT);
1737 mwifiex_unmap_pci_memory(adapter, skb,
1738 PCI_DMA_FROMDEVICE);
1739 skb_pull(skb, INTF_HEADER_LEN);
1740 while (reg->sleep_cookie && (count++ < 10) &&
1741 mwifiex_pcie_ok_to_access_hw(adapter))
1742 usleep_range(50, 60);
1743 mwifiex_pcie_enable_host_int(adapter);
1744 mwifiex_process_sleep_confirm_resp(adapter, skb->data,
1747 mwifiex_dbg(adapter, ERROR,
1748 "There is no command but got cmdrsp\n");
1750 memcpy(adapter->upld_buf, skb->data,
1751 min_t(u32, MWIFIEX_SIZE_OF_CMD_BUFFER, skb->len));
1752 skb_push(skb, INTF_HEADER_LEN);
1753 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1754 PCI_DMA_FROMDEVICE))
1756 } else if (mwifiex_pcie_ok_to_access_hw(adapter)) {
1757 skb_pull(skb, INTF_HEADER_LEN);
1758 adapter->curr_cmd->resp_skb = skb;
1759 adapter->cmd_resp_received = true;
1760 /* Take the pointer and set it to CMD node and will
1761 return in the response complete callback */
1762 card->cmdrsp_buf = NULL;
1764 /* Clear the cmd-rsp buffer address in scratch registers. This
1765 will prevent firmware from writing to the same response
1767 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo, 0)) {
1768 mwifiex_dbg(adapter, ERROR,
1769 "cmd_done: failed to clear cmd_rsp_addr_lo\n");
1772 /* Write the upper 32bits of the cmdrsp buffer physical
1774 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi, 0)) {
1775 mwifiex_dbg(adapter, ERROR,
1776 "cmd_done: failed to clear cmd_rsp_addr_hi\n");
1785 * Command Response processing complete handler
1787 static int mwifiex_pcie_cmdrsp_complete(struct mwifiex_adapter *adapter,
1788 struct sk_buff *skb)
1790 struct pcie_service_card *card = adapter->card;
1793 card->cmdrsp_buf = skb;
1794 skb_push(card->cmdrsp_buf, INTF_HEADER_LEN);
1795 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1796 PCI_DMA_FROMDEVICE))
1804 * This function handles firmware event ready interrupt
1806 static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter *adapter)
1808 struct pcie_service_card *card = adapter->card;
1809 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1810 u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1812 struct mwifiex_evt_buf_desc *desc;
1814 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1815 mwifiex_pm_wakeup_card(adapter);
1817 if (adapter->event_received) {
1818 mwifiex_dbg(adapter, EVENT,
1819 "info: Event being processed,\t"
1820 "do not process this interrupt just yet\n");
1824 if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1825 mwifiex_dbg(adapter, ERROR,
1826 "info: Invalid read pointer...\n");
1830 /* Read the event ring write pointer set by firmware */
1831 if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1832 mwifiex_dbg(adapter, ERROR,
1833 "EventReady: failed to read reg->evt_wrptr\n");
1837 mwifiex_dbg(adapter, EVENT,
1838 "info: EventReady: Initial <Rd: 0x%x, Wr: 0x%x>",
1839 card->evtbd_rdptr, wrptr);
1840 if (((wrptr & MWIFIEX_EVTBD_MASK) != (card->evtbd_rdptr
1841 & MWIFIEX_EVTBD_MASK)) ||
1842 ((wrptr & reg->evt_rollover_ind) ==
1843 (card->evtbd_rdptr & reg->evt_rollover_ind))) {
1844 struct sk_buff *skb_cmd;
1845 __le16 data_len = 0;
1848 mwifiex_dbg(adapter, INFO,
1849 "info: Read Index: %d\n", rdptr);
1850 skb_cmd = card->evt_buf_list[rdptr];
1851 mwifiex_unmap_pci_memory(adapter, skb_cmd, PCI_DMA_FROMDEVICE);
1853 /* Take the pointer and set it to event pointer in adapter
1854 and will return back after event handling callback */
1855 card->evt_buf_list[rdptr] = NULL;
1856 desc = card->evtbd_ring[rdptr];
1857 memset(desc, 0, sizeof(*desc));
1859 event = get_unaligned_le32(&skb_cmd->data[INTF_HEADER_LEN]);
1860 adapter->event_cause = event;
1861 /* The first 4bytes will be the event transfer header
1862 len is 2 bytes followed by type which is 2 bytes */
1863 memcpy(&data_len, skb_cmd->data, sizeof(__le16));
1864 evt_len = le16_to_cpu(data_len);
1865 skb_trim(skb_cmd, evt_len);
1866 skb_pull(skb_cmd, INTF_HEADER_LEN);
1867 mwifiex_dbg(adapter, EVENT,
1868 "info: Event length: %d\n", evt_len);
1870 if ((evt_len > 0) && (evt_len < MAX_EVENT_SIZE))
1871 memcpy(adapter->event_body, skb_cmd->data +
1872 MWIFIEX_EVENT_HEADER_LEN, evt_len -
1873 MWIFIEX_EVENT_HEADER_LEN);
1875 adapter->event_received = true;
1876 adapter->event_skb = skb_cmd;
1878 /* Do not update the event read pointer here, wait till the
1879 buffer is released. This is just to make things simpler,
1880 we need to find a better method of managing these buffers.
1883 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1884 CPU_INTR_EVENT_DONE)) {
1885 mwifiex_dbg(adapter, ERROR,
1886 "Write register failed\n");
1895 * Event processing complete handler
1897 static int mwifiex_pcie_event_complete(struct mwifiex_adapter *adapter,
1898 struct sk_buff *skb)
1900 struct pcie_service_card *card = adapter->card;
1901 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1903 u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1905 struct mwifiex_evt_buf_desc *desc;
1910 if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1911 mwifiex_dbg(adapter, ERROR,
1912 "event_complete: Invalid rdptr 0x%x\n",
1917 /* Read the event ring write pointer set by firmware */
1918 if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1919 mwifiex_dbg(adapter, ERROR,
1920 "event_complete: failed to read reg->evt_wrptr\n");
1924 if (!card->evt_buf_list[rdptr]) {
1925 skb_push(skb, INTF_HEADER_LEN);
1926 skb_put(skb, MAX_EVENT_SIZE - skb->len);
1927 if (mwifiex_map_pci_memory(adapter, skb,
1929 PCI_DMA_FROMDEVICE))
1931 card->evt_buf_list[rdptr] = skb;
1932 desc = card->evtbd_ring[rdptr];
1933 desc->paddr = MWIFIEX_SKB_DMA_ADDR(skb);
1934 desc->len = (u16)skb->len;
1938 mwifiex_dbg(adapter, ERROR,
1939 "info: ERROR: buf still valid at index %d, <%p, %p>\n",
1940 rdptr, card->evt_buf_list[rdptr], skb);
1943 if ((++card->evtbd_rdptr & MWIFIEX_EVTBD_MASK) == MWIFIEX_MAX_EVT_BD) {
1944 card->evtbd_rdptr = ((card->evtbd_rdptr &
1945 reg->evt_rollover_ind) ^
1946 reg->evt_rollover_ind);
1949 mwifiex_dbg(adapter, EVENT,
1950 "info: Updated <Rd: 0x%x, Wr: 0x%x>",
1951 card->evtbd_rdptr, wrptr);
1953 /* Write the event ring read pointer in to reg->evt_rdptr */
1954 if (mwifiex_write_reg(adapter, reg->evt_rdptr,
1955 card->evtbd_rdptr)) {
1956 mwifiex_dbg(adapter, ERROR,
1957 "event_complete: failed to read reg->evt_rdptr\n");
1961 mwifiex_dbg(adapter, EVENT,
1962 "info: Check Events Again\n");
1963 ret = mwifiex_pcie_process_event_ready(adapter);
1968 /* Combo firmware image is a combination of
1969 * (1) combo crc heaer, start with CMD5
1970 * (2) bluetooth image, start with CMD7, end with CMD6, data wrapped in CMD1.
1973 * This function bypass the header and bluetooth part, return
1974 * the offset of tail wifi-only part.
1977 static int mwifiex_extract_wifi_fw(struct mwifiex_adapter *adapter,
1978 const void *firmware, u32 firmware_len) {
1979 const struct mwifiex_fw_data *fwdata;
1980 u32 offset = 0, data_len, dnld_cmd;
1982 bool cmd7_before = false;
1985 /* Check for integer and buffer overflow */
1986 if (offset + sizeof(fwdata->header) < sizeof(fwdata->header) ||
1987 offset + sizeof(fwdata->header) >= firmware_len) {
1988 mwifiex_dbg(adapter, ERROR,
1989 "extract wifi-only fw failure!\n");
1994 fwdata = firmware + offset;
1995 dnld_cmd = le32_to_cpu(fwdata->header.dnld_cmd);
1996 data_len = le32_to_cpu(fwdata->header.data_length);
1998 /* Skip past header */
1999 offset += sizeof(fwdata->header);
2002 case MWIFIEX_FW_DNLD_CMD_1:
2004 mwifiex_dbg(adapter, ERROR,
2005 "no cmd7 before cmd1!\n");
2009 if (offset + data_len < data_len) {
2010 mwifiex_dbg(adapter, ERROR, "bad FW parse\n");
2016 case MWIFIEX_FW_DNLD_CMD_5:
2017 /* Check for integer overflow */
2018 if (offset + data_len < data_len) {
2019 mwifiex_dbg(adapter, ERROR, "bad FW parse\n");
2025 case MWIFIEX_FW_DNLD_CMD_6:
2026 /* Check for integer overflow */
2027 if (offset + data_len < data_len) {
2028 mwifiex_dbg(adapter, ERROR, "bad FW parse\n");
2033 if (offset >= firmware_len) {
2034 mwifiex_dbg(adapter, ERROR,
2035 "extract wifi-only fw failure!\n");
2041 case MWIFIEX_FW_DNLD_CMD_7:
2045 mwifiex_dbg(adapter, ERROR, "unknown dnld_cmd %d\n",
2057 * This function downloads the firmware to the card.
2059 * Firmware is downloaded to the card in blocks. Every block download
2060 * is tested for CRC errors, and retried a number of times before
2061 * returning failure.
2063 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter *adapter,
2064 struct mwifiex_fw_image *fw)
2067 u8 *firmware = fw->fw_buf;
2068 u32 firmware_len = fw->fw_len;
2070 struct sk_buff *skb;
2071 u32 txlen, tx_blocks = 0, tries, len, val;
2072 u32 block_retry_cnt = 0;
2073 struct pcie_service_card *card = adapter->card;
2074 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2076 if (!firmware || !firmware_len) {
2077 mwifiex_dbg(adapter, ERROR,
2078 "No firmware image found! Terminating download\n");
2082 mwifiex_dbg(adapter, INFO,
2083 "info: Downloading FW image (%d bytes)\n",
2086 if (mwifiex_pcie_disable_host_int(adapter)) {
2087 mwifiex_dbg(adapter, ERROR,
2088 "%s: Disabling interrupts failed.\n", __func__);
2092 skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
2098 ret = mwifiex_read_reg(adapter, PCIE_SCRATCH_13_REG, &val);
2100 mwifiex_dbg(adapter, FATAL, "Failed to read scratch register 13\n");
2104 /* PCIE FLR case: extract wifi part from combo firmware*/
2105 if (val == MWIFIEX_PCIE_FLR_HAPPENS) {
2106 ret = mwifiex_extract_wifi_fw(adapter, firmware, firmware_len);
2108 mwifiex_dbg(adapter, ERROR, "Failed to extract wifi fw\n");
2112 mwifiex_dbg(adapter, MSG,
2113 "info: dnld wifi firmware from %d bytes\n", offset);
2116 /* Perform firmware data transfer */
2121 if (offset >= firmware_len)
2124 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
2125 ret = mwifiex_read_reg(adapter, reg->cmd_size,
2128 mwifiex_dbg(adapter, FATAL,
2129 "Failed reading len from boot code\n");
2134 usleep_range(10, 20);
2139 } else if (len > MWIFIEX_UPLD_SIZE) {
2140 mwifiex_dbg(adapter, ERROR,
2141 "FW download failure @ %d, invalid length %d\n",
2151 if (block_retry_cnt > MAX_WRITE_IOMEM_RETRY) {
2152 mwifiex_dbg(adapter, ERROR,
2153 "FW download failure @ %d, over max\t"
2154 "retry count\n", offset);
2158 mwifiex_dbg(adapter, ERROR,
2159 "FW CRC error indicated by the\t"
2160 "helper: len = 0x%04X, txlen = %d\n",
2163 /* Setting this to 0 to resend from same offset */
2166 block_retry_cnt = 0;
2167 /* Set blocksize to transfer - checking for
2169 if (firmware_len - offset < txlen)
2170 txlen = firmware_len - offset;
2172 tx_blocks = (txlen + card->pcie.blksz_fw_dl - 1) /
2173 card->pcie.blksz_fw_dl;
2175 /* Copy payload to buffer */
2176 memmove(skb->data, &firmware[offset], txlen);
2179 skb_put(skb, MWIFIEX_UPLD_SIZE - skb->len);
2180 skb_trim(skb, tx_blocks * card->pcie.blksz_fw_dl);
2182 /* Send the boot command to device */
2183 if (mwifiex_pcie_send_boot_cmd(adapter, skb)) {
2184 mwifiex_dbg(adapter, ERROR,
2185 "Failed to send firmware download command\n");
2190 /* Wait for the command done interrupt */
2191 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
2192 if (mwifiex_read_reg(adapter, PCIE_CPU_INT_STATUS,
2194 mwifiex_dbg(adapter, ERROR,
2195 "%s: Failed to read\t"
2196 "interrupt status during fw dnld.\n",
2198 mwifiex_unmap_pci_memory(adapter, skb,
2203 if (!(ireg_intr & CPU_INTR_DOOR_BELL))
2205 usleep_range(10, 20);
2207 if (ireg_intr & CPU_INTR_DOOR_BELL) {
2208 mwifiex_dbg(adapter, ERROR, "%s: Card failed to ACK download\n",
2210 mwifiex_unmap_pci_memory(adapter, skb,
2216 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
2221 mwifiex_dbg(adapter, MSG,
2222 "info: FW download over, size %d bytes\n", offset);
2227 dev_kfree_skb_any(skb);
2232 * This function checks the firmware status in card.
2235 mwifiex_check_fw_status(struct mwifiex_adapter *adapter, u32 poll_num)
2239 struct pcie_service_card *card = adapter->card;
2240 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2243 /* Mask spurios interrupts */
2244 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS_MASK,
2246 mwifiex_dbg(adapter, ERROR,
2247 "Write register failed\n");
2251 mwifiex_dbg(adapter, INFO,
2252 "Setting driver ready signature\n");
2253 if (mwifiex_write_reg(adapter, reg->drv_rdy,
2254 FIRMWARE_READY_PCIE)) {
2255 mwifiex_dbg(adapter, ERROR,
2256 "Failed to write driver ready signature\n");
2260 /* Wait for firmware initialization event */
2261 for (tries = 0; tries < poll_num; tries++) {
2262 if (mwifiex_read_reg(adapter, reg->fw_status,
2268 mwifiex_dbg(adapter, INFO, "Try %d if FW is ready <%d,%#x>",
2269 tries, ret, firmware_stat);
2273 if (firmware_stat == FIRMWARE_READY_PCIE) {
2285 /* This function checks if WLAN is the winner.
2288 mwifiex_check_winner_status(struct mwifiex_adapter *adapter)
2292 struct pcie_service_card *card = adapter->card;
2293 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2295 if (mwifiex_read_reg(adapter, reg->fw_status, &winner)) {
2297 } else if (!winner) {
2298 mwifiex_dbg(adapter, INFO, "PCI-E is the winner\n");
2299 adapter->winner = 1;
2301 mwifiex_dbg(adapter, ERROR,
2302 "PCI-E is not the winner <%#x>", winner);
2309 * This function reads the interrupt status from card.
2311 static void mwifiex_interrupt_status(struct mwifiex_adapter *adapter,
2315 unsigned long flags;
2316 struct pcie_service_card *card = adapter->card;
2318 if (card->msi_enable) {
2319 spin_lock_irqsave(&adapter->int_lock, flags);
2320 adapter->int_status = 1;
2321 spin_unlock_irqrestore(&adapter->int_lock, flags);
2325 if (!mwifiex_pcie_ok_to_access_hw(adapter))
2328 if (card->msix_enable && msg_id >= 0) {
2329 pcie_ireg = BIT(msg_id);
2331 if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS,
2333 mwifiex_dbg(adapter, ERROR, "Read register failed\n");
2337 if ((pcie_ireg == 0xFFFFFFFF) || !pcie_ireg)
2341 mwifiex_pcie_disable_host_int(adapter);
2343 /* Clear the pending interrupts */
2344 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS,
2346 mwifiex_dbg(adapter, ERROR,
2347 "Write register failed\n");
2352 if (!adapter->pps_uapsd_mode &&
2353 adapter->ps_state == PS_STATE_SLEEP &&
2354 mwifiex_pcie_ok_to_access_hw(adapter)) {
2355 /* Potentially for PCIe we could get other
2356 * interrupts like shared. Don't change power
2357 * state until cookie is set
2359 adapter->ps_state = PS_STATE_AWAKE;
2360 adapter->pm_wakeup_fw_try = false;
2361 del_timer(&adapter->wakeup_timer);
2364 spin_lock_irqsave(&adapter->int_lock, flags);
2365 adapter->int_status |= pcie_ireg;
2366 spin_unlock_irqrestore(&adapter->int_lock, flags);
2367 mwifiex_dbg(adapter, INTR, "ireg: 0x%08x\n", pcie_ireg);
2371 * Interrupt handler for PCIe root port
2373 * This function reads the interrupt status from firmware and assigns
2374 * the main process in workqueue which will handle the interrupt.
2376 static irqreturn_t mwifiex_pcie_interrupt(int irq, void *context)
2378 struct mwifiex_msix_context *ctx = context;
2379 struct pci_dev *pdev = ctx->dev;
2380 struct pcie_service_card *card;
2381 struct mwifiex_adapter *adapter;
2384 pr_err("info: %s: pdev is NULL\n", __func__);
2388 card = pci_get_drvdata(pdev);
2390 if (!card->adapter) {
2391 pr_err("info: %s: card=%p adapter=%p\n", __func__, card,
2392 card ? card->adapter : NULL);
2395 adapter = card->adapter;
2397 if (adapter->surprise_removed)
2400 if (card->msix_enable)
2401 mwifiex_interrupt_status(adapter, ctx->msg_id);
2403 mwifiex_interrupt_status(adapter, -1);
2405 mwifiex_queue_main_work(adapter);
2412 * This function checks the current interrupt status.
2414 * The following interrupts are checked and handled by this function -
2417 * - Command received
2418 * - Packets received
2421 * In case of Rx packets received, the packets are uploaded from card to
2422 * host and processed accordingly.
2424 static int mwifiex_process_pcie_int(struct mwifiex_adapter *adapter)
2428 unsigned long flags;
2429 struct pcie_service_card *card = adapter->card;
2431 spin_lock_irqsave(&adapter->int_lock, flags);
2432 if (!card->msi_enable) {
2433 /* Clear out unused interrupts */
2434 pcie_ireg = adapter->int_status;
2436 adapter->int_status = 0;
2437 spin_unlock_irqrestore(&adapter->int_lock, flags);
2439 if (card->msi_enable) {
2440 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
2441 if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS,
2443 mwifiex_dbg(adapter, ERROR,
2444 "Read register failed\n");
2448 if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
2449 if (mwifiex_write_reg(adapter,
2450 PCIE_HOST_INT_STATUS,
2452 mwifiex_dbg(adapter, ERROR,
2453 "Write register failed\n");
2456 if (!adapter->pps_uapsd_mode &&
2457 adapter->ps_state == PS_STATE_SLEEP) {
2458 adapter->ps_state = PS_STATE_AWAKE;
2459 adapter->pm_wakeup_fw_try = false;
2460 del_timer(&adapter->wakeup_timer);
2466 if (pcie_ireg & HOST_INTR_DNLD_DONE) {
2467 pcie_ireg &= ~HOST_INTR_DNLD_DONE;
2468 mwifiex_dbg(adapter, INTR, "info: TX DNLD Done\n");
2469 ret = mwifiex_pcie_send_data_complete(adapter);
2473 if (pcie_ireg & HOST_INTR_UPLD_RDY) {
2474 pcie_ireg &= ~HOST_INTR_UPLD_RDY;
2475 mwifiex_dbg(adapter, INTR, "info: Rx DATA\n");
2476 ret = mwifiex_pcie_process_recv_data(adapter);
2480 if (pcie_ireg & HOST_INTR_EVENT_RDY) {
2481 pcie_ireg &= ~HOST_INTR_EVENT_RDY;
2482 mwifiex_dbg(adapter, INTR, "info: Rx EVENT\n");
2483 ret = mwifiex_pcie_process_event_ready(adapter);
2487 if (pcie_ireg & HOST_INTR_CMD_DONE) {
2488 pcie_ireg &= ~HOST_INTR_CMD_DONE;
2489 if (adapter->cmd_sent) {
2490 mwifiex_dbg(adapter, INTR,
2491 "info: CMD sent Interrupt\n");
2492 adapter->cmd_sent = false;
2494 /* Handle command response */
2495 ret = mwifiex_pcie_process_cmd_complete(adapter);
2500 mwifiex_dbg(adapter, INTR,
2501 "info: cmd_sent=%d data_sent=%d\n",
2502 adapter->cmd_sent, adapter->data_sent);
2503 if (!card->msi_enable && adapter->ps_state != PS_STATE_SLEEP)
2504 mwifiex_pcie_enable_host_int(adapter);
2509 static int mwifiex_process_msix_int(struct mwifiex_adapter *adapter)
2513 unsigned long flags;
2515 spin_lock_irqsave(&adapter->int_lock, flags);
2516 /* Clear out unused interrupts */
2517 pcie_ireg = adapter->int_status;
2518 adapter->int_status = 0;
2519 spin_unlock_irqrestore(&adapter->int_lock, flags);
2521 if (pcie_ireg & HOST_INTR_DNLD_DONE) {
2522 mwifiex_dbg(adapter, INTR,
2523 "info: TX DNLD Done\n");
2524 ret = mwifiex_pcie_send_data_complete(adapter);
2528 if (pcie_ireg & HOST_INTR_UPLD_RDY) {
2529 mwifiex_dbg(adapter, INTR,
2531 ret = mwifiex_pcie_process_recv_data(adapter);
2535 if (pcie_ireg & HOST_INTR_EVENT_RDY) {
2536 mwifiex_dbg(adapter, INTR,
2537 "info: Rx EVENT\n");
2538 ret = mwifiex_pcie_process_event_ready(adapter);
2543 if (pcie_ireg & HOST_INTR_CMD_DONE) {
2544 if (adapter->cmd_sent) {
2545 mwifiex_dbg(adapter, INTR,
2546 "info: CMD sent Interrupt\n");
2547 adapter->cmd_sent = false;
2549 /* Handle command response */
2550 ret = mwifiex_pcie_process_cmd_complete(adapter);
2555 mwifiex_dbg(adapter, INTR,
2556 "info: cmd_sent=%d data_sent=%d\n",
2557 adapter->cmd_sent, adapter->data_sent);
2562 static int mwifiex_process_int_status(struct mwifiex_adapter *adapter)
2564 struct pcie_service_card *card = adapter->card;
2566 if (card->msix_enable)
2567 return mwifiex_process_msix_int(adapter);
2569 return mwifiex_process_pcie_int(adapter);
2573 * This function downloads data from driver to card.
2575 * Both commands and data packets are transferred to the card by this
2578 * This function adds the PCIE specific header to the front of the buffer
2579 * before transferring. The header contains the length of the packet and
2580 * the type. The firmware handles the packets based upon this set type.
2582 static int mwifiex_pcie_host_to_card(struct mwifiex_adapter *adapter, u8 type,
2583 struct sk_buff *skb,
2584 struct mwifiex_tx_param *tx_param)
2587 mwifiex_dbg(adapter, ERROR,
2588 "Passed NULL skb to %s\n", __func__);
2592 if (type == MWIFIEX_TYPE_DATA)
2593 return mwifiex_pcie_send_data(adapter, skb, tx_param);
2594 else if (type == MWIFIEX_TYPE_CMD)
2595 return mwifiex_pcie_send_cmd(adapter, skb);
2600 /* Function to dump PCIE scratch registers in case of FW crash
2603 mwifiex_pcie_reg_dump(struct mwifiex_adapter *adapter, char *drv_buf)
2606 char buf[256], *ptr;
2609 struct pcie_service_card *card = adapter->card;
2610 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2611 int pcie_scratch_reg[] = {PCIE_SCRATCH_12_REG,
2612 PCIE_SCRATCH_14_REG,
2613 PCIE_SCRATCH_15_REG};
2618 mwifiex_dbg(adapter, MSG, "PCIE register dump start\n");
2620 if (mwifiex_read_reg(adapter, reg->fw_status, &value)) {
2621 mwifiex_dbg(adapter, ERROR, "failed to read firmware status");
2626 mwifiex_dbg(adapter, MSG, "pcie scratch register:");
2627 for (i = 0; i < ARRAY_SIZE(pcie_scratch_reg); i++) {
2628 mwifiex_read_reg(adapter, pcie_scratch_reg[i], &value);
2629 ptr += sprintf(ptr, "reg:0x%x, value=0x%x\n",
2630 pcie_scratch_reg[i], value);
2633 mwifiex_dbg(adapter, MSG, "%s\n", buf);
2634 p += sprintf(p, "%s\n", buf);
2636 mwifiex_dbg(adapter, MSG, "PCIE register dump end\n");
2641 /* This function read/write firmware */
2642 static enum rdwr_status
2643 mwifiex_pcie_rdwr_firmware(struct mwifiex_adapter *adapter, u8 doneflag)
2648 struct pcie_service_card *card = adapter->card;
2649 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2651 if (mwifiex_read_reg(adapter, reg->fw_status, &fw_status))
2652 return RDWR_STATUS_FAILURE;
2654 ret = mwifiex_write_reg(adapter, reg->fw_dump_ctrl,
2655 reg->fw_dump_host_ready);
2657 mwifiex_dbg(adapter, ERROR,
2658 "PCIE write err\n");
2659 return RDWR_STATUS_FAILURE;
2662 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
2663 mwifiex_read_reg_byte(adapter, reg->fw_dump_ctrl, &ctrl_data);
2664 if (ctrl_data == FW_DUMP_DONE)
2665 return RDWR_STATUS_SUCCESS;
2666 if (doneflag && ctrl_data == doneflag)
2667 return RDWR_STATUS_DONE;
2668 if (ctrl_data != reg->fw_dump_host_ready) {
2669 mwifiex_dbg(adapter, WARN,
2670 "The ctrl reg was changed, re-try again!\n");
2671 ret = mwifiex_write_reg(adapter, reg->fw_dump_ctrl,
2672 reg->fw_dump_host_ready);
2674 mwifiex_dbg(adapter, ERROR,
2675 "PCIE write err\n");
2676 return RDWR_STATUS_FAILURE;
2679 usleep_range(100, 200);
2682 mwifiex_dbg(adapter, ERROR, "Fail to pull ctrl_data\n");
2683 return RDWR_STATUS_FAILURE;
2686 /* This function dump firmware memory to file */
2687 static void mwifiex_pcie_fw_dump(struct mwifiex_adapter *adapter)
2689 struct pcie_service_card *card = adapter->card;
2690 const struct mwifiex_pcie_card_reg *creg = card->pcie.reg;
2691 unsigned int reg, reg_start, reg_end;
2692 u8 *dbg_ptr, *end_ptr, *tmp_ptr, fw_dump_num, dump_num;
2693 u8 idx, i, read_reg, doneflag = 0;
2694 enum rdwr_status stat;
2698 if (!card->pcie.can_dump_fw)
2701 for (idx = 0; idx < adapter->num_mem_types; idx++) {
2702 struct memory_type_mapping *entry =
2703 &adapter->mem_type_mapping_tbl[idx];
2705 if (entry->mem_ptr) {
2706 vfree(entry->mem_ptr);
2707 entry->mem_ptr = NULL;
2709 entry->mem_size = 0;
2712 mwifiex_dbg(adapter, MSG, "== mwifiex firmware dump start ==\n");
2714 /* Read the number of the memories which will dump */
2715 stat = mwifiex_pcie_rdwr_firmware(adapter, doneflag);
2716 if (stat == RDWR_STATUS_FAILURE)
2719 reg = creg->fw_dump_start;
2720 mwifiex_read_reg_byte(adapter, reg, &fw_dump_num);
2722 /* W8997 chipset firmware dump will be restore in single region*/
2723 if (fw_dump_num == 0)
2726 dump_num = fw_dump_num;
2728 /* Read the length of every memory which will dump */
2729 for (idx = 0; idx < dump_num; idx++) {
2730 struct memory_type_mapping *entry =
2731 &adapter->mem_type_mapping_tbl[idx];
2733 if (fw_dump_num != 0) {
2734 stat = mwifiex_pcie_rdwr_firmware(adapter, doneflag);
2735 if (stat == RDWR_STATUS_FAILURE)
2738 reg = creg->fw_dump_start;
2739 for (i = 0; i < 4; i++) {
2740 mwifiex_read_reg_byte(adapter, reg, &read_reg);
2741 memory_size |= (read_reg << (i * 8));
2745 memory_size = MWIFIEX_FW_DUMP_MAX_MEMSIZE;
2748 if (memory_size == 0) {
2749 mwifiex_dbg(adapter, MSG, "Firmware dump Finished!\n");
2750 ret = mwifiex_write_reg(adapter, creg->fw_dump_ctrl,
2751 creg->fw_dump_read_done);
2753 mwifiex_dbg(adapter, ERROR, "PCIE write err\n");
2759 mwifiex_dbg(adapter, DUMP,
2760 "%s_SIZE=0x%x\n", entry->mem_name, memory_size);
2761 entry->mem_ptr = vmalloc(memory_size + 1);
2762 entry->mem_size = memory_size;
2763 if (!entry->mem_ptr) {
2764 mwifiex_dbg(adapter, ERROR,
2765 "Vmalloc %s failed\n", entry->mem_name);
2768 dbg_ptr = entry->mem_ptr;
2769 end_ptr = dbg_ptr + memory_size;
2771 doneflag = entry->done_flag;
2772 mwifiex_dbg(adapter, DUMP, "Start %s output, please wait...\n",
2776 stat = mwifiex_pcie_rdwr_firmware(adapter, doneflag);
2777 if (RDWR_STATUS_FAILURE == stat)
2780 reg_start = creg->fw_dump_start;
2781 reg_end = creg->fw_dump_end;
2782 for (reg = reg_start; reg <= reg_end; reg++) {
2783 mwifiex_read_reg_byte(adapter, reg, dbg_ptr);
2784 if (dbg_ptr < end_ptr) {
2788 mwifiex_dbg(adapter, ERROR,
2789 "pre-allocated buf not enough\n");
2791 vzalloc(memory_size + MWIFIEX_SIZE_4K);
2794 memcpy(tmp_ptr, entry->mem_ptr, memory_size);
2795 vfree(entry->mem_ptr);
2796 entry->mem_ptr = tmp_ptr;
2798 dbg_ptr = entry->mem_ptr + memory_size;
2799 memory_size += MWIFIEX_SIZE_4K;
2800 end_ptr = entry->mem_ptr + memory_size;
2803 if (stat != RDWR_STATUS_DONE)
2806 mwifiex_dbg(adapter, DUMP,
2807 "%s done: size=0x%tx\n",
2808 entry->mem_name, dbg_ptr - entry->mem_ptr);
2812 mwifiex_dbg(adapter, MSG, "== mwifiex firmware dump end ==\n");
2815 static void mwifiex_pcie_device_dump_work(struct mwifiex_adapter *adapter)
2820 drv_info_size = mwifiex_drv_info_dump(adapter, &drv_info);
2821 mwifiex_pcie_fw_dump(adapter);
2822 mwifiex_upload_device_dump(adapter, drv_info, drv_info_size);
2825 static void mwifiex_pcie_work(struct work_struct *work)
2827 struct pcie_service_card *card =
2828 container_of(work, struct pcie_service_card, work);
2830 if (test_and_clear_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP,
2832 mwifiex_pcie_device_dump_work(card->adapter);
2835 /* This function dumps FW information */
2836 static void mwifiex_pcie_device_dump(struct mwifiex_adapter *adapter)
2838 struct pcie_service_card *card = adapter->card;
2840 if (test_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP, &card->work_flags))
2843 set_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP, &card->work_flags);
2845 schedule_work(&card->work);
2848 static void mwifiex_pcie_free_buffers(struct mwifiex_adapter *adapter)
2850 struct pcie_service_card *card = adapter->card;
2851 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2853 if (reg->sleep_cookie)
2854 mwifiex_pcie_delete_sleep_cookie_buf(adapter);
2856 mwifiex_pcie_delete_cmdrsp_buf(adapter);
2857 mwifiex_pcie_delete_evtbd_ring(adapter);
2858 mwifiex_pcie_delete_rxbd_ring(adapter);
2859 mwifiex_pcie_delete_txbd_ring(adapter);
2860 card->cmdrsp_buf = NULL;
2864 * This function initializes the PCI-E host memory space, WCB rings, etc.
2866 * The following initializations steps are followed -
2867 * - Allocate TXBD ring buffers
2868 * - Allocate RXBD ring buffers
2869 * - Allocate event BD ring buffers
2870 * - Allocate command response ring buffer
2871 * - Allocate sleep cookie buffer
2873 static int mwifiex_init_pcie(struct mwifiex_adapter *adapter)
2875 struct pcie_service_card *card = adapter->card;
2877 struct pci_dev *pdev = card->dev;
2878 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2880 pci_set_drvdata(pdev, card);
2882 ret = pci_enable_device(pdev);
2884 goto err_enable_dev;
2886 pci_set_master(pdev);
2888 pr_notice("try set_consistent_dma_mask(32)\n");
2889 ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2891 pr_err("set_dma_mask(32) failed\n");
2892 goto err_set_dma_mask;
2895 ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
2897 pr_err("set_consistent_dma_mask(64) failed\n");
2898 goto err_set_dma_mask;
2901 ret = pci_request_region(pdev, 0, DRV_NAME);
2903 pr_err("req_reg(0) error\n");
2904 goto err_req_region0;
2906 card->pci_mmap = pci_iomap(pdev, 0, 0);
2907 if (!card->pci_mmap) {
2908 pr_err("iomap(0) error\n");
2912 ret = pci_request_region(pdev, 2, DRV_NAME);
2914 pr_err("req_reg(2) error\n");
2915 goto err_req_region2;
2917 card->pci_mmap1 = pci_iomap(pdev, 2, 0);
2918 if (!card->pci_mmap1) {
2919 pr_err("iomap(2) error\n");
2924 pr_notice("PCI memory map Virt0: %p PCI memory map Virt2: %p\n",
2925 card->pci_mmap, card->pci_mmap1);
2927 card->cmdrsp_buf = NULL;
2928 ret = mwifiex_pcie_create_txbd_ring(adapter);
2931 ret = mwifiex_pcie_create_rxbd_ring(adapter);
2934 ret = mwifiex_pcie_create_evtbd_ring(adapter);
2937 ret = mwifiex_pcie_alloc_cmdrsp_buf(adapter);
2939 goto err_alloc_cmdbuf;
2940 if (reg->sleep_cookie) {
2941 ret = mwifiex_pcie_alloc_sleep_cookie_buf(adapter);
2943 goto err_alloc_cookie;
2945 card->sleep_cookie_vbase = NULL;
2950 mwifiex_pcie_delete_cmdrsp_buf(adapter);
2952 mwifiex_pcie_delete_evtbd_ring(adapter);
2954 mwifiex_pcie_delete_rxbd_ring(adapter);
2956 mwifiex_pcie_delete_txbd_ring(adapter);
2958 pci_iounmap(pdev, card->pci_mmap1);
2960 pci_release_region(pdev, 2);
2962 pci_iounmap(pdev, card->pci_mmap);
2964 pci_release_region(pdev, 0);
2967 pci_disable_device(pdev);
2973 * This function cleans up the allocated card buffers.
2975 static void mwifiex_cleanup_pcie(struct mwifiex_adapter *adapter)
2977 struct pcie_service_card *card = adapter->card;
2978 struct pci_dev *pdev = card->dev;
2979 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2983 cancel_work_sync(&card->work);
2985 ret = mwifiex_read_reg(adapter, reg->fw_status, &fw_status);
2986 if (fw_status == FIRMWARE_READY_PCIE) {
2987 mwifiex_dbg(adapter, INFO,
2988 "Clearing driver ready signature\n");
2989 if (mwifiex_write_reg(adapter, reg->drv_rdy, 0x00000000))
2990 mwifiex_dbg(adapter, ERROR,
2991 "Failed to write driver not-ready signature\n");
2994 mwifiex_pcie_free_buffers(adapter);
2997 pci_iounmap(pdev, card->pci_mmap);
2998 pci_iounmap(pdev, card->pci_mmap1);
2999 pci_disable_device(pdev);
3000 pci_release_region(pdev, 2);
3001 pci_release_region(pdev, 0);
3005 static int mwifiex_pcie_request_irq(struct mwifiex_adapter *adapter)
3008 struct pcie_service_card *card = adapter->card;
3009 struct pci_dev *pdev = card->dev;
3011 if (card->pcie.reg->msix_support) {
3012 for (i = 0; i < MWIFIEX_NUM_MSIX_VECTORS; i++)
3013 card->msix_entries[i].entry = i;
3014 ret = pci_enable_msix_exact(pdev, card->msix_entries,
3015 MWIFIEX_NUM_MSIX_VECTORS);
3017 for (i = 0; i < MWIFIEX_NUM_MSIX_VECTORS; i++) {
3018 card->msix_ctx[i].dev = pdev;
3019 card->msix_ctx[i].msg_id = i;
3021 ret = request_irq(card->msix_entries[i].vector,
3022 mwifiex_pcie_interrupt, 0,
3023 "MWIFIEX_PCIE_MSIX",
3024 &card->msix_ctx[i]);
3030 mwifiex_dbg(adapter, INFO, "request_irq fail: %d\n",
3032 for (j = 0; j < i; j++)
3033 free_irq(card->msix_entries[j].vector,
3034 &card->msix_ctx[i]);
3035 pci_disable_msix(pdev);
3037 mwifiex_dbg(adapter, MSG, "MSIx enabled!");
3038 card->msix_enable = 1;
3044 if (pci_enable_msi(pdev) != 0)
3045 pci_disable_msi(pdev);
3047 card->msi_enable = 1;
3049 mwifiex_dbg(adapter, INFO, "msi_enable = %d\n", card->msi_enable);
3051 card->share_irq_ctx.dev = pdev;
3052 card->share_irq_ctx.msg_id = -1;
3053 ret = request_irq(pdev->irq, mwifiex_pcie_interrupt, IRQF_SHARED,
3054 "MRVL_PCIE", &card->share_irq_ctx);
3056 pr_err("request_irq failed: ret=%d\n", ret);
3064 * This function gets the firmware name for downloading by revision id
3066 * Read revision id register to get revision id
3068 static void mwifiex_pcie_get_fw_name(struct mwifiex_adapter *adapter)
3070 int revision_id = 0;
3072 struct pcie_service_card *card = adapter->card;
3074 switch (card->dev->device) {
3075 case PCIE_DEVICE_ID_MARVELL_88W8766P:
3076 strcpy(adapter->fw_name, PCIE8766_DEFAULT_FW_NAME);
3078 case PCIE_DEVICE_ID_MARVELL_88W8897:
3079 mwifiex_write_reg(adapter, 0x0c58, 0x80c00000);
3080 mwifiex_read_reg(adapter, 0x0c58, &revision_id);
3081 revision_id &= 0xff00;
3082 switch (revision_id) {
3084 strcpy(adapter->fw_name, PCIE8897_A0_FW_NAME);
3087 strcpy(adapter->fw_name, PCIE8897_B0_FW_NAME);
3090 strcpy(adapter->fw_name, PCIE8897_DEFAULT_FW_NAME);
3095 case PCIE_DEVICE_ID_MARVELL_88W8997:
3096 mwifiex_read_reg(adapter, 0x8, &revision_id);
3097 mwifiex_read_reg(adapter, 0x0cd0, &version);
3098 mwifiex_read_reg(adapter, 0x0cd4, &magic);
3099 revision_id &= 0xff;
3102 if (revision_id == PCIE8997_A1 &&
3103 magic == CHIP_MAGIC_VALUE &&
3104 version == CHIP_VER_PCIEUART)
3105 strcpy(adapter->fw_name, PCIEUART8997_FW_NAME_V4);
3107 strcpy(adapter->fw_name, PCIEUSB8997_FW_NAME_V4);
3115 * This function registers the PCIE device.
3117 * PCIE IRQ is claimed, block size is set and driver data is initialized.
3119 static int mwifiex_register_dev(struct mwifiex_adapter *adapter)
3121 struct pcie_service_card *card = adapter->card;
3123 /* save adapter pointer in card */
3124 card->adapter = adapter;
3126 if (mwifiex_pcie_request_irq(adapter))
3129 adapter->tx_buf_size = card->pcie.tx_buf_size;
3130 adapter->mem_type_mapping_tbl = card->pcie.mem_type_mapping_tbl;
3131 adapter->num_mem_types = card->pcie.num_mem_types;
3132 adapter->ext_scan = card->pcie.can_ext_scan;
3133 mwifiex_pcie_get_fw_name(adapter);
3139 * This function unregisters the PCIE device.
3141 * The PCIE IRQ is released, the function is disabled and driver
3142 * data is set to null.
3144 static void mwifiex_unregister_dev(struct mwifiex_adapter *adapter)
3146 struct pcie_service_card *card = adapter->card;
3147 struct pci_dev *pdev = card->dev;
3150 if (card->msix_enable) {
3151 for (i = 0; i < MWIFIEX_NUM_MSIX_VECTORS; i++)
3152 synchronize_irq(card->msix_entries[i].vector);
3154 for (i = 0; i < MWIFIEX_NUM_MSIX_VECTORS; i++)
3155 free_irq(card->msix_entries[i].vector,
3156 &card->msix_ctx[i]);
3158 card->msix_enable = 0;
3159 pci_disable_msix(pdev);
3161 mwifiex_dbg(adapter, INFO,
3162 "%s(): calling free_irq()\n", __func__);
3163 free_irq(card->dev->irq, &card->share_irq_ctx);
3165 if (card->msi_enable)
3166 pci_disable_msi(pdev);
3168 card->adapter = NULL;
3171 /* This function initializes the PCI-E host memory space, WCB rings, etc.
3173 * The following initializations steps are followed -
3174 * - Allocate TXBD ring buffers
3175 * - Allocate RXBD ring buffers
3176 * - Allocate event BD ring buffers
3177 * - Allocate command response ring buffer
3178 * - Allocate sleep cookie buffer
3179 * Part of mwifiex_init_pcie(), not reset the PCIE registers
3181 static void mwifiex_pcie_up_dev(struct mwifiex_adapter *adapter)
3183 struct pcie_service_card *card = adapter->card;
3185 struct pci_dev *pdev = card->dev;
3186 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
3188 /* tx_buf_size might be changed to 3584 by firmware during
3189 * data transfer, we should reset it to default size.
3191 adapter->tx_buf_size = card->pcie.tx_buf_size;
3193 card->cmdrsp_buf = NULL;
3194 ret = mwifiex_pcie_create_txbd_ring(adapter);
3196 mwifiex_dbg(adapter, ERROR, "Failed to create txbd ring\n");
3200 ret = mwifiex_pcie_create_rxbd_ring(adapter);
3202 mwifiex_dbg(adapter, ERROR, "Failed to create rxbd ring\n");
3206 ret = mwifiex_pcie_create_evtbd_ring(adapter);
3208 mwifiex_dbg(adapter, ERROR, "Failed to create evtbd ring\n");
3212 ret = mwifiex_pcie_alloc_cmdrsp_buf(adapter);
3214 mwifiex_dbg(adapter, ERROR, "Failed to allocate cmdbuf buffer\n");
3215 goto err_alloc_cmdbuf;
3218 if (reg->sleep_cookie) {
3219 ret = mwifiex_pcie_alloc_sleep_cookie_buf(adapter);
3221 mwifiex_dbg(adapter, ERROR, "Failed to allocate sleep_cookie buffer\n");
3222 goto err_alloc_cookie;
3225 card->sleep_cookie_vbase = NULL;
3230 mwifiex_pcie_delete_cmdrsp_buf(adapter);
3232 mwifiex_pcie_delete_evtbd_ring(adapter);
3234 mwifiex_pcie_delete_rxbd_ring(adapter);
3236 mwifiex_pcie_delete_txbd_ring(adapter);
3238 pci_iounmap(pdev, card->pci_mmap1);
3241 /* This function cleans up the PCI-E host memory space. */
3242 static void mwifiex_pcie_down_dev(struct mwifiex_adapter *adapter)
3244 struct pcie_service_card *card = adapter->card;
3245 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
3247 if (mwifiex_write_reg(adapter, reg->drv_rdy, 0x00000000))
3248 mwifiex_dbg(adapter, ERROR, "Failed to write driver not-ready signature\n");
3250 adapter->seq_num = 0;
3252 mwifiex_pcie_free_buffers(adapter);
3255 static struct mwifiex_if_ops pcie_ops = {
3256 .init_if = mwifiex_init_pcie,
3257 .cleanup_if = mwifiex_cleanup_pcie,
3258 .check_fw_status = mwifiex_check_fw_status,
3259 .check_winner_status = mwifiex_check_winner_status,
3260 .prog_fw = mwifiex_prog_fw_w_helper,
3261 .register_dev = mwifiex_register_dev,
3262 .unregister_dev = mwifiex_unregister_dev,
3263 .enable_int = mwifiex_pcie_enable_host_int,
3264 .disable_int = mwifiex_pcie_disable_host_int_noerr,
3265 .process_int_status = mwifiex_process_int_status,
3266 .host_to_card = mwifiex_pcie_host_to_card,
3267 .wakeup = mwifiex_pm_wakeup_card,
3268 .wakeup_complete = mwifiex_pm_wakeup_card_complete,
3271 .cmdrsp_complete = mwifiex_pcie_cmdrsp_complete,
3272 .event_complete = mwifiex_pcie_event_complete,
3273 .update_mp_end_port = NULL,
3274 .cleanup_mpa_buf = NULL,
3275 .init_fw_port = mwifiex_pcie_init_fw_port,
3276 .clean_pcie_ring = mwifiex_clean_pcie_ring_buf,
3277 .reg_dump = mwifiex_pcie_reg_dump,
3278 .device_dump = mwifiex_pcie_device_dump,
3279 .down_dev = mwifiex_pcie_down_dev,
3280 .up_dev = mwifiex_pcie_up_dev,
3283 module_pci_driver(mwifiex_pcie);
3285 MODULE_AUTHOR("Marvell International Ltd.");
3286 MODULE_DESCRIPTION("Marvell WiFi-Ex PCI-Express Driver version " PCIE_VERSION);
3287 MODULE_VERSION(PCIE_VERSION);
3288 MODULE_LICENSE("GPL v2");