2 * Marvell Wireless LAN device driver: PCIE specific handling
4 * Copyright (C) 2011, Marvell International Ltd.
6 * This software file (the "File") is distributed by Marvell International
7 * Ltd. under the terms of the GNU General Public License Version 2, June 1991
8 * (the "License"). You may use, redistribute and/or modify this File in
9 * accordance with the terms and conditions of the License, a copy of which
10 * is available by writing to the Free Software Foundation, Inc.,
11 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
12 * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
14 * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
16 * ARE EXPRESSLY DISCLAIMED. The License provides additional details about
17 * this warranty disclaimer.
20 #include <linux/firmware.h>
31 #define PCIE_VERSION "1.0"
32 #define DRV_NAME "Marvell mwifiex PCIe"
36 static struct mwifiex_if_ops pcie_ops;
38 static struct semaphore add_remove_card_sem;
41 mwifiex_map_pci_memory(struct mwifiex_adapter *adapter, struct sk_buff *skb,
44 struct pcie_service_card *card = adapter->card;
47 buf_pa = pci_map_single(card->dev, skb->data, size, flags);
48 if (pci_dma_mapping_error(card->dev, buf_pa)) {
49 dev_err(adapter->dev, "failed to map pci memory!\n");
52 memcpy(skb->cb, &buf_pa, sizeof(dma_addr_t));
57 * This function reads sleep cookie and checks if FW is ready
59 static bool mwifiex_pcie_ok_to_access_hw(struct mwifiex_adapter *adapter)
62 struct pcie_service_card *card = adapter->card;
63 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
65 if (!reg->sleep_cookie)
68 if (card->sleep_cookie_vbase) {
69 cookie_addr = (u32 *)card->sleep_cookie_vbase;
70 dev_dbg(adapter->dev, "info: ACCESS_HW: sleep cookie=0x%x\n",
72 if (*cookie_addr == FW_AWAKE_COOKIE)
79 #ifdef CONFIG_PM_SLEEP
81 * Kernel needs to suspend all functions separately. Therefore all
82 * registered functions must have drivers with suspend and resume
83 * methods. Failing that the kernel simply removes the whole card.
85 * If already not suspended, this function allocates and sends a host
86 * sleep activate request to the firmware and turns off the traffic.
88 static int mwifiex_pcie_suspend(struct device *dev)
90 struct mwifiex_adapter *adapter;
91 struct pcie_service_card *card;
93 struct pci_dev *pdev = to_pci_dev(dev);
96 card = pci_get_drvdata(pdev);
97 if (!card || !card->adapter) {
98 pr_err("Card or adapter structure is not valid\n");
102 pr_err("PCIE device is not specified\n");
106 adapter = card->adapter;
108 hs_actived = mwifiex_enable_hs(adapter);
110 /* Indicate device suspended */
111 adapter->is_suspended = true;
117 * Kernel needs to suspend all functions separately. Therefore all
118 * registered functions must have drivers with suspend and resume
119 * methods. Failing that the kernel simply removes the whole card.
121 * If already not resumed, this function turns on the traffic and
122 * sends a host sleep cancel request to the firmware.
124 static int mwifiex_pcie_resume(struct device *dev)
126 struct mwifiex_adapter *adapter;
127 struct pcie_service_card *card;
128 struct pci_dev *pdev = to_pci_dev(dev);
131 card = pci_get_drvdata(pdev);
132 if (!card || !card->adapter) {
133 pr_err("Card or adapter structure is not valid\n");
137 pr_err("PCIE device is not specified\n");
141 adapter = card->adapter;
143 if (!adapter->is_suspended) {
144 dev_warn(adapter->dev, "Device already resumed\n");
148 adapter->is_suspended = false;
150 mwifiex_cancel_hs(mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA),
158 * This function probes an mwifiex device and registers it. It allocates
159 * the card structure, enables PCIE function number and initiates the
160 * device registration and initialization procedure by adding a logical
163 static int mwifiex_pcie_probe(struct pci_dev *pdev,
164 const struct pci_device_id *ent)
166 struct pcie_service_card *card;
168 pr_debug("info: vendor=0x%4.04X device=0x%4.04X rev=%d\n",
169 pdev->vendor, pdev->device, pdev->revision);
171 card = kzalloc(sizeof(struct pcie_service_card), GFP_KERNEL);
177 if (ent->driver_data) {
178 struct mwifiex_pcie_device *data = (void *)ent->driver_data;
179 card->pcie.firmware = data->firmware;
180 card->pcie.reg = data->reg;
181 card->pcie.blksz_fw_dl = data->blksz_fw_dl;
184 if (mwifiex_add_card(card, &add_remove_card_sem, &pcie_ops,
186 pr_err("%s failed\n", __func__);
195 * This function removes the interface and frees up the card structure.
197 static void mwifiex_pcie_remove(struct pci_dev *pdev)
199 struct pcie_service_card *card;
200 struct mwifiex_adapter *adapter;
201 struct mwifiex_private *priv;
204 card = pci_get_drvdata(pdev);
208 adapter = card->adapter;
209 if (!adapter || !adapter->priv_num)
212 /* In case driver is removed when asynchronous FW load is in progress */
213 wait_for_completion(&adapter->fw_load);
216 #ifdef CONFIG_PM_SLEEP
217 if (adapter->is_suspended)
218 mwifiex_pcie_resume(&pdev->dev);
221 for (i = 0; i < adapter->priv_num; i++)
222 if ((GET_BSS_ROLE(adapter->priv[i]) ==
223 MWIFIEX_BSS_ROLE_STA) &&
224 adapter->priv[i]->media_connected)
225 mwifiex_deauthenticate(adapter->priv[i], NULL);
227 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
229 mwifiex_disable_auto_ds(priv);
231 mwifiex_init_shutdown_fw(priv, MWIFIEX_FUNC_SHUTDOWN);
234 mwifiex_remove_card(card->adapter, &add_remove_card_sem);
237 static void mwifiex_pcie_shutdown(struct pci_dev *pdev)
240 mwifiex_pcie_remove(pdev);
245 static DEFINE_PCI_DEVICE_TABLE(mwifiex_ids) = {
247 PCIE_VENDOR_ID_MARVELL, PCIE_DEVICE_ID_MARVELL_88W8766P,
248 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
249 .driver_data = (unsigned long) &mwifiex_pcie8766,
252 PCIE_VENDOR_ID_MARVELL, PCIE_DEVICE_ID_MARVELL_88W8897,
253 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
254 .driver_data = (unsigned long) &mwifiex_pcie8897,
259 MODULE_DEVICE_TABLE(pci, mwifiex_ids);
261 #ifdef CONFIG_PM_SLEEP
262 /* Power Management Hooks */
263 static SIMPLE_DEV_PM_OPS(mwifiex_pcie_pm_ops, mwifiex_pcie_suspend,
264 mwifiex_pcie_resume);
267 /* PCI Device Driver */
268 static struct pci_driver __refdata mwifiex_pcie = {
269 .name = "mwifiex_pcie",
270 .id_table = mwifiex_ids,
271 .probe = mwifiex_pcie_probe,
272 .remove = mwifiex_pcie_remove,
273 #ifdef CONFIG_PM_SLEEP
275 .pm = &mwifiex_pcie_pm_ops,
278 .shutdown = mwifiex_pcie_shutdown,
282 * This function writes data into PCIE card register.
284 static int mwifiex_write_reg(struct mwifiex_adapter *adapter, int reg, u32 data)
286 struct pcie_service_card *card = adapter->card;
288 iowrite32(data, card->pci_mmap1 + reg);
294 * This function reads data from PCIE card register.
296 static int mwifiex_read_reg(struct mwifiex_adapter *adapter, int reg, u32 *data)
298 struct pcie_service_card *card = adapter->card;
300 *data = ioread32(card->pci_mmap1 + reg);
306 * This function adds delay loop to ensure FW is awake before proceeding.
308 static void mwifiex_pcie_dev_wakeup_delay(struct mwifiex_adapter *adapter)
312 while (mwifiex_pcie_ok_to_access_hw(adapter)) {
314 usleep_range(10, 20);
323 /* This function wakes up the card by reading fw_status register. */
324 static int mwifiex_pm_wakeup_card(struct mwifiex_adapter *adapter)
327 struct pcie_service_card *card = adapter->card;
328 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
330 dev_dbg(adapter->dev, "event: Wakeup device...\n");
332 if (reg->sleep_cookie)
333 mwifiex_pcie_dev_wakeup_delay(adapter);
335 /* Reading fw_status register will wakeup device */
336 if (mwifiex_read_reg(adapter, reg->fw_status, &fw_status)) {
337 dev_warn(adapter->dev, "Reading fw_status register failed\n");
341 if (reg->sleep_cookie) {
342 mwifiex_pcie_dev_wakeup_delay(adapter);
343 dev_dbg(adapter->dev, "PCIE wakeup: Setting PS_STATE_AWAKE\n");
344 adapter->ps_state = PS_STATE_AWAKE;
351 * This function is called after the card has woken up.
353 * The card configuration register is reset.
355 static int mwifiex_pm_wakeup_card_complete(struct mwifiex_adapter *adapter)
357 dev_dbg(adapter->dev, "cmd: Wakeup device completed\n");
363 * This function disables the host interrupt.
365 * The host interrupt mask is read, the disable bit is reset and
366 * written back to the card host interrupt mask register.
368 static int mwifiex_pcie_disable_host_int(struct mwifiex_adapter *adapter)
370 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
371 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK,
373 dev_warn(adapter->dev, "Disable host interrupt failed\n");
382 * This function enables the host interrupt.
384 * The host interrupt enable mask is written to the card
385 * host interrupt mask register.
387 static int mwifiex_pcie_enable_host_int(struct mwifiex_adapter *adapter)
389 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
390 /* Simply write the mask to the register */
391 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK,
393 dev_warn(adapter->dev, "Enable host interrupt failed\n");
402 * This function initializes TX buffer ring descriptors
404 static int mwifiex_init_txq_ring(struct mwifiex_adapter *adapter)
406 struct pcie_service_card *card = adapter->card;
407 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
408 struct mwifiex_pcie_buf_desc *desc;
409 struct mwifiex_pfu_buf_desc *desc2;
412 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
413 card->tx_buf_list[i] = NULL;
414 if (reg->pfu_enabled) {
415 card->txbd_ring[i] = (void *)card->txbd_ring_vbase +
416 (sizeof(*desc2) * i);
417 desc2 = card->txbd_ring[i];
418 memset(desc2, 0, sizeof(*desc2));
420 card->txbd_ring[i] = (void *)card->txbd_ring_vbase +
422 desc = card->txbd_ring[i];
423 memset(desc, 0, sizeof(*desc));
430 /* This function initializes RX buffer ring descriptors. Each SKB is allocated
431 * here and after mapping PCI memory, its physical address is assigned to
432 * PCIE Rx buffer descriptor's physical address.
434 static int mwifiex_init_rxq_ring(struct mwifiex_adapter *adapter)
436 struct pcie_service_card *card = adapter->card;
437 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
439 struct mwifiex_pcie_buf_desc *desc;
440 struct mwifiex_pfu_buf_desc *desc2;
444 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
445 /* Allocate skb here so that firmware can DMA data from it */
446 skb = dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE);
448 dev_err(adapter->dev,
449 "Unable to allocate skb for RX ring.\n");
450 kfree(card->rxbd_ring_vbase);
454 if (mwifiex_map_pci_memory(adapter, skb,
455 MWIFIEX_RX_DATA_BUF_SIZE,
459 MWIFIEX_SKB_PACB(skb, &buf_pa);
461 dev_dbg(adapter->dev,
462 "info: RX ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
463 skb, skb->len, skb->data, (u32)buf_pa,
464 (u32)((u64)buf_pa >> 32));
466 card->rx_buf_list[i] = skb;
467 if (reg->pfu_enabled) {
468 card->rxbd_ring[i] = (void *)card->rxbd_ring_vbase +
469 (sizeof(*desc2) * i);
470 desc2 = card->rxbd_ring[i];
471 desc2->paddr = buf_pa;
472 desc2->len = (u16)skb->len;
473 desc2->frag_len = (u16)skb->len;
474 desc2->flags = reg->ring_flag_eop | reg->ring_flag_sop;
477 card->rxbd_ring[i] = (void *)(card->rxbd_ring_vbase +
478 (sizeof(*desc) * i));
479 desc = card->rxbd_ring[i];
480 desc->paddr = buf_pa;
481 desc->len = (u16)skb->len;
489 /* This function initializes event buffer ring descriptors. Each SKB is
490 * allocated here and after mapping PCI memory, its physical address is assigned
491 * to PCIE Rx buffer descriptor's physical address
493 static int mwifiex_pcie_init_evt_ring(struct mwifiex_adapter *adapter)
495 struct pcie_service_card *card = adapter->card;
496 struct mwifiex_evt_buf_desc *desc;
501 for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) {
502 /* Allocate skb here so that firmware can DMA data from it */
503 skb = dev_alloc_skb(MAX_EVENT_SIZE);
505 dev_err(adapter->dev,
506 "Unable to allocate skb for EVENT buf.\n");
507 kfree(card->evtbd_ring_vbase);
510 skb_put(skb, MAX_EVENT_SIZE);
512 if (mwifiex_map_pci_memory(adapter, skb, MAX_EVENT_SIZE,
516 MWIFIEX_SKB_PACB(skb, &buf_pa);
518 dev_dbg(adapter->dev,
519 "info: EVT ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
520 skb, skb->len, skb->data, (u32)buf_pa,
521 (u32)((u64)buf_pa >> 32));
523 card->evt_buf_list[i] = skb;
524 card->evtbd_ring[i] = (void *)(card->evtbd_ring_vbase +
525 (sizeof(*desc) * i));
526 desc = card->evtbd_ring[i];
527 desc->paddr = buf_pa;
528 desc->len = (u16)skb->len;
535 /* This function cleans up TX buffer rings. If any of the buffer list has valid
536 * SKB address, associated SKB is freed.
538 static void mwifiex_cleanup_txq_ring(struct mwifiex_adapter *adapter)
540 struct pcie_service_card *card = adapter->card;
541 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
543 struct mwifiex_pcie_buf_desc *desc;
544 struct mwifiex_pfu_buf_desc *desc2;
547 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
548 if (reg->pfu_enabled) {
549 desc2 = card->txbd_ring[i];
550 if (card->tx_buf_list[i]) {
551 skb = card->tx_buf_list[i];
552 pci_unmap_single(card->dev, desc2->paddr,
553 skb->len, PCI_DMA_TODEVICE);
554 dev_kfree_skb_any(skb);
556 memset(desc2, 0, sizeof(*desc2));
558 desc = card->txbd_ring[i];
559 if (card->tx_buf_list[i]) {
560 skb = card->tx_buf_list[i];
561 pci_unmap_single(card->dev, desc->paddr,
562 skb->len, PCI_DMA_TODEVICE);
563 dev_kfree_skb_any(skb);
565 memset(desc, 0, sizeof(*desc));
567 card->tx_buf_list[i] = NULL;
573 /* This function cleans up RX buffer rings. If any of the buffer list has valid
574 * SKB address, associated SKB is freed.
576 static void mwifiex_cleanup_rxq_ring(struct mwifiex_adapter *adapter)
578 struct pcie_service_card *card = adapter->card;
579 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
580 struct mwifiex_pcie_buf_desc *desc;
581 struct mwifiex_pfu_buf_desc *desc2;
585 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
586 if (reg->pfu_enabled) {
587 desc2 = card->rxbd_ring[i];
588 if (card->rx_buf_list[i]) {
589 skb = card->rx_buf_list[i];
590 pci_unmap_single(card->dev, desc2->paddr,
591 skb->len, PCI_DMA_FROMDEVICE);
592 dev_kfree_skb_any(skb);
594 memset(desc2, 0, sizeof(*desc2));
596 desc = card->rxbd_ring[i];
597 if (card->rx_buf_list[i]) {
598 skb = card->rx_buf_list[i];
599 pci_unmap_single(card->dev, desc->paddr,
600 skb->len, PCI_DMA_FROMDEVICE);
601 dev_kfree_skb_any(skb);
603 memset(desc, 0, sizeof(*desc));
605 card->rx_buf_list[i] = NULL;
611 /* This function cleans up event buffer rings. If any of the buffer list has
612 * valid SKB address, associated SKB is freed.
614 static void mwifiex_cleanup_evt_ring(struct mwifiex_adapter *adapter)
616 struct pcie_service_card *card = adapter->card;
617 struct mwifiex_evt_buf_desc *desc;
621 for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) {
622 desc = card->evtbd_ring[i];
623 if (card->evt_buf_list[i]) {
624 skb = card->evt_buf_list[i];
625 pci_unmap_single(card->dev, desc->paddr, MAX_EVENT_SIZE,
627 dev_kfree_skb_any(skb);
629 card->evt_buf_list[i] = NULL;
630 memset(desc, 0, sizeof(*desc));
636 /* This function creates buffer descriptor ring for TX
638 static int mwifiex_pcie_create_txbd_ring(struct mwifiex_adapter *adapter)
640 struct pcie_service_card *card = adapter->card;
641 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
644 * driver maintaines the write pointer and firmware maintaines the read
645 * pointer. The write pointer starts at 0 (zero) while the read pointer
646 * starts at zero with rollover bit set
648 card->txbd_wrptr = 0;
650 if (reg->pfu_enabled)
651 card->txbd_rdptr = 0;
653 card->txbd_rdptr |= reg->tx_rollover_ind;
655 /* allocate shared memory for the BD ring and divide the same in to
656 several descriptors */
657 if (reg->pfu_enabled)
658 card->txbd_ring_size = sizeof(struct mwifiex_pfu_buf_desc) *
661 card->txbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
664 dev_dbg(adapter->dev, "info: txbd_ring: Allocating %d bytes\n",
665 card->txbd_ring_size);
666 card->txbd_ring_vbase = pci_alloc_consistent(card->dev,
667 card->txbd_ring_size,
668 &card->txbd_ring_pbase);
669 if (!card->txbd_ring_vbase) {
670 dev_err(adapter->dev,
671 "allocate consistent memory (%d bytes) failed!\n",
672 card->txbd_ring_size);
675 dev_dbg(adapter->dev,
676 "info: txbd_ring - base: %p, pbase: %#x:%x, len: %x\n",
677 card->txbd_ring_vbase, (unsigned int)card->txbd_ring_pbase,
678 (u32)((u64)card->txbd_ring_pbase >> 32), card->txbd_ring_size);
680 return mwifiex_init_txq_ring(adapter);
683 static int mwifiex_pcie_delete_txbd_ring(struct mwifiex_adapter *adapter)
685 struct pcie_service_card *card = adapter->card;
686 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
688 mwifiex_cleanup_txq_ring(adapter);
690 if (card->txbd_ring_vbase)
691 pci_free_consistent(card->dev, card->txbd_ring_size,
692 card->txbd_ring_vbase,
693 card->txbd_ring_pbase);
694 card->txbd_ring_size = 0;
695 card->txbd_wrptr = 0;
696 card->txbd_rdptr = 0 | reg->tx_rollover_ind;
697 card->txbd_ring_vbase = NULL;
698 card->txbd_ring_pbase = 0;
704 * This function creates buffer descriptor ring for RX
706 static int mwifiex_pcie_create_rxbd_ring(struct mwifiex_adapter *adapter)
708 struct pcie_service_card *card = adapter->card;
709 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
712 * driver maintaines the read pointer and firmware maintaines the write
713 * pointer. The write pointer starts at 0 (zero) while the read pointer
714 * starts at zero with rollover bit set
716 card->rxbd_wrptr = 0;
717 card->rxbd_rdptr = reg->rx_rollover_ind;
719 if (reg->pfu_enabled)
720 card->rxbd_ring_size = sizeof(struct mwifiex_pfu_buf_desc) *
723 card->rxbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
726 dev_dbg(adapter->dev, "info: rxbd_ring: Allocating %d bytes\n",
727 card->rxbd_ring_size);
728 card->rxbd_ring_vbase = pci_alloc_consistent(card->dev,
729 card->rxbd_ring_size,
730 &card->rxbd_ring_pbase);
731 if (!card->rxbd_ring_vbase) {
732 dev_err(adapter->dev,
733 "allocate consistent memory (%d bytes) failed!\n",
734 card->rxbd_ring_size);
738 dev_dbg(adapter->dev,
739 "info: rxbd_ring - base: %p, pbase: %#x:%x, len: %#x\n",
740 card->rxbd_ring_vbase, (u32)card->rxbd_ring_pbase,
741 (u32)((u64)card->rxbd_ring_pbase >> 32),
742 card->rxbd_ring_size);
744 return mwifiex_init_rxq_ring(adapter);
748 * This function deletes Buffer descriptor ring for RX
750 static int mwifiex_pcie_delete_rxbd_ring(struct mwifiex_adapter *adapter)
752 struct pcie_service_card *card = adapter->card;
753 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
755 mwifiex_cleanup_rxq_ring(adapter);
757 if (card->rxbd_ring_vbase)
758 pci_free_consistent(card->dev, card->rxbd_ring_size,
759 card->rxbd_ring_vbase,
760 card->rxbd_ring_pbase);
761 card->rxbd_ring_size = 0;
762 card->rxbd_wrptr = 0;
763 card->rxbd_rdptr = 0 | reg->rx_rollover_ind;
764 card->rxbd_ring_vbase = NULL;
765 card->rxbd_ring_pbase = 0;
771 * This function creates buffer descriptor ring for Events
773 static int mwifiex_pcie_create_evtbd_ring(struct mwifiex_adapter *adapter)
775 struct pcie_service_card *card = adapter->card;
776 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
779 * driver maintaines the read pointer and firmware maintaines the write
780 * pointer. The write pointer starts at 0 (zero) while the read pointer
781 * starts at zero with rollover bit set
783 card->evtbd_wrptr = 0;
784 card->evtbd_rdptr = reg->evt_rollover_ind;
786 card->evtbd_ring_size = sizeof(struct mwifiex_evt_buf_desc) *
789 dev_dbg(adapter->dev, "info: evtbd_ring: Allocating %d bytes\n",
790 card->evtbd_ring_size);
791 card->evtbd_ring_vbase = pci_alloc_consistent(card->dev,
792 card->evtbd_ring_size,
793 &card->evtbd_ring_pbase);
794 if (!card->evtbd_ring_vbase) {
795 dev_err(adapter->dev,
796 "allocate consistent memory (%d bytes) failed!\n",
797 card->evtbd_ring_size);
801 dev_dbg(adapter->dev,
802 "info: CMDRSP/EVT bd_ring - base: %p pbase: %#x:%x len: %#x\n",
803 card->evtbd_ring_vbase, (u32)card->evtbd_ring_pbase,
804 (u32)((u64)card->evtbd_ring_pbase >> 32),
805 card->evtbd_ring_size);
807 return mwifiex_pcie_init_evt_ring(adapter);
811 * This function deletes Buffer descriptor ring for Events
813 static int mwifiex_pcie_delete_evtbd_ring(struct mwifiex_adapter *adapter)
815 struct pcie_service_card *card = adapter->card;
816 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
818 mwifiex_cleanup_evt_ring(adapter);
820 if (card->evtbd_ring_vbase)
821 pci_free_consistent(card->dev, card->evtbd_ring_size,
822 card->evtbd_ring_vbase,
823 card->evtbd_ring_pbase);
824 card->evtbd_wrptr = 0;
825 card->evtbd_rdptr = 0 | reg->evt_rollover_ind;
826 card->evtbd_ring_size = 0;
827 card->evtbd_ring_vbase = NULL;
828 card->evtbd_ring_pbase = 0;
834 * This function allocates a buffer for CMDRSP
836 static int mwifiex_pcie_alloc_cmdrsp_buf(struct mwifiex_adapter *adapter)
838 struct pcie_service_card *card = adapter->card;
841 /* Allocate memory for receiving command response data */
842 skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
844 dev_err(adapter->dev,
845 "Unable to allocate skb for command response data.\n");
848 skb_put(skb, MWIFIEX_UPLD_SIZE);
849 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
853 card->cmdrsp_buf = skb;
859 * This function deletes a buffer for CMDRSP
861 static int mwifiex_pcie_delete_cmdrsp_buf(struct mwifiex_adapter *adapter)
863 struct pcie_service_card *card;
869 card = adapter->card;
871 if (card && card->cmdrsp_buf) {
872 MWIFIEX_SKB_PACB(card->cmdrsp_buf, &buf_pa);
873 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
875 dev_kfree_skb_any(card->cmdrsp_buf);
878 if (card && card->cmd_buf) {
879 MWIFIEX_SKB_PACB(card->cmd_buf, &buf_pa);
880 pci_unmap_single(card->dev, buf_pa, card->cmd_buf->len,
887 * This function allocates a buffer for sleep cookie
889 static int mwifiex_pcie_alloc_sleep_cookie_buf(struct mwifiex_adapter *adapter)
891 struct pcie_service_card *card = adapter->card;
893 card->sleep_cookie_vbase = pci_alloc_consistent(card->dev, sizeof(u32),
894 &card->sleep_cookie_pbase);
895 if (!card->sleep_cookie_vbase) {
896 dev_err(adapter->dev, "pci_alloc_consistent failed!\n");
899 /* Init val of Sleep Cookie */
900 *(u32 *)card->sleep_cookie_vbase = FW_AWAKE_COOKIE;
902 dev_dbg(adapter->dev, "alloc_scook: sleep cookie=0x%x\n",
903 *((u32 *)card->sleep_cookie_vbase));
909 * This function deletes buffer for sleep cookie
911 static int mwifiex_pcie_delete_sleep_cookie_buf(struct mwifiex_adapter *adapter)
913 struct pcie_service_card *card;
918 card = adapter->card;
920 if (card && card->sleep_cookie_vbase) {
921 pci_free_consistent(card->dev, sizeof(u32),
922 card->sleep_cookie_vbase,
923 card->sleep_cookie_pbase);
924 card->sleep_cookie_vbase = NULL;
930 /* This function flushes the TX buffer descriptor ring
931 * This function defined as handler is also called while cleaning TXRX
932 * during disconnect/ bss stop.
934 static int mwifiex_clean_pcie_ring_buf(struct mwifiex_adapter *adapter)
936 struct pcie_service_card *card = adapter->card;
938 if (!mwifiex_pcie_txbd_empty(card, card->txbd_rdptr)) {
939 card->txbd_flush = 1;
940 /* write pointer already set at last send
941 * send dnld-rdy intr again, wait for completion.
943 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
944 CPU_INTR_DNLD_RDY)) {
945 dev_err(adapter->dev,
946 "failed to assert dnld-rdy interrupt.\n");
954 * This function unmaps and frees downloaded data buffer
956 static int mwifiex_pcie_send_data_complete(struct mwifiex_adapter *adapter)
960 u32 wrdoneidx, rdptr, num_tx_buffs, unmap_count = 0;
961 struct mwifiex_pcie_buf_desc *desc;
962 struct mwifiex_pfu_buf_desc *desc2;
963 struct pcie_service_card *card = adapter->card;
964 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
966 if (!mwifiex_pcie_ok_to_access_hw(adapter))
967 mwifiex_pm_wakeup_card(adapter);
969 /* Read the TX ring read pointer set by firmware */
970 if (mwifiex_read_reg(adapter, reg->tx_rdptr, &rdptr)) {
971 dev_err(adapter->dev,
972 "SEND COMP: failed to read reg->tx_rdptr\n");
976 dev_dbg(adapter->dev, "SEND COMP: rdptr_prev=0x%x, rdptr=0x%x\n",
977 card->txbd_rdptr, rdptr);
979 num_tx_buffs = MWIFIEX_MAX_TXRX_BD << reg->tx_start_ptr;
980 /* free from previous txbd_rdptr to current txbd_rdptr */
981 while (((card->txbd_rdptr & reg->tx_mask) !=
982 (rdptr & reg->tx_mask)) ||
983 ((card->txbd_rdptr & reg->tx_rollover_ind) !=
984 (rdptr & reg->tx_rollover_ind))) {
985 wrdoneidx = (card->txbd_rdptr & reg->tx_mask) >>
988 skb = card->tx_buf_list[wrdoneidx];
990 dev_dbg(adapter->dev,
991 "SEND COMP: Detach skb %p at txbd_rdidx=%d\n",
993 MWIFIEX_SKB_PACB(skb, &buf_pa);
994 pci_unmap_single(card->dev, buf_pa, skb->len,
999 if (card->txbd_flush)
1000 mwifiex_write_data_complete(adapter, skb, 0,
1003 mwifiex_write_data_complete(adapter, skb, 0, 0);
1006 card->tx_buf_list[wrdoneidx] = NULL;
1008 if (reg->pfu_enabled) {
1009 desc2 = (void *)card->txbd_ring[wrdoneidx];
1010 memset(desc2, 0, sizeof(*desc2));
1012 desc = card->txbd_ring[wrdoneidx];
1013 memset(desc, 0, sizeof(*desc));
1015 switch (card->dev->device) {
1016 case PCIE_DEVICE_ID_MARVELL_88W8766P:
1019 case PCIE_DEVICE_ID_MARVELL_88W8897:
1020 card->txbd_rdptr += reg->ring_tx_start_ptr;
1025 if ((card->txbd_rdptr & reg->tx_mask) == num_tx_buffs)
1026 card->txbd_rdptr = ((card->txbd_rdptr &
1027 reg->tx_rollover_ind) ^
1028 reg->tx_rollover_ind);
1032 adapter->data_sent = false;
1034 if (card->txbd_flush) {
1035 if (mwifiex_pcie_txbd_empty(card, card->txbd_rdptr))
1036 card->txbd_flush = 0;
1038 mwifiex_clean_pcie_ring_buf(adapter);
1044 /* This function sends data buffer to device. First 4 bytes of payload
1045 * are filled with payload length and payload type. Then this payload
1046 * is mapped to PCI device memory. Tx ring pointers are advanced accordingly.
1047 * Download ready interrupt to FW is deffered if Tx ring is not full and
1048 * additional payload can be accomodated.
1051 mwifiex_pcie_send_data(struct mwifiex_adapter *adapter, struct sk_buff *skb,
1052 struct mwifiex_tx_param *tx_param)
1054 struct pcie_service_card *card = adapter->card;
1055 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1056 u32 wrindx, num_tx_buffs, rx_val;
1059 struct mwifiex_pcie_buf_desc *desc = NULL;
1060 struct mwifiex_pfu_buf_desc *desc2 = NULL;
1063 if (!(skb->data && skb->len)) {
1064 dev_err(adapter->dev, "%s(): invalid parameter <%p, %#x>\n",
1065 __func__, skb->data, skb->len);
1069 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1070 mwifiex_pm_wakeup_card(adapter);
1072 num_tx_buffs = MWIFIEX_MAX_TXRX_BD << reg->tx_start_ptr;
1073 dev_dbg(adapter->dev, "info: SEND DATA: <Rd: %#x, Wr: %#x>\n",
1074 card->txbd_rdptr, card->txbd_wrptr);
1075 if (mwifiex_pcie_txbd_not_full(card)) {
1078 adapter->data_sent = true;
1079 payload = skb->data;
1080 tmp = (__le16 *)&payload[0];
1081 *tmp = cpu_to_le16((u16)skb->len);
1082 tmp = (__le16 *)&payload[2];
1083 *tmp = cpu_to_le16(MWIFIEX_TYPE_DATA);
1085 if (mwifiex_map_pci_memory(adapter, skb, skb->len ,
1089 wrindx = (card->txbd_wrptr & reg->tx_mask) >> reg->tx_start_ptr;
1090 MWIFIEX_SKB_PACB(skb, &buf_pa);
1091 card->tx_buf_list[wrindx] = skb;
1093 if (reg->pfu_enabled) {
1094 desc2 = (void *)card->txbd_ring[wrindx];
1095 desc2->paddr = buf_pa;
1096 desc2->len = (u16)skb->len;
1097 desc2->frag_len = (u16)skb->len;
1099 desc2->flags = MWIFIEX_BD_FLAG_FIRST_DESC |
1100 MWIFIEX_BD_FLAG_LAST_DESC;
1102 desc = card->txbd_ring[wrindx];
1103 desc->paddr = buf_pa;
1104 desc->len = (u16)skb->len;
1105 desc->flags = MWIFIEX_BD_FLAG_FIRST_DESC |
1106 MWIFIEX_BD_FLAG_LAST_DESC;
1109 switch (card->dev->device) {
1110 case PCIE_DEVICE_ID_MARVELL_88W8766P:
1113 case PCIE_DEVICE_ID_MARVELL_88W8897:
1114 card->txbd_wrptr += reg->ring_tx_start_ptr;
1118 if ((card->txbd_wrptr & reg->tx_mask) == num_tx_buffs)
1119 card->txbd_wrptr = ((card->txbd_wrptr &
1120 reg->tx_rollover_ind) ^
1121 reg->tx_rollover_ind);
1123 rx_val = card->rxbd_rdptr & reg->rx_wrap_mask;
1124 /* Write the TX ring write pointer in to reg->tx_wrptr */
1125 if (mwifiex_write_reg(adapter, reg->tx_wrptr,
1126 card->txbd_wrptr | rx_val)) {
1127 dev_err(adapter->dev,
1128 "SEND DATA: failed to write reg->tx_wrptr\n");
1132 if ((mwifiex_pcie_txbd_not_full(card)) &&
1133 tx_param->next_pkt_len) {
1134 /* have more packets and TxBD still can hold more */
1135 dev_dbg(adapter->dev,
1136 "SEND DATA: delay dnld-rdy interrupt.\n");
1137 adapter->data_sent = false;
1139 /* Send the TX ready interrupt */
1140 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1141 CPU_INTR_DNLD_RDY)) {
1142 dev_err(adapter->dev,
1143 "SEND DATA: failed to assert dnld-rdy interrupt.\n");
1148 dev_dbg(adapter->dev, "info: SEND DATA: Updated <Rd: %#x, Wr: "
1149 "%#x> and sent packet to firmware successfully\n",
1150 card->txbd_rdptr, card->txbd_wrptr);
1152 dev_dbg(adapter->dev,
1153 "info: TX Ring full, can't send packets to fw\n");
1154 adapter->data_sent = true;
1155 /* Send the TX ready interrupt */
1156 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1158 dev_err(adapter->dev,
1159 "SEND DATA: failed to assert door-bell intr\n");
1163 return -EINPROGRESS;
1165 MWIFIEX_SKB_PACB(skb, &buf_pa);
1166 pci_unmap_single(card->dev, buf_pa, skb->len, PCI_DMA_TODEVICE);
1167 card->tx_buf_list[wrindx] = NULL;
1168 if (reg->pfu_enabled)
1169 memset(desc2, 0, sizeof(*desc2));
1171 memset(desc, 0, sizeof(*desc));
1177 * This function handles received buffer ring and
1178 * dispatches packets to upper
1180 static int mwifiex_pcie_process_recv_data(struct mwifiex_adapter *adapter)
1182 struct pcie_service_card *card = adapter->card;
1183 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1184 u32 wrptr, rd_index, tx_val;
1187 struct sk_buff *skb_tmp = NULL;
1188 struct mwifiex_pcie_buf_desc *desc;
1189 struct mwifiex_pfu_buf_desc *desc2;
1191 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1192 mwifiex_pm_wakeup_card(adapter);
1194 /* Read the RX ring Write pointer set by firmware */
1195 if (mwifiex_read_reg(adapter, reg->rx_wrptr, &wrptr)) {
1196 dev_err(adapter->dev,
1197 "RECV DATA: failed to read reg->rx_wrptr\n");
1201 card->rxbd_wrptr = wrptr;
1203 while (((wrptr & reg->rx_mask) !=
1204 (card->rxbd_rdptr & reg->rx_mask)) ||
1205 ((wrptr & reg->rx_rollover_ind) ==
1206 (card->rxbd_rdptr & reg->rx_rollover_ind))) {
1207 struct sk_buff *skb_data;
1211 rd_index = card->rxbd_rdptr & reg->rx_mask;
1212 skb_data = card->rx_buf_list[rd_index];
1214 /* If skb allocation was failed earlier for Rx packet,
1215 * rx_buf_list[rd_index] would have been left with a NULL.
1220 MWIFIEX_SKB_PACB(skb_data, &buf_pa);
1221 pci_unmap_single(card->dev, buf_pa, MWIFIEX_RX_DATA_BUF_SIZE,
1222 PCI_DMA_FROMDEVICE);
1223 card->rx_buf_list[rd_index] = NULL;
1225 /* Get data length from interface header -
1226 * first 2 bytes for len, next 2 bytes is for type
1228 pkt_len = *((__le16 *)skb_data->data);
1229 rx_len = le16_to_cpu(pkt_len);
1230 skb_put(skb_data, rx_len);
1231 dev_dbg(adapter->dev,
1232 "info: RECV DATA: Rd=%#x, Wr=%#x, Len=%d\n",
1233 card->rxbd_rdptr, wrptr, rx_len);
1234 skb_pull(skb_data, INTF_HEADER_LEN);
1235 mwifiex_handle_rx_packet(adapter, skb_data);
1237 skb_tmp = dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE);
1239 dev_err(adapter->dev,
1240 "Unable to allocate skb.\n");
1244 if (mwifiex_map_pci_memory(adapter, skb_tmp,
1245 MWIFIEX_RX_DATA_BUF_SIZE,
1246 PCI_DMA_FROMDEVICE))
1249 MWIFIEX_SKB_PACB(skb_tmp, &buf_pa);
1251 dev_dbg(adapter->dev,
1252 "RECV DATA: Attach new sk_buff %p at rxbd_rdidx=%d\n",
1254 card->rx_buf_list[rd_index] = skb_tmp;
1256 if (reg->pfu_enabled) {
1257 desc2 = (void *)card->rxbd_ring[rd_index];
1258 desc2->paddr = buf_pa;
1259 desc2->len = skb_tmp->len;
1260 desc2->frag_len = skb_tmp->len;
1262 desc2->flags = reg->ring_flag_sop | reg->ring_flag_eop;
1264 desc = card->rxbd_ring[rd_index];
1265 desc->paddr = buf_pa;
1266 desc->len = skb_tmp->len;
1270 if ((++card->rxbd_rdptr & reg->rx_mask) ==
1271 MWIFIEX_MAX_TXRX_BD) {
1272 card->rxbd_rdptr = ((card->rxbd_rdptr &
1273 reg->rx_rollover_ind) ^
1274 reg->rx_rollover_ind);
1276 dev_dbg(adapter->dev, "info: RECV DATA: <Rd: %#x, Wr: %#x>\n",
1277 card->rxbd_rdptr, wrptr);
1279 tx_val = card->txbd_wrptr & reg->tx_wrap_mask;
1280 /* Write the RX ring read pointer in to reg->rx_rdptr */
1281 if (mwifiex_write_reg(adapter, reg->rx_rdptr,
1282 card->rxbd_rdptr | tx_val)) {
1283 dev_err(adapter->dev,
1284 "RECV DATA: failed to write reg->rx_rdptr\n");
1289 /* Read the RX ring Write pointer set by firmware */
1290 if (mwifiex_read_reg(adapter, reg->rx_wrptr, &wrptr)) {
1291 dev_err(adapter->dev,
1292 "RECV DATA: failed to read reg->rx_wrptr\n");
1296 dev_dbg(adapter->dev,
1297 "info: RECV DATA: Rcvd packet from fw successfully\n");
1298 card->rxbd_wrptr = wrptr;
1306 * This function downloads the boot command to device
1309 mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
1312 struct pcie_service_card *card = adapter->card;
1313 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1315 if (!(skb->data && skb->len)) {
1316 dev_err(adapter->dev,
1317 "Invalid parameter in %s <%p. len %d>\n",
1318 __func__, skb->data, skb->len);
1322 if (mwifiex_map_pci_memory(adapter, skb, skb->len , PCI_DMA_TODEVICE))
1325 MWIFIEX_SKB_PACB(skb, &buf_pa);
1327 /* Write the lower 32bits of the physical address to low command
1328 * address scratch register
1330 if (mwifiex_write_reg(adapter, reg->cmd_addr_lo, (u32)buf_pa)) {
1331 dev_err(adapter->dev,
1332 "%s: failed to write download command to boot code.\n",
1334 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1339 /* Write the upper 32bits of the physical address to high command
1340 * address scratch register
1342 if (mwifiex_write_reg(adapter, reg->cmd_addr_hi,
1343 (u32)((u64)buf_pa >> 32))) {
1344 dev_err(adapter->dev,
1345 "%s: failed to write download command to boot code.\n",
1347 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1352 /* Write the command length to cmd_size scratch register */
1353 if (mwifiex_write_reg(adapter, reg->cmd_size, skb->len)) {
1354 dev_err(adapter->dev,
1355 "%s: failed to write command len to cmd_size scratch reg\n",
1357 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1362 /* Ring the door bell */
1363 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1364 CPU_INTR_DOOR_BELL)) {
1365 dev_err(adapter->dev,
1366 "%s: failed to assert door-bell intr\n", __func__);
1367 pci_unmap_single(card->dev, buf_pa,
1368 MWIFIEX_UPLD_SIZE, PCI_DMA_TODEVICE);
1375 /* This function init rx port in firmware which in turn enables to receive data
1376 * from device before transmitting any packet.
1378 static int mwifiex_pcie_init_fw_port(struct mwifiex_adapter *adapter)
1380 struct pcie_service_card *card = adapter->card;
1381 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1382 int tx_wrap = card->txbd_wrptr & reg->tx_wrap_mask;
1384 /* Write the RX ring read pointer in to reg->rx_rdptr */
1385 if (mwifiex_write_reg(adapter, reg->rx_rdptr, card->rxbd_rdptr |
1387 dev_err(adapter->dev,
1388 "RECV DATA: failed to write reg->rx_rdptr\n");
1394 /* This function downloads commands to the device
1397 mwifiex_pcie_send_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
1399 struct pcie_service_card *card = adapter->card;
1400 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1402 dma_addr_t cmd_buf_pa, cmdrsp_buf_pa;
1403 u8 *payload = (u8 *)skb->data;
1405 if (!(skb->data && skb->len)) {
1406 dev_err(adapter->dev, "Invalid parameter in %s <%p, %#x>\n",
1407 __func__, skb->data, skb->len);
1411 /* Make sure a command response buffer is available */
1412 if (!card->cmdrsp_buf) {
1413 dev_err(adapter->dev,
1414 "No response buffer available, send command failed\n");
1418 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1419 mwifiex_pm_wakeup_card(adapter);
1421 adapter->cmd_sent = true;
1423 *(__le16 *)&payload[0] = cpu_to_le16((u16)skb->len);
1424 *(__le16 *)&payload[2] = cpu_to_le16(MWIFIEX_TYPE_CMD);
1426 if (mwifiex_map_pci_memory(adapter, skb, skb->len, PCI_DMA_TODEVICE))
1429 card->cmd_buf = skb;
1431 /* To send a command, the driver will:
1432 1. Write the 64bit physical address of the data buffer to
1433 cmd response address low + cmd response address high
1434 2. Ring the door bell (i.e. set the door bell interrupt)
1436 In response to door bell interrupt, the firmware will perform
1437 the DMA of the command packet (first header to obtain the total
1438 length and then rest of the command).
1441 if (card->cmdrsp_buf) {
1442 MWIFIEX_SKB_PACB(card->cmdrsp_buf, &cmdrsp_buf_pa);
1443 /* Write the lower 32bits of the cmdrsp buffer physical
1445 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo,
1446 (u32)cmdrsp_buf_pa)) {
1447 dev_err(adapter->dev,
1448 "Failed to write download cmd to boot code.\n");
1452 /* Write the upper 32bits of the cmdrsp buffer physical
1454 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi,
1455 (u32)((u64)cmdrsp_buf_pa >> 32))) {
1456 dev_err(adapter->dev,
1457 "Failed to write download cmd to boot code.\n");
1463 MWIFIEX_SKB_PACB(card->cmd_buf, &cmd_buf_pa);
1464 /* Write the lower 32bits of the physical address to reg->cmd_addr_lo */
1465 if (mwifiex_write_reg(adapter, reg->cmd_addr_lo,
1467 dev_err(adapter->dev,
1468 "Failed to write download cmd to boot code.\n");
1472 /* Write the upper 32bits of the physical address to reg->cmd_addr_hi */
1473 if (mwifiex_write_reg(adapter, reg->cmd_addr_hi,
1474 (u32)((u64)cmd_buf_pa >> 32))) {
1475 dev_err(adapter->dev,
1476 "Failed to write download cmd to boot code.\n");
1481 /* Write the command length to reg->cmd_size */
1482 if (mwifiex_write_reg(adapter, reg->cmd_size,
1483 card->cmd_buf->len)) {
1484 dev_err(adapter->dev,
1485 "Failed to write cmd len to reg->cmd_size\n");
1490 /* Ring the door bell */
1491 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1492 CPU_INTR_DOOR_BELL)) {
1493 dev_err(adapter->dev,
1494 "Failed to assert door-bell intr\n");
1501 adapter->cmd_sent = false;
1507 * This function handles command complete interrupt
1509 static int mwifiex_pcie_process_cmd_complete(struct mwifiex_adapter *adapter)
1511 struct pcie_service_card *card = adapter->card;
1512 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1513 struct sk_buff *skb = card->cmdrsp_buf;
1519 dev_dbg(adapter->dev, "info: Rx CMD Response\n");
1521 MWIFIEX_SKB_PACB(skb, &buf_pa);
1522 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1523 PCI_DMA_FROMDEVICE);
1525 pkt_len = *((__le16 *)skb->data);
1526 rx_len = le16_to_cpu(pkt_len);
1527 skb_trim(skb, rx_len);
1528 skb_pull(skb, INTF_HEADER_LEN);
1530 if (!adapter->curr_cmd) {
1531 if (adapter->ps_state == PS_STATE_SLEEP_CFM) {
1532 mwifiex_process_sleep_confirm_resp(adapter, skb->data,
1534 mwifiex_pcie_enable_host_int(adapter);
1535 if (mwifiex_write_reg(adapter,
1537 CPU_INTR_SLEEP_CFM_DONE)) {
1538 dev_warn(adapter->dev,
1539 "Write register failed\n");
1542 while (reg->sleep_cookie && (count++ < 10) &&
1543 mwifiex_pcie_ok_to_access_hw(adapter))
1544 usleep_range(50, 60);
1546 dev_err(adapter->dev,
1547 "There is no command but got cmdrsp\n");
1549 memcpy(adapter->upld_buf, skb->data,
1550 min_t(u32, MWIFIEX_SIZE_OF_CMD_BUFFER, skb->len));
1551 skb_push(skb, INTF_HEADER_LEN);
1552 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1553 PCI_DMA_FROMDEVICE))
1556 MWIFIEX_SKB_PACB(skb, &buf_pa);
1557 } else if (mwifiex_pcie_ok_to_access_hw(adapter)) {
1558 adapter->curr_cmd->resp_skb = skb;
1559 adapter->cmd_resp_received = true;
1560 /* Take the pointer and set it to CMD node and will
1561 return in the response complete callback */
1562 card->cmdrsp_buf = NULL;
1564 /* Clear the cmd-rsp buffer address in scratch registers. This
1565 will prevent firmware from writing to the same response
1567 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo, 0)) {
1568 dev_err(adapter->dev,
1569 "cmd_done: failed to clear cmd_rsp_addr_lo\n");
1572 /* Write the upper 32bits of the cmdrsp buffer physical
1574 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi, 0)) {
1575 dev_err(adapter->dev,
1576 "cmd_done: failed to clear cmd_rsp_addr_hi\n");
1585 * Command Response processing complete handler
1587 static int mwifiex_pcie_cmdrsp_complete(struct mwifiex_adapter *adapter,
1588 struct sk_buff *skb)
1590 struct pcie_service_card *card = adapter->card;
1592 struct sk_buff *skb_tmp;
1595 card->cmdrsp_buf = skb;
1596 skb_push(card->cmdrsp_buf, INTF_HEADER_LEN);
1597 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1598 PCI_DMA_FROMDEVICE))
1602 skb_tmp = card->cmd_buf;
1604 MWIFIEX_SKB_PACB(skb_tmp, &buf_pa);
1605 pci_unmap_single(card->dev, buf_pa, skb_tmp->len,
1606 PCI_DMA_FROMDEVICE);
1607 card->cmd_buf = NULL;
1614 * This function handles firmware event ready interrupt
1616 static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter *adapter)
1618 struct pcie_service_card *card = adapter->card;
1619 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1620 u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1623 struct mwifiex_evt_buf_desc *desc;
1625 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1626 mwifiex_pm_wakeup_card(adapter);
1628 if (adapter->event_received) {
1629 dev_dbg(adapter->dev, "info: Event being processed, "
1630 "do not process this interrupt just yet\n");
1634 if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1635 dev_dbg(adapter->dev, "info: Invalid read pointer...\n");
1639 /* Read the event ring write pointer set by firmware */
1640 if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1641 dev_err(adapter->dev,
1642 "EventReady: failed to read reg->evt_wrptr\n");
1646 dev_dbg(adapter->dev, "info: EventReady: Initial <Rd: 0x%x, Wr: 0x%x>",
1647 card->evtbd_rdptr, wrptr);
1648 if (((wrptr & MWIFIEX_EVTBD_MASK) != (card->evtbd_rdptr
1649 & MWIFIEX_EVTBD_MASK)) ||
1650 ((wrptr & reg->evt_rollover_ind) ==
1651 (card->evtbd_rdptr & reg->evt_rollover_ind))) {
1652 struct sk_buff *skb_cmd;
1653 __le16 data_len = 0;
1656 dev_dbg(adapter->dev, "info: Read Index: %d\n", rdptr);
1657 skb_cmd = card->evt_buf_list[rdptr];
1658 MWIFIEX_SKB_PACB(skb_cmd, &buf_pa);
1659 pci_unmap_single(card->dev, buf_pa, MAX_EVENT_SIZE,
1660 PCI_DMA_FROMDEVICE);
1662 /* Take the pointer and set it to event pointer in adapter
1663 and will return back after event handling callback */
1664 card->evt_buf_list[rdptr] = NULL;
1665 desc = card->evtbd_ring[rdptr];
1666 memset(desc, 0, sizeof(*desc));
1668 event = *(u32 *) &skb_cmd->data[INTF_HEADER_LEN];
1669 adapter->event_cause = event;
1670 /* The first 4bytes will be the event transfer header
1671 len is 2 bytes followed by type which is 2 bytes */
1672 memcpy(&data_len, skb_cmd->data, sizeof(__le16));
1673 evt_len = le16_to_cpu(data_len);
1675 skb_pull(skb_cmd, INTF_HEADER_LEN);
1676 dev_dbg(adapter->dev, "info: Event length: %d\n", evt_len);
1678 if ((evt_len > 0) && (evt_len < MAX_EVENT_SIZE))
1679 memcpy(adapter->event_body, skb_cmd->data +
1680 MWIFIEX_EVENT_HEADER_LEN, evt_len -
1681 MWIFIEX_EVENT_HEADER_LEN);
1683 adapter->event_received = true;
1684 adapter->event_skb = skb_cmd;
1686 /* Do not update the event read pointer here, wait till the
1687 buffer is released. This is just to make things simpler,
1688 we need to find a better method of managing these buffers.
1696 * Event processing complete handler
1698 static int mwifiex_pcie_event_complete(struct mwifiex_adapter *adapter,
1699 struct sk_buff *skb)
1701 struct pcie_service_card *card = adapter->card;
1702 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1704 u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1707 struct mwifiex_evt_buf_desc *desc;
1712 if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1713 dev_err(adapter->dev, "event_complete: Invalid rdptr 0x%x\n",
1718 /* Read the event ring write pointer set by firmware */
1719 if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1720 dev_err(adapter->dev,
1721 "event_complete: failed to read reg->evt_wrptr\n");
1725 if (!card->evt_buf_list[rdptr]) {
1726 skb_push(skb, INTF_HEADER_LEN);
1727 if (mwifiex_map_pci_memory(adapter, skb,
1729 PCI_DMA_FROMDEVICE))
1731 MWIFIEX_SKB_PACB(skb, &buf_pa);
1732 card->evt_buf_list[rdptr] = skb;
1733 MWIFIEX_SKB_PACB(skb, &buf_pa);
1734 desc = card->evtbd_ring[rdptr];
1735 desc->paddr = buf_pa;
1736 desc->len = (u16)skb->len;
1740 dev_dbg(adapter->dev,
1741 "info: ERROR: buf still valid at index %d, <%p, %p>\n",
1742 rdptr, card->evt_buf_list[rdptr], skb);
1745 if ((++card->evtbd_rdptr & MWIFIEX_EVTBD_MASK) == MWIFIEX_MAX_EVT_BD) {
1746 card->evtbd_rdptr = ((card->evtbd_rdptr &
1747 reg->evt_rollover_ind) ^
1748 reg->evt_rollover_ind);
1751 dev_dbg(adapter->dev, "info: Updated <Rd: 0x%x, Wr: 0x%x>",
1752 card->evtbd_rdptr, wrptr);
1754 /* Write the event ring read pointer in to reg->evt_rdptr */
1755 if (mwifiex_write_reg(adapter, reg->evt_rdptr,
1756 card->evtbd_rdptr)) {
1757 dev_err(adapter->dev,
1758 "event_complete: failed to read reg->evt_rdptr\n");
1762 dev_dbg(adapter->dev, "info: Check Events Again\n");
1763 ret = mwifiex_pcie_process_event_ready(adapter);
1769 * This function downloads the firmware to the card.
1771 * Firmware is downloaded to the card in blocks. Every block download
1772 * is tested for CRC errors, and retried a number of times before
1773 * returning failure.
1775 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter *adapter,
1776 struct mwifiex_fw_image *fw)
1779 u8 *firmware = fw->fw_buf;
1780 u32 firmware_len = fw->fw_len;
1782 struct sk_buff *skb;
1783 u32 txlen, tx_blocks = 0, tries, len;
1784 u32 block_retry_cnt = 0;
1786 struct pcie_service_card *card = adapter->card;
1787 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1789 if (!firmware || !firmware_len) {
1790 dev_err(adapter->dev,
1791 "No firmware image found! Terminating download\n");
1795 dev_dbg(adapter->dev, "info: Downloading FW image (%d bytes)\n",
1798 if (mwifiex_pcie_disable_host_int(adapter)) {
1799 dev_err(adapter->dev,
1800 "%s: Disabling interrupts failed.\n", __func__);
1804 skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
1810 /* Perform firmware data transfer */
1815 if (offset >= firmware_len)
1818 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
1819 ret = mwifiex_read_reg(adapter, reg->cmd_size,
1822 dev_warn(adapter->dev,
1823 "Failed reading len from boot code\n");
1828 usleep_range(10, 20);
1833 } else if (len > MWIFIEX_UPLD_SIZE) {
1834 pr_err("FW download failure @ %d, invalid length %d\n",
1844 if (block_retry_cnt > MAX_WRITE_IOMEM_RETRY) {
1845 pr_err("FW download failure @ %d, over max "
1846 "retry count\n", offset);
1850 dev_err(adapter->dev, "FW CRC error indicated by the "
1851 "helper: len = 0x%04X, txlen = %d\n",
1854 /* Setting this to 0 to resend from same offset */
1857 block_retry_cnt = 0;
1858 /* Set blocksize to transfer - checking for
1860 if (firmware_len - offset < txlen)
1861 txlen = firmware_len - offset;
1863 dev_dbg(adapter->dev, ".");
1865 tx_blocks = (txlen + card->pcie.blksz_fw_dl - 1) /
1866 card->pcie.blksz_fw_dl;
1868 /* Copy payload to buffer */
1869 memmove(skb->data, &firmware[offset], txlen);
1872 skb_put(skb, MWIFIEX_UPLD_SIZE - skb->len);
1873 skb_trim(skb, tx_blocks * card->pcie.blksz_fw_dl);
1875 /* Send the boot command to device */
1876 if (mwifiex_pcie_send_boot_cmd(adapter, skb)) {
1877 dev_err(adapter->dev,
1878 "Failed to send firmware download command\n");
1883 MWIFIEX_SKB_PACB(skb, &buf_pa);
1885 /* Wait for the command done interrupt */
1887 if (mwifiex_read_reg(adapter, PCIE_CPU_INT_STATUS,
1889 dev_err(adapter->dev, "%s: Failed to read "
1890 "interrupt status during fw dnld.\n",
1892 pci_unmap_single(card->dev, buf_pa, skb->len,
1897 } while ((ireg_intr & CPU_INTR_DOOR_BELL) ==
1898 CPU_INTR_DOOR_BELL);
1900 pci_unmap_single(card->dev, buf_pa, skb->len,
1906 dev_dbg(adapter->dev, "info:\nFW download over, size %d bytes\n",
1912 dev_kfree_skb_any(skb);
1917 * This function checks the firmware status in card.
1919 * The winner interface is also determined by this function.
1922 mwifiex_check_fw_status(struct mwifiex_adapter *adapter, u32 poll_num)
1925 u32 firmware_stat, winner_status;
1926 struct pcie_service_card *card = adapter->card;
1927 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1930 /* Mask spurios interrupts */
1931 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS_MASK,
1933 dev_warn(adapter->dev, "Write register failed\n");
1937 dev_dbg(adapter->dev, "Setting driver ready signature\n");
1938 if (mwifiex_write_reg(adapter, reg->drv_rdy,
1939 FIRMWARE_READY_PCIE)) {
1940 dev_err(adapter->dev,
1941 "Failed to write driver ready signature\n");
1945 /* Wait for firmware initialization event */
1946 for (tries = 0; tries < poll_num; tries++) {
1947 if (mwifiex_read_reg(adapter, reg->fw_status,
1954 if (firmware_stat == FIRMWARE_READY_PCIE) {
1964 if (mwifiex_read_reg(adapter, reg->fw_status,
1967 else if (!winner_status) {
1968 dev_err(adapter->dev, "PCI-E is the winner\n");
1969 adapter->winner = 1;
1971 dev_err(adapter->dev,
1972 "PCI-E is not the winner <%#x,%d>, exit dnld\n",
1973 ret, adapter->winner);
1981 * This function reads the interrupt status from card.
1983 static void mwifiex_interrupt_status(struct mwifiex_adapter *adapter)
1986 unsigned long flags;
1988 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1991 if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS, &pcie_ireg)) {
1992 dev_warn(adapter->dev, "Read register failed\n");
1996 if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
1998 mwifiex_pcie_disable_host_int(adapter);
2000 /* Clear the pending interrupts */
2001 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS,
2003 dev_warn(adapter->dev, "Write register failed\n");
2006 spin_lock_irqsave(&adapter->int_lock, flags);
2007 adapter->int_status |= pcie_ireg;
2008 spin_unlock_irqrestore(&adapter->int_lock, flags);
2010 if (!adapter->pps_uapsd_mode &&
2011 adapter->ps_state == PS_STATE_SLEEP &&
2012 mwifiex_pcie_ok_to_access_hw(adapter)) {
2013 /* Potentially for PCIe we could get other
2014 * interrupts like shared. Don't change power
2015 * state until cookie is set */
2016 adapter->ps_state = PS_STATE_AWAKE;
2017 adapter->pm_wakeup_fw_try = false;
2023 * Interrupt handler for PCIe root port
2025 * This function reads the interrupt status from firmware and assigns
2026 * the main process in workqueue which will handle the interrupt.
2028 static irqreturn_t mwifiex_pcie_interrupt(int irq, void *context)
2030 struct pci_dev *pdev = (struct pci_dev *)context;
2031 struct pcie_service_card *card;
2032 struct mwifiex_adapter *adapter;
2035 pr_debug("info: %s: pdev is NULL\n", (u8 *)pdev);
2039 card = pci_get_drvdata(pdev);
2040 if (!card || !card->adapter) {
2041 pr_debug("info: %s: card=%p adapter=%p\n", __func__, card,
2042 card ? card->adapter : NULL);
2045 adapter = card->adapter;
2047 if (adapter->surprise_removed)
2050 mwifiex_interrupt_status(adapter);
2051 queue_work(adapter->workqueue, &adapter->main_work);
2058 * This function checks the current interrupt status.
2060 * The following interrupts are checked and handled by this function -
2063 * - Command received
2064 * - Packets received
2067 * In case of Rx packets received, the packets are uploaded from card to
2068 * host and processed accordingly.
2070 static int mwifiex_process_int_status(struct mwifiex_adapter *adapter)
2074 unsigned long flags;
2076 spin_lock_irqsave(&adapter->int_lock, flags);
2077 /* Clear out unused interrupts */
2078 pcie_ireg = adapter->int_status;
2079 adapter->int_status = 0;
2080 spin_unlock_irqrestore(&adapter->int_lock, flags);
2082 while (pcie_ireg & HOST_INTR_MASK) {
2083 if (pcie_ireg & HOST_INTR_DNLD_DONE) {
2084 pcie_ireg &= ~HOST_INTR_DNLD_DONE;
2085 dev_dbg(adapter->dev, "info: TX DNLD Done\n");
2086 ret = mwifiex_pcie_send_data_complete(adapter);
2090 if (pcie_ireg & HOST_INTR_UPLD_RDY) {
2091 pcie_ireg &= ~HOST_INTR_UPLD_RDY;
2092 dev_dbg(adapter->dev, "info: Rx DATA\n");
2093 ret = mwifiex_pcie_process_recv_data(adapter);
2097 if (pcie_ireg & HOST_INTR_EVENT_RDY) {
2098 pcie_ireg &= ~HOST_INTR_EVENT_RDY;
2099 dev_dbg(adapter->dev, "info: Rx EVENT\n");
2100 ret = mwifiex_pcie_process_event_ready(adapter);
2105 if (pcie_ireg & HOST_INTR_CMD_DONE) {
2106 pcie_ireg &= ~HOST_INTR_CMD_DONE;
2107 if (adapter->cmd_sent) {
2108 dev_dbg(adapter->dev,
2109 "info: CMD sent Interrupt\n");
2110 adapter->cmd_sent = false;
2112 /* Handle command response */
2113 ret = mwifiex_pcie_process_cmd_complete(adapter);
2118 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
2119 if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS,
2121 dev_warn(adapter->dev,
2122 "Read register failed\n");
2126 if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
2127 if (mwifiex_write_reg(adapter,
2128 PCIE_HOST_INT_STATUS,
2130 dev_warn(adapter->dev,
2131 "Write register failed\n");
2138 dev_dbg(adapter->dev, "info: cmd_sent=%d data_sent=%d\n",
2139 adapter->cmd_sent, adapter->data_sent);
2140 if (adapter->ps_state != PS_STATE_SLEEP)
2141 mwifiex_pcie_enable_host_int(adapter);
2147 * This function downloads data from driver to card.
2149 * Both commands and data packets are transferred to the card by this
2152 * This function adds the PCIE specific header to the front of the buffer
2153 * before transferring. The header contains the length of the packet and
2154 * the type. The firmware handles the packets based upon this set type.
2156 static int mwifiex_pcie_host_to_card(struct mwifiex_adapter *adapter, u8 type,
2157 struct sk_buff *skb,
2158 struct mwifiex_tx_param *tx_param)
2161 dev_err(adapter->dev, "Passed NULL skb to %s\n", __func__);
2165 if (type == MWIFIEX_TYPE_DATA)
2166 return mwifiex_pcie_send_data(adapter, skb, tx_param);
2167 else if (type == MWIFIEX_TYPE_CMD)
2168 return mwifiex_pcie_send_cmd(adapter, skb);
2174 * This function initializes the PCI-E host memory space, WCB rings, etc.
2176 * The following initializations steps are followed -
2177 * - Allocate TXBD ring buffers
2178 * - Allocate RXBD ring buffers
2179 * - Allocate event BD ring buffers
2180 * - Allocate command response ring buffer
2181 * - Allocate sleep cookie buffer
2183 static int mwifiex_pcie_init(struct mwifiex_adapter *adapter)
2185 struct pcie_service_card *card = adapter->card;
2187 struct pci_dev *pdev = card->dev;
2188 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2190 pci_set_drvdata(pdev, card);
2192 ret = pci_enable_device(pdev);
2194 goto err_enable_dev;
2196 pci_set_master(pdev);
2198 dev_dbg(adapter->dev, "try set_consistent_dma_mask(32)\n");
2199 ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2201 dev_err(adapter->dev, "set_dma_mask(32) failed\n");
2202 goto err_set_dma_mask;
2205 ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
2207 dev_err(adapter->dev, "set_consistent_dma_mask(64) failed\n");
2208 goto err_set_dma_mask;
2211 ret = pci_request_region(pdev, 0, DRV_NAME);
2213 dev_err(adapter->dev, "req_reg(0) error\n");
2214 goto err_req_region0;
2216 card->pci_mmap = pci_iomap(pdev, 0, 0);
2217 if (!card->pci_mmap) {
2218 dev_err(adapter->dev, "iomap(0) error\n");
2222 ret = pci_request_region(pdev, 2, DRV_NAME);
2224 dev_err(adapter->dev, "req_reg(2) error\n");
2225 goto err_req_region2;
2227 card->pci_mmap1 = pci_iomap(pdev, 2, 0);
2228 if (!card->pci_mmap1) {
2229 dev_err(adapter->dev, "iomap(2) error\n");
2234 dev_dbg(adapter->dev,
2235 "PCI memory map Virt0: %p PCI memory map Virt2: %p\n",
2236 card->pci_mmap, card->pci_mmap1);
2238 card->cmdrsp_buf = NULL;
2239 ret = mwifiex_pcie_create_txbd_ring(adapter);
2242 ret = mwifiex_pcie_create_rxbd_ring(adapter);
2245 ret = mwifiex_pcie_create_evtbd_ring(adapter);
2248 ret = mwifiex_pcie_alloc_cmdrsp_buf(adapter);
2250 goto err_alloc_cmdbuf;
2251 if (reg->sleep_cookie) {
2252 ret = mwifiex_pcie_alloc_sleep_cookie_buf(adapter);
2254 goto err_alloc_cookie;
2256 card->sleep_cookie_vbase = NULL;
2261 mwifiex_pcie_delete_cmdrsp_buf(adapter);
2263 mwifiex_pcie_delete_evtbd_ring(adapter);
2265 mwifiex_pcie_delete_rxbd_ring(adapter);
2267 mwifiex_pcie_delete_txbd_ring(adapter);
2269 pci_iounmap(pdev, card->pci_mmap1);
2271 pci_release_region(pdev, 2);
2273 pci_iounmap(pdev, card->pci_mmap);
2275 pci_release_region(pdev, 0);
2278 pci_disable_device(pdev);
2280 pci_set_drvdata(pdev, NULL);
2285 * This function cleans up the allocated card buffers.
2287 * The following are freed by this function -
2288 * - TXBD ring buffers
2289 * - RXBD ring buffers
2290 * - Event BD ring buffers
2291 * - Command response ring buffer
2292 * - Sleep cookie buffer
2294 static void mwifiex_pcie_cleanup(struct mwifiex_adapter *adapter)
2296 struct pcie_service_card *card = adapter->card;
2297 struct pci_dev *pdev = card->dev;
2298 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2301 dev_dbg(adapter->dev, "Clearing driver ready signature\n");
2302 if (mwifiex_write_reg(adapter, reg->drv_rdy, 0x00000000))
2303 dev_err(adapter->dev,
2304 "Failed to write driver not-ready signature\n");
2308 pci_iounmap(pdev, card->pci_mmap);
2309 pci_iounmap(pdev, card->pci_mmap1);
2310 pci_disable_device(pdev);
2311 pci_release_region(pdev, 2);
2312 pci_release_region(pdev, 0);
2313 pci_set_drvdata(pdev, NULL);
2319 * This function registers the PCIE device.
2321 * PCIE IRQ is claimed, block size is set and driver data is initialized.
2323 static int mwifiex_register_dev(struct mwifiex_adapter *adapter)
2326 struct pcie_service_card *card = adapter->card;
2327 struct pci_dev *pdev = card->dev;
2329 /* save adapter pointer in card */
2330 card->adapter = adapter;
2332 ret = request_irq(pdev->irq, mwifiex_pcie_interrupt, IRQF_SHARED,
2335 pr_err("request_irq failed: ret=%d\n", ret);
2336 adapter->card = NULL;
2340 adapter->dev = &pdev->dev;
2341 strcpy(adapter->fw_name, card->pcie.firmware);
2347 * This function unregisters the PCIE device.
2349 * The PCIE IRQ is released, the function is disabled and driver
2350 * data is set to null.
2352 static void mwifiex_unregister_dev(struct mwifiex_adapter *adapter)
2354 struct pcie_service_card *card = adapter->card;
2355 const struct mwifiex_pcie_card_reg *reg;
2358 dev_dbg(adapter->dev, "%s(): calling free_irq()\n", __func__);
2359 free_irq(card->dev->irq, card->dev);
2361 reg = card->pcie.reg;
2362 if (reg->sleep_cookie)
2363 mwifiex_pcie_delete_sleep_cookie_buf(adapter);
2365 mwifiex_pcie_delete_cmdrsp_buf(adapter);
2366 mwifiex_pcie_delete_evtbd_ring(adapter);
2367 mwifiex_pcie_delete_rxbd_ring(adapter);
2368 mwifiex_pcie_delete_txbd_ring(adapter);
2369 card->cmdrsp_buf = NULL;
2373 static struct mwifiex_if_ops pcie_ops = {
2374 .init_if = mwifiex_pcie_init,
2375 .cleanup_if = mwifiex_pcie_cleanup,
2376 .check_fw_status = mwifiex_check_fw_status,
2377 .prog_fw = mwifiex_prog_fw_w_helper,
2378 .register_dev = mwifiex_register_dev,
2379 .unregister_dev = mwifiex_unregister_dev,
2380 .enable_int = mwifiex_pcie_enable_host_int,
2381 .process_int_status = mwifiex_process_int_status,
2382 .host_to_card = mwifiex_pcie_host_to_card,
2383 .wakeup = mwifiex_pm_wakeup_card,
2384 .wakeup_complete = mwifiex_pm_wakeup_card_complete,
2387 .cmdrsp_complete = mwifiex_pcie_cmdrsp_complete,
2388 .event_complete = mwifiex_pcie_event_complete,
2389 .update_mp_end_port = NULL,
2390 .cleanup_mpa_buf = NULL,
2391 .init_fw_port = mwifiex_pcie_init_fw_port,
2392 .clean_pcie_ring = mwifiex_clean_pcie_ring_buf,
2396 * This function initializes the PCIE driver module.
2398 * This initiates the semaphore and registers the device with
2401 static int mwifiex_pcie_init_module(void)
2405 pr_debug("Marvell PCIe Driver\n");
2407 sema_init(&add_remove_card_sem, 1);
2409 /* Clear the flag in case user removes the card. */
2412 ret = pci_register_driver(&mwifiex_pcie);
2414 pr_err("Driver register failed!\n");
2416 pr_debug("info: Driver registered successfully!\n");
2422 * This function cleans up the PCIE driver.
2424 * The following major steps are followed for cleanup -
2425 * - Resume the device if its suspended
2426 * - Disconnect the device if connected
2427 * - Shutdown the firmware
2428 * - Unregister the device from PCIE bus.
2430 static void mwifiex_pcie_cleanup_module(void)
2432 if (!down_interruptible(&add_remove_card_sem))
2433 up(&add_remove_card_sem);
2435 /* Set the flag as user is removing this module. */
2438 pci_unregister_driver(&mwifiex_pcie);
2441 module_init(mwifiex_pcie_init_module);
2442 module_exit(mwifiex_pcie_cleanup_module);
2444 MODULE_AUTHOR("Marvell International Ltd.");
2445 MODULE_DESCRIPTION("Marvell WiFi-Ex PCI-Express Driver version " PCIE_VERSION);
2446 MODULE_VERSION(PCIE_VERSION);
2447 MODULE_LICENSE("GPL v2");
2448 MODULE_FIRMWARE(PCIE8766_DEFAULT_FW_NAME);
2449 MODULE_FIRMWARE(PCIE8897_DEFAULT_FW_NAME);