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;
375 /* Kernel stores and restores PCIe function context before and
376 * after performing FLR respectively. Reconfigure the software
377 * and firmware including firmware redownload
379 adapter->surprise_removed = false;
380 ret = mwifiex_reinit_sw(adapter);
382 dev_err(&pdev->dev, "reinit failed: %d\n", ret);
386 mwifiex_dbg(adapter, INFO, "%s, successful\n", __func__);
389 static const struct pci_error_handlers mwifiex_pcie_err_handler[] = {
390 { .reset_notify = mwifiex_pcie_reset_notify, },
393 #ifdef CONFIG_PM_SLEEP
394 /* Power Management Hooks */
395 static SIMPLE_DEV_PM_OPS(mwifiex_pcie_pm_ops, mwifiex_pcie_suspend,
396 mwifiex_pcie_resume);
399 /* PCI Device Driver */
400 static struct pci_driver __refdata mwifiex_pcie = {
401 .name = "mwifiex_pcie",
402 .id_table = mwifiex_ids,
403 .probe = mwifiex_pcie_probe,
404 .remove = mwifiex_pcie_remove,
405 #ifdef CONFIG_PM_SLEEP
407 .pm = &mwifiex_pcie_pm_ops,
410 .shutdown = mwifiex_pcie_shutdown,
411 .err_handler = mwifiex_pcie_err_handler,
415 * This function adds delay loop to ensure FW is awake before proceeding.
417 static void mwifiex_pcie_dev_wakeup_delay(struct mwifiex_adapter *adapter)
421 while (mwifiex_pcie_ok_to_access_hw(adapter)) {
423 usleep_range(10, 20);
432 static void mwifiex_delay_for_sleep_cookie(struct mwifiex_adapter *adapter,
433 u32 max_delay_loop_cnt)
435 struct pcie_service_card *card = adapter->card;
437 u32 sleep_cookie, count;
438 struct sk_buff *cmdrsp = card->cmdrsp_buf;
440 for (count = 0; count < max_delay_loop_cnt; count++) {
441 pci_dma_sync_single_for_cpu(card->dev,
442 MWIFIEX_SKB_DMA_ADDR(cmdrsp),
443 sizeof(sleep_cookie),
445 buffer = cmdrsp->data;
446 sleep_cookie = get_unaligned_le32(buffer);
448 if (sleep_cookie == MWIFIEX_DEF_SLEEP_COOKIE) {
449 mwifiex_dbg(adapter, INFO,
450 "sleep cookie found at count %d\n", count);
453 pci_dma_sync_single_for_device(card->dev,
454 MWIFIEX_SKB_DMA_ADDR(cmdrsp),
455 sizeof(sleep_cookie),
457 usleep_range(20, 30);
460 if (count >= max_delay_loop_cnt)
461 mwifiex_dbg(adapter, INFO,
462 "max count reached while accessing sleep cookie\n");
465 /* This function wakes up the card by reading fw_status register. */
466 static int mwifiex_pm_wakeup_card(struct mwifiex_adapter *adapter)
468 struct pcie_service_card *card = adapter->card;
469 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
471 mwifiex_dbg(adapter, EVENT,
472 "event: Wakeup device...\n");
474 if (reg->sleep_cookie)
475 mwifiex_pcie_dev_wakeup_delay(adapter);
477 /* Accessing fw_status register will wakeup device */
478 if (mwifiex_write_reg(adapter, reg->fw_status, FIRMWARE_READY_PCIE)) {
479 mwifiex_dbg(adapter, ERROR,
480 "Writing fw_status register failed\n");
484 if (reg->sleep_cookie) {
485 mwifiex_pcie_dev_wakeup_delay(adapter);
486 mwifiex_dbg(adapter, INFO,
487 "PCIE wakeup: Setting PS_STATE_AWAKE\n");
488 adapter->ps_state = PS_STATE_AWAKE;
495 * This function is called after the card has woken up.
497 * The card configuration register is reset.
499 static int mwifiex_pm_wakeup_card_complete(struct mwifiex_adapter *adapter)
501 mwifiex_dbg(adapter, CMD,
502 "cmd: Wakeup device completed\n");
508 * This function disables the host interrupt.
510 * The host interrupt mask is read, the disable bit is reset and
511 * written back to the card host interrupt mask register.
513 static int mwifiex_pcie_disable_host_int(struct mwifiex_adapter *adapter)
515 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
516 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK,
518 mwifiex_dbg(adapter, ERROR,
519 "Disable host interrupt failed\n");
524 atomic_set(&adapter->tx_hw_pending, 0);
528 static void mwifiex_pcie_disable_host_int_noerr(struct mwifiex_adapter *adapter)
530 WARN_ON(mwifiex_pcie_disable_host_int(adapter));
534 * This function enables the host interrupt.
536 * The host interrupt enable mask is written to the card
537 * host interrupt mask register.
539 static int mwifiex_pcie_enable_host_int(struct mwifiex_adapter *adapter)
541 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
542 /* Simply write the mask to the register */
543 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK,
545 mwifiex_dbg(adapter, ERROR,
546 "Enable host interrupt failed\n");
555 * This function initializes TX buffer ring descriptors
557 static int mwifiex_init_txq_ring(struct mwifiex_adapter *adapter)
559 struct pcie_service_card *card = adapter->card;
560 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
561 struct mwifiex_pcie_buf_desc *desc;
562 struct mwifiex_pfu_buf_desc *desc2;
565 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
566 card->tx_buf_list[i] = NULL;
567 if (reg->pfu_enabled) {
568 card->txbd_ring[i] = (void *)card->txbd_ring_vbase +
569 (sizeof(*desc2) * i);
570 desc2 = card->txbd_ring[i];
571 memset(desc2, 0, sizeof(*desc2));
573 card->txbd_ring[i] = (void *)card->txbd_ring_vbase +
575 desc = card->txbd_ring[i];
576 memset(desc, 0, sizeof(*desc));
583 /* This function initializes RX buffer ring descriptors. Each SKB is allocated
584 * here and after mapping PCI memory, its physical address is assigned to
585 * PCIE Rx buffer descriptor's physical address.
587 static int mwifiex_init_rxq_ring(struct mwifiex_adapter *adapter)
589 struct pcie_service_card *card = adapter->card;
590 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
592 struct mwifiex_pcie_buf_desc *desc;
593 struct mwifiex_pfu_buf_desc *desc2;
597 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
598 /* Allocate skb here so that firmware can DMA data from it */
599 skb = mwifiex_alloc_dma_align_buf(MWIFIEX_RX_DATA_BUF_SIZE,
602 mwifiex_dbg(adapter, ERROR,
603 "Unable to allocate skb for RX ring.\n");
604 kfree(card->rxbd_ring_vbase);
608 if (mwifiex_map_pci_memory(adapter, skb,
609 MWIFIEX_RX_DATA_BUF_SIZE,
613 buf_pa = MWIFIEX_SKB_DMA_ADDR(skb);
615 mwifiex_dbg(adapter, INFO,
616 "info: RX ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
617 skb, skb->len, skb->data, (u32)buf_pa,
618 (u32)((u64)buf_pa >> 32));
620 card->rx_buf_list[i] = skb;
621 if (reg->pfu_enabled) {
622 card->rxbd_ring[i] = (void *)card->rxbd_ring_vbase +
623 (sizeof(*desc2) * i);
624 desc2 = card->rxbd_ring[i];
625 desc2->paddr = buf_pa;
626 desc2->len = (u16)skb->len;
627 desc2->frag_len = (u16)skb->len;
628 desc2->flags = reg->ring_flag_eop | reg->ring_flag_sop;
631 card->rxbd_ring[i] = (void *)(card->rxbd_ring_vbase +
632 (sizeof(*desc) * i));
633 desc = card->rxbd_ring[i];
634 desc->paddr = buf_pa;
635 desc->len = (u16)skb->len;
643 /* This function initializes event buffer ring descriptors. Each SKB is
644 * allocated here and after mapping PCI memory, its physical address is assigned
645 * to PCIE Rx buffer descriptor's physical address
647 static int mwifiex_pcie_init_evt_ring(struct mwifiex_adapter *adapter)
649 struct pcie_service_card *card = adapter->card;
650 struct mwifiex_evt_buf_desc *desc;
655 for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) {
656 /* Allocate skb here so that firmware can DMA data from it */
657 skb = dev_alloc_skb(MAX_EVENT_SIZE);
659 mwifiex_dbg(adapter, ERROR,
660 "Unable to allocate skb for EVENT buf.\n");
661 kfree(card->evtbd_ring_vbase);
664 skb_put(skb, MAX_EVENT_SIZE);
666 if (mwifiex_map_pci_memory(adapter, skb, MAX_EVENT_SIZE,
670 buf_pa = MWIFIEX_SKB_DMA_ADDR(skb);
672 mwifiex_dbg(adapter, EVENT,
673 "info: EVT ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
674 skb, skb->len, skb->data, (u32)buf_pa,
675 (u32)((u64)buf_pa >> 32));
677 card->evt_buf_list[i] = skb;
678 card->evtbd_ring[i] = (void *)(card->evtbd_ring_vbase +
679 (sizeof(*desc) * i));
680 desc = card->evtbd_ring[i];
681 desc->paddr = buf_pa;
682 desc->len = (u16)skb->len;
689 /* This function cleans up TX buffer rings. If any of the buffer list has valid
690 * SKB address, associated SKB is freed.
692 static void mwifiex_cleanup_txq_ring(struct mwifiex_adapter *adapter)
694 struct pcie_service_card *card = adapter->card;
695 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
697 struct mwifiex_pcie_buf_desc *desc;
698 struct mwifiex_pfu_buf_desc *desc2;
701 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
702 if (reg->pfu_enabled) {
703 desc2 = card->txbd_ring[i];
704 if (card->tx_buf_list[i]) {
705 skb = card->tx_buf_list[i];
706 mwifiex_unmap_pci_memory(adapter, skb,
708 dev_kfree_skb_any(skb);
710 memset(desc2, 0, sizeof(*desc2));
712 desc = card->txbd_ring[i];
713 if (card->tx_buf_list[i]) {
714 skb = card->tx_buf_list[i];
715 mwifiex_unmap_pci_memory(adapter, skb,
717 dev_kfree_skb_any(skb);
719 memset(desc, 0, sizeof(*desc));
721 card->tx_buf_list[i] = NULL;
724 atomic_set(&adapter->tx_hw_pending, 0);
728 /* This function cleans up RX buffer rings. If any of the buffer list has valid
729 * SKB address, associated SKB is freed.
731 static void mwifiex_cleanup_rxq_ring(struct mwifiex_adapter *adapter)
733 struct pcie_service_card *card = adapter->card;
734 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
735 struct mwifiex_pcie_buf_desc *desc;
736 struct mwifiex_pfu_buf_desc *desc2;
740 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
741 if (reg->pfu_enabled) {
742 desc2 = card->rxbd_ring[i];
743 if (card->rx_buf_list[i]) {
744 skb = card->rx_buf_list[i];
745 mwifiex_unmap_pci_memory(adapter, skb,
747 dev_kfree_skb_any(skb);
749 memset(desc2, 0, sizeof(*desc2));
751 desc = card->rxbd_ring[i];
752 if (card->rx_buf_list[i]) {
753 skb = card->rx_buf_list[i];
754 mwifiex_unmap_pci_memory(adapter, skb,
756 dev_kfree_skb_any(skb);
758 memset(desc, 0, sizeof(*desc));
760 card->rx_buf_list[i] = NULL;
766 /* This function cleans up event buffer rings. If any of the buffer list has
767 * valid SKB address, associated SKB is freed.
769 static void mwifiex_cleanup_evt_ring(struct mwifiex_adapter *adapter)
771 struct pcie_service_card *card = adapter->card;
772 struct mwifiex_evt_buf_desc *desc;
776 for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) {
777 desc = card->evtbd_ring[i];
778 if (card->evt_buf_list[i]) {
779 skb = card->evt_buf_list[i];
780 mwifiex_unmap_pci_memory(adapter, skb,
782 dev_kfree_skb_any(skb);
784 card->evt_buf_list[i] = NULL;
785 memset(desc, 0, sizeof(*desc));
791 /* This function creates buffer descriptor ring for TX
793 static int mwifiex_pcie_create_txbd_ring(struct mwifiex_adapter *adapter)
795 struct pcie_service_card *card = adapter->card;
796 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
799 * driver maintaines the write pointer and firmware maintaines the read
800 * pointer. The write pointer starts at 0 (zero) while the read pointer
801 * starts at zero with rollover bit set
803 card->txbd_wrptr = 0;
805 if (reg->pfu_enabled)
806 card->txbd_rdptr = 0;
808 card->txbd_rdptr |= reg->tx_rollover_ind;
810 /* allocate shared memory for the BD ring and divide the same in to
811 several descriptors */
812 if (reg->pfu_enabled)
813 card->txbd_ring_size = sizeof(struct mwifiex_pfu_buf_desc) *
816 card->txbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
819 mwifiex_dbg(adapter, INFO,
820 "info: txbd_ring: Allocating %d bytes\n",
821 card->txbd_ring_size);
822 card->txbd_ring_vbase = pci_alloc_consistent(card->dev,
823 card->txbd_ring_size,
824 &card->txbd_ring_pbase);
825 if (!card->txbd_ring_vbase) {
826 mwifiex_dbg(adapter, ERROR,
827 "allocate consistent memory (%d bytes) failed!\n",
828 card->txbd_ring_size);
831 mwifiex_dbg(adapter, DATA,
832 "info: txbd_ring - base: %p, pbase: %#x:%x, len: %x\n",
833 card->txbd_ring_vbase, (unsigned int)card->txbd_ring_pbase,
834 (u32)((u64)card->txbd_ring_pbase >> 32),
835 card->txbd_ring_size);
837 return mwifiex_init_txq_ring(adapter);
840 static int mwifiex_pcie_delete_txbd_ring(struct mwifiex_adapter *adapter)
842 struct pcie_service_card *card = adapter->card;
843 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
845 mwifiex_cleanup_txq_ring(adapter);
847 if (card->txbd_ring_vbase)
848 pci_free_consistent(card->dev, card->txbd_ring_size,
849 card->txbd_ring_vbase,
850 card->txbd_ring_pbase);
851 card->txbd_ring_size = 0;
852 card->txbd_wrptr = 0;
853 card->txbd_rdptr = 0 | reg->tx_rollover_ind;
854 card->txbd_ring_vbase = NULL;
855 card->txbd_ring_pbase = 0;
861 * This function creates buffer descriptor ring for RX
863 static int mwifiex_pcie_create_rxbd_ring(struct mwifiex_adapter *adapter)
865 struct pcie_service_card *card = adapter->card;
866 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
869 * driver maintaines the read pointer and firmware maintaines the write
870 * pointer. The write pointer starts at 0 (zero) while the read pointer
871 * starts at zero with rollover bit set
873 card->rxbd_wrptr = 0;
874 card->rxbd_rdptr = reg->rx_rollover_ind;
876 if (reg->pfu_enabled)
877 card->rxbd_ring_size = sizeof(struct mwifiex_pfu_buf_desc) *
880 card->rxbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
883 mwifiex_dbg(adapter, INFO,
884 "info: rxbd_ring: Allocating %d bytes\n",
885 card->rxbd_ring_size);
886 card->rxbd_ring_vbase = pci_alloc_consistent(card->dev,
887 card->rxbd_ring_size,
888 &card->rxbd_ring_pbase);
889 if (!card->rxbd_ring_vbase) {
890 mwifiex_dbg(adapter, ERROR,
891 "allocate consistent memory (%d bytes) failed!\n",
892 card->rxbd_ring_size);
896 mwifiex_dbg(adapter, DATA,
897 "info: rxbd_ring - base: %p, pbase: %#x:%x, len: %#x\n",
898 card->rxbd_ring_vbase, (u32)card->rxbd_ring_pbase,
899 (u32)((u64)card->rxbd_ring_pbase >> 32),
900 card->rxbd_ring_size);
902 return mwifiex_init_rxq_ring(adapter);
906 * This function deletes Buffer descriptor ring for RX
908 static int mwifiex_pcie_delete_rxbd_ring(struct mwifiex_adapter *adapter)
910 struct pcie_service_card *card = adapter->card;
911 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
913 mwifiex_cleanup_rxq_ring(adapter);
915 if (card->rxbd_ring_vbase)
916 pci_free_consistent(card->dev, card->rxbd_ring_size,
917 card->rxbd_ring_vbase,
918 card->rxbd_ring_pbase);
919 card->rxbd_ring_size = 0;
920 card->rxbd_wrptr = 0;
921 card->rxbd_rdptr = 0 | reg->rx_rollover_ind;
922 card->rxbd_ring_vbase = NULL;
923 card->rxbd_ring_pbase = 0;
929 * This function creates buffer descriptor ring for Events
931 static int mwifiex_pcie_create_evtbd_ring(struct mwifiex_adapter *adapter)
933 struct pcie_service_card *card = adapter->card;
934 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
937 * driver maintaines the read pointer and firmware maintaines the write
938 * pointer. The write pointer starts at 0 (zero) while the read pointer
939 * starts at zero with rollover bit set
941 card->evtbd_wrptr = 0;
942 card->evtbd_rdptr = reg->evt_rollover_ind;
944 card->evtbd_ring_size = sizeof(struct mwifiex_evt_buf_desc) *
947 mwifiex_dbg(adapter, INFO,
948 "info: evtbd_ring: Allocating %d bytes\n",
949 card->evtbd_ring_size);
950 card->evtbd_ring_vbase = pci_alloc_consistent(card->dev,
951 card->evtbd_ring_size,
952 &card->evtbd_ring_pbase);
953 if (!card->evtbd_ring_vbase) {
954 mwifiex_dbg(adapter, ERROR,
955 "allocate consistent memory (%d bytes) failed!\n",
956 card->evtbd_ring_size);
960 mwifiex_dbg(adapter, EVENT,
961 "info: CMDRSP/EVT bd_ring - base: %p pbase: %#x:%x len: %#x\n",
962 card->evtbd_ring_vbase, (u32)card->evtbd_ring_pbase,
963 (u32)((u64)card->evtbd_ring_pbase >> 32),
964 card->evtbd_ring_size);
966 return mwifiex_pcie_init_evt_ring(adapter);
970 * This function deletes Buffer descriptor ring for Events
972 static int mwifiex_pcie_delete_evtbd_ring(struct mwifiex_adapter *adapter)
974 struct pcie_service_card *card = adapter->card;
975 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
977 mwifiex_cleanup_evt_ring(adapter);
979 if (card->evtbd_ring_vbase)
980 pci_free_consistent(card->dev, card->evtbd_ring_size,
981 card->evtbd_ring_vbase,
982 card->evtbd_ring_pbase);
983 card->evtbd_wrptr = 0;
984 card->evtbd_rdptr = 0 | reg->evt_rollover_ind;
985 card->evtbd_ring_size = 0;
986 card->evtbd_ring_vbase = NULL;
987 card->evtbd_ring_pbase = 0;
993 * This function allocates a buffer for CMDRSP
995 static int mwifiex_pcie_alloc_cmdrsp_buf(struct mwifiex_adapter *adapter)
997 struct pcie_service_card *card = adapter->card;
1000 /* Allocate memory for receiving command response data */
1001 skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
1003 mwifiex_dbg(adapter, ERROR,
1004 "Unable to allocate skb for command response data.\n");
1007 skb_put(skb, MWIFIEX_UPLD_SIZE);
1008 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1009 PCI_DMA_FROMDEVICE))
1012 card->cmdrsp_buf = skb;
1018 * This function deletes a buffer for CMDRSP
1020 static int mwifiex_pcie_delete_cmdrsp_buf(struct mwifiex_adapter *adapter)
1022 struct pcie_service_card *card;
1027 card = adapter->card;
1029 if (card && card->cmdrsp_buf) {
1030 mwifiex_unmap_pci_memory(adapter, card->cmdrsp_buf,
1031 PCI_DMA_FROMDEVICE);
1032 dev_kfree_skb_any(card->cmdrsp_buf);
1035 if (card && card->cmd_buf) {
1036 mwifiex_unmap_pci_memory(adapter, card->cmd_buf,
1038 dev_kfree_skb_any(card->cmd_buf);
1044 * This function allocates a buffer for sleep cookie
1046 static int mwifiex_pcie_alloc_sleep_cookie_buf(struct mwifiex_adapter *adapter)
1048 struct pcie_service_card *card = adapter->card;
1051 card->sleep_cookie_vbase = pci_alloc_consistent(card->dev, sizeof(u32),
1052 &card->sleep_cookie_pbase);
1053 if (!card->sleep_cookie_vbase) {
1054 mwifiex_dbg(adapter, ERROR,
1055 "pci_alloc_consistent failed!\n");
1058 /* Init val of Sleep Cookie */
1059 tmp = FW_AWAKE_COOKIE;
1060 put_unaligned(tmp, card->sleep_cookie_vbase);
1062 mwifiex_dbg(adapter, INFO,
1063 "alloc_scook: sleep cookie=0x%x\n",
1064 get_unaligned(card->sleep_cookie_vbase));
1070 * This function deletes buffer for sleep cookie
1072 static int mwifiex_pcie_delete_sleep_cookie_buf(struct mwifiex_adapter *adapter)
1074 struct pcie_service_card *card;
1079 card = adapter->card;
1081 if (card && card->sleep_cookie_vbase) {
1082 pci_free_consistent(card->dev, sizeof(u32),
1083 card->sleep_cookie_vbase,
1084 card->sleep_cookie_pbase);
1085 card->sleep_cookie_vbase = NULL;
1091 /* This function flushes the TX buffer descriptor ring
1092 * This function defined as handler is also called while cleaning TXRX
1093 * during disconnect/ bss stop.
1095 static int mwifiex_clean_pcie_ring_buf(struct mwifiex_adapter *adapter)
1097 struct pcie_service_card *card = adapter->card;
1099 if (!mwifiex_pcie_txbd_empty(card, card->txbd_rdptr)) {
1100 card->txbd_flush = 1;
1101 /* write pointer already set at last send
1102 * send dnld-rdy intr again, wait for completion.
1104 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1105 CPU_INTR_DNLD_RDY)) {
1106 mwifiex_dbg(adapter, ERROR,
1107 "failed to assert dnld-rdy interrupt.\n");
1115 * This function unmaps and frees downloaded data buffer
1117 static int mwifiex_pcie_send_data_complete(struct mwifiex_adapter *adapter)
1119 struct sk_buff *skb;
1120 u32 wrdoneidx, rdptr, num_tx_buffs, unmap_count = 0;
1121 struct mwifiex_pcie_buf_desc *desc;
1122 struct mwifiex_pfu_buf_desc *desc2;
1123 struct pcie_service_card *card = adapter->card;
1124 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1126 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1127 mwifiex_pm_wakeup_card(adapter);
1129 /* Read the TX ring read pointer set by firmware */
1130 if (mwifiex_read_reg(adapter, reg->tx_rdptr, &rdptr)) {
1131 mwifiex_dbg(adapter, ERROR,
1132 "SEND COMP: failed to read reg->tx_rdptr\n");
1136 mwifiex_dbg(adapter, DATA,
1137 "SEND COMP: rdptr_prev=0x%x, rdptr=0x%x\n",
1138 card->txbd_rdptr, rdptr);
1140 num_tx_buffs = MWIFIEX_MAX_TXRX_BD << reg->tx_start_ptr;
1141 /* free from previous txbd_rdptr to current txbd_rdptr */
1142 while (((card->txbd_rdptr & reg->tx_mask) !=
1143 (rdptr & reg->tx_mask)) ||
1144 ((card->txbd_rdptr & reg->tx_rollover_ind) !=
1145 (rdptr & reg->tx_rollover_ind))) {
1146 wrdoneidx = (card->txbd_rdptr & reg->tx_mask) >>
1149 skb = card->tx_buf_list[wrdoneidx];
1152 mwifiex_dbg(adapter, DATA,
1153 "SEND COMP: Detach skb %p at txbd_rdidx=%d\n",
1155 mwifiex_unmap_pci_memory(adapter, skb,
1160 if (card->txbd_flush)
1161 mwifiex_write_data_complete(adapter, skb, 0,
1164 mwifiex_write_data_complete(adapter, skb, 0, 0);
1165 atomic_dec(&adapter->tx_hw_pending);
1168 card->tx_buf_list[wrdoneidx] = NULL;
1170 if (reg->pfu_enabled) {
1171 desc2 = card->txbd_ring[wrdoneidx];
1172 memset(desc2, 0, sizeof(*desc2));
1174 desc = card->txbd_ring[wrdoneidx];
1175 memset(desc, 0, sizeof(*desc));
1177 switch (card->dev->device) {
1178 case PCIE_DEVICE_ID_MARVELL_88W8766P:
1181 case PCIE_DEVICE_ID_MARVELL_88W8897:
1182 case PCIE_DEVICE_ID_MARVELL_88W8997:
1183 card->txbd_rdptr += reg->ring_tx_start_ptr;
1188 if ((card->txbd_rdptr & reg->tx_mask) == num_tx_buffs)
1189 card->txbd_rdptr = ((card->txbd_rdptr &
1190 reg->tx_rollover_ind) ^
1191 reg->tx_rollover_ind);
1195 adapter->data_sent = false;
1197 if (card->txbd_flush) {
1198 if (mwifiex_pcie_txbd_empty(card, card->txbd_rdptr))
1199 card->txbd_flush = 0;
1201 mwifiex_clean_pcie_ring_buf(adapter);
1207 /* This function sends data buffer to device. First 4 bytes of payload
1208 * are filled with payload length and payload type. Then this payload
1209 * is mapped to PCI device memory. Tx ring pointers are advanced accordingly.
1210 * Download ready interrupt to FW is deffered if Tx ring is not full and
1211 * additional payload can be accomodated.
1212 * Caller must ensure tx_param parameter to this function is not NULL.
1215 mwifiex_pcie_send_data(struct mwifiex_adapter *adapter, struct sk_buff *skb,
1216 struct mwifiex_tx_param *tx_param)
1218 struct pcie_service_card *card = adapter->card;
1219 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1220 u32 wrindx, num_tx_buffs, rx_val;
1223 struct mwifiex_pcie_buf_desc *desc = NULL;
1224 struct mwifiex_pfu_buf_desc *desc2 = NULL;
1226 if (!(skb->data && skb->len)) {
1227 mwifiex_dbg(adapter, ERROR,
1228 "%s(): invalid parameter <%p, %#x>\n",
1229 __func__, skb->data, skb->len);
1233 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1234 mwifiex_pm_wakeup_card(adapter);
1236 num_tx_buffs = MWIFIEX_MAX_TXRX_BD << reg->tx_start_ptr;
1237 mwifiex_dbg(adapter, DATA,
1238 "info: SEND DATA: <Rd: %#x, Wr: %#x>\n",
1239 card->txbd_rdptr, card->txbd_wrptr);
1240 if (mwifiex_pcie_txbd_not_full(card)) {
1243 adapter->data_sent = true;
1244 payload = skb->data;
1245 put_unaligned_le16((u16)skb->len, payload + 0);
1246 put_unaligned_le16(MWIFIEX_TYPE_DATA, payload + 2);
1248 if (mwifiex_map_pci_memory(adapter, skb, skb->len,
1252 wrindx = (card->txbd_wrptr & reg->tx_mask) >> reg->tx_start_ptr;
1253 buf_pa = MWIFIEX_SKB_DMA_ADDR(skb);
1254 card->tx_buf_list[wrindx] = skb;
1255 atomic_inc(&adapter->tx_hw_pending);
1257 if (reg->pfu_enabled) {
1258 desc2 = card->txbd_ring[wrindx];
1259 desc2->paddr = buf_pa;
1260 desc2->len = (u16)skb->len;
1261 desc2->frag_len = (u16)skb->len;
1263 desc2->flags = MWIFIEX_BD_FLAG_FIRST_DESC |
1264 MWIFIEX_BD_FLAG_LAST_DESC;
1266 desc = card->txbd_ring[wrindx];
1267 desc->paddr = buf_pa;
1268 desc->len = (u16)skb->len;
1269 desc->flags = MWIFIEX_BD_FLAG_FIRST_DESC |
1270 MWIFIEX_BD_FLAG_LAST_DESC;
1273 switch (card->dev->device) {
1274 case PCIE_DEVICE_ID_MARVELL_88W8766P:
1277 case PCIE_DEVICE_ID_MARVELL_88W8897:
1278 case PCIE_DEVICE_ID_MARVELL_88W8997:
1279 card->txbd_wrptr += reg->ring_tx_start_ptr;
1283 if ((card->txbd_wrptr & reg->tx_mask) == num_tx_buffs)
1284 card->txbd_wrptr = ((card->txbd_wrptr &
1285 reg->tx_rollover_ind) ^
1286 reg->tx_rollover_ind);
1288 rx_val = card->rxbd_rdptr & reg->rx_wrap_mask;
1289 /* Write the TX ring write pointer in to reg->tx_wrptr */
1290 if (mwifiex_write_reg(adapter, reg->tx_wrptr,
1291 card->txbd_wrptr | rx_val)) {
1292 mwifiex_dbg(adapter, ERROR,
1293 "SEND DATA: failed to write reg->tx_wrptr\n");
1297 if ((mwifiex_pcie_txbd_not_full(card)) &&
1298 tx_param->next_pkt_len) {
1299 /* have more packets and TxBD still can hold more */
1300 mwifiex_dbg(adapter, DATA,
1301 "SEND DATA: delay dnld-rdy interrupt.\n");
1302 adapter->data_sent = false;
1304 /* Send the TX ready interrupt */
1305 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1306 CPU_INTR_DNLD_RDY)) {
1307 mwifiex_dbg(adapter, ERROR,
1308 "SEND DATA: failed to assert dnld-rdy interrupt.\n");
1313 mwifiex_dbg(adapter, DATA,
1314 "info: SEND DATA: Updated <Rd: %#x, Wr:\t"
1315 "%#x> and sent packet to firmware successfully\n",
1316 card->txbd_rdptr, card->txbd_wrptr);
1318 mwifiex_dbg(adapter, DATA,
1319 "info: TX Ring full, can't send packets to fw\n");
1320 adapter->data_sent = true;
1321 /* Send the TX ready interrupt */
1322 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1324 mwifiex_dbg(adapter, ERROR,
1325 "SEND DATA: failed to assert door-bell intr\n");
1329 return -EINPROGRESS;
1331 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1332 card->tx_buf_list[wrindx] = NULL;
1333 atomic_dec(&adapter->tx_hw_pending);
1334 if (reg->pfu_enabled)
1335 memset(desc2, 0, sizeof(*desc2));
1337 memset(desc, 0, sizeof(*desc));
1343 * This function handles received buffer ring and
1344 * dispatches packets to upper
1346 static int mwifiex_pcie_process_recv_data(struct mwifiex_adapter *adapter)
1348 struct pcie_service_card *card = adapter->card;
1349 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1350 u32 wrptr, rd_index, tx_val;
1353 struct sk_buff *skb_tmp = NULL;
1354 struct mwifiex_pcie_buf_desc *desc;
1355 struct mwifiex_pfu_buf_desc *desc2;
1357 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1358 mwifiex_pm_wakeup_card(adapter);
1360 /* Read the RX ring Write pointer set by firmware */
1361 if (mwifiex_read_reg(adapter, reg->rx_wrptr, &wrptr)) {
1362 mwifiex_dbg(adapter, ERROR,
1363 "RECV DATA: failed to read reg->rx_wrptr\n");
1367 card->rxbd_wrptr = wrptr;
1369 while (((wrptr & reg->rx_mask) !=
1370 (card->rxbd_rdptr & reg->rx_mask)) ||
1371 ((wrptr & reg->rx_rollover_ind) ==
1372 (card->rxbd_rdptr & reg->rx_rollover_ind))) {
1373 struct sk_buff *skb_data;
1376 rd_index = card->rxbd_rdptr & reg->rx_mask;
1377 skb_data = card->rx_buf_list[rd_index];
1379 /* If skb allocation was failed earlier for Rx packet,
1380 * rx_buf_list[rd_index] would have been left with a NULL.
1385 mwifiex_unmap_pci_memory(adapter, skb_data, PCI_DMA_FROMDEVICE);
1386 card->rx_buf_list[rd_index] = NULL;
1388 /* Get data length from interface header -
1389 * first 2 bytes for len, next 2 bytes is for type
1391 rx_len = get_unaligned_le16(skb_data->data);
1392 if (WARN_ON(rx_len <= INTF_HEADER_LEN ||
1393 rx_len > MWIFIEX_RX_DATA_BUF_SIZE)) {
1394 mwifiex_dbg(adapter, ERROR,
1395 "Invalid RX len %d, Rd=%#x, Wr=%#x\n",
1396 rx_len, card->rxbd_rdptr, wrptr);
1397 dev_kfree_skb_any(skb_data);
1399 skb_put(skb_data, rx_len);
1400 mwifiex_dbg(adapter, DATA,
1401 "info: RECV DATA: Rd=%#x, Wr=%#x, Len=%d\n",
1402 card->rxbd_rdptr, wrptr, rx_len);
1403 skb_pull(skb_data, INTF_HEADER_LEN);
1404 if (adapter->rx_work_enabled) {
1405 skb_queue_tail(&adapter->rx_data_q, skb_data);
1406 adapter->data_received = true;
1407 atomic_inc(&adapter->rx_pending);
1409 mwifiex_handle_rx_packet(adapter, skb_data);
1413 skb_tmp = mwifiex_alloc_dma_align_buf(MWIFIEX_RX_DATA_BUF_SIZE,
1416 mwifiex_dbg(adapter, ERROR,
1417 "Unable to allocate skb.\n");
1421 if (mwifiex_map_pci_memory(adapter, skb_tmp,
1422 MWIFIEX_RX_DATA_BUF_SIZE,
1423 PCI_DMA_FROMDEVICE))
1426 buf_pa = MWIFIEX_SKB_DMA_ADDR(skb_tmp);
1428 mwifiex_dbg(adapter, INFO,
1429 "RECV DATA: Attach new sk_buff %p at rxbd_rdidx=%d\n",
1431 card->rx_buf_list[rd_index] = skb_tmp;
1433 if (reg->pfu_enabled) {
1434 desc2 = card->rxbd_ring[rd_index];
1435 desc2->paddr = buf_pa;
1436 desc2->len = skb_tmp->len;
1437 desc2->frag_len = skb_tmp->len;
1439 desc2->flags = reg->ring_flag_sop | reg->ring_flag_eop;
1441 desc = card->rxbd_ring[rd_index];
1442 desc->paddr = buf_pa;
1443 desc->len = skb_tmp->len;
1447 if ((++card->rxbd_rdptr & reg->rx_mask) ==
1448 MWIFIEX_MAX_TXRX_BD) {
1449 card->rxbd_rdptr = ((card->rxbd_rdptr &
1450 reg->rx_rollover_ind) ^
1451 reg->rx_rollover_ind);
1453 mwifiex_dbg(adapter, DATA,
1454 "info: RECV DATA: <Rd: %#x, Wr: %#x>\n",
1455 card->rxbd_rdptr, wrptr);
1457 tx_val = card->txbd_wrptr & reg->tx_wrap_mask;
1458 /* Write the RX ring read pointer in to reg->rx_rdptr */
1459 if (mwifiex_write_reg(adapter, reg->rx_rdptr,
1460 card->rxbd_rdptr | tx_val)) {
1461 mwifiex_dbg(adapter, DATA,
1462 "RECV DATA: failed to write reg->rx_rdptr\n");
1467 /* Read the RX ring Write pointer set by firmware */
1468 if (mwifiex_read_reg(adapter, reg->rx_wrptr, &wrptr)) {
1469 mwifiex_dbg(adapter, ERROR,
1470 "RECV DATA: failed to read reg->rx_wrptr\n");
1474 mwifiex_dbg(adapter, DATA,
1475 "info: RECV DATA: Rcvd packet from fw successfully\n");
1476 card->rxbd_wrptr = wrptr;
1484 * This function downloads the boot command to device
1487 mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
1490 struct pcie_service_card *card = adapter->card;
1491 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1493 if (!(skb->data && skb->len)) {
1494 mwifiex_dbg(adapter, ERROR,
1495 "Invalid parameter in %s <%p. len %d>\n",
1496 __func__, skb->data, skb->len);
1500 if (mwifiex_map_pci_memory(adapter, skb, skb->len, PCI_DMA_TODEVICE))
1503 buf_pa = MWIFIEX_SKB_DMA_ADDR(skb);
1505 /* Write the lower 32bits of the physical address to low command
1506 * address scratch register
1508 if (mwifiex_write_reg(adapter, reg->cmd_addr_lo, (u32)buf_pa)) {
1509 mwifiex_dbg(adapter, ERROR,
1510 "%s: failed to write download command to boot code.\n",
1512 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1516 /* Write the upper 32bits of the physical address to high command
1517 * address scratch register
1519 if (mwifiex_write_reg(adapter, reg->cmd_addr_hi,
1520 (u32)((u64)buf_pa >> 32))) {
1521 mwifiex_dbg(adapter, ERROR,
1522 "%s: failed to write download command to boot code.\n",
1524 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1528 /* Write the command length to cmd_size scratch register */
1529 if (mwifiex_write_reg(adapter, reg->cmd_size, skb->len)) {
1530 mwifiex_dbg(adapter, ERROR,
1531 "%s: failed to write command len to cmd_size scratch reg\n",
1533 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1537 /* Ring the door bell */
1538 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1539 CPU_INTR_DOOR_BELL)) {
1540 mwifiex_dbg(adapter, ERROR,
1541 "%s: failed to assert door-bell intr\n", __func__);
1542 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1549 /* This function init rx port in firmware which in turn enables to receive data
1550 * from device before transmitting any packet.
1552 static int mwifiex_pcie_init_fw_port(struct mwifiex_adapter *adapter)
1554 struct pcie_service_card *card = adapter->card;
1555 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1556 int tx_wrap = card->txbd_wrptr & reg->tx_wrap_mask;
1558 /* Write the RX ring read pointer in to reg->rx_rdptr */
1559 if (mwifiex_write_reg(adapter, reg->rx_rdptr, card->rxbd_rdptr |
1561 mwifiex_dbg(adapter, ERROR,
1562 "RECV DATA: failed to write reg->rx_rdptr\n");
1568 /* This function downloads commands to the device
1571 mwifiex_pcie_send_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
1573 struct pcie_service_card *card = adapter->card;
1574 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1576 dma_addr_t cmd_buf_pa, cmdrsp_buf_pa;
1577 u8 *payload = (u8 *)skb->data;
1579 if (!(skb->data && skb->len)) {
1580 mwifiex_dbg(adapter, ERROR,
1581 "Invalid parameter in %s <%p, %#x>\n",
1582 __func__, skb->data, skb->len);
1586 /* Make sure a command response buffer is available */
1587 if (!card->cmdrsp_buf) {
1588 mwifiex_dbg(adapter, ERROR,
1589 "No response buffer available, send command failed\n");
1593 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1594 mwifiex_pm_wakeup_card(adapter);
1596 adapter->cmd_sent = true;
1598 put_unaligned_le16((u16)skb->len, &payload[0]);
1599 put_unaligned_le16(MWIFIEX_TYPE_CMD, &payload[2]);
1601 if (mwifiex_map_pci_memory(adapter, skb, skb->len, PCI_DMA_TODEVICE))
1604 card->cmd_buf = skb;
1606 * Need to keep a reference, since core driver might free up this
1607 * buffer before we've unmapped it.
1611 /* To send a command, the driver will:
1612 1. Write the 64bit physical address of the data buffer to
1613 cmd response address low + cmd response address high
1614 2. Ring the door bell (i.e. set the door bell interrupt)
1616 In response to door bell interrupt, the firmware will perform
1617 the DMA of the command packet (first header to obtain the total
1618 length and then rest of the command).
1621 if (card->cmdrsp_buf) {
1622 cmdrsp_buf_pa = MWIFIEX_SKB_DMA_ADDR(card->cmdrsp_buf);
1623 /* Write the lower 32bits of the cmdrsp buffer physical
1625 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo,
1626 (u32)cmdrsp_buf_pa)) {
1627 mwifiex_dbg(adapter, ERROR,
1628 "Failed to write download cmd to boot code.\n");
1632 /* Write the upper 32bits of the cmdrsp buffer physical
1634 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi,
1635 (u32)((u64)cmdrsp_buf_pa >> 32))) {
1636 mwifiex_dbg(adapter, ERROR,
1637 "Failed to write download cmd to boot code.\n");
1643 cmd_buf_pa = MWIFIEX_SKB_DMA_ADDR(card->cmd_buf);
1644 /* Write the lower 32bits of the physical address to reg->cmd_addr_lo */
1645 if (mwifiex_write_reg(adapter, reg->cmd_addr_lo,
1647 mwifiex_dbg(adapter, ERROR,
1648 "Failed to write download cmd to boot code.\n");
1652 /* Write the upper 32bits of the physical address to reg->cmd_addr_hi */
1653 if (mwifiex_write_reg(adapter, reg->cmd_addr_hi,
1654 (u32)((u64)cmd_buf_pa >> 32))) {
1655 mwifiex_dbg(adapter, ERROR,
1656 "Failed to write download cmd to boot code.\n");
1661 /* Write the command length to reg->cmd_size */
1662 if (mwifiex_write_reg(adapter, reg->cmd_size,
1663 card->cmd_buf->len)) {
1664 mwifiex_dbg(adapter, ERROR,
1665 "Failed to write cmd len to reg->cmd_size\n");
1670 /* Ring the door bell */
1671 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1672 CPU_INTR_DOOR_BELL)) {
1673 mwifiex_dbg(adapter, ERROR,
1674 "Failed to assert door-bell intr\n");
1681 adapter->cmd_sent = false;
1687 * This function handles command complete interrupt
1689 static int mwifiex_pcie_process_cmd_complete(struct mwifiex_adapter *adapter)
1691 struct pcie_service_card *card = adapter->card;
1692 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1693 struct sk_buff *skb = card->cmdrsp_buf;
1697 mwifiex_dbg(adapter, CMD,
1698 "info: Rx CMD Response\n");
1700 if (adapter->curr_cmd)
1701 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_FROMDEVICE);
1703 pci_dma_sync_single_for_cpu(card->dev,
1704 MWIFIEX_SKB_DMA_ADDR(skb),
1706 PCI_DMA_FROMDEVICE);
1708 /* Unmap the command as a response has been received. */
1709 if (card->cmd_buf) {
1710 mwifiex_unmap_pci_memory(adapter, card->cmd_buf,
1712 dev_kfree_skb_any(card->cmd_buf);
1713 card->cmd_buf = NULL;
1716 rx_len = get_unaligned_le16(skb->data);
1717 skb_put(skb, MWIFIEX_UPLD_SIZE - skb->len);
1718 skb_trim(skb, rx_len);
1720 if (!adapter->curr_cmd) {
1721 if (adapter->ps_state == PS_STATE_SLEEP_CFM) {
1722 pci_dma_sync_single_for_device(card->dev,
1723 MWIFIEX_SKB_DMA_ADDR(skb),
1724 MWIFIEX_SLEEP_COOKIE_SIZE,
1725 PCI_DMA_FROMDEVICE);
1726 if (mwifiex_write_reg(adapter,
1728 CPU_INTR_SLEEP_CFM_DONE)) {
1729 mwifiex_dbg(adapter, ERROR,
1730 "Write register failed\n");
1733 mwifiex_delay_for_sleep_cookie(adapter,
1734 MWIFIEX_MAX_DELAY_COUNT);
1735 mwifiex_unmap_pci_memory(adapter, skb,
1736 PCI_DMA_FROMDEVICE);
1737 skb_pull(skb, INTF_HEADER_LEN);
1738 while (reg->sleep_cookie && (count++ < 10) &&
1739 mwifiex_pcie_ok_to_access_hw(adapter))
1740 usleep_range(50, 60);
1741 mwifiex_pcie_enable_host_int(adapter);
1742 mwifiex_process_sleep_confirm_resp(adapter, skb->data,
1745 mwifiex_dbg(adapter, ERROR,
1746 "There is no command but got cmdrsp\n");
1748 memcpy(adapter->upld_buf, skb->data,
1749 min_t(u32, MWIFIEX_SIZE_OF_CMD_BUFFER, skb->len));
1750 skb_push(skb, INTF_HEADER_LEN);
1751 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1752 PCI_DMA_FROMDEVICE))
1754 } else if (mwifiex_pcie_ok_to_access_hw(adapter)) {
1755 skb_pull(skb, INTF_HEADER_LEN);
1756 adapter->curr_cmd->resp_skb = skb;
1757 adapter->cmd_resp_received = true;
1758 /* Take the pointer and set it to CMD node and will
1759 return in the response complete callback */
1760 card->cmdrsp_buf = NULL;
1762 /* Clear the cmd-rsp buffer address in scratch registers. This
1763 will prevent firmware from writing to the same response
1765 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo, 0)) {
1766 mwifiex_dbg(adapter, ERROR,
1767 "cmd_done: failed to clear cmd_rsp_addr_lo\n");
1770 /* Write the upper 32bits of the cmdrsp buffer physical
1772 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi, 0)) {
1773 mwifiex_dbg(adapter, ERROR,
1774 "cmd_done: failed to clear cmd_rsp_addr_hi\n");
1783 * Command Response processing complete handler
1785 static int mwifiex_pcie_cmdrsp_complete(struct mwifiex_adapter *adapter,
1786 struct sk_buff *skb)
1788 struct pcie_service_card *card = adapter->card;
1791 card->cmdrsp_buf = skb;
1792 skb_push(card->cmdrsp_buf, INTF_HEADER_LEN);
1793 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1794 PCI_DMA_FROMDEVICE))
1802 * This function handles firmware event ready interrupt
1804 static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter *adapter)
1806 struct pcie_service_card *card = adapter->card;
1807 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1808 u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1810 struct mwifiex_evt_buf_desc *desc;
1812 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1813 mwifiex_pm_wakeup_card(adapter);
1815 if (adapter->event_received) {
1816 mwifiex_dbg(adapter, EVENT,
1817 "info: Event being processed,\t"
1818 "do not process this interrupt just yet\n");
1822 if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1823 mwifiex_dbg(adapter, ERROR,
1824 "info: Invalid read pointer...\n");
1828 /* Read the event ring write pointer set by firmware */
1829 if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1830 mwifiex_dbg(adapter, ERROR,
1831 "EventReady: failed to read reg->evt_wrptr\n");
1835 mwifiex_dbg(adapter, EVENT,
1836 "info: EventReady: Initial <Rd: 0x%x, Wr: 0x%x>",
1837 card->evtbd_rdptr, wrptr);
1838 if (((wrptr & MWIFIEX_EVTBD_MASK) != (card->evtbd_rdptr
1839 & MWIFIEX_EVTBD_MASK)) ||
1840 ((wrptr & reg->evt_rollover_ind) ==
1841 (card->evtbd_rdptr & reg->evt_rollover_ind))) {
1842 struct sk_buff *skb_cmd;
1843 __le16 data_len = 0;
1846 mwifiex_dbg(adapter, INFO,
1847 "info: Read Index: %d\n", rdptr);
1848 skb_cmd = card->evt_buf_list[rdptr];
1849 mwifiex_unmap_pci_memory(adapter, skb_cmd, PCI_DMA_FROMDEVICE);
1851 /* Take the pointer and set it to event pointer in adapter
1852 and will return back after event handling callback */
1853 card->evt_buf_list[rdptr] = NULL;
1854 desc = card->evtbd_ring[rdptr];
1855 memset(desc, 0, sizeof(*desc));
1857 event = get_unaligned_le32(&skb_cmd->data[INTF_HEADER_LEN]);
1858 adapter->event_cause = event;
1859 /* The first 4bytes will be the event transfer header
1860 len is 2 bytes followed by type which is 2 bytes */
1861 memcpy(&data_len, skb_cmd->data, sizeof(__le16));
1862 evt_len = le16_to_cpu(data_len);
1863 skb_trim(skb_cmd, evt_len);
1864 skb_pull(skb_cmd, INTF_HEADER_LEN);
1865 mwifiex_dbg(adapter, EVENT,
1866 "info: Event length: %d\n", evt_len);
1868 if ((evt_len > 0) && (evt_len < MAX_EVENT_SIZE))
1869 memcpy(adapter->event_body, skb_cmd->data +
1870 MWIFIEX_EVENT_HEADER_LEN, evt_len -
1871 MWIFIEX_EVENT_HEADER_LEN);
1873 adapter->event_received = true;
1874 adapter->event_skb = skb_cmd;
1876 /* Do not update the event read pointer here, wait till the
1877 buffer is released. This is just to make things simpler,
1878 we need to find a better method of managing these buffers.
1881 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1882 CPU_INTR_EVENT_DONE)) {
1883 mwifiex_dbg(adapter, ERROR,
1884 "Write register failed\n");
1893 * Event processing complete handler
1895 static int mwifiex_pcie_event_complete(struct mwifiex_adapter *adapter,
1896 struct sk_buff *skb)
1898 struct pcie_service_card *card = adapter->card;
1899 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1901 u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1903 struct mwifiex_evt_buf_desc *desc;
1908 if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1909 mwifiex_dbg(adapter, ERROR,
1910 "event_complete: Invalid rdptr 0x%x\n",
1915 /* Read the event ring write pointer set by firmware */
1916 if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1917 mwifiex_dbg(adapter, ERROR,
1918 "event_complete: failed to read reg->evt_wrptr\n");
1922 if (!card->evt_buf_list[rdptr]) {
1923 skb_push(skb, INTF_HEADER_LEN);
1924 skb_put(skb, MAX_EVENT_SIZE - skb->len);
1925 if (mwifiex_map_pci_memory(adapter, skb,
1927 PCI_DMA_FROMDEVICE))
1929 card->evt_buf_list[rdptr] = skb;
1930 desc = card->evtbd_ring[rdptr];
1931 desc->paddr = MWIFIEX_SKB_DMA_ADDR(skb);
1932 desc->len = (u16)skb->len;
1936 mwifiex_dbg(adapter, ERROR,
1937 "info: ERROR: buf still valid at index %d, <%p, %p>\n",
1938 rdptr, card->evt_buf_list[rdptr], skb);
1941 if ((++card->evtbd_rdptr & MWIFIEX_EVTBD_MASK) == MWIFIEX_MAX_EVT_BD) {
1942 card->evtbd_rdptr = ((card->evtbd_rdptr &
1943 reg->evt_rollover_ind) ^
1944 reg->evt_rollover_ind);
1947 mwifiex_dbg(adapter, EVENT,
1948 "info: Updated <Rd: 0x%x, Wr: 0x%x>",
1949 card->evtbd_rdptr, wrptr);
1951 /* Write the event ring read pointer in to reg->evt_rdptr */
1952 if (mwifiex_write_reg(adapter, reg->evt_rdptr,
1953 card->evtbd_rdptr)) {
1954 mwifiex_dbg(adapter, ERROR,
1955 "event_complete: failed to read reg->evt_rdptr\n");
1959 mwifiex_dbg(adapter, EVENT,
1960 "info: Check Events Again\n");
1961 ret = mwifiex_pcie_process_event_ready(adapter);
1966 /* Combo firmware image is a combination of
1967 * (1) combo crc heaer, start with CMD5
1968 * (2) bluetooth image, start with CMD7, end with CMD6, data wrapped in CMD1.
1971 * This function bypass the header and bluetooth part, return
1972 * the offset of tail wifi-only part.
1975 static int mwifiex_extract_wifi_fw(struct mwifiex_adapter *adapter,
1976 const void *firmware, u32 firmware_len) {
1977 const struct mwifiex_fw_data *fwdata;
1978 u32 offset = 0, data_len, dnld_cmd;
1980 bool cmd7_before = false;
1983 /* Check for integer and buffer overflow */
1984 if (offset + sizeof(fwdata->header) < sizeof(fwdata->header) ||
1985 offset + sizeof(fwdata->header) >= firmware_len) {
1986 mwifiex_dbg(adapter, ERROR,
1987 "extract wifi-only fw failure!\n");
1992 fwdata = firmware + offset;
1993 dnld_cmd = le32_to_cpu(fwdata->header.dnld_cmd);
1994 data_len = le32_to_cpu(fwdata->header.data_length);
1996 /* Skip past header */
1997 offset += sizeof(fwdata->header);
2000 case MWIFIEX_FW_DNLD_CMD_1:
2002 mwifiex_dbg(adapter, ERROR,
2003 "no cmd7 before cmd1!\n");
2007 if (offset + data_len < data_len) {
2008 mwifiex_dbg(adapter, ERROR, "bad FW parse\n");
2014 case MWIFIEX_FW_DNLD_CMD_5:
2015 /* Check for integer overflow */
2016 if (offset + data_len < data_len) {
2017 mwifiex_dbg(adapter, ERROR, "bad FW parse\n");
2023 case MWIFIEX_FW_DNLD_CMD_6:
2024 /* Check for integer overflow */
2025 if (offset + data_len < data_len) {
2026 mwifiex_dbg(adapter, ERROR, "bad FW parse\n");
2031 if (offset >= firmware_len) {
2032 mwifiex_dbg(adapter, ERROR,
2033 "extract wifi-only fw failure!\n");
2039 case MWIFIEX_FW_DNLD_CMD_7:
2043 mwifiex_dbg(adapter, ERROR, "unknown dnld_cmd %d\n",
2055 * This function downloads the firmware to the card.
2057 * Firmware is downloaded to the card in blocks. Every block download
2058 * is tested for CRC errors, and retried a number of times before
2059 * returning failure.
2061 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter *adapter,
2062 struct mwifiex_fw_image *fw)
2065 u8 *firmware = fw->fw_buf;
2066 u32 firmware_len = fw->fw_len;
2068 struct sk_buff *skb;
2069 u32 txlen, tx_blocks = 0, tries, len, val;
2070 u32 block_retry_cnt = 0;
2071 struct pcie_service_card *card = adapter->card;
2072 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2074 if (!firmware || !firmware_len) {
2075 mwifiex_dbg(adapter, ERROR,
2076 "No firmware image found! Terminating download\n");
2080 mwifiex_dbg(adapter, INFO,
2081 "info: Downloading FW image (%d bytes)\n",
2084 if (mwifiex_pcie_disable_host_int(adapter)) {
2085 mwifiex_dbg(adapter, ERROR,
2086 "%s: Disabling interrupts failed.\n", __func__);
2090 skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
2096 ret = mwifiex_read_reg(adapter, PCIE_SCRATCH_13_REG, &val);
2098 mwifiex_dbg(adapter, FATAL, "Failed to read scratch register 13\n");
2102 /* PCIE FLR case: extract wifi part from combo firmware*/
2103 if (val == MWIFIEX_PCIE_FLR_HAPPENS) {
2104 ret = mwifiex_extract_wifi_fw(adapter, firmware, firmware_len);
2106 mwifiex_dbg(adapter, ERROR, "Failed to extract wifi fw\n");
2110 mwifiex_dbg(adapter, MSG,
2111 "info: dnld wifi firmware from %d bytes\n", offset);
2114 /* Perform firmware data transfer */
2119 if (offset >= firmware_len)
2122 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
2123 ret = mwifiex_read_reg(adapter, reg->cmd_size,
2126 mwifiex_dbg(adapter, FATAL,
2127 "Failed reading len from boot code\n");
2132 usleep_range(10, 20);
2137 } else if (len > MWIFIEX_UPLD_SIZE) {
2138 mwifiex_dbg(adapter, ERROR,
2139 "FW download failure @ %d, invalid length %d\n",
2149 if (block_retry_cnt > MAX_WRITE_IOMEM_RETRY) {
2150 mwifiex_dbg(adapter, ERROR,
2151 "FW download failure @ %d, over max\t"
2152 "retry count\n", offset);
2156 mwifiex_dbg(adapter, ERROR,
2157 "FW CRC error indicated by the\t"
2158 "helper: len = 0x%04X, txlen = %d\n",
2161 /* Setting this to 0 to resend from same offset */
2164 block_retry_cnt = 0;
2165 /* Set blocksize to transfer - checking for
2167 if (firmware_len - offset < txlen)
2168 txlen = firmware_len - offset;
2170 tx_blocks = (txlen + card->pcie.blksz_fw_dl - 1) /
2171 card->pcie.blksz_fw_dl;
2173 /* Copy payload to buffer */
2174 memmove(skb->data, &firmware[offset], txlen);
2177 skb_put(skb, MWIFIEX_UPLD_SIZE - skb->len);
2178 skb_trim(skb, tx_blocks * card->pcie.blksz_fw_dl);
2180 /* Send the boot command to device */
2181 if (mwifiex_pcie_send_boot_cmd(adapter, skb)) {
2182 mwifiex_dbg(adapter, ERROR,
2183 "Failed to send firmware download command\n");
2188 /* Wait for the command done interrupt */
2189 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
2190 if (mwifiex_read_reg(adapter, PCIE_CPU_INT_STATUS,
2192 mwifiex_dbg(adapter, ERROR,
2193 "%s: Failed to read\t"
2194 "interrupt status during fw dnld.\n",
2196 mwifiex_unmap_pci_memory(adapter, skb,
2201 if (!(ireg_intr & CPU_INTR_DOOR_BELL))
2203 usleep_range(10, 20);
2205 if (ireg_intr & CPU_INTR_DOOR_BELL) {
2206 mwifiex_dbg(adapter, ERROR, "%s: Card failed to ACK download\n",
2208 mwifiex_unmap_pci_memory(adapter, skb,
2214 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
2219 mwifiex_dbg(adapter, MSG,
2220 "info: FW download over, size %d bytes\n", offset);
2225 dev_kfree_skb_any(skb);
2230 * This function checks the firmware status in card.
2233 mwifiex_check_fw_status(struct mwifiex_adapter *adapter, u32 poll_num)
2237 struct pcie_service_card *card = adapter->card;
2238 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2241 /* Mask spurios interrupts */
2242 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS_MASK,
2244 mwifiex_dbg(adapter, ERROR,
2245 "Write register failed\n");
2249 mwifiex_dbg(adapter, INFO,
2250 "Setting driver ready signature\n");
2251 if (mwifiex_write_reg(adapter, reg->drv_rdy,
2252 FIRMWARE_READY_PCIE)) {
2253 mwifiex_dbg(adapter, ERROR,
2254 "Failed to write driver ready signature\n");
2258 /* Wait for firmware initialization event */
2259 for (tries = 0; tries < poll_num; tries++) {
2260 if (mwifiex_read_reg(adapter, reg->fw_status,
2266 mwifiex_dbg(adapter, INFO, "Try %d if FW is ready <%d,%#x>",
2267 tries, ret, firmware_stat);
2271 if (firmware_stat == FIRMWARE_READY_PCIE) {
2283 /* This function checks if WLAN is the winner.
2286 mwifiex_check_winner_status(struct mwifiex_adapter *adapter)
2290 struct pcie_service_card *card = adapter->card;
2291 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2293 if (mwifiex_read_reg(adapter, reg->fw_status, &winner)) {
2295 } else if (!winner) {
2296 mwifiex_dbg(adapter, INFO, "PCI-E is the winner\n");
2297 adapter->winner = 1;
2299 mwifiex_dbg(adapter, ERROR,
2300 "PCI-E is not the winner <%#x>", winner);
2307 * This function reads the interrupt status from card.
2309 static void mwifiex_interrupt_status(struct mwifiex_adapter *adapter,
2313 unsigned long flags;
2314 struct pcie_service_card *card = adapter->card;
2316 if (card->msi_enable) {
2317 spin_lock_irqsave(&adapter->int_lock, flags);
2318 adapter->int_status = 1;
2319 spin_unlock_irqrestore(&adapter->int_lock, flags);
2323 if (!mwifiex_pcie_ok_to_access_hw(adapter))
2326 if (card->msix_enable && msg_id >= 0) {
2327 pcie_ireg = BIT(msg_id);
2329 if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS,
2331 mwifiex_dbg(adapter, ERROR, "Read register failed\n");
2335 if ((pcie_ireg == 0xFFFFFFFF) || !pcie_ireg)
2339 mwifiex_pcie_disable_host_int(adapter);
2341 /* Clear the pending interrupts */
2342 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS,
2344 mwifiex_dbg(adapter, ERROR,
2345 "Write register failed\n");
2350 if (!adapter->pps_uapsd_mode &&
2351 adapter->ps_state == PS_STATE_SLEEP &&
2352 mwifiex_pcie_ok_to_access_hw(adapter)) {
2353 /* Potentially for PCIe we could get other
2354 * interrupts like shared. Don't change power
2355 * state until cookie is set
2357 adapter->ps_state = PS_STATE_AWAKE;
2358 adapter->pm_wakeup_fw_try = false;
2359 del_timer(&adapter->wakeup_timer);
2362 spin_lock_irqsave(&adapter->int_lock, flags);
2363 adapter->int_status |= pcie_ireg;
2364 spin_unlock_irqrestore(&adapter->int_lock, flags);
2365 mwifiex_dbg(adapter, INTR, "ireg: 0x%08x\n", pcie_ireg);
2369 * Interrupt handler for PCIe root port
2371 * This function reads the interrupt status from firmware and assigns
2372 * the main process in workqueue which will handle the interrupt.
2374 static irqreturn_t mwifiex_pcie_interrupt(int irq, void *context)
2376 struct mwifiex_msix_context *ctx = context;
2377 struct pci_dev *pdev = ctx->dev;
2378 struct pcie_service_card *card;
2379 struct mwifiex_adapter *adapter;
2382 pr_err("info: %s: pdev is NULL\n", __func__);
2386 card = pci_get_drvdata(pdev);
2388 if (!card->adapter) {
2389 pr_err("info: %s: card=%p adapter=%p\n", __func__, card,
2390 card ? card->adapter : NULL);
2393 adapter = card->adapter;
2395 if (adapter->surprise_removed)
2398 if (card->msix_enable)
2399 mwifiex_interrupt_status(adapter, ctx->msg_id);
2401 mwifiex_interrupt_status(adapter, -1);
2403 mwifiex_queue_main_work(adapter);
2410 * This function checks the current interrupt status.
2412 * The following interrupts are checked and handled by this function -
2415 * - Command received
2416 * - Packets received
2419 * In case of Rx packets received, the packets are uploaded from card to
2420 * host and processed accordingly.
2422 static int mwifiex_process_pcie_int(struct mwifiex_adapter *adapter)
2426 unsigned long flags;
2427 struct pcie_service_card *card = adapter->card;
2429 spin_lock_irqsave(&adapter->int_lock, flags);
2430 if (!card->msi_enable) {
2431 /* Clear out unused interrupts */
2432 pcie_ireg = adapter->int_status;
2434 adapter->int_status = 0;
2435 spin_unlock_irqrestore(&adapter->int_lock, flags);
2437 if (card->msi_enable) {
2438 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
2439 if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS,
2441 mwifiex_dbg(adapter, ERROR,
2442 "Read register failed\n");
2446 if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
2447 if (mwifiex_write_reg(adapter,
2448 PCIE_HOST_INT_STATUS,
2450 mwifiex_dbg(adapter, ERROR,
2451 "Write register failed\n");
2454 if (!adapter->pps_uapsd_mode &&
2455 adapter->ps_state == PS_STATE_SLEEP) {
2456 adapter->ps_state = PS_STATE_AWAKE;
2457 adapter->pm_wakeup_fw_try = false;
2458 del_timer(&adapter->wakeup_timer);
2464 if (pcie_ireg & HOST_INTR_DNLD_DONE) {
2465 pcie_ireg &= ~HOST_INTR_DNLD_DONE;
2466 mwifiex_dbg(adapter, INTR, "info: TX DNLD Done\n");
2467 ret = mwifiex_pcie_send_data_complete(adapter);
2471 if (pcie_ireg & HOST_INTR_UPLD_RDY) {
2472 pcie_ireg &= ~HOST_INTR_UPLD_RDY;
2473 mwifiex_dbg(adapter, INTR, "info: Rx DATA\n");
2474 ret = mwifiex_pcie_process_recv_data(adapter);
2478 if (pcie_ireg & HOST_INTR_EVENT_RDY) {
2479 pcie_ireg &= ~HOST_INTR_EVENT_RDY;
2480 mwifiex_dbg(adapter, INTR, "info: Rx EVENT\n");
2481 ret = mwifiex_pcie_process_event_ready(adapter);
2485 if (pcie_ireg & HOST_INTR_CMD_DONE) {
2486 pcie_ireg &= ~HOST_INTR_CMD_DONE;
2487 if (adapter->cmd_sent) {
2488 mwifiex_dbg(adapter, INTR,
2489 "info: CMD sent Interrupt\n");
2490 adapter->cmd_sent = false;
2492 /* Handle command response */
2493 ret = mwifiex_pcie_process_cmd_complete(adapter);
2498 mwifiex_dbg(adapter, INTR,
2499 "info: cmd_sent=%d data_sent=%d\n",
2500 adapter->cmd_sent, adapter->data_sent);
2501 if (!card->msi_enable && adapter->ps_state != PS_STATE_SLEEP)
2502 mwifiex_pcie_enable_host_int(adapter);
2507 static int mwifiex_process_msix_int(struct mwifiex_adapter *adapter)
2511 unsigned long flags;
2513 spin_lock_irqsave(&adapter->int_lock, flags);
2514 /* Clear out unused interrupts */
2515 pcie_ireg = adapter->int_status;
2516 adapter->int_status = 0;
2517 spin_unlock_irqrestore(&adapter->int_lock, flags);
2519 if (pcie_ireg & HOST_INTR_DNLD_DONE) {
2520 mwifiex_dbg(adapter, INTR,
2521 "info: TX DNLD Done\n");
2522 ret = mwifiex_pcie_send_data_complete(adapter);
2526 if (pcie_ireg & HOST_INTR_UPLD_RDY) {
2527 mwifiex_dbg(adapter, INTR,
2529 ret = mwifiex_pcie_process_recv_data(adapter);
2533 if (pcie_ireg & HOST_INTR_EVENT_RDY) {
2534 mwifiex_dbg(adapter, INTR,
2535 "info: Rx EVENT\n");
2536 ret = mwifiex_pcie_process_event_ready(adapter);
2541 if (pcie_ireg & HOST_INTR_CMD_DONE) {
2542 if (adapter->cmd_sent) {
2543 mwifiex_dbg(adapter, INTR,
2544 "info: CMD sent Interrupt\n");
2545 adapter->cmd_sent = false;
2547 /* Handle command response */
2548 ret = mwifiex_pcie_process_cmd_complete(adapter);
2553 mwifiex_dbg(adapter, INTR,
2554 "info: cmd_sent=%d data_sent=%d\n",
2555 adapter->cmd_sent, adapter->data_sent);
2560 static int mwifiex_process_int_status(struct mwifiex_adapter *adapter)
2562 struct pcie_service_card *card = adapter->card;
2564 if (card->msix_enable)
2565 return mwifiex_process_msix_int(adapter);
2567 return mwifiex_process_pcie_int(adapter);
2571 * This function downloads data from driver to card.
2573 * Both commands and data packets are transferred to the card by this
2576 * This function adds the PCIE specific header to the front of the buffer
2577 * before transferring. The header contains the length of the packet and
2578 * the type. The firmware handles the packets based upon this set type.
2580 static int mwifiex_pcie_host_to_card(struct mwifiex_adapter *adapter, u8 type,
2581 struct sk_buff *skb,
2582 struct mwifiex_tx_param *tx_param)
2585 mwifiex_dbg(adapter, ERROR,
2586 "Passed NULL skb to %s\n", __func__);
2590 if (type == MWIFIEX_TYPE_DATA)
2591 return mwifiex_pcie_send_data(adapter, skb, tx_param);
2592 else if (type == MWIFIEX_TYPE_CMD)
2593 return mwifiex_pcie_send_cmd(adapter, skb);
2598 /* Function to dump PCIE scratch registers in case of FW crash
2601 mwifiex_pcie_reg_dump(struct mwifiex_adapter *adapter, char *drv_buf)
2604 char buf[256], *ptr;
2607 struct pcie_service_card *card = adapter->card;
2608 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2609 int pcie_scratch_reg[] = {PCIE_SCRATCH_12_REG,
2610 PCIE_SCRATCH_14_REG,
2611 PCIE_SCRATCH_15_REG};
2616 mwifiex_dbg(adapter, MSG, "PCIE register dump start\n");
2618 if (mwifiex_read_reg(adapter, reg->fw_status, &value)) {
2619 mwifiex_dbg(adapter, ERROR, "failed to read firmware status");
2624 mwifiex_dbg(adapter, MSG, "pcie scratch register:");
2625 for (i = 0; i < ARRAY_SIZE(pcie_scratch_reg); i++) {
2626 mwifiex_read_reg(adapter, pcie_scratch_reg[i], &value);
2627 ptr += sprintf(ptr, "reg:0x%x, value=0x%x\n",
2628 pcie_scratch_reg[i], value);
2631 mwifiex_dbg(adapter, MSG, "%s\n", buf);
2632 p += sprintf(p, "%s\n", buf);
2634 mwifiex_dbg(adapter, MSG, "PCIE register dump end\n");
2639 /* This function read/write firmware */
2640 static enum rdwr_status
2641 mwifiex_pcie_rdwr_firmware(struct mwifiex_adapter *adapter, u8 doneflag)
2646 struct pcie_service_card *card = adapter->card;
2647 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2649 if (mwifiex_read_reg(adapter, reg->fw_status, &fw_status))
2650 return RDWR_STATUS_FAILURE;
2652 ret = mwifiex_write_reg(adapter, reg->fw_dump_ctrl,
2653 reg->fw_dump_host_ready);
2655 mwifiex_dbg(adapter, ERROR,
2656 "PCIE write err\n");
2657 return RDWR_STATUS_FAILURE;
2660 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
2661 mwifiex_read_reg_byte(adapter, reg->fw_dump_ctrl, &ctrl_data);
2662 if (ctrl_data == FW_DUMP_DONE)
2663 return RDWR_STATUS_SUCCESS;
2664 if (doneflag && ctrl_data == doneflag)
2665 return RDWR_STATUS_DONE;
2666 if (ctrl_data != reg->fw_dump_host_ready) {
2667 mwifiex_dbg(adapter, WARN,
2668 "The ctrl reg was changed, re-try again!\n");
2669 ret = mwifiex_write_reg(adapter, reg->fw_dump_ctrl,
2670 reg->fw_dump_host_ready);
2672 mwifiex_dbg(adapter, ERROR,
2673 "PCIE write err\n");
2674 return RDWR_STATUS_FAILURE;
2677 usleep_range(100, 200);
2680 mwifiex_dbg(adapter, ERROR, "Fail to pull ctrl_data\n");
2681 return RDWR_STATUS_FAILURE;
2684 /* This function dump firmware memory to file */
2685 static void mwifiex_pcie_fw_dump(struct mwifiex_adapter *adapter)
2687 struct pcie_service_card *card = adapter->card;
2688 const struct mwifiex_pcie_card_reg *creg = card->pcie.reg;
2689 unsigned int reg, reg_start, reg_end;
2690 u8 *dbg_ptr, *end_ptr, *tmp_ptr, fw_dump_num, dump_num;
2691 u8 idx, i, read_reg, doneflag = 0;
2692 enum rdwr_status stat;
2696 if (!card->pcie.can_dump_fw)
2699 for (idx = 0; idx < adapter->num_mem_types; idx++) {
2700 struct memory_type_mapping *entry =
2701 &adapter->mem_type_mapping_tbl[idx];
2703 if (entry->mem_ptr) {
2704 vfree(entry->mem_ptr);
2705 entry->mem_ptr = NULL;
2707 entry->mem_size = 0;
2710 mwifiex_dbg(adapter, MSG, "== mwifiex firmware dump start ==\n");
2712 /* Read the number of the memories which will dump */
2713 stat = mwifiex_pcie_rdwr_firmware(adapter, doneflag);
2714 if (stat == RDWR_STATUS_FAILURE)
2717 reg = creg->fw_dump_start;
2718 mwifiex_read_reg_byte(adapter, reg, &fw_dump_num);
2720 /* W8997 chipset firmware dump will be restore in single region*/
2721 if (fw_dump_num == 0)
2724 dump_num = fw_dump_num;
2726 /* Read the length of every memory which will dump */
2727 for (idx = 0; idx < dump_num; idx++) {
2728 struct memory_type_mapping *entry =
2729 &adapter->mem_type_mapping_tbl[idx];
2731 if (fw_dump_num != 0) {
2732 stat = mwifiex_pcie_rdwr_firmware(adapter, doneflag);
2733 if (stat == RDWR_STATUS_FAILURE)
2736 reg = creg->fw_dump_start;
2737 for (i = 0; i < 4; i++) {
2738 mwifiex_read_reg_byte(adapter, reg, &read_reg);
2739 memory_size |= (read_reg << (i * 8));
2743 memory_size = MWIFIEX_FW_DUMP_MAX_MEMSIZE;
2746 if (memory_size == 0) {
2747 mwifiex_dbg(adapter, MSG, "Firmware dump Finished!\n");
2748 ret = mwifiex_write_reg(adapter, creg->fw_dump_ctrl,
2749 creg->fw_dump_read_done);
2751 mwifiex_dbg(adapter, ERROR, "PCIE write err\n");
2757 mwifiex_dbg(adapter, DUMP,
2758 "%s_SIZE=0x%x\n", entry->mem_name, memory_size);
2759 entry->mem_ptr = vmalloc(memory_size + 1);
2760 entry->mem_size = memory_size;
2761 if (!entry->mem_ptr) {
2762 mwifiex_dbg(adapter, ERROR,
2763 "Vmalloc %s failed\n", entry->mem_name);
2766 dbg_ptr = entry->mem_ptr;
2767 end_ptr = dbg_ptr + memory_size;
2769 doneflag = entry->done_flag;
2770 mwifiex_dbg(adapter, DUMP, "Start %s output, please wait...\n",
2774 stat = mwifiex_pcie_rdwr_firmware(adapter, doneflag);
2775 if (RDWR_STATUS_FAILURE == stat)
2778 reg_start = creg->fw_dump_start;
2779 reg_end = creg->fw_dump_end;
2780 for (reg = reg_start; reg <= reg_end; reg++) {
2781 mwifiex_read_reg_byte(adapter, reg, dbg_ptr);
2782 if (dbg_ptr < end_ptr) {
2786 mwifiex_dbg(adapter, ERROR,
2787 "pre-allocated buf not enough\n");
2789 vzalloc(memory_size + MWIFIEX_SIZE_4K);
2792 memcpy(tmp_ptr, entry->mem_ptr, memory_size);
2793 vfree(entry->mem_ptr);
2794 entry->mem_ptr = tmp_ptr;
2796 dbg_ptr = entry->mem_ptr + memory_size;
2797 memory_size += MWIFIEX_SIZE_4K;
2798 end_ptr = entry->mem_ptr + memory_size;
2801 if (stat != RDWR_STATUS_DONE)
2804 mwifiex_dbg(adapter, DUMP,
2805 "%s done: size=0x%tx\n",
2806 entry->mem_name, dbg_ptr - entry->mem_ptr);
2810 mwifiex_dbg(adapter, MSG, "== mwifiex firmware dump end ==\n");
2813 static void mwifiex_pcie_device_dump_work(struct mwifiex_adapter *adapter)
2818 drv_info_size = mwifiex_drv_info_dump(adapter, &drv_info);
2819 mwifiex_pcie_fw_dump(adapter);
2820 mwifiex_upload_device_dump(adapter, drv_info, drv_info_size);
2823 static void mwifiex_pcie_work(struct work_struct *work)
2825 struct pcie_service_card *card =
2826 container_of(work, struct pcie_service_card, work);
2828 if (test_and_clear_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP,
2830 mwifiex_pcie_device_dump_work(card->adapter);
2833 /* This function dumps FW information */
2834 static void mwifiex_pcie_device_dump(struct mwifiex_adapter *adapter)
2836 struct pcie_service_card *card = adapter->card;
2838 if (test_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP, &card->work_flags))
2841 set_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP, &card->work_flags);
2843 schedule_work(&card->work);
2846 static void mwifiex_pcie_free_buffers(struct mwifiex_adapter *adapter)
2848 struct pcie_service_card *card = adapter->card;
2849 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2851 if (reg->sleep_cookie)
2852 mwifiex_pcie_delete_sleep_cookie_buf(adapter);
2854 mwifiex_pcie_delete_cmdrsp_buf(adapter);
2855 mwifiex_pcie_delete_evtbd_ring(adapter);
2856 mwifiex_pcie_delete_rxbd_ring(adapter);
2857 mwifiex_pcie_delete_txbd_ring(adapter);
2858 card->cmdrsp_buf = NULL;
2862 * This function initializes the PCI-E host memory space, WCB rings, etc.
2864 * The following initializations steps are followed -
2865 * - Allocate TXBD ring buffers
2866 * - Allocate RXBD ring buffers
2867 * - Allocate event BD ring buffers
2868 * - Allocate command response ring buffer
2869 * - Allocate sleep cookie buffer
2871 static int mwifiex_init_pcie(struct mwifiex_adapter *adapter)
2873 struct pcie_service_card *card = adapter->card;
2875 struct pci_dev *pdev = card->dev;
2876 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2878 pci_set_drvdata(pdev, card);
2880 ret = pci_enable_device(pdev);
2882 goto err_enable_dev;
2884 pci_set_master(pdev);
2886 pr_notice("try set_consistent_dma_mask(32)\n");
2887 ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2889 pr_err("set_dma_mask(32) failed\n");
2890 goto err_set_dma_mask;
2893 ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
2895 pr_err("set_consistent_dma_mask(64) failed\n");
2896 goto err_set_dma_mask;
2899 ret = pci_request_region(pdev, 0, DRV_NAME);
2901 pr_err("req_reg(0) error\n");
2902 goto err_req_region0;
2904 card->pci_mmap = pci_iomap(pdev, 0, 0);
2905 if (!card->pci_mmap) {
2906 pr_err("iomap(0) error\n");
2910 ret = pci_request_region(pdev, 2, DRV_NAME);
2912 pr_err("req_reg(2) error\n");
2913 goto err_req_region2;
2915 card->pci_mmap1 = pci_iomap(pdev, 2, 0);
2916 if (!card->pci_mmap1) {
2917 pr_err("iomap(2) error\n");
2922 pr_notice("PCI memory map Virt0: %p PCI memory map Virt2: %p\n",
2923 card->pci_mmap, card->pci_mmap1);
2925 card->cmdrsp_buf = NULL;
2926 ret = mwifiex_pcie_create_txbd_ring(adapter);
2929 ret = mwifiex_pcie_create_rxbd_ring(adapter);
2932 ret = mwifiex_pcie_create_evtbd_ring(adapter);
2935 ret = mwifiex_pcie_alloc_cmdrsp_buf(adapter);
2937 goto err_alloc_cmdbuf;
2938 if (reg->sleep_cookie) {
2939 ret = mwifiex_pcie_alloc_sleep_cookie_buf(adapter);
2941 goto err_alloc_cookie;
2943 card->sleep_cookie_vbase = NULL;
2948 mwifiex_pcie_delete_cmdrsp_buf(adapter);
2950 mwifiex_pcie_delete_evtbd_ring(adapter);
2952 mwifiex_pcie_delete_rxbd_ring(adapter);
2954 mwifiex_pcie_delete_txbd_ring(adapter);
2956 pci_iounmap(pdev, card->pci_mmap1);
2958 pci_release_region(pdev, 2);
2960 pci_iounmap(pdev, card->pci_mmap);
2962 pci_release_region(pdev, 0);
2965 pci_disable_device(pdev);
2971 * This function cleans up the allocated card buffers.
2973 static void mwifiex_cleanup_pcie(struct mwifiex_adapter *adapter)
2975 struct pcie_service_card *card = adapter->card;
2976 struct pci_dev *pdev = card->dev;
2977 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2981 cancel_work_sync(&card->work);
2983 ret = mwifiex_read_reg(adapter, reg->fw_status, &fw_status);
2984 if (fw_status == FIRMWARE_READY_PCIE) {
2985 mwifiex_dbg(adapter, INFO,
2986 "Clearing driver ready signature\n");
2987 if (mwifiex_write_reg(adapter, reg->drv_rdy, 0x00000000))
2988 mwifiex_dbg(adapter, ERROR,
2989 "Failed to write driver not-ready signature\n");
2992 mwifiex_pcie_free_buffers(adapter);
2995 pci_iounmap(pdev, card->pci_mmap);
2996 pci_iounmap(pdev, card->pci_mmap1);
2997 pci_disable_device(pdev);
2998 pci_release_region(pdev, 2);
2999 pci_release_region(pdev, 0);
3003 static int mwifiex_pcie_request_irq(struct mwifiex_adapter *adapter)
3006 struct pcie_service_card *card = adapter->card;
3007 struct pci_dev *pdev = card->dev;
3009 if (card->pcie.reg->msix_support) {
3010 for (i = 0; i < MWIFIEX_NUM_MSIX_VECTORS; i++)
3011 card->msix_entries[i].entry = i;
3012 ret = pci_enable_msix_exact(pdev, card->msix_entries,
3013 MWIFIEX_NUM_MSIX_VECTORS);
3015 for (i = 0; i < MWIFIEX_NUM_MSIX_VECTORS; i++) {
3016 card->msix_ctx[i].dev = pdev;
3017 card->msix_ctx[i].msg_id = i;
3019 ret = request_irq(card->msix_entries[i].vector,
3020 mwifiex_pcie_interrupt, 0,
3021 "MWIFIEX_PCIE_MSIX",
3022 &card->msix_ctx[i]);
3028 mwifiex_dbg(adapter, INFO, "request_irq fail: %d\n",
3030 for (j = 0; j < i; j++)
3031 free_irq(card->msix_entries[j].vector,
3032 &card->msix_ctx[i]);
3033 pci_disable_msix(pdev);
3035 mwifiex_dbg(adapter, MSG, "MSIx enabled!");
3036 card->msix_enable = 1;
3042 if (pci_enable_msi(pdev) != 0)
3043 pci_disable_msi(pdev);
3045 card->msi_enable = 1;
3047 mwifiex_dbg(adapter, INFO, "msi_enable = %d\n", card->msi_enable);
3049 card->share_irq_ctx.dev = pdev;
3050 card->share_irq_ctx.msg_id = -1;
3051 ret = request_irq(pdev->irq, mwifiex_pcie_interrupt, IRQF_SHARED,
3052 "MRVL_PCIE", &card->share_irq_ctx);
3054 pr_err("request_irq failed: ret=%d\n", ret);
3062 * This function gets the firmware name for downloading by revision id
3064 * Read revision id register to get revision id
3066 static void mwifiex_pcie_get_fw_name(struct mwifiex_adapter *adapter)
3068 int revision_id = 0;
3070 struct pcie_service_card *card = adapter->card;
3072 switch (card->dev->device) {
3073 case PCIE_DEVICE_ID_MARVELL_88W8766P:
3074 strcpy(adapter->fw_name, PCIE8766_DEFAULT_FW_NAME);
3076 case PCIE_DEVICE_ID_MARVELL_88W8897:
3077 mwifiex_write_reg(adapter, 0x0c58, 0x80c00000);
3078 mwifiex_read_reg(adapter, 0x0c58, &revision_id);
3079 revision_id &= 0xff00;
3080 switch (revision_id) {
3082 strcpy(adapter->fw_name, PCIE8897_A0_FW_NAME);
3085 strcpy(adapter->fw_name, PCIE8897_B0_FW_NAME);
3088 strcpy(adapter->fw_name, PCIE8897_DEFAULT_FW_NAME);
3093 case PCIE_DEVICE_ID_MARVELL_88W8997:
3094 mwifiex_read_reg(adapter, 0x8, &revision_id);
3095 mwifiex_read_reg(adapter, 0x0cd0, &version);
3096 mwifiex_read_reg(adapter, 0x0cd4, &magic);
3097 revision_id &= 0xff;
3100 if (revision_id == PCIE8997_A1 &&
3101 magic == CHIP_MAGIC_VALUE &&
3102 version == CHIP_VER_PCIEUART)
3103 strcpy(adapter->fw_name, PCIEUART8997_FW_NAME_V4);
3105 strcpy(adapter->fw_name, PCIEUSB8997_FW_NAME_V4);
3113 * This function registers the PCIE device.
3115 * PCIE IRQ is claimed, block size is set and driver data is initialized.
3117 static int mwifiex_register_dev(struct mwifiex_adapter *adapter)
3119 struct pcie_service_card *card = adapter->card;
3121 /* save adapter pointer in card */
3122 card->adapter = adapter;
3124 if (mwifiex_pcie_request_irq(adapter))
3127 adapter->tx_buf_size = card->pcie.tx_buf_size;
3128 adapter->mem_type_mapping_tbl = card->pcie.mem_type_mapping_tbl;
3129 adapter->num_mem_types = card->pcie.num_mem_types;
3130 adapter->ext_scan = card->pcie.can_ext_scan;
3131 mwifiex_pcie_get_fw_name(adapter);
3137 * This function unregisters the PCIE device.
3139 * The PCIE IRQ is released, the function is disabled and driver
3140 * data is set to null.
3142 static void mwifiex_unregister_dev(struct mwifiex_adapter *adapter)
3144 struct pcie_service_card *card = adapter->card;
3145 struct pci_dev *pdev = card->dev;
3148 if (card->msix_enable) {
3149 for (i = 0; i < MWIFIEX_NUM_MSIX_VECTORS; i++)
3150 synchronize_irq(card->msix_entries[i].vector);
3152 for (i = 0; i < MWIFIEX_NUM_MSIX_VECTORS; i++)
3153 free_irq(card->msix_entries[i].vector,
3154 &card->msix_ctx[i]);
3156 card->msix_enable = 0;
3157 pci_disable_msix(pdev);
3159 mwifiex_dbg(adapter, INFO,
3160 "%s(): calling free_irq()\n", __func__);
3161 free_irq(card->dev->irq, &card->share_irq_ctx);
3163 if (card->msi_enable)
3164 pci_disable_msi(pdev);
3166 card->adapter = NULL;
3169 /* This function initializes the PCI-E host memory space, WCB rings, etc.
3171 * The following initializations steps are followed -
3172 * - Allocate TXBD ring buffers
3173 * - Allocate RXBD ring buffers
3174 * - Allocate event BD ring buffers
3175 * - Allocate command response ring buffer
3176 * - Allocate sleep cookie buffer
3177 * Part of mwifiex_init_pcie(), not reset the PCIE registers
3179 static void mwifiex_pcie_up_dev(struct mwifiex_adapter *adapter)
3181 struct pcie_service_card *card = adapter->card;
3183 struct pci_dev *pdev = card->dev;
3184 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
3186 /* tx_buf_size might be changed to 3584 by firmware during
3187 * data transfer, we should reset it to default size.
3189 adapter->tx_buf_size = card->pcie.tx_buf_size;
3191 card->cmdrsp_buf = NULL;
3192 ret = mwifiex_pcie_create_txbd_ring(adapter);
3194 mwifiex_dbg(adapter, ERROR, "Failed to create txbd ring\n");
3198 ret = mwifiex_pcie_create_rxbd_ring(adapter);
3200 mwifiex_dbg(adapter, ERROR, "Failed to create rxbd ring\n");
3204 ret = mwifiex_pcie_create_evtbd_ring(adapter);
3206 mwifiex_dbg(adapter, ERROR, "Failed to create evtbd ring\n");
3210 ret = mwifiex_pcie_alloc_cmdrsp_buf(adapter);
3212 mwifiex_dbg(adapter, ERROR, "Failed to allocate cmdbuf buffer\n");
3213 goto err_alloc_cmdbuf;
3216 if (reg->sleep_cookie) {
3217 ret = mwifiex_pcie_alloc_sleep_cookie_buf(adapter);
3219 mwifiex_dbg(adapter, ERROR, "Failed to allocate sleep_cookie buffer\n");
3220 goto err_alloc_cookie;
3223 card->sleep_cookie_vbase = NULL;
3228 mwifiex_pcie_delete_cmdrsp_buf(adapter);
3230 mwifiex_pcie_delete_evtbd_ring(adapter);
3232 mwifiex_pcie_delete_rxbd_ring(adapter);
3234 mwifiex_pcie_delete_txbd_ring(adapter);
3236 pci_iounmap(pdev, card->pci_mmap1);
3239 /* This function cleans up the PCI-E host memory space. */
3240 static void mwifiex_pcie_down_dev(struct mwifiex_adapter *adapter)
3242 struct pcie_service_card *card = adapter->card;
3243 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
3245 if (mwifiex_write_reg(adapter, reg->drv_rdy, 0x00000000))
3246 mwifiex_dbg(adapter, ERROR, "Failed to write driver not-ready signature\n");
3248 adapter->seq_num = 0;
3250 mwifiex_pcie_free_buffers(adapter);
3253 static struct mwifiex_if_ops pcie_ops = {
3254 .init_if = mwifiex_init_pcie,
3255 .cleanup_if = mwifiex_cleanup_pcie,
3256 .check_fw_status = mwifiex_check_fw_status,
3257 .check_winner_status = mwifiex_check_winner_status,
3258 .prog_fw = mwifiex_prog_fw_w_helper,
3259 .register_dev = mwifiex_register_dev,
3260 .unregister_dev = mwifiex_unregister_dev,
3261 .enable_int = mwifiex_pcie_enable_host_int,
3262 .disable_int = mwifiex_pcie_disable_host_int_noerr,
3263 .process_int_status = mwifiex_process_int_status,
3264 .host_to_card = mwifiex_pcie_host_to_card,
3265 .wakeup = mwifiex_pm_wakeup_card,
3266 .wakeup_complete = mwifiex_pm_wakeup_card_complete,
3269 .cmdrsp_complete = mwifiex_pcie_cmdrsp_complete,
3270 .event_complete = mwifiex_pcie_event_complete,
3271 .update_mp_end_port = NULL,
3272 .cleanup_mpa_buf = NULL,
3273 .init_fw_port = mwifiex_pcie_init_fw_port,
3274 .clean_pcie_ring = mwifiex_clean_pcie_ring_buf,
3275 .reg_dump = mwifiex_pcie_reg_dump,
3276 .device_dump = mwifiex_pcie_device_dump,
3277 .down_dev = mwifiex_pcie_down_dev,
3278 .up_dev = mwifiex_pcie_up_dev,
3281 module_pci_driver(mwifiex_pcie);
3283 MODULE_AUTHOR("Marvell International Ltd.");
3284 MODULE_DESCRIPTION("Marvell WiFi-Ex PCI-Express Driver version " PCIE_VERSION);
3285 MODULE_VERSION(PCIE_VERSION);
3286 MODULE_LICENSE("GPL v2");