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);
350 * Cleanup all software without cleaning anything related to PCIe and HW.
352 static void mwifiex_pcie_reset_prepare(struct pci_dev *pdev)
354 struct pcie_service_card *card = pci_get_drvdata(pdev);
355 struct mwifiex_adapter *adapter = card->adapter;
358 dev_err(&pdev->dev, "%s: adapter structure is not valid\n",
363 mwifiex_dbg(adapter, INFO,
364 "%s: vendor=0x%4.04x device=0x%4.04x rev=%d Pre-FLR\n",
365 __func__, pdev->vendor, pdev->device, pdev->revision);
367 mwifiex_shutdown_sw(adapter);
368 clear_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP, &card->work_flags);
369 clear_bit(MWIFIEX_IFACE_WORK_CARD_RESET, &card->work_flags);
370 mwifiex_dbg(adapter, INFO, "%s, successful\n", __func__);
372 card->pci_reset_ongoing = true;
376 * Kernel stores and restores PCIe function context before and after performing
377 * FLR respectively. Reconfigure the software and firmware including firmware
380 static void mwifiex_pcie_reset_done(struct pci_dev *pdev)
382 struct pcie_service_card *card = pci_get_drvdata(pdev);
383 struct mwifiex_adapter *adapter = card->adapter;
387 dev_err(&pdev->dev, "%s: adapter structure is not valid\n",
392 mwifiex_dbg(adapter, INFO,
393 "%s: vendor=0x%4.04x device=0x%4.04x rev=%d Post-FLR\n",
394 __func__, pdev->vendor, pdev->device, pdev->revision);
396 ret = mwifiex_reinit_sw(adapter);
398 dev_err(&pdev->dev, "reinit failed: %d\n", ret);
400 mwifiex_dbg(adapter, INFO, "%s, successful\n", __func__);
402 card->pci_reset_ongoing = false;
405 static const struct pci_error_handlers mwifiex_pcie_err_handler = {
406 .reset_prepare = mwifiex_pcie_reset_prepare,
407 .reset_done = mwifiex_pcie_reset_done,
410 #ifdef CONFIG_PM_SLEEP
411 /* Power Management Hooks */
412 static SIMPLE_DEV_PM_OPS(mwifiex_pcie_pm_ops, mwifiex_pcie_suspend,
413 mwifiex_pcie_resume);
416 /* PCI Device Driver */
417 static struct pci_driver __refdata mwifiex_pcie = {
418 .name = "mwifiex_pcie",
419 .id_table = mwifiex_ids,
420 .probe = mwifiex_pcie_probe,
421 .remove = mwifiex_pcie_remove,
422 #ifdef CONFIG_PM_SLEEP
424 .pm = &mwifiex_pcie_pm_ops,
427 .shutdown = mwifiex_pcie_shutdown,
428 .err_handler = &mwifiex_pcie_err_handler,
432 * This function adds delay loop to ensure FW is awake before proceeding.
434 static void mwifiex_pcie_dev_wakeup_delay(struct mwifiex_adapter *adapter)
438 while (mwifiex_pcie_ok_to_access_hw(adapter)) {
440 usleep_range(10, 20);
449 static void mwifiex_delay_for_sleep_cookie(struct mwifiex_adapter *adapter,
450 u32 max_delay_loop_cnt)
452 struct pcie_service_card *card = adapter->card;
454 u32 sleep_cookie, count;
455 struct sk_buff *cmdrsp = card->cmdrsp_buf;
457 for (count = 0; count < max_delay_loop_cnt; count++) {
458 pci_dma_sync_single_for_cpu(card->dev,
459 MWIFIEX_SKB_DMA_ADDR(cmdrsp),
460 sizeof(sleep_cookie),
462 buffer = cmdrsp->data;
463 sleep_cookie = get_unaligned_le32(buffer);
465 if (sleep_cookie == MWIFIEX_DEF_SLEEP_COOKIE) {
466 mwifiex_dbg(adapter, INFO,
467 "sleep cookie found at count %d\n", count);
470 pci_dma_sync_single_for_device(card->dev,
471 MWIFIEX_SKB_DMA_ADDR(cmdrsp),
472 sizeof(sleep_cookie),
474 usleep_range(20, 30);
477 if (count >= max_delay_loop_cnt)
478 mwifiex_dbg(adapter, INFO,
479 "max count reached while accessing sleep cookie\n");
482 /* This function wakes up the card by reading fw_status register. */
483 static int mwifiex_pm_wakeup_card(struct mwifiex_adapter *adapter)
485 struct pcie_service_card *card = adapter->card;
486 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
488 mwifiex_dbg(adapter, EVENT,
489 "event: Wakeup device...\n");
491 if (reg->sleep_cookie)
492 mwifiex_pcie_dev_wakeup_delay(adapter);
494 /* Accessing fw_status register will wakeup device */
495 if (mwifiex_write_reg(adapter, reg->fw_status, FIRMWARE_READY_PCIE)) {
496 mwifiex_dbg(adapter, ERROR,
497 "Writing fw_status register failed\n");
501 if (reg->sleep_cookie) {
502 mwifiex_pcie_dev_wakeup_delay(adapter);
503 mwifiex_dbg(adapter, INFO,
504 "PCIE wakeup: Setting PS_STATE_AWAKE\n");
505 adapter->ps_state = PS_STATE_AWAKE;
512 * This function is called after the card has woken up.
514 * The card configuration register is reset.
516 static int mwifiex_pm_wakeup_card_complete(struct mwifiex_adapter *adapter)
518 mwifiex_dbg(adapter, CMD,
519 "cmd: Wakeup device completed\n");
525 * This function disables the host interrupt.
527 * The host interrupt mask is read, the disable bit is reset and
528 * written back to the card host interrupt mask register.
530 static int mwifiex_pcie_disable_host_int(struct mwifiex_adapter *adapter)
532 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
533 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK,
535 mwifiex_dbg(adapter, ERROR,
536 "Disable host interrupt failed\n");
541 atomic_set(&adapter->tx_hw_pending, 0);
545 static void mwifiex_pcie_disable_host_int_noerr(struct mwifiex_adapter *adapter)
547 WARN_ON(mwifiex_pcie_disable_host_int(adapter));
551 * This function enables the host interrupt.
553 * The host interrupt enable mask is written to the card
554 * host interrupt mask register.
556 static int mwifiex_pcie_enable_host_int(struct mwifiex_adapter *adapter)
558 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
559 /* Simply write the mask to the register */
560 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK,
562 mwifiex_dbg(adapter, ERROR,
563 "Enable host interrupt failed\n");
572 * This function initializes TX buffer ring descriptors
574 static int mwifiex_init_txq_ring(struct mwifiex_adapter *adapter)
576 struct pcie_service_card *card = adapter->card;
577 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
578 struct mwifiex_pcie_buf_desc *desc;
579 struct mwifiex_pfu_buf_desc *desc2;
582 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
583 card->tx_buf_list[i] = NULL;
584 if (reg->pfu_enabled) {
585 card->txbd_ring[i] = (void *)card->txbd_ring_vbase +
586 (sizeof(*desc2) * i);
587 desc2 = card->txbd_ring[i];
588 memset(desc2, 0, sizeof(*desc2));
590 card->txbd_ring[i] = (void *)card->txbd_ring_vbase +
592 desc = card->txbd_ring[i];
593 memset(desc, 0, sizeof(*desc));
600 /* This function initializes RX buffer ring descriptors. Each SKB is allocated
601 * here and after mapping PCI memory, its physical address is assigned to
602 * PCIE Rx buffer descriptor's physical address.
604 static int mwifiex_init_rxq_ring(struct mwifiex_adapter *adapter)
606 struct pcie_service_card *card = adapter->card;
607 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
609 struct mwifiex_pcie_buf_desc *desc;
610 struct mwifiex_pfu_buf_desc *desc2;
614 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
615 /* Allocate skb here so that firmware can DMA data from it */
616 skb = mwifiex_alloc_dma_align_buf(MWIFIEX_RX_DATA_BUF_SIZE,
619 mwifiex_dbg(adapter, ERROR,
620 "Unable to allocate skb for RX ring.\n");
621 kfree(card->rxbd_ring_vbase);
625 if (mwifiex_map_pci_memory(adapter, skb,
626 MWIFIEX_RX_DATA_BUF_SIZE,
630 buf_pa = MWIFIEX_SKB_DMA_ADDR(skb);
632 mwifiex_dbg(adapter, INFO,
633 "info: RX ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
634 skb, skb->len, skb->data, (u32)buf_pa,
635 (u32)((u64)buf_pa >> 32));
637 card->rx_buf_list[i] = skb;
638 if (reg->pfu_enabled) {
639 card->rxbd_ring[i] = (void *)card->rxbd_ring_vbase +
640 (sizeof(*desc2) * i);
641 desc2 = card->rxbd_ring[i];
642 desc2->paddr = buf_pa;
643 desc2->len = (u16)skb->len;
644 desc2->frag_len = (u16)skb->len;
645 desc2->flags = reg->ring_flag_eop | reg->ring_flag_sop;
648 card->rxbd_ring[i] = (void *)(card->rxbd_ring_vbase +
649 (sizeof(*desc) * i));
650 desc = card->rxbd_ring[i];
651 desc->paddr = buf_pa;
652 desc->len = (u16)skb->len;
660 /* This function initializes event buffer ring descriptors. Each SKB is
661 * allocated here and after mapping PCI memory, its physical address is assigned
662 * to PCIE Rx buffer descriptor's physical address
664 static int mwifiex_pcie_init_evt_ring(struct mwifiex_adapter *adapter)
666 struct pcie_service_card *card = adapter->card;
667 struct mwifiex_evt_buf_desc *desc;
672 for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) {
673 /* Allocate skb here so that firmware can DMA data from it */
674 skb = dev_alloc_skb(MAX_EVENT_SIZE);
676 mwifiex_dbg(adapter, ERROR,
677 "Unable to allocate skb for EVENT buf.\n");
678 kfree(card->evtbd_ring_vbase);
681 skb_put(skb, MAX_EVENT_SIZE);
683 if (mwifiex_map_pci_memory(adapter, skb, MAX_EVENT_SIZE,
684 PCI_DMA_FROMDEVICE)) {
686 kfree(card->evtbd_ring_vbase);
690 buf_pa = MWIFIEX_SKB_DMA_ADDR(skb);
692 mwifiex_dbg(adapter, EVENT,
693 "info: EVT ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
694 skb, skb->len, skb->data, (u32)buf_pa,
695 (u32)((u64)buf_pa >> 32));
697 card->evt_buf_list[i] = skb;
698 card->evtbd_ring[i] = (void *)(card->evtbd_ring_vbase +
699 (sizeof(*desc) * i));
700 desc = card->evtbd_ring[i];
701 desc->paddr = buf_pa;
702 desc->len = (u16)skb->len;
709 /* This function cleans up TX buffer rings. If any of the buffer list has valid
710 * SKB address, associated SKB is freed.
712 static void mwifiex_cleanup_txq_ring(struct mwifiex_adapter *adapter)
714 struct pcie_service_card *card = adapter->card;
715 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
717 struct mwifiex_pcie_buf_desc *desc;
718 struct mwifiex_pfu_buf_desc *desc2;
721 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
722 if (reg->pfu_enabled) {
723 desc2 = card->txbd_ring[i];
724 if (card->tx_buf_list[i]) {
725 skb = card->tx_buf_list[i];
726 mwifiex_unmap_pci_memory(adapter, skb,
728 dev_kfree_skb_any(skb);
730 memset(desc2, 0, sizeof(*desc2));
732 desc = card->txbd_ring[i];
733 if (card->tx_buf_list[i]) {
734 skb = card->tx_buf_list[i];
735 mwifiex_unmap_pci_memory(adapter, skb,
737 dev_kfree_skb_any(skb);
739 memset(desc, 0, sizeof(*desc));
741 card->tx_buf_list[i] = NULL;
744 atomic_set(&adapter->tx_hw_pending, 0);
748 /* This function cleans up RX buffer rings. If any of the buffer list has valid
749 * SKB address, associated SKB is freed.
751 static void mwifiex_cleanup_rxq_ring(struct mwifiex_adapter *adapter)
753 struct pcie_service_card *card = adapter->card;
754 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
755 struct mwifiex_pcie_buf_desc *desc;
756 struct mwifiex_pfu_buf_desc *desc2;
760 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
761 if (reg->pfu_enabled) {
762 desc2 = card->rxbd_ring[i];
763 if (card->rx_buf_list[i]) {
764 skb = card->rx_buf_list[i];
765 mwifiex_unmap_pci_memory(adapter, skb,
767 dev_kfree_skb_any(skb);
769 memset(desc2, 0, sizeof(*desc2));
771 desc = card->rxbd_ring[i];
772 if (card->rx_buf_list[i]) {
773 skb = card->rx_buf_list[i];
774 mwifiex_unmap_pci_memory(adapter, skb,
776 dev_kfree_skb_any(skb);
778 memset(desc, 0, sizeof(*desc));
780 card->rx_buf_list[i] = NULL;
786 /* This function cleans up event buffer rings. If any of the buffer list has
787 * valid SKB address, associated SKB is freed.
789 static void mwifiex_cleanup_evt_ring(struct mwifiex_adapter *adapter)
791 struct pcie_service_card *card = adapter->card;
792 struct mwifiex_evt_buf_desc *desc;
796 for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) {
797 desc = card->evtbd_ring[i];
798 if (card->evt_buf_list[i]) {
799 skb = card->evt_buf_list[i];
800 mwifiex_unmap_pci_memory(adapter, skb,
802 dev_kfree_skb_any(skb);
804 card->evt_buf_list[i] = NULL;
805 memset(desc, 0, sizeof(*desc));
811 /* This function creates buffer descriptor ring for TX
813 static int mwifiex_pcie_create_txbd_ring(struct mwifiex_adapter *adapter)
815 struct pcie_service_card *card = adapter->card;
816 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
819 * driver maintaines the write pointer and firmware maintaines the read
820 * pointer. The write pointer starts at 0 (zero) while the read pointer
821 * starts at zero with rollover bit set
823 card->txbd_wrptr = 0;
825 if (reg->pfu_enabled)
826 card->txbd_rdptr = 0;
828 card->txbd_rdptr |= reg->tx_rollover_ind;
830 /* allocate shared memory for the BD ring and divide the same in to
831 several descriptors */
832 if (reg->pfu_enabled)
833 card->txbd_ring_size = sizeof(struct mwifiex_pfu_buf_desc) *
836 card->txbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
839 mwifiex_dbg(adapter, INFO,
840 "info: txbd_ring: Allocating %d bytes\n",
841 card->txbd_ring_size);
842 card->txbd_ring_vbase = pci_alloc_consistent(card->dev,
843 card->txbd_ring_size,
844 &card->txbd_ring_pbase);
845 if (!card->txbd_ring_vbase) {
846 mwifiex_dbg(adapter, ERROR,
847 "allocate consistent memory (%d bytes) failed!\n",
848 card->txbd_ring_size);
851 mwifiex_dbg(adapter, DATA,
852 "info: txbd_ring - base: %p, pbase: %#x:%x, len: %x\n",
853 card->txbd_ring_vbase, (unsigned int)card->txbd_ring_pbase,
854 (u32)((u64)card->txbd_ring_pbase >> 32),
855 card->txbd_ring_size);
857 return mwifiex_init_txq_ring(adapter);
860 static int mwifiex_pcie_delete_txbd_ring(struct mwifiex_adapter *adapter)
862 struct pcie_service_card *card = adapter->card;
863 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
865 mwifiex_cleanup_txq_ring(adapter);
867 if (card->txbd_ring_vbase)
868 pci_free_consistent(card->dev, card->txbd_ring_size,
869 card->txbd_ring_vbase,
870 card->txbd_ring_pbase);
871 card->txbd_ring_size = 0;
872 card->txbd_wrptr = 0;
873 card->txbd_rdptr = 0 | reg->tx_rollover_ind;
874 card->txbd_ring_vbase = NULL;
875 card->txbd_ring_pbase = 0;
881 * This function creates buffer descriptor ring for RX
883 static int mwifiex_pcie_create_rxbd_ring(struct mwifiex_adapter *adapter)
885 struct pcie_service_card *card = adapter->card;
886 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
889 * driver maintaines the read pointer and firmware maintaines the write
890 * pointer. The write pointer starts at 0 (zero) while the read pointer
891 * starts at zero with rollover bit set
893 card->rxbd_wrptr = 0;
894 card->rxbd_rdptr = reg->rx_rollover_ind;
896 if (reg->pfu_enabled)
897 card->rxbd_ring_size = sizeof(struct mwifiex_pfu_buf_desc) *
900 card->rxbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
903 mwifiex_dbg(adapter, INFO,
904 "info: rxbd_ring: Allocating %d bytes\n",
905 card->rxbd_ring_size);
906 card->rxbd_ring_vbase = pci_alloc_consistent(card->dev,
907 card->rxbd_ring_size,
908 &card->rxbd_ring_pbase);
909 if (!card->rxbd_ring_vbase) {
910 mwifiex_dbg(adapter, ERROR,
911 "allocate consistent memory (%d bytes) failed!\n",
912 card->rxbd_ring_size);
916 mwifiex_dbg(adapter, DATA,
917 "info: rxbd_ring - base: %p, pbase: %#x:%x, len: %#x\n",
918 card->rxbd_ring_vbase, (u32)card->rxbd_ring_pbase,
919 (u32)((u64)card->rxbd_ring_pbase >> 32),
920 card->rxbd_ring_size);
922 return mwifiex_init_rxq_ring(adapter);
926 * This function deletes Buffer descriptor ring for RX
928 static int mwifiex_pcie_delete_rxbd_ring(struct mwifiex_adapter *adapter)
930 struct pcie_service_card *card = adapter->card;
931 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
933 mwifiex_cleanup_rxq_ring(adapter);
935 if (card->rxbd_ring_vbase)
936 pci_free_consistent(card->dev, card->rxbd_ring_size,
937 card->rxbd_ring_vbase,
938 card->rxbd_ring_pbase);
939 card->rxbd_ring_size = 0;
940 card->rxbd_wrptr = 0;
941 card->rxbd_rdptr = 0 | reg->rx_rollover_ind;
942 card->rxbd_ring_vbase = NULL;
943 card->rxbd_ring_pbase = 0;
949 * This function creates buffer descriptor ring for Events
951 static int mwifiex_pcie_create_evtbd_ring(struct mwifiex_adapter *adapter)
953 struct pcie_service_card *card = adapter->card;
954 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
957 * driver maintaines the read pointer and firmware maintaines the write
958 * pointer. The write pointer starts at 0 (zero) while the read pointer
959 * starts at zero with rollover bit set
961 card->evtbd_wrptr = 0;
962 card->evtbd_rdptr = reg->evt_rollover_ind;
964 card->evtbd_ring_size = sizeof(struct mwifiex_evt_buf_desc) *
967 mwifiex_dbg(adapter, INFO,
968 "info: evtbd_ring: Allocating %d bytes\n",
969 card->evtbd_ring_size);
970 card->evtbd_ring_vbase = pci_alloc_consistent(card->dev,
971 card->evtbd_ring_size,
972 &card->evtbd_ring_pbase);
973 if (!card->evtbd_ring_vbase) {
974 mwifiex_dbg(adapter, ERROR,
975 "allocate consistent memory (%d bytes) failed!\n",
976 card->evtbd_ring_size);
980 mwifiex_dbg(adapter, EVENT,
981 "info: CMDRSP/EVT bd_ring - base: %p pbase: %#x:%x len: %#x\n",
982 card->evtbd_ring_vbase, (u32)card->evtbd_ring_pbase,
983 (u32)((u64)card->evtbd_ring_pbase >> 32),
984 card->evtbd_ring_size);
986 return mwifiex_pcie_init_evt_ring(adapter);
990 * This function deletes Buffer descriptor ring for Events
992 static int mwifiex_pcie_delete_evtbd_ring(struct mwifiex_adapter *adapter)
994 struct pcie_service_card *card = adapter->card;
995 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
997 mwifiex_cleanup_evt_ring(adapter);
999 if (card->evtbd_ring_vbase)
1000 pci_free_consistent(card->dev, card->evtbd_ring_size,
1001 card->evtbd_ring_vbase,
1002 card->evtbd_ring_pbase);
1003 card->evtbd_wrptr = 0;
1004 card->evtbd_rdptr = 0 | reg->evt_rollover_ind;
1005 card->evtbd_ring_size = 0;
1006 card->evtbd_ring_vbase = NULL;
1007 card->evtbd_ring_pbase = 0;
1013 * This function allocates a buffer for CMDRSP
1015 static int mwifiex_pcie_alloc_cmdrsp_buf(struct mwifiex_adapter *adapter)
1017 struct pcie_service_card *card = adapter->card;
1018 struct sk_buff *skb;
1020 /* Allocate memory for receiving command response data */
1021 skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
1023 mwifiex_dbg(adapter, ERROR,
1024 "Unable to allocate skb for command response data.\n");
1027 skb_put(skb, MWIFIEX_UPLD_SIZE);
1028 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1029 PCI_DMA_FROMDEVICE)) {
1034 card->cmdrsp_buf = skb;
1040 * This function deletes a buffer for CMDRSP
1042 static int mwifiex_pcie_delete_cmdrsp_buf(struct mwifiex_adapter *adapter)
1044 struct pcie_service_card *card;
1049 card = adapter->card;
1051 if (card && card->cmdrsp_buf) {
1052 mwifiex_unmap_pci_memory(adapter, card->cmdrsp_buf,
1053 PCI_DMA_FROMDEVICE);
1054 dev_kfree_skb_any(card->cmdrsp_buf);
1055 card->cmdrsp_buf = NULL;
1058 if (card && card->cmd_buf) {
1059 mwifiex_unmap_pci_memory(adapter, card->cmd_buf,
1061 dev_kfree_skb_any(card->cmd_buf);
1062 card->cmd_buf = NULL;
1068 * This function allocates a buffer for sleep cookie
1070 static int mwifiex_pcie_alloc_sleep_cookie_buf(struct mwifiex_adapter *adapter)
1072 struct pcie_service_card *card = adapter->card;
1075 card->sleep_cookie_vbase = pci_alloc_consistent(card->dev, sizeof(u32),
1076 &card->sleep_cookie_pbase);
1077 if (!card->sleep_cookie_vbase) {
1078 mwifiex_dbg(adapter, ERROR,
1079 "pci_alloc_consistent failed!\n");
1082 cookie = (u32 *)card->sleep_cookie_vbase;
1083 /* Init val of Sleep Cookie */
1084 *cookie = FW_AWAKE_COOKIE;
1086 mwifiex_dbg(adapter, INFO, "alloc_scook: sleep cookie=0x%x\n", *cookie);
1092 * This function deletes buffer for sleep cookie
1094 static int mwifiex_pcie_delete_sleep_cookie_buf(struct mwifiex_adapter *adapter)
1096 struct pcie_service_card *card;
1101 card = adapter->card;
1103 if (card && card->sleep_cookie_vbase) {
1104 pci_free_consistent(card->dev, sizeof(u32),
1105 card->sleep_cookie_vbase,
1106 card->sleep_cookie_pbase);
1107 card->sleep_cookie_vbase = NULL;
1113 /* This function flushes the TX buffer descriptor ring
1114 * This function defined as handler is also called while cleaning TXRX
1115 * during disconnect/ bss stop.
1117 static int mwifiex_clean_pcie_ring_buf(struct mwifiex_adapter *adapter)
1119 struct pcie_service_card *card = adapter->card;
1121 if (!mwifiex_pcie_txbd_empty(card, card->txbd_rdptr)) {
1122 card->txbd_flush = 1;
1123 /* write pointer already set at last send
1124 * send dnld-rdy intr again, wait for completion.
1126 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1127 CPU_INTR_DNLD_RDY)) {
1128 mwifiex_dbg(adapter, ERROR,
1129 "failed to assert dnld-rdy interrupt.\n");
1137 * This function unmaps and frees downloaded data buffer
1139 static int mwifiex_pcie_send_data_complete(struct mwifiex_adapter *adapter)
1141 struct sk_buff *skb;
1142 u32 wrdoneidx, rdptr, num_tx_buffs, unmap_count = 0;
1143 struct mwifiex_pcie_buf_desc *desc;
1144 struct mwifiex_pfu_buf_desc *desc2;
1145 struct pcie_service_card *card = adapter->card;
1146 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1148 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1149 mwifiex_pm_wakeup_card(adapter);
1151 /* Read the TX ring read pointer set by firmware */
1152 if (mwifiex_read_reg(adapter, reg->tx_rdptr, &rdptr)) {
1153 mwifiex_dbg(adapter, ERROR,
1154 "SEND COMP: failed to read reg->tx_rdptr\n");
1158 mwifiex_dbg(adapter, DATA,
1159 "SEND COMP: rdptr_prev=0x%x, rdptr=0x%x\n",
1160 card->txbd_rdptr, rdptr);
1162 num_tx_buffs = MWIFIEX_MAX_TXRX_BD << reg->tx_start_ptr;
1163 /* free from previous txbd_rdptr to current txbd_rdptr */
1164 while (((card->txbd_rdptr & reg->tx_mask) !=
1165 (rdptr & reg->tx_mask)) ||
1166 ((card->txbd_rdptr & reg->tx_rollover_ind) !=
1167 (rdptr & reg->tx_rollover_ind))) {
1168 wrdoneidx = (card->txbd_rdptr & reg->tx_mask) >>
1171 skb = card->tx_buf_list[wrdoneidx];
1174 mwifiex_dbg(adapter, DATA,
1175 "SEND COMP: Detach skb %p at txbd_rdidx=%d\n",
1177 mwifiex_unmap_pci_memory(adapter, skb,
1182 if (card->txbd_flush)
1183 mwifiex_write_data_complete(adapter, skb, 0,
1186 mwifiex_write_data_complete(adapter, skb, 0, 0);
1187 atomic_dec(&adapter->tx_hw_pending);
1190 card->tx_buf_list[wrdoneidx] = NULL;
1192 if (reg->pfu_enabled) {
1193 desc2 = card->txbd_ring[wrdoneidx];
1194 memset(desc2, 0, sizeof(*desc2));
1196 desc = card->txbd_ring[wrdoneidx];
1197 memset(desc, 0, sizeof(*desc));
1199 switch (card->dev->device) {
1200 case PCIE_DEVICE_ID_MARVELL_88W8766P:
1203 case PCIE_DEVICE_ID_MARVELL_88W8897:
1204 case PCIE_DEVICE_ID_MARVELL_88W8997:
1205 card->txbd_rdptr += reg->ring_tx_start_ptr;
1210 if ((card->txbd_rdptr & reg->tx_mask) == num_tx_buffs)
1211 card->txbd_rdptr = ((card->txbd_rdptr &
1212 reg->tx_rollover_ind) ^
1213 reg->tx_rollover_ind);
1217 adapter->data_sent = false;
1219 if (card->txbd_flush) {
1220 if (mwifiex_pcie_txbd_empty(card, card->txbd_rdptr))
1221 card->txbd_flush = 0;
1223 mwifiex_clean_pcie_ring_buf(adapter);
1229 /* This function sends data buffer to device. First 4 bytes of payload
1230 * are filled with payload length and payload type. Then this payload
1231 * is mapped to PCI device memory. Tx ring pointers are advanced accordingly.
1232 * Download ready interrupt to FW is deffered if Tx ring is not full and
1233 * additional payload can be accomodated.
1234 * Caller must ensure tx_param parameter to this function is not NULL.
1237 mwifiex_pcie_send_data(struct mwifiex_adapter *adapter, struct sk_buff *skb,
1238 struct mwifiex_tx_param *tx_param)
1240 struct pcie_service_card *card = adapter->card;
1241 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1242 u32 wrindx, num_tx_buffs, rx_val;
1245 struct mwifiex_pcie_buf_desc *desc = NULL;
1246 struct mwifiex_pfu_buf_desc *desc2 = NULL;
1248 if (!(skb->data && skb->len)) {
1249 mwifiex_dbg(adapter, ERROR,
1250 "%s(): invalid parameter <%p, %#x>\n",
1251 __func__, skb->data, skb->len);
1255 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1256 mwifiex_pm_wakeup_card(adapter);
1258 num_tx_buffs = MWIFIEX_MAX_TXRX_BD << reg->tx_start_ptr;
1259 mwifiex_dbg(adapter, DATA,
1260 "info: SEND DATA: <Rd: %#x, Wr: %#x>\n",
1261 card->txbd_rdptr, card->txbd_wrptr);
1262 if (mwifiex_pcie_txbd_not_full(card)) {
1265 adapter->data_sent = true;
1266 payload = skb->data;
1267 put_unaligned_le16((u16)skb->len, payload + 0);
1268 put_unaligned_le16(MWIFIEX_TYPE_DATA, payload + 2);
1270 if (mwifiex_map_pci_memory(adapter, skb, skb->len,
1274 wrindx = (card->txbd_wrptr & reg->tx_mask) >> reg->tx_start_ptr;
1275 buf_pa = MWIFIEX_SKB_DMA_ADDR(skb);
1276 card->tx_buf_list[wrindx] = skb;
1277 atomic_inc(&adapter->tx_hw_pending);
1279 if (reg->pfu_enabled) {
1280 desc2 = card->txbd_ring[wrindx];
1281 desc2->paddr = buf_pa;
1282 desc2->len = (u16)skb->len;
1283 desc2->frag_len = (u16)skb->len;
1285 desc2->flags = MWIFIEX_BD_FLAG_FIRST_DESC |
1286 MWIFIEX_BD_FLAG_LAST_DESC;
1288 desc = card->txbd_ring[wrindx];
1289 desc->paddr = buf_pa;
1290 desc->len = (u16)skb->len;
1291 desc->flags = MWIFIEX_BD_FLAG_FIRST_DESC |
1292 MWIFIEX_BD_FLAG_LAST_DESC;
1295 switch (card->dev->device) {
1296 case PCIE_DEVICE_ID_MARVELL_88W8766P:
1299 case PCIE_DEVICE_ID_MARVELL_88W8897:
1300 case PCIE_DEVICE_ID_MARVELL_88W8997:
1301 card->txbd_wrptr += reg->ring_tx_start_ptr;
1305 if ((card->txbd_wrptr & reg->tx_mask) == num_tx_buffs)
1306 card->txbd_wrptr = ((card->txbd_wrptr &
1307 reg->tx_rollover_ind) ^
1308 reg->tx_rollover_ind);
1310 rx_val = card->rxbd_rdptr & reg->rx_wrap_mask;
1311 /* Write the TX ring write pointer in to reg->tx_wrptr */
1312 if (mwifiex_write_reg(adapter, reg->tx_wrptr,
1313 card->txbd_wrptr | rx_val)) {
1314 mwifiex_dbg(adapter, ERROR,
1315 "SEND DATA: failed to write reg->tx_wrptr\n");
1320 /* The firmware (latest version 15.68.19.p21) of the 88W8897 PCIe+USB card
1321 * seems to crash randomly after setting the TX ring write pointer when
1322 * ASPM powersaving is enabled. A workaround seems to be keeping the bus
1323 * busy by reading a random register afterwards.
1325 mwifiex_read_reg(adapter, PCI_VENDOR_ID, &rx_val);
1327 if ((mwifiex_pcie_txbd_not_full(card)) &&
1328 tx_param->next_pkt_len) {
1329 /* have more packets and TxBD still can hold more */
1330 mwifiex_dbg(adapter, DATA,
1331 "SEND DATA: delay dnld-rdy interrupt.\n");
1332 adapter->data_sent = false;
1334 /* Send the TX ready interrupt */
1335 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1336 CPU_INTR_DNLD_RDY)) {
1337 mwifiex_dbg(adapter, ERROR,
1338 "SEND DATA: failed to assert dnld-rdy interrupt.\n");
1343 mwifiex_dbg(adapter, DATA,
1344 "info: SEND DATA: Updated <Rd: %#x, Wr:\t"
1345 "%#x> and sent packet to firmware successfully\n",
1346 card->txbd_rdptr, card->txbd_wrptr);
1348 mwifiex_dbg(adapter, DATA,
1349 "info: TX Ring full, can't send packets to fw\n");
1350 adapter->data_sent = true;
1351 /* Send the TX ready interrupt */
1352 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1354 mwifiex_dbg(adapter, ERROR,
1355 "SEND DATA: failed to assert door-bell intr\n");
1359 return -EINPROGRESS;
1361 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1362 card->tx_buf_list[wrindx] = NULL;
1363 atomic_dec(&adapter->tx_hw_pending);
1364 if (reg->pfu_enabled)
1365 memset(desc2, 0, sizeof(*desc2));
1367 memset(desc, 0, sizeof(*desc));
1373 * This function handles received buffer ring and
1374 * dispatches packets to upper
1376 static int mwifiex_pcie_process_recv_data(struct mwifiex_adapter *adapter)
1378 struct pcie_service_card *card = adapter->card;
1379 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1380 u32 wrptr, rd_index, tx_val;
1383 struct sk_buff *skb_tmp = NULL;
1384 struct mwifiex_pcie_buf_desc *desc;
1385 struct mwifiex_pfu_buf_desc *desc2;
1387 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1388 mwifiex_pm_wakeup_card(adapter);
1390 /* Read the RX ring Write pointer set by firmware */
1391 if (mwifiex_read_reg(adapter, reg->rx_wrptr, &wrptr)) {
1392 mwifiex_dbg(adapter, ERROR,
1393 "RECV DATA: failed to read reg->rx_wrptr\n");
1397 card->rxbd_wrptr = wrptr;
1399 while (((wrptr & reg->rx_mask) !=
1400 (card->rxbd_rdptr & reg->rx_mask)) ||
1401 ((wrptr & reg->rx_rollover_ind) ==
1402 (card->rxbd_rdptr & reg->rx_rollover_ind))) {
1403 struct sk_buff *skb_data;
1406 rd_index = card->rxbd_rdptr & reg->rx_mask;
1407 skb_data = card->rx_buf_list[rd_index];
1409 /* If skb allocation was failed earlier for Rx packet,
1410 * rx_buf_list[rd_index] would have been left with a NULL.
1415 mwifiex_unmap_pci_memory(adapter, skb_data, PCI_DMA_FROMDEVICE);
1416 card->rx_buf_list[rd_index] = NULL;
1418 /* Get data length from interface header -
1419 * first 2 bytes for len, next 2 bytes is for type
1421 rx_len = get_unaligned_le16(skb_data->data);
1422 if (WARN_ON(rx_len <= adapter->intf_hdr_len ||
1423 rx_len > MWIFIEX_RX_DATA_BUF_SIZE)) {
1424 mwifiex_dbg(adapter, ERROR,
1425 "Invalid RX len %d, Rd=%#x, Wr=%#x\n",
1426 rx_len, card->rxbd_rdptr, wrptr);
1427 dev_kfree_skb_any(skb_data);
1429 skb_put(skb_data, rx_len);
1430 mwifiex_dbg(adapter, DATA,
1431 "info: RECV DATA: Rd=%#x, Wr=%#x, Len=%d\n",
1432 card->rxbd_rdptr, wrptr, rx_len);
1433 skb_pull(skb_data, adapter->intf_hdr_len);
1434 if (adapter->rx_work_enabled) {
1435 skb_queue_tail(&adapter->rx_data_q, skb_data);
1436 adapter->data_received = true;
1437 atomic_inc(&adapter->rx_pending);
1439 mwifiex_handle_rx_packet(adapter, skb_data);
1443 skb_tmp = mwifiex_alloc_dma_align_buf(MWIFIEX_RX_DATA_BUF_SIZE,
1446 mwifiex_dbg(adapter, ERROR,
1447 "Unable to allocate skb.\n");
1451 if (mwifiex_map_pci_memory(adapter, skb_tmp,
1452 MWIFIEX_RX_DATA_BUF_SIZE,
1453 PCI_DMA_FROMDEVICE))
1456 buf_pa = MWIFIEX_SKB_DMA_ADDR(skb_tmp);
1458 mwifiex_dbg(adapter, INFO,
1459 "RECV DATA: Attach new sk_buff %p at rxbd_rdidx=%d\n",
1461 card->rx_buf_list[rd_index] = skb_tmp;
1463 if (reg->pfu_enabled) {
1464 desc2 = card->rxbd_ring[rd_index];
1465 desc2->paddr = buf_pa;
1466 desc2->len = skb_tmp->len;
1467 desc2->frag_len = skb_tmp->len;
1469 desc2->flags = reg->ring_flag_sop | reg->ring_flag_eop;
1471 desc = card->rxbd_ring[rd_index];
1472 desc->paddr = buf_pa;
1473 desc->len = skb_tmp->len;
1477 if ((++card->rxbd_rdptr & reg->rx_mask) ==
1478 MWIFIEX_MAX_TXRX_BD) {
1479 card->rxbd_rdptr = ((card->rxbd_rdptr &
1480 reg->rx_rollover_ind) ^
1481 reg->rx_rollover_ind);
1483 mwifiex_dbg(adapter, DATA,
1484 "info: RECV DATA: <Rd: %#x, Wr: %#x>\n",
1485 card->rxbd_rdptr, wrptr);
1487 tx_val = card->txbd_wrptr & reg->tx_wrap_mask;
1488 /* Write the RX ring read pointer in to reg->rx_rdptr */
1489 if (mwifiex_write_reg(adapter, reg->rx_rdptr,
1490 card->rxbd_rdptr | tx_val)) {
1491 mwifiex_dbg(adapter, DATA,
1492 "RECV DATA: failed to write reg->rx_rdptr\n");
1497 /* Read the RX ring Write pointer set by firmware */
1498 if (mwifiex_read_reg(adapter, reg->rx_wrptr, &wrptr)) {
1499 mwifiex_dbg(adapter, ERROR,
1500 "RECV DATA: failed to read reg->rx_wrptr\n");
1504 mwifiex_dbg(adapter, DATA,
1505 "info: RECV DATA: Rcvd packet from fw successfully\n");
1506 card->rxbd_wrptr = wrptr;
1514 * This function downloads the boot command to device
1517 mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
1520 struct pcie_service_card *card = adapter->card;
1521 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1523 if (!(skb->data && skb->len)) {
1524 mwifiex_dbg(adapter, ERROR,
1525 "Invalid parameter in %s <%p. len %d>\n",
1526 __func__, skb->data, skb->len);
1530 if (mwifiex_map_pci_memory(adapter, skb, skb->len, PCI_DMA_TODEVICE))
1533 buf_pa = MWIFIEX_SKB_DMA_ADDR(skb);
1535 /* Write the lower 32bits of the physical address to low command
1536 * address scratch register
1538 if (mwifiex_write_reg(adapter, reg->cmd_addr_lo, (u32)buf_pa)) {
1539 mwifiex_dbg(adapter, ERROR,
1540 "%s: failed to write download command to boot code.\n",
1542 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1546 /* Write the upper 32bits of the physical address to high command
1547 * address scratch register
1549 if (mwifiex_write_reg(adapter, reg->cmd_addr_hi,
1550 (u32)((u64)buf_pa >> 32))) {
1551 mwifiex_dbg(adapter, ERROR,
1552 "%s: failed to write download command to boot code.\n",
1554 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1558 /* Write the command length to cmd_size scratch register */
1559 if (mwifiex_write_reg(adapter, reg->cmd_size, skb->len)) {
1560 mwifiex_dbg(adapter, ERROR,
1561 "%s: failed to write command len to cmd_size scratch reg\n",
1563 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1567 /* Ring the door bell */
1568 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1569 CPU_INTR_DOOR_BELL)) {
1570 mwifiex_dbg(adapter, ERROR,
1571 "%s: failed to assert door-bell intr\n", __func__);
1572 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
1579 /* This function init rx port in firmware which in turn enables to receive data
1580 * from device before transmitting any packet.
1582 static int mwifiex_pcie_init_fw_port(struct mwifiex_adapter *adapter)
1584 struct pcie_service_card *card = adapter->card;
1585 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1586 int tx_wrap = card->txbd_wrptr & reg->tx_wrap_mask;
1588 /* Write the RX ring read pointer in to reg->rx_rdptr */
1589 if (mwifiex_write_reg(adapter, reg->rx_rdptr, card->rxbd_rdptr |
1591 mwifiex_dbg(adapter, ERROR,
1592 "RECV DATA: failed to write reg->rx_rdptr\n");
1598 /* This function downloads commands to the device
1601 mwifiex_pcie_send_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
1603 struct pcie_service_card *card = adapter->card;
1604 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1606 dma_addr_t cmd_buf_pa, cmdrsp_buf_pa;
1607 u8 *payload = (u8 *)skb->data;
1609 if (!(skb->data && skb->len)) {
1610 mwifiex_dbg(adapter, ERROR,
1611 "Invalid parameter in %s <%p, %#x>\n",
1612 __func__, skb->data, skb->len);
1616 /* Make sure a command response buffer is available */
1617 if (!card->cmdrsp_buf) {
1618 mwifiex_dbg(adapter, ERROR,
1619 "No response buffer available, send command failed\n");
1623 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1624 mwifiex_pm_wakeup_card(adapter);
1626 adapter->cmd_sent = true;
1628 put_unaligned_le16((u16)skb->len, &payload[0]);
1629 put_unaligned_le16(MWIFIEX_TYPE_CMD, &payload[2]);
1631 if (mwifiex_map_pci_memory(adapter, skb, skb->len, PCI_DMA_TODEVICE))
1634 card->cmd_buf = skb;
1636 * Need to keep a reference, since core driver might free up this
1637 * buffer before we've unmapped it.
1641 /* To send a command, the driver will:
1642 1. Write the 64bit physical address of the data buffer to
1643 cmd response address low + cmd response address high
1644 2. Ring the door bell (i.e. set the door bell interrupt)
1646 In response to door bell interrupt, the firmware will perform
1647 the DMA of the command packet (first header to obtain the total
1648 length and then rest of the command).
1651 if (card->cmdrsp_buf) {
1652 cmdrsp_buf_pa = MWIFIEX_SKB_DMA_ADDR(card->cmdrsp_buf);
1653 /* Write the lower 32bits of the cmdrsp buffer physical
1655 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo,
1656 (u32)cmdrsp_buf_pa)) {
1657 mwifiex_dbg(adapter, ERROR,
1658 "Failed to write download cmd to boot code.\n");
1662 /* Write the upper 32bits of the cmdrsp buffer physical
1664 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi,
1665 (u32)((u64)cmdrsp_buf_pa >> 32))) {
1666 mwifiex_dbg(adapter, ERROR,
1667 "Failed to write download cmd to boot code.\n");
1673 cmd_buf_pa = MWIFIEX_SKB_DMA_ADDR(card->cmd_buf);
1674 /* Write the lower 32bits of the physical address to reg->cmd_addr_lo */
1675 if (mwifiex_write_reg(adapter, reg->cmd_addr_lo,
1677 mwifiex_dbg(adapter, ERROR,
1678 "Failed to write download cmd to boot code.\n");
1682 /* Write the upper 32bits of the physical address to reg->cmd_addr_hi */
1683 if (mwifiex_write_reg(adapter, reg->cmd_addr_hi,
1684 (u32)((u64)cmd_buf_pa >> 32))) {
1685 mwifiex_dbg(adapter, ERROR,
1686 "Failed to write download cmd to boot code.\n");
1691 /* Write the command length to reg->cmd_size */
1692 if (mwifiex_write_reg(adapter, reg->cmd_size,
1693 card->cmd_buf->len)) {
1694 mwifiex_dbg(adapter, ERROR,
1695 "Failed to write cmd len to reg->cmd_size\n");
1700 /* Ring the door bell */
1701 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1702 CPU_INTR_DOOR_BELL)) {
1703 mwifiex_dbg(adapter, ERROR,
1704 "Failed to assert door-bell intr\n");
1711 adapter->cmd_sent = false;
1717 * This function handles command complete interrupt
1719 static int mwifiex_pcie_process_cmd_complete(struct mwifiex_adapter *adapter)
1721 struct pcie_service_card *card = adapter->card;
1722 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1723 struct sk_buff *skb = card->cmdrsp_buf;
1727 mwifiex_dbg(adapter, CMD,
1728 "info: Rx CMD Response\n");
1730 if (adapter->curr_cmd)
1731 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_FROMDEVICE);
1733 pci_dma_sync_single_for_cpu(card->dev,
1734 MWIFIEX_SKB_DMA_ADDR(skb),
1736 PCI_DMA_FROMDEVICE);
1738 /* Unmap the command as a response has been received. */
1739 if (card->cmd_buf) {
1740 mwifiex_unmap_pci_memory(adapter, card->cmd_buf,
1742 dev_kfree_skb_any(card->cmd_buf);
1743 card->cmd_buf = NULL;
1746 rx_len = get_unaligned_le16(skb->data);
1747 skb_put(skb, MWIFIEX_UPLD_SIZE - skb->len);
1748 skb_trim(skb, rx_len);
1750 if (!adapter->curr_cmd) {
1751 if (adapter->ps_state == PS_STATE_SLEEP_CFM) {
1752 pci_dma_sync_single_for_device(card->dev,
1753 MWIFIEX_SKB_DMA_ADDR(skb),
1754 MWIFIEX_SLEEP_COOKIE_SIZE,
1755 PCI_DMA_FROMDEVICE);
1756 if (mwifiex_write_reg(adapter,
1758 CPU_INTR_SLEEP_CFM_DONE)) {
1759 mwifiex_dbg(adapter, ERROR,
1760 "Write register failed\n");
1763 mwifiex_delay_for_sleep_cookie(adapter,
1764 MWIFIEX_MAX_DELAY_COUNT);
1765 mwifiex_unmap_pci_memory(adapter, skb,
1766 PCI_DMA_FROMDEVICE);
1767 skb_pull(skb, adapter->intf_hdr_len);
1768 while (reg->sleep_cookie && (count++ < 10) &&
1769 mwifiex_pcie_ok_to_access_hw(adapter))
1770 usleep_range(50, 60);
1771 mwifiex_pcie_enable_host_int(adapter);
1772 mwifiex_process_sleep_confirm_resp(adapter, skb->data,
1775 mwifiex_dbg(adapter, ERROR,
1776 "There is no command but got cmdrsp\n");
1778 memcpy(adapter->upld_buf, skb->data,
1779 min_t(u32, MWIFIEX_SIZE_OF_CMD_BUFFER, skb->len));
1780 skb_push(skb, adapter->intf_hdr_len);
1781 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1782 PCI_DMA_FROMDEVICE))
1784 } else if (mwifiex_pcie_ok_to_access_hw(adapter)) {
1785 skb_pull(skb, adapter->intf_hdr_len);
1786 adapter->curr_cmd->resp_skb = skb;
1787 adapter->cmd_resp_received = true;
1788 /* Take the pointer and set it to CMD node and will
1789 return in the response complete callback */
1790 card->cmdrsp_buf = NULL;
1792 /* Clear the cmd-rsp buffer address in scratch registers. This
1793 will prevent firmware from writing to the same response
1795 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo, 0)) {
1796 mwifiex_dbg(adapter, ERROR,
1797 "cmd_done: failed to clear cmd_rsp_addr_lo\n");
1800 /* Write the upper 32bits of the cmdrsp buffer physical
1802 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi, 0)) {
1803 mwifiex_dbg(adapter, ERROR,
1804 "cmd_done: failed to clear cmd_rsp_addr_hi\n");
1813 * Command Response processing complete handler
1815 static int mwifiex_pcie_cmdrsp_complete(struct mwifiex_adapter *adapter,
1816 struct sk_buff *skb)
1818 struct pcie_service_card *card = adapter->card;
1821 card->cmdrsp_buf = skb;
1822 skb_push(card->cmdrsp_buf, adapter->intf_hdr_len);
1823 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1824 PCI_DMA_FROMDEVICE))
1832 * This function handles firmware event ready interrupt
1834 static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter *adapter)
1836 struct pcie_service_card *card = adapter->card;
1837 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1838 u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1840 struct mwifiex_evt_buf_desc *desc;
1842 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1843 mwifiex_pm_wakeup_card(adapter);
1845 if (adapter->event_received) {
1846 mwifiex_dbg(adapter, EVENT,
1847 "info: Event being processed,\t"
1848 "do not process this interrupt just yet\n");
1852 if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1853 mwifiex_dbg(adapter, ERROR,
1854 "info: Invalid read pointer...\n");
1858 /* Read the event ring write pointer set by firmware */
1859 if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1860 mwifiex_dbg(adapter, ERROR,
1861 "EventReady: failed to read reg->evt_wrptr\n");
1865 mwifiex_dbg(adapter, EVENT,
1866 "info: EventReady: Initial <Rd: 0x%x, Wr: 0x%x>",
1867 card->evtbd_rdptr, wrptr);
1868 if (((wrptr & MWIFIEX_EVTBD_MASK) != (card->evtbd_rdptr
1869 & MWIFIEX_EVTBD_MASK)) ||
1870 ((wrptr & reg->evt_rollover_ind) ==
1871 (card->evtbd_rdptr & reg->evt_rollover_ind))) {
1872 struct sk_buff *skb_cmd;
1873 __le16 data_len = 0;
1876 mwifiex_dbg(adapter, INFO,
1877 "info: Read Index: %d\n", rdptr);
1878 skb_cmd = card->evt_buf_list[rdptr];
1879 mwifiex_unmap_pci_memory(adapter, skb_cmd, PCI_DMA_FROMDEVICE);
1881 /* Take the pointer and set it to event pointer in adapter
1882 and will return back after event handling callback */
1883 card->evt_buf_list[rdptr] = NULL;
1884 desc = card->evtbd_ring[rdptr];
1885 memset(desc, 0, sizeof(*desc));
1887 event = get_unaligned_le32(
1888 &skb_cmd->data[adapter->intf_hdr_len]);
1889 adapter->event_cause = event;
1890 /* The first 4bytes will be the event transfer header
1891 len is 2 bytes followed by type which is 2 bytes */
1892 memcpy(&data_len, skb_cmd->data, sizeof(__le16));
1893 evt_len = le16_to_cpu(data_len);
1894 skb_trim(skb_cmd, evt_len);
1895 skb_pull(skb_cmd, adapter->intf_hdr_len);
1896 mwifiex_dbg(adapter, EVENT,
1897 "info: Event length: %d\n", evt_len);
1899 if ((evt_len > 0) && (evt_len < MAX_EVENT_SIZE))
1900 memcpy(adapter->event_body, skb_cmd->data +
1901 MWIFIEX_EVENT_HEADER_LEN, evt_len -
1902 MWIFIEX_EVENT_HEADER_LEN);
1904 adapter->event_received = true;
1905 adapter->event_skb = skb_cmd;
1907 /* Do not update the event read pointer here, wait till the
1908 buffer is released. This is just to make things simpler,
1909 we need to find a better method of managing these buffers.
1912 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1913 CPU_INTR_EVENT_DONE)) {
1914 mwifiex_dbg(adapter, ERROR,
1915 "Write register failed\n");
1924 * Event processing complete handler
1926 static int mwifiex_pcie_event_complete(struct mwifiex_adapter *adapter,
1927 struct sk_buff *skb)
1929 struct pcie_service_card *card = adapter->card;
1930 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1932 u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1934 struct mwifiex_evt_buf_desc *desc;
1939 if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1940 mwifiex_dbg(adapter, ERROR,
1941 "event_complete: Invalid rdptr 0x%x\n",
1946 /* Read the event ring write pointer set by firmware */
1947 if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1948 mwifiex_dbg(adapter, ERROR,
1949 "event_complete: failed to read reg->evt_wrptr\n");
1953 if (!card->evt_buf_list[rdptr]) {
1954 skb_push(skb, adapter->intf_hdr_len);
1955 skb_put(skb, MAX_EVENT_SIZE - skb->len);
1956 if (mwifiex_map_pci_memory(adapter, skb,
1958 PCI_DMA_FROMDEVICE))
1960 card->evt_buf_list[rdptr] = skb;
1961 desc = card->evtbd_ring[rdptr];
1962 desc->paddr = MWIFIEX_SKB_DMA_ADDR(skb);
1963 desc->len = (u16)skb->len;
1967 mwifiex_dbg(adapter, ERROR,
1968 "info: ERROR: buf still valid at index %d, <%p, %p>\n",
1969 rdptr, card->evt_buf_list[rdptr], skb);
1972 if ((++card->evtbd_rdptr & MWIFIEX_EVTBD_MASK) == MWIFIEX_MAX_EVT_BD) {
1973 card->evtbd_rdptr = ((card->evtbd_rdptr &
1974 reg->evt_rollover_ind) ^
1975 reg->evt_rollover_ind);
1978 mwifiex_dbg(adapter, EVENT,
1979 "info: Updated <Rd: 0x%x, Wr: 0x%x>",
1980 card->evtbd_rdptr, wrptr);
1982 /* Write the event ring read pointer in to reg->evt_rdptr */
1983 if (mwifiex_write_reg(adapter, reg->evt_rdptr,
1984 card->evtbd_rdptr)) {
1985 mwifiex_dbg(adapter, ERROR,
1986 "event_complete: failed to read reg->evt_rdptr\n");
1990 mwifiex_dbg(adapter, EVENT,
1991 "info: Check Events Again\n");
1992 ret = mwifiex_pcie_process_event_ready(adapter);
1997 /* Combo firmware image is a combination of
1998 * (1) combo crc heaer, start with CMD5
1999 * (2) bluetooth image, start with CMD7, end with CMD6, data wrapped in CMD1.
2002 * This function bypass the header and bluetooth part, return
2003 * the offset of tail wifi-only part. If the image is already wifi-only,
2004 * that is start with CMD1, return 0.
2007 static int mwifiex_extract_wifi_fw(struct mwifiex_adapter *adapter,
2008 const void *firmware, u32 firmware_len) {
2009 const struct mwifiex_fw_data *fwdata;
2010 u32 offset = 0, data_len, dnld_cmd;
2012 bool cmd7_before = false, first_cmd = false;
2015 /* Check for integer and buffer overflow */
2016 if (offset + sizeof(fwdata->header) < sizeof(fwdata->header) ||
2017 offset + sizeof(fwdata->header) >= firmware_len) {
2018 mwifiex_dbg(adapter, ERROR,
2019 "extract wifi-only fw failure!\n");
2024 fwdata = firmware + offset;
2025 dnld_cmd = le32_to_cpu(fwdata->header.dnld_cmd);
2026 data_len = le32_to_cpu(fwdata->header.data_length);
2028 /* Skip past header */
2029 offset += sizeof(fwdata->header);
2032 case MWIFIEX_FW_DNLD_CMD_1:
2033 if (offset + data_len < data_len) {
2034 mwifiex_dbg(adapter, ERROR, "bad FW parse\n");
2039 /* Image start with cmd1, already wifi-only firmware */
2041 mwifiex_dbg(adapter, MSG,
2042 "input wifi-only firmware\n");
2047 mwifiex_dbg(adapter, ERROR,
2048 "no cmd7 before cmd1!\n");
2054 case MWIFIEX_FW_DNLD_CMD_5:
2056 /* Check for integer overflow */
2057 if (offset + data_len < data_len) {
2058 mwifiex_dbg(adapter, ERROR, "bad FW parse\n");
2064 case MWIFIEX_FW_DNLD_CMD_6:
2066 /* Check for integer overflow */
2067 if (offset + data_len < data_len) {
2068 mwifiex_dbg(adapter, ERROR, "bad FW parse\n");
2073 if (offset >= firmware_len) {
2074 mwifiex_dbg(adapter, ERROR,
2075 "extract wifi-only fw failure!\n");
2081 case MWIFIEX_FW_DNLD_CMD_7:
2086 mwifiex_dbg(adapter, ERROR, "unknown dnld_cmd %d\n",
2098 * This function downloads the firmware to the card.
2100 * Firmware is downloaded to the card in blocks. Every block download
2101 * is tested for CRC errors, and retried a number of times before
2102 * returning failure.
2104 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter *adapter,
2105 struct mwifiex_fw_image *fw)
2108 u8 *firmware = fw->fw_buf;
2109 u32 firmware_len = fw->fw_len;
2111 struct sk_buff *skb;
2112 u32 txlen, tx_blocks = 0, tries, len, val;
2113 u32 block_retry_cnt = 0;
2114 struct pcie_service_card *card = adapter->card;
2115 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2117 if (!firmware || !firmware_len) {
2118 mwifiex_dbg(adapter, ERROR,
2119 "No firmware image found! Terminating download\n");
2123 mwifiex_dbg(adapter, INFO,
2124 "info: Downloading FW image (%d bytes)\n",
2127 if (mwifiex_pcie_disable_host_int(adapter)) {
2128 mwifiex_dbg(adapter, ERROR,
2129 "%s: Disabling interrupts failed.\n", __func__);
2133 skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
2139 ret = mwifiex_read_reg(adapter, PCIE_SCRATCH_13_REG, &val);
2141 mwifiex_dbg(adapter, FATAL, "Failed to read scratch register 13\n");
2145 /* PCIE FLR case: extract wifi part from combo firmware*/
2146 if (val == MWIFIEX_PCIE_FLR_HAPPENS) {
2147 ret = mwifiex_extract_wifi_fw(adapter, firmware, firmware_len);
2149 mwifiex_dbg(adapter, ERROR, "Failed to extract wifi fw\n");
2153 mwifiex_dbg(adapter, MSG,
2154 "info: dnld wifi firmware from %d bytes\n", offset);
2157 /* Perform firmware data transfer */
2162 if (offset >= firmware_len)
2165 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
2166 ret = mwifiex_read_reg(adapter, reg->cmd_size,
2169 mwifiex_dbg(adapter, FATAL,
2170 "Failed reading len from boot code\n");
2175 usleep_range(10, 20);
2180 } else if (len > MWIFIEX_UPLD_SIZE) {
2181 mwifiex_dbg(adapter, ERROR,
2182 "FW download failure @ %d, invalid length %d\n",
2192 if (block_retry_cnt > MAX_WRITE_IOMEM_RETRY) {
2193 mwifiex_dbg(adapter, ERROR,
2194 "FW download failure @ %d, over max\t"
2195 "retry count\n", offset);
2199 mwifiex_dbg(adapter, ERROR,
2200 "FW CRC error indicated by the\t"
2201 "helper: len = 0x%04X, txlen = %d\n",
2204 /* Setting this to 0 to resend from same offset */
2207 block_retry_cnt = 0;
2208 /* Set blocksize to transfer - checking for
2210 if (firmware_len - offset < txlen)
2211 txlen = firmware_len - offset;
2213 tx_blocks = (txlen + card->pcie.blksz_fw_dl - 1) /
2214 card->pcie.blksz_fw_dl;
2216 /* Copy payload to buffer */
2217 memmove(skb->data, &firmware[offset], txlen);
2220 skb_put(skb, MWIFIEX_UPLD_SIZE - skb->len);
2221 skb_trim(skb, tx_blocks * card->pcie.blksz_fw_dl);
2223 /* Send the boot command to device */
2224 if (mwifiex_pcie_send_boot_cmd(adapter, skb)) {
2225 mwifiex_dbg(adapter, ERROR,
2226 "Failed to send firmware download command\n");
2231 /* Wait for the command done interrupt */
2232 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
2233 if (mwifiex_read_reg(adapter, PCIE_CPU_INT_STATUS,
2235 mwifiex_dbg(adapter, ERROR,
2236 "%s: Failed to read\t"
2237 "interrupt status during fw dnld.\n",
2239 mwifiex_unmap_pci_memory(adapter, skb,
2244 if (!(ireg_intr & CPU_INTR_DOOR_BELL))
2246 usleep_range(10, 20);
2248 if (ireg_intr & CPU_INTR_DOOR_BELL) {
2249 mwifiex_dbg(adapter, ERROR, "%s: Card failed to ACK download\n",
2251 mwifiex_unmap_pci_memory(adapter, skb,
2257 mwifiex_unmap_pci_memory(adapter, skb, PCI_DMA_TODEVICE);
2262 mwifiex_dbg(adapter, MSG,
2263 "info: FW download over, size %d bytes\n", offset);
2268 dev_kfree_skb_any(skb);
2273 * This function checks the firmware status in card.
2276 mwifiex_check_fw_status(struct mwifiex_adapter *adapter, u32 poll_num)
2280 struct pcie_service_card *card = adapter->card;
2281 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2284 /* Mask spurios interrupts */
2285 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS_MASK,
2287 mwifiex_dbg(adapter, ERROR,
2288 "Write register failed\n");
2292 mwifiex_dbg(adapter, INFO,
2293 "Setting driver ready signature\n");
2294 if (mwifiex_write_reg(adapter, reg->drv_rdy,
2295 FIRMWARE_READY_PCIE)) {
2296 mwifiex_dbg(adapter, ERROR,
2297 "Failed to write driver ready signature\n");
2301 /* Wait for firmware initialization event */
2302 for (tries = 0; tries < poll_num; tries++) {
2303 if (mwifiex_read_reg(adapter, reg->fw_status,
2309 mwifiex_dbg(adapter, INFO, "Try %d if FW is ready <%d,%#x>",
2310 tries, ret, firmware_stat);
2314 if (firmware_stat == FIRMWARE_READY_PCIE) {
2326 /* This function checks if WLAN is the winner.
2329 mwifiex_check_winner_status(struct mwifiex_adapter *adapter)
2333 struct pcie_service_card *card = adapter->card;
2334 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2336 if (mwifiex_read_reg(adapter, reg->fw_status, &winner)) {
2338 } else if (!winner) {
2339 mwifiex_dbg(adapter, INFO, "PCI-E is the winner\n");
2340 adapter->winner = 1;
2342 mwifiex_dbg(adapter, ERROR,
2343 "PCI-E is not the winner <%#x>", winner);
2350 * This function reads the interrupt status from card.
2352 static void mwifiex_interrupt_status(struct mwifiex_adapter *adapter,
2356 unsigned long flags;
2357 struct pcie_service_card *card = adapter->card;
2359 if (card->msi_enable) {
2360 spin_lock_irqsave(&adapter->int_lock, flags);
2361 adapter->int_status = 1;
2362 spin_unlock_irqrestore(&adapter->int_lock, flags);
2366 if (!mwifiex_pcie_ok_to_access_hw(adapter))
2369 if (card->msix_enable && msg_id >= 0) {
2370 pcie_ireg = BIT(msg_id);
2372 if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS,
2374 mwifiex_dbg(adapter, ERROR, "Read register failed\n");
2378 if ((pcie_ireg == 0xFFFFFFFF) || !pcie_ireg)
2382 mwifiex_pcie_disable_host_int(adapter);
2384 /* Clear the pending interrupts */
2385 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS,
2387 mwifiex_dbg(adapter, ERROR,
2388 "Write register failed\n");
2393 if (!adapter->pps_uapsd_mode &&
2394 adapter->ps_state == PS_STATE_SLEEP &&
2395 mwifiex_pcie_ok_to_access_hw(adapter)) {
2396 /* Potentially for PCIe we could get other
2397 * interrupts like shared. Don't change power
2398 * state until cookie is set
2400 adapter->ps_state = PS_STATE_AWAKE;
2401 adapter->pm_wakeup_fw_try = false;
2402 del_timer(&adapter->wakeup_timer);
2405 spin_lock_irqsave(&adapter->int_lock, flags);
2406 adapter->int_status |= pcie_ireg;
2407 spin_unlock_irqrestore(&adapter->int_lock, flags);
2408 mwifiex_dbg(adapter, INTR, "ireg: 0x%08x\n", pcie_ireg);
2412 * Interrupt handler for PCIe root port
2414 * This function reads the interrupt status from firmware and assigns
2415 * the main process in workqueue which will handle the interrupt.
2417 static irqreturn_t mwifiex_pcie_interrupt(int irq, void *context)
2419 struct mwifiex_msix_context *ctx = context;
2420 struct pci_dev *pdev = ctx->dev;
2421 struct pcie_service_card *card;
2422 struct mwifiex_adapter *adapter;
2424 card = pci_get_drvdata(pdev);
2426 if (!card->adapter) {
2427 pr_err("info: %s: card=%p adapter=%p\n", __func__, card,
2428 card ? card->adapter : NULL);
2431 adapter = card->adapter;
2433 if (adapter->surprise_removed)
2436 if (card->msix_enable)
2437 mwifiex_interrupt_status(adapter, ctx->msg_id);
2439 mwifiex_interrupt_status(adapter, -1);
2441 mwifiex_queue_main_work(adapter);
2448 * This function checks the current interrupt status.
2450 * The following interrupts are checked and handled by this function -
2453 * - Command received
2454 * - Packets received
2457 * In case of Rx packets received, the packets are uploaded from card to
2458 * host and processed accordingly.
2460 static int mwifiex_process_int_status(struct mwifiex_adapter *adapter)
2464 unsigned long flags;
2465 struct pcie_service_card *card = adapter->card;
2467 spin_lock_irqsave(&adapter->int_lock, flags);
2468 if (!card->msi_enable) {
2469 /* Clear out unused interrupts */
2470 pcie_ireg = adapter->int_status;
2472 adapter->int_status = 0;
2473 spin_unlock_irqrestore(&adapter->int_lock, flags);
2475 if (card->msi_enable) {
2476 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
2477 if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS,
2479 mwifiex_dbg(adapter, ERROR,
2480 "Read register failed\n");
2484 if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
2485 if (mwifiex_write_reg(adapter,
2486 PCIE_HOST_INT_STATUS,
2488 mwifiex_dbg(adapter, ERROR,
2489 "Write register failed\n");
2492 if (!adapter->pps_uapsd_mode &&
2493 adapter->ps_state == PS_STATE_SLEEP) {
2494 adapter->ps_state = PS_STATE_AWAKE;
2495 adapter->pm_wakeup_fw_try = false;
2496 del_timer(&adapter->wakeup_timer);
2502 if (pcie_ireg & HOST_INTR_DNLD_DONE) {
2503 mwifiex_dbg(adapter, INTR, "info: TX DNLD Done\n");
2504 ret = mwifiex_pcie_send_data_complete(adapter);
2508 if (pcie_ireg & HOST_INTR_UPLD_RDY) {
2509 mwifiex_dbg(adapter, INTR, "info: Rx DATA\n");
2510 ret = mwifiex_pcie_process_recv_data(adapter);
2514 if (pcie_ireg & HOST_INTR_EVENT_RDY) {
2515 mwifiex_dbg(adapter, INTR, "info: Rx EVENT\n");
2516 ret = mwifiex_pcie_process_event_ready(adapter);
2520 if (pcie_ireg & HOST_INTR_CMD_DONE) {
2521 if (adapter->cmd_sent) {
2522 mwifiex_dbg(adapter, INTR,
2523 "info: CMD sent Interrupt\n");
2524 adapter->cmd_sent = false;
2526 /* Handle command response */
2527 ret = mwifiex_pcie_process_cmd_complete(adapter);
2532 mwifiex_dbg(adapter, INTR,
2533 "info: cmd_sent=%d data_sent=%d\n",
2534 adapter->cmd_sent, adapter->data_sent);
2535 if (!card->msi_enable && !card->msix_enable &&
2536 adapter->ps_state != PS_STATE_SLEEP)
2537 mwifiex_pcie_enable_host_int(adapter);
2543 * This function downloads data from driver to card.
2545 * Both commands and data packets are transferred to the card by this
2548 * This function adds the PCIE specific header to the front of the buffer
2549 * before transferring. The header contains the length of the packet and
2550 * the type. The firmware handles the packets based upon this set type.
2552 static int mwifiex_pcie_host_to_card(struct mwifiex_adapter *adapter, u8 type,
2553 struct sk_buff *skb,
2554 struct mwifiex_tx_param *tx_param)
2557 mwifiex_dbg(adapter, ERROR,
2558 "Passed NULL skb to %s\n", __func__);
2562 if (type == MWIFIEX_TYPE_DATA)
2563 return mwifiex_pcie_send_data(adapter, skb, tx_param);
2564 else if (type == MWIFIEX_TYPE_CMD)
2565 return mwifiex_pcie_send_cmd(adapter, skb);
2570 /* Function to dump PCIE scratch registers in case of FW crash
2573 mwifiex_pcie_reg_dump(struct mwifiex_adapter *adapter, char *drv_buf)
2576 char buf[256], *ptr;
2579 struct pcie_service_card *card = adapter->card;
2580 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2581 int pcie_scratch_reg[] = {PCIE_SCRATCH_12_REG,
2582 PCIE_SCRATCH_14_REG,
2583 PCIE_SCRATCH_15_REG};
2588 mwifiex_dbg(adapter, MSG, "PCIE register dump start\n");
2590 if (mwifiex_read_reg(adapter, reg->fw_status, &value)) {
2591 mwifiex_dbg(adapter, ERROR, "failed to read firmware status");
2596 mwifiex_dbg(adapter, MSG, "pcie scratch register:");
2597 for (i = 0; i < ARRAY_SIZE(pcie_scratch_reg); i++) {
2598 mwifiex_read_reg(adapter, pcie_scratch_reg[i], &value);
2599 ptr += sprintf(ptr, "reg:0x%x, value=0x%x\n",
2600 pcie_scratch_reg[i], value);
2603 mwifiex_dbg(adapter, MSG, "%s\n", buf);
2604 p += sprintf(p, "%s\n", buf);
2606 mwifiex_dbg(adapter, MSG, "PCIE register dump end\n");
2611 /* This function read/write firmware */
2612 static enum rdwr_status
2613 mwifiex_pcie_rdwr_firmware(struct mwifiex_adapter *adapter, u8 doneflag)
2618 struct pcie_service_card *card = adapter->card;
2619 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2621 if (mwifiex_read_reg(adapter, reg->fw_status, &fw_status))
2622 return RDWR_STATUS_FAILURE;
2624 ret = mwifiex_write_reg(adapter, reg->fw_dump_ctrl,
2625 reg->fw_dump_host_ready);
2627 mwifiex_dbg(adapter, ERROR,
2628 "PCIE write err\n");
2629 return RDWR_STATUS_FAILURE;
2632 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
2633 mwifiex_read_reg_byte(adapter, reg->fw_dump_ctrl, &ctrl_data);
2634 if (ctrl_data == FW_DUMP_DONE)
2635 return RDWR_STATUS_SUCCESS;
2636 if (doneflag && ctrl_data == doneflag)
2637 return RDWR_STATUS_DONE;
2638 if (ctrl_data != reg->fw_dump_host_ready) {
2639 mwifiex_dbg(adapter, WARN,
2640 "The ctrl reg was changed, re-try again!\n");
2641 ret = mwifiex_write_reg(adapter, reg->fw_dump_ctrl,
2642 reg->fw_dump_host_ready);
2644 mwifiex_dbg(adapter, ERROR,
2645 "PCIE write err\n");
2646 return RDWR_STATUS_FAILURE;
2649 usleep_range(100, 200);
2652 mwifiex_dbg(adapter, ERROR, "Fail to pull ctrl_data\n");
2653 return RDWR_STATUS_FAILURE;
2656 /* This function dump firmware memory to file */
2657 static void mwifiex_pcie_fw_dump(struct mwifiex_adapter *adapter)
2659 struct pcie_service_card *card = adapter->card;
2660 const struct mwifiex_pcie_card_reg *creg = card->pcie.reg;
2661 unsigned int reg, reg_start, reg_end;
2662 u8 *dbg_ptr, *end_ptr, *tmp_ptr, fw_dump_num, dump_num;
2663 u8 idx, i, read_reg, doneflag = 0;
2664 enum rdwr_status stat;
2668 if (!card->pcie.can_dump_fw)
2671 for (idx = 0; idx < adapter->num_mem_types; idx++) {
2672 struct memory_type_mapping *entry =
2673 &adapter->mem_type_mapping_tbl[idx];
2675 if (entry->mem_ptr) {
2676 vfree(entry->mem_ptr);
2677 entry->mem_ptr = NULL;
2679 entry->mem_size = 0;
2682 mwifiex_dbg(adapter, MSG, "== mwifiex firmware dump start ==\n");
2684 /* Read the number of the memories which will dump */
2685 stat = mwifiex_pcie_rdwr_firmware(adapter, doneflag);
2686 if (stat == RDWR_STATUS_FAILURE)
2689 reg = creg->fw_dump_start;
2690 mwifiex_read_reg_byte(adapter, reg, &fw_dump_num);
2692 /* W8997 chipset firmware dump will be restore in single region*/
2693 if (fw_dump_num == 0)
2696 dump_num = fw_dump_num;
2698 /* Read the length of every memory which will dump */
2699 for (idx = 0; idx < dump_num; idx++) {
2700 struct memory_type_mapping *entry =
2701 &adapter->mem_type_mapping_tbl[idx];
2703 if (fw_dump_num != 0) {
2704 stat = mwifiex_pcie_rdwr_firmware(adapter, doneflag);
2705 if (stat == RDWR_STATUS_FAILURE)
2708 reg = creg->fw_dump_start;
2709 for (i = 0; i < 4; i++) {
2710 mwifiex_read_reg_byte(adapter, reg, &read_reg);
2711 memory_size |= (read_reg << (i * 8));
2715 memory_size = MWIFIEX_FW_DUMP_MAX_MEMSIZE;
2718 if (memory_size == 0) {
2719 mwifiex_dbg(adapter, MSG, "Firmware dump Finished!\n");
2720 ret = mwifiex_write_reg(adapter, creg->fw_dump_ctrl,
2721 creg->fw_dump_read_done);
2723 mwifiex_dbg(adapter, ERROR, "PCIE write err\n");
2729 mwifiex_dbg(adapter, DUMP,
2730 "%s_SIZE=0x%x\n", entry->mem_name, memory_size);
2731 entry->mem_ptr = vmalloc(memory_size + 1);
2732 entry->mem_size = memory_size;
2733 if (!entry->mem_ptr) {
2734 mwifiex_dbg(adapter, ERROR,
2735 "Vmalloc %s failed\n", entry->mem_name);
2738 dbg_ptr = entry->mem_ptr;
2739 end_ptr = dbg_ptr + memory_size;
2741 doneflag = entry->done_flag;
2742 mwifiex_dbg(adapter, DUMP, "Start %s output, please wait...\n",
2746 stat = mwifiex_pcie_rdwr_firmware(adapter, doneflag);
2747 if (RDWR_STATUS_FAILURE == stat)
2750 reg_start = creg->fw_dump_start;
2751 reg_end = creg->fw_dump_end;
2752 for (reg = reg_start; reg <= reg_end; reg++) {
2753 mwifiex_read_reg_byte(adapter, reg, dbg_ptr);
2754 if (dbg_ptr < end_ptr) {
2758 mwifiex_dbg(adapter, ERROR,
2759 "pre-allocated buf not enough\n");
2761 vzalloc(memory_size + MWIFIEX_SIZE_4K);
2764 memcpy(tmp_ptr, entry->mem_ptr, memory_size);
2765 vfree(entry->mem_ptr);
2766 entry->mem_ptr = tmp_ptr;
2768 dbg_ptr = entry->mem_ptr + memory_size;
2769 memory_size += MWIFIEX_SIZE_4K;
2770 end_ptr = entry->mem_ptr + memory_size;
2773 if (stat != RDWR_STATUS_DONE)
2776 mwifiex_dbg(adapter, DUMP,
2777 "%s done: size=0x%tx\n",
2778 entry->mem_name, dbg_ptr - entry->mem_ptr);
2782 mwifiex_dbg(adapter, MSG, "== mwifiex firmware dump end ==\n");
2785 static void mwifiex_pcie_device_dump_work(struct mwifiex_adapter *adapter)
2790 drv_info_size = mwifiex_drv_info_dump(adapter, &drv_info);
2791 mwifiex_pcie_fw_dump(adapter);
2792 mwifiex_upload_device_dump(adapter, drv_info, drv_info_size);
2795 static void mwifiex_pcie_card_reset_work(struct mwifiex_adapter *adapter)
2797 struct pcie_service_card *card = adapter->card;
2799 /* We can't afford to wait here; remove() might be waiting on us. If we
2800 * can't grab the device lock, maybe we'll get another chance later.
2802 pci_try_reset_function(card->dev);
2805 static void mwifiex_pcie_work(struct work_struct *work)
2807 struct pcie_service_card *card =
2808 container_of(work, struct pcie_service_card, work);
2810 if (test_and_clear_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP,
2812 mwifiex_pcie_device_dump_work(card->adapter);
2813 if (test_and_clear_bit(MWIFIEX_IFACE_WORK_CARD_RESET,
2815 mwifiex_pcie_card_reset_work(card->adapter);
2818 /* This function dumps FW information */
2819 static void mwifiex_pcie_device_dump(struct mwifiex_adapter *adapter)
2821 struct pcie_service_card *card = adapter->card;
2823 if (!test_and_set_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP,
2825 schedule_work(&card->work);
2828 static void mwifiex_pcie_card_reset(struct mwifiex_adapter *adapter)
2830 struct pcie_service_card *card = adapter->card;
2832 if (!test_and_set_bit(MWIFIEX_IFACE_WORK_CARD_RESET, &card->work_flags))
2833 schedule_work(&card->work);
2836 static int mwifiex_pcie_alloc_buffers(struct mwifiex_adapter *adapter)
2838 struct pcie_service_card *card = adapter->card;
2839 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2842 card->cmdrsp_buf = NULL;
2843 ret = mwifiex_pcie_create_txbd_ring(adapter);
2845 mwifiex_dbg(adapter, ERROR, "Failed to create txbd ring\n");
2849 ret = mwifiex_pcie_create_rxbd_ring(adapter);
2851 mwifiex_dbg(adapter, ERROR, "Failed to create rxbd ring\n");
2855 ret = mwifiex_pcie_create_evtbd_ring(adapter);
2857 mwifiex_dbg(adapter, ERROR, "Failed to create evtbd ring\n");
2861 ret = mwifiex_pcie_alloc_cmdrsp_buf(adapter);
2863 mwifiex_dbg(adapter, ERROR, "Failed to allocate cmdbuf buffer\n");
2864 goto err_alloc_cmdbuf;
2867 if (reg->sleep_cookie) {
2868 ret = mwifiex_pcie_alloc_sleep_cookie_buf(adapter);
2870 mwifiex_dbg(adapter, ERROR, "Failed to allocate sleep_cookie buffer\n");
2871 goto err_alloc_cookie;
2874 card->sleep_cookie_vbase = NULL;
2880 mwifiex_pcie_delete_cmdrsp_buf(adapter);
2882 mwifiex_pcie_delete_evtbd_ring(adapter);
2884 mwifiex_pcie_delete_rxbd_ring(adapter);
2886 mwifiex_pcie_delete_txbd_ring(adapter);
2891 static void mwifiex_pcie_free_buffers(struct mwifiex_adapter *adapter)
2893 struct pcie_service_card *card = adapter->card;
2894 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2896 if (reg->sleep_cookie)
2897 mwifiex_pcie_delete_sleep_cookie_buf(adapter);
2899 mwifiex_pcie_delete_cmdrsp_buf(adapter);
2900 mwifiex_pcie_delete_evtbd_ring(adapter);
2901 mwifiex_pcie_delete_rxbd_ring(adapter);
2902 mwifiex_pcie_delete_txbd_ring(adapter);
2906 * This function initializes the PCI-E host memory space, WCB rings, etc.
2908 static int mwifiex_init_pcie(struct mwifiex_adapter *adapter)
2910 struct pcie_service_card *card = adapter->card;
2912 struct pci_dev *pdev = card->dev;
2914 pci_set_drvdata(pdev, card);
2916 ret = pci_enable_device(pdev);
2918 goto err_enable_dev;
2920 pci_set_master(pdev);
2922 pr_notice("try set_consistent_dma_mask(32)\n");
2923 ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2925 pr_err("set_dma_mask(32) failed\n");
2926 goto err_set_dma_mask;
2929 ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
2931 pr_err("set_consistent_dma_mask(64) failed\n");
2932 goto err_set_dma_mask;
2935 ret = pci_request_region(pdev, 0, DRV_NAME);
2937 pr_err("req_reg(0) error\n");
2938 goto err_req_region0;
2940 card->pci_mmap = pci_iomap(pdev, 0, 0);
2941 if (!card->pci_mmap) {
2942 pr_err("iomap(0) error\n");
2946 ret = pci_request_region(pdev, 2, DRV_NAME);
2948 pr_err("req_reg(2) error\n");
2949 goto err_req_region2;
2951 card->pci_mmap1 = pci_iomap(pdev, 2, 0);
2952 if (!card->pci_mmap1) {
2953 pr_err("iomap(2) error\n");
2958 pr_notice("PCI memory map Virt0: %p PCI memory map Virt2: %p\n",
2959 card->pci_mmap, card->pci_mmap1);
2961 ret = mwifiex_pcie_alloc_buffers(adapter);
2963 goto err_alloc_buffers;
2968 pci_iounmap(pdev, card->pci_mmap1);
2970 pci_release_region(pdev, 2);
2972 pci_iounmap(pdev, card->pci_mmap);
2974 pci_release_region(pdev, 0);
2977 pci_disable_device(pdev);
2983 * This function cleans up the allocated card buffers.
2985 static void mwifiex_cleanup_pcie(struct mwifiex_adapter *adapter)
2987 struct pcie_service_card *card = adapter->card;
2988 struct pci_dev *pdev = card->dev;
2989 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2993 /* Perform the cancel_work_sync() only when we're not resetting
2994 * the card. It's because that function never returns if we're
2995 * in reset path. If we're here when resetting the card, it means
2996 * that we failed to reset the card (reset failure path).
2998 if (!card->pci_reset_ongoing) {
2999 mwifiex_dbg(adapter, MSG, "performing cancel_work_sync()...\n");
3000 cancel_work_sync(&card->work);
3001 mwifiex_dbg(adapter, MSG, "cancel_work_sync() done\n");
3003 mwifiex_dbg(adapter, MSG,
3004 "skipped cancel_work_sync() because we're in card reset failure path\n");
3007 ret = mwifiex_read_reg(adapter, reg->fw_status, &fw_status);
3008 if (fw_status == FIRMWARE_READY_PCIE) {
3009 mwifiex_dbg(adapter, INFO,
3010 "Clearing driver ready signature\n");
3011 if (mwifiex_write_reg(adapter, reg->drv_rdy, 0x00000000))
3012 mwifiex_dbg(adapter, ERROR,
3013 "Failed to write driver not-ready signature\n");
3016 pci_disable_device(pdev);
3018 pci_iounmap(pdev, card->pci_mmap);
3019 pci_iounmap(pdev, card->pci_mmap1);
3020 pci_release_region(pdev, 2);
3021 pci_release_region(pdev, 0);
3023 mwifiex_pcie_free_buffers(adapter);
3026 static int mwifiex_pcie_request_irq(struct mwifiex_adapter *adapter)
3029 struct pcie_service_card *card = adapter->card;
3030 struct pci_dev *pdev = card->dev;
3032 if (card->pcie.reg->msix_support) {
3033 for (i = 0; i < MWIFIEX_NUM_MSIX_VECTORS; i++)
3034 card->msix_entries[i].entry = i;
3035 ret = pci_enable_msix_exact(pdev, card->msix_entries,
3036 MWIFIEX_NUM_MSIX_VECTORS);
3038 for (i = 0; i < MWIFIEX_NUM_MSIX_VECTORS; i++) {
3039 card->msix_ctx[i].dev = pdev;
3040 card->msix_ctx[i].msg_id = i;
3042 ret = request_irq(card->msix_entries[i].vector,
3043 mwifiex_pcie_interrupt, 0,
3044 "MWIFIEX_PCIE_MSIX",
3045 &card->msix_ctx[i]);
3051 mwifiex_dbg(adapter, INFO, "request_irq fail: %d\n",
3053 for (j = 0; j < i; j++)
3054 free_irq(card->msix_entries[j].vector,
3055 &card->msix_ctx[i]);
3056 pci_disable_msix(pdev);
3058 mwifiex_dbg(adapter, MSG, "MSIx enabled!");
3059 card->msix_enable = 1;
3065 if (pci_enable_msi(pdev) != 0)
3066 pci_disable_msi(pdev);
3068 card->msi_enable = 1;
3070 mwifiex_dbg(adapter, INFO, "msi_enable = %d\n", card->msi_enable);
3072 card->share_irq_ctx.dev = pdev;
3073 card->share_irq_ctx.msg_id = -1;
3074 ret = request_irq(pdev->irq, mwifiex_pcie_interrupt, IRQF_SHARED,
3075 "MRVL_PCIE", &card->share_irq_ctx);
3077 pr_err("request_irq failed: ret=%d\n", ret);
3085 * This function gets the firmware name for downloading by revision id
3087 * Read revision id register to get revision id
3089 static void mwifiex_pcie_get_fw_name(struct mwifiex_adapter *adapter)
3091 int revision_id = 0;
3093 struct pcie_service_card *card = adapter->card;
3095 switch (card->dev->device) {
3096 case PCIE_DEVICE_ID_MARVELL_88W8766P:
3097 strcpy(adapter->fw_name, PCIE8766_DEFAULT_FW_NAME);
3099 case PCIE_DEVICE_ID_MARVELL_88W8897:
3100 mwifiex_write_reg(adapter, 0x0c58, 0x80c00000);
3101 mwifiex_read_reg(adapter, 0x0c58, &revision_id);
3102 revision_id &= 0xff00;
3103 switch (revision_id) {
3105 strcpy(adapter->fw_name, PCIE8897_A0_FW_NAME);
3108 strcpy(adapter->fw_name, PCIE8897_B0_FW_NAME);
3111 strcpy(adapter->fw_name, PCIE8897_DEFAULT_FW_NAME);
3116 case PCIE_DEVICE_ID_MARVELL_88W8997:
3117 mwifiex_read_reg(adapter, 0x8, &revision_id);
3118 mwifiex_read_reg(adapter, 0x0cd0, &version);
3119 mwifiex_read_reg(adapter, 0x0cd4, &magic);
3120 revision_id &= 0xff;
3123 if (revision_id == PCIE8997_A1 &&
3124 magic == CHIP_MAGIC_VALUE &&
3125 version == CHIP_VER_PCIEUART)
3126 strcpy(adapter->fw_name, PCIEUART8997_FW_NAME_V4);
3128 strcpy(adapter->fw_name, PCIEUSB8997_FW_NAME_V4);
3136 * This function registers the PCIE device.
3138 * PCIE IRQ is claimed, block size is set and driver data is initialized.
3140 static int mwifiex_register_dev(struct mwifiex_adapter *adapter)
3142 struct pcie_service_card *card = adapter->card;
3144 /* save adapter pointer in card */
3145 card->adapter = adapter;
3147 if (mwifiex_pcie_request_irq(adapter))
3150 adapter->tx_buf_size = card->pcie.tx_buf_size;
3151 adapter->mem_type_mapping_tbl = card->pcie.mem_type_mapping_tbl;
3152 adapter->num_mem_types = card->pcie.num_mem_types;
3153 adapter->ext_scan = card->pcie.can_ext_scan;
3154 mwifiex_pcie_get_fw_name(adapter);
3160 * This function unregisters the PCIE device.
3162 * The PCIE IRQ is released, the function is disabled and driver
3163 * data is set to null.
3165 static void mwifiex_unregister_dev(struct mwifiex_adapter *adapter)
3167 struct pcie_service_card *card = adapter->card;
3168 struct pci_dev *pdev = card->dev;
3171 if (card->msix_enable) {
3172 for (i = 0; i < MWIFIEX_NUM_MSIX_VECTORS; i++)
3173 synchronize_irq(card->msix_entries[i].vector);
3175 for (i = 0; i < MWIFIEX_NUM_MSIX_VECTORS; i++)
3176 free_irq(card->msix_entries[i].vector,
3177 &card->msix_ctx[i]);
3179 card->msix_enable = 0;
3180 pci_disable_msix(pdev);
3182 mwifiex_dbg(adapter, INFO,
3183 "%s(): calling free_irq()\n", __func__);
3184 free_irq(card->dev->irq, &card->share_irq_ctx);
3186 if (card->msi_enable)
3187 pci_disable_msi(pdev);
3189 card->adapter = NULL;
3193 * This function initializes the PCI-E host memory space, WCB rings, etc.,
3194 * similar to mwifiex_init_pcie(), but without resetting PCI-E state.
3196 static void mwifiex_pcie_up_dev(struct mwifiex_adapter *adapter)
3198 struct pcie_service_card *card = adapter->card;
3199 struct pci_dev *pdev = card->dev;
3201 /* tx_buf_size might be changed to 3584 by firmware during
3202 * data transfer, we should reset it to default size.
3204 adapter->tx_buf_size = card->pcie.tx_buf_size;
3206 mwifiex_pcie_alloc_buffers(adapter);
3208 pci_set_master(pdev);
3211 /* This function cleans up the PCI-E host memory space. */
3212 static void mwifiex_pcie_down_dev(struct mwifiex_adapter *adapter)
3214 struct pcie_service_card *card = adapter->card;
3215 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
3216 struct pci_dev *pdev = card->dev;
3218 if (mwifiex_write_reg(adapter, reg->drv_rdy, 0x00000000))
3219 mwifiex_dbg(adapter, ERROR, "Failed to write driver not-ready signature\n");
3221 pci_clear_master(pdev);
3223 adapter->seq_num = 0;
3225 mwifiex_pcie_free_buffers(adapter);
3228 static struct mwifiex_if_ops pcie_ops = {
3229 .init_if = mwifiex_init_pcie,
3230 .cleanup_if = mwifiex_cleanup_pcie,
3231 .check_fw_status = mwifiex_check_fw_status,
3232 .check_winner_status = mwifiex_check_winner_status,
3233 .prog_fw = mwifiex_prog_fw_w_helper,
3234 .register_dev = mwifiex_register_dev,
3235 .unregister_dev = mwifiex_unregister_dev,
3236 .enable_int = mwifiex_pcie_enable_host_int,
3237 .disable_int = mwifiex_pcie_disable_host_int_noerr,
3238 .process_int_status = mwifiex_process_int_status,
3239 .host_to_card = mwifiex_pcie_host_to_card,
3240 .wakeup = mwifiex_pm_wakeup_card,
3241 .wakeup_complete = mwifiex_pm_wakeup_card_complete,
3244 .cmdrsp_complete = mwifiex_pcie_cmdrsp_complete,
3245 .event_complete = mwifiex_pcie_event_complete,
3246 .update_mp_end_port = NULL,
3247 .cleanup_mpa_buf = NULL,
3248 .init_fw_port = mwifiex_pcie_init_fw_port,
3249 .clean_pcie_ring = mwifiex_clean_pcie_ring_buf,
3250 .card_reset = mwifiex_pcie_card_reset,
3251 .reg_dump = mwifiex_pcie_reg_dump,
3252 .device_dump = mwifiex_pcie_device_dump,
3253 .down_dev = mwifiex_pcie_down_dev,
3254 .up_dev = mwifiex_pcie_up_dev,
3257 module_pci_driver(mwifiex_pcie);
3259 MODULE_AUTHOR("Marvell International Ltd.");
3260 MODULE_DESCRIPTION("Marvell WiFi-Ex PCI-Express Driver version " PCIE_VERSION);
3261 MODULE_VERSION(PCIE_VERSION);
3262 MODULE_LICENSE("GPL v2");