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);
238 static void mwifiex_pcie_shutdown(struct pci_dev *pdev)
241 mwifiex_pcie_remove(pdev);
246 static DEFINE_PCI_DEVICE_TABLE(mwifiex_ids) = {
248 PCIE_VENDOR_ID_MARVELL, PCIE_DEVICE_ID_MARVELL_88W8766P,
249 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
250 .driver_data = (unsigned long) &mwifiex_pcie8766,
253 PCIE_VENDOR_ID_MARVELL, PCIE_DEVICE_ID_MARVELL_88W8897,
254 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
255 .driver_data = (unsigned long) &mwifiex_pcie8897,
260 MODULE_DEVICE_TABLE(pci, mwifiex_ids);
262 #ifdef CONFIG_PM_SLEEP
263 /* Power Management Hooks */
264 static SIMPLE_DEV_PM_OPS(mwifiex_pcie_pm_ops, mwifiex_pcie_suspend,
265 mwifiex_pcie_resume);
268 /* PCI Device Driver */
269 static struct pci_driver __refdata mwifiex_pcie = {
270 .name = "mwifiex_pcie",
271 .id_table = mwifiex_ids,
272 .probe = mwifiex_pcie_probe,
273 .remove = mwifiex_pcie_remove,
274 #ifdef CONFIG_PM_SLEEP
276 .pm = &mwifiex_pcie_pm_ops,
279 .shutdown = mwifiex_pcie_shutdown,
283 * This function writes data into PCIE card register.
285 static int mwifiex_write_reg(struct mwifiex_adapter *adapter, int reg, u32 data)
287 struct pcie_service_card *card = adapter->card;
289 iowrite32(data, card->pci_mmap1 + reg);
295 * This function reads data from PCIE card register.
297 static int mwifiex_read_reg(struct mwifiex_adapter *adapter, int reg, u32 *data)
299 struct pcie_service_card *card = adapter->card;
301 *data = ioread32(card->pci_mmap1 + reg);
307 * This function adds delay loop to ensure FW is awake before proceeding.
309 static void mwifiex_pcie_dev_wakeup_delay(struct mwifiex_adapter *adapter)
313 while (mwifiex_pcie_ok_to_access_hw(adapter)) {
315 usleep_range(10, 20);
324 /* This function wakes up the card by reading fw_status register. */
325 static int mwifiex_pm_wakeup_card(struct mwifiex_adapter *adapter)
328 struct pcie_service_card *card = adapter->card;
329 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
331 dev_dbg(adapter->dev, "event: Wakeup device...\n");
333 if (reg->sleep_cookie)
334 mwifiex_pcie_dev_wakeup_delay(adapter);
336 /* Reading fw_status register will wakeup device */
337 if (mwifiex_read_reg(adapter, reg->fw_status, &fw_status)) {
338 dev_warn(adapter->dev, "Reading fw_status register failed\n");
342 if (reg->sleep_cookie) {
343 mwifiex_pcie_dev_wakeup_delay(adapter);
344 dev_dbg(adapter->dev, "PCIE wakeup: Setting PS_STATE_AWAKE\n");
345 adapter->ps_state = PS_STATE_AWAKE;
352 * This function is called after the card has woken up.
354 * The card configuration register is reset.
356 static int mwifiex_pm_wakeup_card_complete(struct mwifiex_adapter *adapter)
358 dev_dbg(adapter->dev, "cmd: Wakeup device completed\n");
364 * This function disables the host interrupt.
366 * The host interrupt mask is read, the disable bit is reset and
367 * written back to the card host interrupt mask register.
369 static int mwifiex_pcie_disable_host_int(struct mwifiex_adapter *adapter)
371 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
372 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK,
374 dev_warn(adapter->dev, "Disable host interrupt failed\n");
383 * This function enables the host interrupt.
385 * The host interrupt enable mask is written to the card
386 * host interrupt mask register.
388 static int mwifiex_pcie_enable_host_int(struct mwifiex_adapter *adapter)
390 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
391 /* Simply write the mask to the register */
392 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK,
394 dev_warn(adapter->dev, "Enable host interrupt failed\n");
403 * This function initializes TX buffer ring descriptors
405 static int mwifiex_init_txq_ring(struct mwifiex_adapter *adapter)
407 struct pcie_service_card *card = adapter->card;
408 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
409 struct mwifiex_pcie_buf_desc *desc;
410 struct mwifiex_pfu_buf_desc *desc2;
413 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
414 card->tx_buf_list[i] = NULL;
415 if (reg->pfu_enabled) {
416 card->txbd_ring[i] = (void *)card->txbd_ring_vbase +
417 (sizeof(*desc2) * i);
418 desc2 = card->txbd_ring[i];
419 memset(desc2, 0, sizeof(*desc2));
421 card->txbd_ring[i] = (void *)card->txbd_ring_vbase +
423 desc = card->txbd_ring[i];
424 memset(desc, 0, sizeof(*desc));
431 /* This function initializes RX buffer ring descriptors. Each SKB is allocated
432 * here and after mapping PCI memory, its physical address is assigned to
433 * PCIE Rx buffer descriptor's physical address.
435 static int mwifiex_init_rxq_ring(struct mwifiex_adapter *adapter)
437 struct pcie_service_card *card = adapter->card;
438 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
440 struct mwifiex_pcie_buf_desc *desc;
441 struct mwifiex_pfu_buf_desc *desc2;
445 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
446 /* Allocate skb here so that firmware can DMA data from it */
447 skb = dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE);
449 dev_err(adapter->dev,
450 "Unable to allocate skb for RX ring.\n");
451 kfree(card->rxbd_ring_vbase);
455 if (mwifiex_map_pci_memory(adapter, skb,
456 MWIFIEX_RX_DATA_BUF_SIZE,
460 MWIFIEX_SKB_PACB(skb, &buf_pa);
462 dev_dbg(adapter->dev,
463 "info: RX ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
464 skb, skb->len, skb->data, (u32)buf_pa,
465 (u32)((u64)buf_pa >> 32));
467 card->rx_buf_list[i] = skb;
468 if (reg->pfu_enabled) {
469 card->rxbd_ring[i] = (void *)card->rxbd_ring_vbase +
470 (sizeof(*desc2) * i);
471 desc2 = card->rxbd_ring[i];
472 desc2->paddr = buf_pa;
473 desc2->len = (u16)skb->len;
474 desc2->frag_len = (u16)skb->len;
475 desc2->flags = reg->ring_flag_eop | reg->ring_flag_sop;
478 card->rxbd_ring[i] = (void *)(card->rxbd_ring_vbase +
479 (sizeof(*desc) * i));
480 desc = card->rxbd_ring[i];
481 desc->paddr = buf_pa;
482 desc->len = (u16)skb->len;
490 /* This function initializes event buffer ring descriptors. Each SKB is
491 * allocated here and after mapping PCI memory, its physical address is assigned
492 * to PCIE Rx buffer descriptor's physical address
494 static int mwifiex_pcie_init_evt_ring(struct mwifiex_adapter *adapter)
496 struct pcie_service_card *card = adapter->card;
497 struct mwifiex_evt_buf_desc *desc;
502 for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) {
503 /* Allocate skb here so that firmware can DMA data from it */
504 skb = dev_alloc_skb(MAX_EVENT_SIZE);
506 dev_err(adapter->dev,
507 "Unable to allocate skb for EVENT buf.\n");
508 kfree(card->evtbd_ring_vbase);
511 skb_put(skb, MAX_EVENT_SIZE);
513 if (mwifiex_map_pci_memory(adapter, skb, MAX_EVENT_SIZE,
517 MWIFIEX_SKB_PACB(skb, &buf_pa);
519 dev_dbg(adapter->dev,
520 "info: EVT ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
521 skb, skb->len, skb->data, (u32)buf_pa,
522 (u32)((u64)buf_pa >> 32));
524 card->evt_buf_list[i] = skb;
525 card->evtbd_ring[i] = (void *)(card->evtbd_ring_vbase +
526 (sizeof(*desc) * i));
527 desc = card->evtbd_ring[i];
528 desc->paddr = buf_pa;
529 desc->len = (u16)skb->len;
536 /* This function cleans up TX buffer rings. If any of the buffer list has valid
537 * SKB address, associated SKB is freed.
539 static void mwifiex_cleanup_txq_ring(struct mwifiex_adapter *adapter)
541 struct pcie_service_card *card = adapter->card;
542 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
544 struct mwifiex_pcie_buf_desc *desc;
545 struct mwifiex_pfu_buf_desc *desc2;
548 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
549 if (reg->pfu_enabled) {
550 desc2 = card->txbd_ring[i];
551 if (card->tx_buf_list[i]) {
552 skb = card->tx_buf_list[i];
553 pci_unmap_single(card->dev, desc2->paddr,
554 skb->len, PCI_DMA_TODEVICE);
555 dev_kfree_skb_any(skb);
557 memset(desc2, 0, sizeof(*desc2));
559 desc = card->txbd_ring[i];
560 if (card->tx_buf_list[i]) {
561 skb = card->tx_buf_list[i];
562 pci_unmap_single(card->dev, desc->paddr,
563 skb->len, PCI_DMA_TODEVICE);
564 dev_kfree_skb_any(skb);
566 memset(desc, 0, sizeof(*desc));
568 card->tx_buf_list[i] = NULL;
574 /* This function cleans up RX buffer rings. If any of the buffer list has valid
575 * SKB address, associated SKB is freed.
577 static void mwifiex_cleanup_rxq_ring(struct mwifiex_adapter *adapter)
579 struct pcie_service_card *card = adapter->card;
580 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
581 struct mwifiex_pcie_buf_desc *desc;
582 struct mwifiex_pfu_buf_desc *desc2;
586 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
587 if (reg->pfu_enabled) {
588 desc2 = card->rxbd_ring[i];
589 if (card->rx_buf_list[i]) {
590 skb = card->rx_buf_list[i];
591 pci_unmap_single(card->dev, desc2->paddr,
592 skb->len, PCI_DMA_FROMDEVICE);
593 dev_kfree_skb_any(skb);
595 memset(desc2, 0, sizeof(*desc2));
597 desc = card->rxbd_ring[i];
598 if (card->rx_buf_list[i]) {
599 skb = card->rx_buf_list[i];
600 pci_unmap_single(card->dev, desc->paddr,
601 skb->len, PCI_DMA_FROMDEVICE);
602 dev_kfree_skb_any(skb);
604 memset(desc, 0, sizeof(*desc));
606 card->rx_buf_list[i] = NULL;
612 /* This function cleans up event buffer rings. If any of the buffer list has
613 * valid SKB address, associated SKB is freed.
615 static void mwifiex_cleanup_evt_ring(struct mwifiex_adapter *adapter)
617 struct pcie_service_card *card = adapter->card;
618 struct mwifiex_evt_buf_desc *desc;
622 for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) {
623 desc = card->evtbd_ring[i];
624 if (card->evt_buf_list[i]) {
625 skb = card->evt_buf_list[i];
626 pci_unmap_single(card->dev, desc->paddr, MAX_EVENT_SIZE,
628 dev_kfree_skb_any(skb);
630 card->evt_buf_list[i] = NULL;
631 memset(desc, 0, sizeof(*desc));
637 /* This function creates buffer descriptor ring for TX
639 static int mwifiex_pcie_create_txbd_ring(struct mwifiex_adapter *adapter)
641 struct pcie_service_card *card = adapter->card;
642 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
645 * driver maintaines the write pointer and firmware maintaines the read
646 * pointer. The write pointer starts at 0 (zero) while the read pointer
647 * starts at zero with rollover bit set
649 card->txbd_wrptr = 0;
651 if (reg->pfu_enabled)
652 card->txbd_rdptr = 0;
654 card->txbd_rdptr |= reg->tx_rollover_ind;
656 /* allocate shared memory for the BD ring and divide the same in to
657 several descriptors */
658 if (reg->pfu_enabled)
659 card->txbd_ring_size = sizeof(struct mwifiex_pfu_buf_desc) *
662 card->txbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
665 dev_dbg(adapter->dev, "info: txbd_ring: Allocating %d bytes\n",
666 card->txbd_ring_size);
667 card->txbd_ring_vbase = pci_alloc_consistent(card->dev,
668 card->txbd_ring_size,
669 &card->txbd_ring_pbase);
670 if (!card->txbd_ring_vbase) {
671 dev_err(adapter->dev,
672 "allocate consistent memory (%d bytes) failed!\n",
673 card->txbd_ring_size);
676 dev_dbg(adapter->dev,
677 "info: txbd_ring - base: %p, pbase: %#x:%x, len: %x\n",
678 card->txbd_ring_vbase, (unsigned int)card->txbd_ring_pbase,
679 (u32)((u64)card->txbd_ring_pbase >> 32), card->txbd_ring_size);
681 return mwifiex_init_txq_ring(adapter);
684 static int mwifiex_pcie_delete_txbd_ring(struct mwifiex_adapter *adapter)
686 struct pcie_service_card *card = adapter->card;
687 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
689 mwifiex_cleanup_txq_ring(adapter);
691 if (card->txbd_ring_vbase)
692 pci_free_consistent(card->dev, card->txbd_ring_size,
693 card->txbd_ring_vbase,
694 card->txbd_ring_pbase);
695 card->txbd_ring_size = 0;
696 card->txbd_wrptr = 0;
697 card->txbd_rdptr = 0 | reg->tx_rollover_ind;
698 card->txbd_ring_vbase = NULL;
699 card->txbd_ring_pbase = 0;
705 * This function creates buffer descriptor ring for RX
707 static int mwifiex_pcie_create_rxbd_ring(struct mwifiex_adapter *adapter)
709 struct pcie_service_card *card = adapter->card;
710 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
713 * driver maintaines the read pointer and firmware maintaines the write
714 * pointer. The write pointer starts at 0 (zero) while the read pointer
715 * starts at zero with rollover bit set
717 card->rxbd_wrptr = 0;
718 card->rxbd_rdptr = reg->rx_rollover_ind;
720 if (reg->pfu_enabled)
721 card->rxbd_ring_size = sizeof(struct mwifiex_pfu_buf_desc) *
724 card->rxbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
727 dev_dbg(adapter->dev, "info: rxbd_ring: Allocating %d bytes\n",
728 card->rxbd_ring_size);
729 card->rxbd_ring_vbase = pci_alloc_consistent(card->dev,
730 card->rxbd_ring_size,
731 &card->rxbd_ring_pbase);
732 if (!card->rxbd_ring_vbase) {
733 dev_err(adapter->dev,
734 "allocate consistent memory (%d bytes) failed!\n",
735 card->rxbd_ring_size);
739 dev_dbg(adapter->dev,
740 "info: rxbd_ring - base: %p, pbase: %#x:%x, len: %#x\n",
741 card->rxbd_ring_vbase, (u32)card->rxbd_ring_pbase,
742 (u32)((u64)card->rxbd_ring_pbase >> 32),
743 card->rxbd_ring_size);
745 return mwifiex_init_rxq_ring(adapter);
749 * This function deletes Buffer descriptor ring for RX
751 static int mwifiex_pcie_delete_rxbd_ring(struct mwifiex_adapter *adapter)
753 struct pcie_service_card *card = adapter->card;
754 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
756 mwifiex_cleanup_rxq_ring(adapter);
758 if (card->rxbd_ring_vbase)
759 pci_free_consistent(card->dev, card->rxbd_ring_size,
760 card->rxbd_ring_vbase,
761 card->rxbd_ring_pbase);
762 card->rxbd_ring_size = 0;
763 card->rxbd_wrptr = 0;
764 card->rxbd_rdptr = 0 | reg->rx_rollover_ind;
765 card->rxbd_ring_vbase = NULL;
766 card->rxbd_ring_pbase = 0;
772 * This function creates buffer descriptor ring for Events
774 static int mwifiex_pcie_create_evtbd_ring(struct mwifiex_adapter *adapter)
776 struct pcie_service_card *card = adapter->card;
777 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
780 * driver maintaines the read pointer and firmware maintaines the write
781 * pointer. The write pointer starts at 0 (zero) while the read pointer
782 * starts at zero with rollover bit set
784 card->evtbd_wrptr = 0;
785 card->evtbd_rdptr = reg->evt_rollover_ind;
787 card->evtbd_ring_size = sizeof(struct mwifiex_evt_buf_desc) *
790 dev_dbg(adapter->dev, "info: evtbd_ring: Allocating %d bytes\n",
791 card->evtbd_ring_size);
792 card->evtbd_ring_vbase = pci_alloc_consistent(card->dev,
793 card->evtbd_ring_size,
794 &card->evtbd_ring_pbase);
795 if (!card->evtbd_ring_vbase) {
796 dev_err(adapter->dev,
797 "allocate consistent memory (%d bytes) failed!\n",
798 card->evtbd_ring_size);
802 dev_dbg(adapter->dev,
803 "info: CMDRSP/EVT bd_ring - base: %p pbase: %#x:%x len: %#x\n",
804 card->evtbd_ring_vbase, (u32)card->evtbd_ring_pbase,
805 (u32)((u64)card->evtbd_ring_pbase >> 32),
806 card->evtbd_ring_size);
808 return mwifiex_pcie_init_evt_ring(adapter);
812 * This function deletes Buffer descriptor ring for Events
814 static int mwifiex_pcie_delete_evtbd_ring(struct mwifiex_adapter *adapter)
816 struct pcie_service_card *card = adapter->card;
817 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
819 mwifiex_cleanup_evt_ring(adapter);
821 if (card->evtbd_ring_vbase)
822 pci_free_consistent(card->dev, card->evtbd_ring_size,
823 card->evtbd_ring_vbase,
824 card->evtbd_ring_pbase);
825 card->evtbd_wrptr = 0;
826 card->evtbd_rdptr = 0 | reg->evt_rollover_ind;
827 card->evtbd_ring_size = 0;
828 card->evtbd_ring_vbase = NULL;
829 card->evtbd_ring_pbase = 0;
835 * This function allocates a buffer for CMDRSP
837 static int mwifiex_pcie_alloc_cmdrsp_buf(struct mwifiex_adapter *adapter)
839 struct pcie_service_card *card = adapter->card;
842 /* Allocate memory for receiving command response data */
843 skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
845 dev_err(adapter->dev,
846 "Unable to allocate skb for command response data.\n");
849 skb_put(skb, MWIFIEX_UPLD_SIZE);
850 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
854 card->cmdrsp_buf = skb;
860 * This function deletes a buffer for CMDRSP
862 static int mwifiex_pcie_delete_cmdrsp_buf(struct mwifiex_adapter *adapter)
864 struct pcie_service_card *card;
870 card = adapter->card;
872 if (card && card->cmdrsp_buf) {
873 MWIFIEX_SKB_PACB(card->cmdrsp_buf, &buf_pa);
874 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
876 dev_kfree_skb_any(card->cmdrsp_buf);
879 if (card && card->cmd_buf) {
880 MWIFIEX_SKB_PACB(card->cmd_buf, &buf_pa);
881 pci_unmap_single(card->dev, buf_pa, card->cmd_buf->len,
888 * This function allocates a buffer for sleep cookie
890 static int mwifiex_pcie_alloc_sleep_cookie_buf(struct mwifiex_adapter *adapter)
892 struct pcie_service_card *card = adapter->card;
894 card->sleep_cookie_vbase = pci_alloc_consistent(card->dev, sizeof(u32),
895 &card->sleep_cookie_pbase);
896 if (!card->sleep_cookie_vbase) {
897 dev_err(adapter->dev, "pci_alloc_consistent failed!\n");
900 /* Init val of Sleep Cookie */
901 *(u32 *)card->sleep_cookie_vbase = FW_AWAKE_COOKIE;
903 dev_dbg(adapter->dev, "alloc_scook: sleep cookie=0x%x\n",
904 *((u32 *)card->sleep_cookie_vbase));
910 * This function deletes buffer for sleep cookie
912 static int mwifiex_pcie_delete_sleep_cookie_buf(struct mwifiex_adapter *adapter)
914 struct pcie_service_card *card;
919 card = adapter->card;
921 if (card && card->sleep_cookie_vbase) {
922 pci_free_consistent(card->dev, sizeof(u32),
923 card->sleep_cookie_vbase,
924 card->sleep_cookie_pbase);
925 card->sleep_cookie_vbase = NULL;
931 /* This function flushes the TX buffer descriptor ring
932 * This function defined as handler is also called while cleaning TXRX
933 * during disconnect/ bss stop.
935 static int mwifiex_clean_pcie_ring_buf(struct mwifiex_adapter *adapter)
937 struct pcie_service_card *card = adapter->card;
939 if (!mwifiex_pcie_txbd_empty(card, card->txbd_rdptr)) {
940 card->txbd_flush = 1;
941 /* write pointer already set at last send
942 * send dnld-rdy intr again, wait for completion.
944 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
945 CPU_INTR_DNLD_RDY)) {
946 dev_err(adapter->dev,
947 "failed to assert dnld-rdy interrupt.\n");
955 * This function unmaps and frees downloaded data buffer
957 static int mwifiex_pcie_send_data_complete(struct mwifiex_adapter *adapter)
961 u32 wrdoneidx, rdptr, num_tx_buffs, unmap_count = 0;
962 struct mwifiex_pcie_buf_desc *desc;
963 struct mwifiex_pfu_buf_desc *desc2;
964 struct pcie_service_card *card = adapter->card;
965 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
967 if (!mwifiex_pcie_ok_to_access_hw(adapter))
968 mwifiex_pm_wakeup_card(adapter);
970 /* Read the TX ring read pointer set by firmware */
971 if (mwifiex_read_reg(adapter, reg->tx_rdptr, &rdptr)) {
972 dev_err(adapter->dev,
973 "SEND COMP: failed to read reg->tx_rdptr\n");
977 dev_dbg(adapter->dev, "SEND COMP: rdptr_prev=0x%x, rdptr=0x%x\n",
978 card->txbd_rdptr, rdptr);
980 num_tx_buffs = MWIFIEX_MAX_TXRX_BD << reg->tx_start_ptr;
981 /* free from previous txbd_rdptr to current txbd_rdptr */
982 while (((card->txbd_rdptr & reg->tx_mask) !=
983 (rdptr & reg->tx_mask)) ||
984 ((card->txbd_rdptr & reg->tx_rollover_ind) !=
985 (rdptr & reg->tx_rollover_ind))) {
986 wrdoneidx = (card->txbd_rdptr & reg->tx_mask) >>
989 skb = card->tx_buf_list[wrdoneidx];
991 dev_dbg(adapter->dev,
992 "SEND COMP: Detach skb %p at txbd_rdidx=%d\n",
994 MWIFIEX_SKB_PACB(skb, &buf_pa);
995 pci_unmap_single(card->dev, buf_pa, skb->len,
1000 if (card->txbd_flush)
1001 mwifiex_write_data_complete(adapter, skb, 0,
1004 mwifiex_write_data_complete(adapter, skb, 0, 0);
1007 card->tx_buf_list[wrdoneidx] = NULL;
1009 if (reg->pfu_enabled) {
1010 desc2 = (void *)card->txbd_ring[wrdoneidx];
1011 memset(desc2, 0, sizeof(*desc2));
1013 desc = card->txbd_ring[wrdoneidx];
1014 memset(desc, 0, sizeof(*desc));
1016 switch (card->dev->device) {
1017 case PCIE_DEVICE_ID_MARVELL_88W8766P:
1020 case PCIE_DEVICE_ID_MARVELL_88W8897:
1021 card->txbd_rdptr += reg->ring_tx_start_ptr;
1026 if ((card->txbd_rdptr & reg->tx_mask) == num_tx_buffs)
1027 card->txbd_rdptr = ((card->txbd_rdptr &
1028 reg->tx_rollover_ind) ^
1029 reg->tx_rollover_ind);
1033 adapter->data_sent = false;
1035 if (card->txbd_flush) {
1036 if (mwifiex_pcie_txbd_empty(card, card->txbd_rdptr))
1037 card->txbd_flush = 0;
1039 mwifiex_clean_pcie_ring_buf(adapter);
1045 /* This function sends data buffer to device. First 4 bytes of payload
1046 * are filled with payload length and payload type. Then this payload
1047 * is mapped to PCI device memory. Tx ring pointers are advanced accordingly.
1048 * Download ready interrupt to FW is deffered if Tx ring is not full and
1049 * additional payload can be accomodated.
1052 mwifiex_pcie_send_data(struct mwifiex_adapter *adapter, struct sk_buff *skb,
1053 struct mwifiex_tx_param *tx_param)
1055 struct pcie_service_card *card = adapter->card;
1056 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1057 u32 wrindx, num_tx_buffs, rx_val;
1060 struct mwifiex_pcie_buf_desc *desc = NULL;
1061 struct mwifiex_pfu_buf_desc *desc2 = NULL;
1064 if (!(skb->data && skb->len)) {
1065 dev_err(adapter->dev, "%s(): invalid parameter <%p, %#x>\n",
1066 __func__, skb->data, skb->len);
1070 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1071 mwifiex_pm_wakeup_card(adapter);
1073 num_tx_buffs = MWIFIEX_MAX_TXRX_BD << reg->tx_start_ptr;
1074 dev_dbg(adapter->dev, "info: SEND DATA: <Rd: %#x, Wr: %#x>\n",
1075 card->txbd_rdptr, card->txbd_wrptr);
1076 if (mwifiex_pcie_txbd_not_full(card)) {
1079 adapter->data_sent = true;
1080 payload = skb->data;
1081 tmp = (__le16 *)&payload[0];
1082 *tmp = cpu_to_le16((u16)skb->len);
1083 tmp = (__le16 *)&payload[2];
1084 *tmp = cpu_to_le16(MWIFIEX_TYPE_DATA);
1086 if (mwifiex_map_pci_memory(adapter, skb, skb->len ,
1090 wrindx = (card->txbd_wrptr & reg->tx_mask) >> reg->tx_start_ptr;
1091 MWIFIEX_SKB_PACB(skb, &buf_pa);
1092 card->tx_buf_list[wrindx] = skb;
1094 if (reg->pfu_enabled) {
1095 desc2 = (void *)card->txbd_ring[wrindx];
1096 desc2->paddr = buf_pa;
1097 desc2->len = (u16)skb->len;
1098 desc2->frag_len = (u16)skb->len;
1100 desc2->flags = MWIFIEX_BD_FLAG_FIRST_DESC |
1101 MWIFIEX_BD_FLAG_LAST_DESC;
1103 desc = card->txbd_ring[wrindx];
1104 desc->paddr = buf_pa;
1105 desc->len = (u16)skb->len;
1106 desc->flags = MWIFIEX_BD_FLAG_FIRST_DESC |
1107 MWIFIEX_BD_FLAG_LAST_DESC;
1110 switch (card->dev->device) {
1111 case PCIE_DEVICE_ID_MARVELL_88W8766P:
1114 case PCIE_DEVICE_ID_MARVELL_88W8897:
1115 card->txbd_wrptr += reg->ring_tx_start_ptr;
1119 if ((card->txbd_wrptr & reg->tx_mask) == num_tx_buffs)
1120 card->txbd_wrptr = ((card->txbd_wrptr &
1121 reg->tx_rollover_ind) ^
1122 reg->tx_rollover_ind);
1124 rx_val = card->rxbd_rdptr & reg->rx_wrap_mask;
1125 /* Write the TX ring write pointer in to reg->tx_wrptr */
1126 if (mwifiex_write_reg(adapter, reg->tx_wrptr,
1127 card->txbd_wrptr | rx_val)) {
1128 dev_err(adapter->dev,
1129 "SEND DATA: failed to write reg->tx_wrptr\n");
1133 if ((mwifiex_pcie_txbd_not_full(card)) &&
1134 tx_param->next_pkt_len) {
1135 /* have more packets and TxBD still can hold more */
1136 dev_dbg(adapter->dev,
1137 "SEND DATA: delay dnld-rdy interrupt.\n");
1138 adapter->data_sent = false;
1140 /* Send the TX ready interrupt */
1141 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1142 CPU_INTR_DNLD_RDY)) {
1143 dev_err(adapter->dev,
1144 "SEND DATA: failed to assert dnld-rdy interrupt.\n");
1149 dev_dbg(adapter->dev, "info: SEND DATA: Updated <Rd: %#x, Wr: "
1150 "%#x> and sent packet to firmware successfully\n",
1151 card->txbd_rdptr, card->txbd_wrptr);
1153 dev_dbg(adapter->dev,
1154 "info: TX Ring full, can't send packets to fw\n");
1155 adapter->data_sent = true;
1156 /* Send the TX ready interrupt */
1157 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1159 dev_err(adapter->dev,
1160 "SEND DATA: failed to assert door-bell intr\n");
1164 return -EINPROGRESS;
1166 MWIFIEX_SKB_PACB(skb, &buf_pa);
1167 pci_unmap_single(card->dev, buf_pa, skb->len, PCI_DMA_TODEVICE);
1168 card->tx_buf_list[wrindx] = NULL;
1169 if (reg->pfu_enabled)
1170 memset(desc2, 0, sizeof(*desc2));
1172 memset(desc, 0, sizeof(*desc));
1178 * This function handles received buffer ring and
1179 * dispatches packets to upper
1181 static int mwifiex_pcie_process_recv_data(struct mwifiex_adapter *adapter)
1183 struct pcie_service_card *card = adapter->card;
1184 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1185 u32 wrptr, rd_index, tx_val;
1188 struct sk_buff *skb_tmp = NULL;
1189 struct mwifiex_pcie_buf_desc *desc;
1190 struct mwifiex_pfu_buf_desc *desc2;
1192 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1193 mwifiex_pm_wakeup_card(adapter);
1195 /* Read the RX ring Write pointer set by firmware */
1196 if (mwifiex_read_reg(adapter, reg->rx_wrptr, &wrptr)) {
1197 dev_err(adapter->dev,
1198 "RECV DATA: failed to read reg->rx_wrptr\n");
1202 card->rxbd_wrptr = wrptr;
1204 while (((wrptr & reg->rx_mask) !=
1205 (card->rxbd_rdptr & reg->rx_mask)) ||
1206 ((wrptr & reg->rx_rollover_ind) ==
1207 (card->rxbd_rdptr & reg->rx_rollover_ind))) {
1208 struct sk_buff *skb_data;
1212 rd_index = card->rxbd_rdptr & reg->rx_mask;
1213 skb_data = card->rx_buf_list[rd_index];
1215 MWIFIEX_SKB_PACB(skb_data, &buf_pa);
1216 pci_unmap_single(card->dev, buf_pa, MWIFIEX_RX_DATA_BUF_SIZE,
1217 PCI_DMA_FROMDEVICE);
1218 card->rx_buf_list[rd_index] = NULL;
1220 /* Get data length from interface header -
1221 * first 2 bytes for len, next 2 bytes is for type
1223 pkt_len = *((__le16 *)skb_data->data);
1224 rx_len = le16_to_cpu(pkt_len);
1225 skb_put(skb_data, rx_len);
1226 dev_dbg(adapter->dev,
1227 "info: RECV DATA: Rd=%#x, Wr=%#x, Len=%d\n",
1228 card->rxbd_rdptr, wrptr, rx_len);
1229 skb_pull(skb_data, INTF_HEADER_LEN);
1230 mwifiex_handle_rx_packet(adapter, skb_data);
1232 skb_tmp = dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE);
1234 dev_err(adapter->dev,
1235 "Unable to allocate skb.\n");
1239 if (mwifiex_map_pci_memory(adapter, skb_tmp,
1240 MWIFIEX_RX_DATA_BUF_SIZE,
1241 PCI_DMA_FROMDEVICE))
1244 MWIFIEX_SKB_PACB(skb_tmp, &buf_pa);
1246 dev_dbg(adapter->dev,
1247 "RECV DATA: Attach new sk_buff %p at rxbd_rdidx=%d\n",
1249 card->rx_buf_list[rd_index] = skb_tmp;
1251 if (reg->pfu_enabled) {
1252 desc2 = (void *)card->rxbd_ring[rd_index];
1253 desc2->paddr = buf_pa;
1254 desc2->len = skb_tmp->len;
1255 desc2->frag_len = skb_tmp->len;
1257 desc2->flags = reg->ring_flag_sop | reg->ring_flag_eop;
1259 desc = card->rxbd_ring[rd_index];
1260 desc->paddr = buf_pa;
1261 desc->len = skb_tmp->len;
1265 if ((++card->rxbd_rdptr & reg->rx_mask) ==
1266 MWIFIEX_MAX_TXRX_BD) {
1267 card->rxbd_rdptr = ((card->rxbd_rdptr &
1268 reg->rx_rollover_ind) ^
1269 reg->rx_rollover_ind);
1271 dev_dbg(adapter->dev, "info: RECV DATA: <Rd: %#x, Wr: %#x>\n",
1272 card->rxbd_rdptr, wrptr);
1274 tx_val = card->txbd_wrptr & reg->tx_wrap_mask;
1275 /* Write the RX ring read pointer in to reg->rx_rdptr */
1276 if (mwifiex_write_reg(adapter, reg->rx_rdptr,
1277 card->rxbd_rdptr | tx_val)) {
1278 dev_err(adapter->dev,
1279 "RECV DATA: failed to write reg->rx_rdptr\n");
1284 /* Read the RX ring Write pointer set by firmware */
1285 if (mwifiex_read_reg(adapter, reg->rx_wrptr, &wrptr)) {
1286 dev_err(adapter->dev,
1287 "RECV DATA: failed to read reg->rx_wrptr\n");
1291 dev_dbg(adapter->dev,
1292 "info: RECV DATA: Rcvd packet from fw successfully\n");
1293 card->rxbd_wrptr = wrptr;
1301 * This function downloads the boot command to device
1304 mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
1307 struct pcie_service_card *card = adapter->card;
1308 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1310 if (!(skb->data && skb->len)) {
1311 dev_err(adapter->dev,
1312 "Invalid parameter in %s <%p. len %d>\n",
1313 __func__, skb->data, skb->len);
1317 if (mwifiex_map_pci_memory(adapter, skb, skb->len , PCI_DMA_TODEVICE))
1320 MWIFIEX_SKB_PACB(skb, &buf_pa);
1322 /* Write the lower 32bits of the physical address to low command
1323 * address scratch register
1325 if (mwifiex_write_reg(adapter, reg->cmd_addr_lo, (u32)buf_pa)) {
1326 dev_err(adapter->dev,
1327 "%s: failed to write download command to boot code.\n",
1329 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1334 /* Write the upper 32bits of the physical address to high command
1335 * address scratch register
1337 if (mwifiex_write_reg(adapter, reg->cmd_addr_hi,
1338 (u32)((u64)buf_pa >> 32))) {
1339 dev_err(adapter->dev,
1340 "%s: failed to write download command to boot code.\n",
1342 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1347 /* Write the command length to cmd_size scratch register */
1348 if (mwifiex_write_reg(adapter, reg->cmd_size, skb->len)) {
1349 dev_err(adapter->dev,
1350 "%s: failed to write command len to cmd_size scratch reg\n",
1352 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1357 /* Ring the door bell */
1358 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1359 CPU_INTR_DOOR_BELL)) {
1360 dev_err(adapter->dev,
1361 "%s: failed to assert door-bell intr\n", __func__);
1362 pci_unmap_single(card->dev, buf_pa,
1363 MWIFIEX_UPLD_SIZE, PCI_DMA_TODEVICE);
1370 /* This function init rx port in firmware which in turn enables to receive data
1371 * from device before transmitting any packet.
1373 static int mwifiex_pcie_init_fw_port(struct mwifiex_adapter *adapter)
1375 struct pcie_service_card *card = adapter->card;
1376 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1377 int tx_wrap = card->txbd_wrptr & reg->tx_wrap_mask;
1379 /* Write the RX ring read pointer in to reg->rx_rdptr */
1380 if (mwifiex_write_reg(adapter, reg->rx_rdptr, card->rxbd_rdptr |
1382 dev_err(adapter->dev,
1383 "RECV DATA: failed to write reg->rx_rdptr\n");
1389 /* This function downloads commands to the device
1392 mwifiex_pcie_send_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
1394 struct pcie_service_card *card = adapter->card;
1395 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1397 dma_addr_t cmd_buf_pa, cmdrsp_buf_pa;
1398 u8 *payload = (u8 *)skb->data;
1400 if (!(skb->data && skb->len)) {
1401 dev_err(adapter->dev, "Invalid parameter in %s <%p, %#x>\n",
1402 __func__, skb->data, skb->len);
1406 /* Make sure a command response buffer is available */
1407 if (!card->cmdrsp_buf) {
1408 dev_err(adapter->dev,
1409 "No response buffer available, send command failed\n");
1413 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1414 mwifiex_pm_wakeup_card(adapter);
1416 adapter->cmd_sent = true;
1418 *(__le16 *)&payload[0] = cpu_to_le16((u16)skb->len);
1419 *(__le16 *)&payload[2] = cpu_to_le16(MWIFIEX_TYPE_CMD);
1421 if (mwifiex_map_pci_memory(adapter, skb, skb->len, PCI_DMA_TODEVICE))
1424 card->cmd_buf = skb;
1426 /* To send a command, the driver will:
1427 1. Write the 64bit physical address of the data buffer to
1428 cmd response address low + cmd response address high
1429 2. Ring the door bell (i.e. set the door bell interrupt)
1431 In response to door bell interrupt, the firmware will perform
1432 the DMA of the command packet (first header to obtain the total
1433 length and then rest of the command).
1436 if (card->cmdrsp_buf) {
1437 MWIFIEX_SKB_PACB(card->cmdrsp_buf, &cmdrsp_buf_pa);
1438 /* Write the lower 32bits of the cmdrsp buffer physical
1440 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo,
1441 (u32)cmdrsp_buf_pa)) {
1442 dev_err(adapter->dev,
1443 "Failed to write download cmd to boot code.\n");
1447 /* Write the upper 32bits of the cmdrsp buffer physical
1449 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi,
1450 (u32)((u64)cmdrsp_buf_pa >> 32))) {
1451 dev_err(adapter->dev,
1452 "Failed to write download cmd to boot code.\n");
1458 MWIFIEX_SKB_PACB(card->cmd_buf, &cmd_buf_pa);
1459 /* Write the lower 32bits of the physical address to reg->cmd_addr_lo */
1460 if (mwifiex_write_reg(adapter, reg->cmd_addr_lo,
1462 dev_err(adapter->dev,
1463 "Failed to write download cmd to boot code.\n");
1467 /* Write the upper 32bits of the physical address to reg->cmd_addr_hi */
1468 if (mwifiex_write_reg(adapter, reg->cmd_addr_hi,
1469 (u32)((u64)cmd_buf_pa >> 32))) {
1470 dev_err(adapter->dev,
1471 "Failed to write download cmd to boot code.\n");
1476 /* Write the command length to reg->cmd_size */
1477 if (mwifiex_write_reg(adapter, reg->cmd_size,
1478 card->cmd_buf->len)) {
1479 dev_err(adapter->dev,
1480 "Failed to write cmd len to reg->cmd_size\n");
1485 /* Ring the door bell */
1486 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1487 CPU_INTR_DOOR_BELL)) {
1488 dev_err(adapter->dev,
1489 "Failed to assert door-bell intr\n");
1496 adapter->cmd_sent = false;
1502 * This function handles command complete interrupt
1504 static int mwifiex_pcie_process_cmd_complete(struct mwifiex_adapter *adapter)
1506 struct pcie_service_card *card = adapter->card;
1507 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1508 struct sk_buff *skb = card->cmdrsp_buf;
1514 dev_dbg(adapter->dev, "info: Rx CMD Response\n");
1516 MWIFIEX_SKB_PACB(skb, &buf_pa);
1517 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1518 PCI_DMA_FROMDEVICE);
1520 pkt_len = *((__le16 *)skb->data);
1521 rx_len = le16_to_cpu(pkt_len);
1522 skb_trim(skb, rx_len);
1523 skb_pull(skb, INTF_HEADER_LEN);
1525 if (!adapter->curr_cmd) {
1526 if (adapter->ps_state == PS_STATE_SLEEP_CFM) {
1527 mwifiex_process_sleep_confirm_resp(adapter, skb->data,
1529 while (reg->sleep_cookie && (count++ < 10) &&
1530 mwifiex_pcie_ok_to_access_hw(adapter))
1531 usleep_range(50, 60);
1533 dev_err(adapter->dev,
1534 "There is no command but got cmdrsp\n");
1536 memcpy(adapter->upld_buf, skb->data,
1537 min_t(u32, MWIFIEX_SIZE_OF_CMD_BUFFER, skb->len));
1538 skb_push(skb, INTF_HEADER_LEN);
1539 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1540 PCI_DMA_FROMDEVICE))
1543 MWIFIEX_SKB_PACB(skb, &buf_pa);
1544 } else if (mwifiex_pcie_ok_to_access_hw(adapter)) {
1545 adapter->curr_cmd->resp_skb = skb;
1546 adapter->cmd_resp_received = true;
1547 /* Take the pointer and set it to CMD node and will
1548 return in the response complete callback */
1549 card->cmdrsp_buf = NULL;
1551 /* Clear the cmd-rsp buffer address in scratch registers. This
1552 will prevent firmware from writing to the same response
1554 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo, 0)) {
1555 dev_err(adapter->dev,
1556 "cmd_done: failed to clear cmd_rsp_addr_lo\n");
1559 /* Write the upper 32bits of the cmdrsp buffer physical
1561 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi, 0)) {
1562 dev_err(adapter->dev,
1563 "cmd_done: failed to clear cmd_rsp_addr_hi\n");
1572 * Command Response processing complete handler
1574 static int mwifiex_pcie_cmdrsp_complete(struct mwifiex_adapter *adapter,
1575 struct sk_buff *skb)
1577 struct pcie_service_card *card = adapter->card;
1579 struct sk_buff *skb_tmp;
1582 card->cmdrsp_buf = skb;
1583 skb_push(card->cmdrsp_buf, INTF_HEADER_LEN);
1584 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1585 PCI_DMA_FROMDEVICE))
1589 skb_tmp = card->cmd_buf;
1591 MWIFIEX_SKB_PACB(skb_tmp, &buf_pa);
1592 pci_unmap_single(card->dev, buf_pa, skb_tmp->len,
1593 PCI_DMA_FROMDEVICE);
1594 card->cmd_buf = NULL;
1601 * This function handles firmware event ready interrupt
1603 static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter *adapter)
1605 struct pcie_service_card *card = adapter->card;
1606 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1607 u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1610 struct mwifiex_evt_buf_desc *desc;
1612 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1613 mwifiex_pm_wakeup_card(adapter);
1615 if (adapter->event_received) {
1616 dev_dbg(adapter->dev, "info: Event being processed, "
1617 "do not process this interrupt just yet\n");
1621 if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1622 dev_dbg(adapter->dev, "info: Invalid read pointer...\n");
1626 /* Read the event ring write pointer set by firmware */
1627 if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1628 dev_err(adapter->dev,
1629 "EventReady: failed to read reg->evt_wrptr\n");
1633 dev_dbg(adapter->dev, "info: EventReady: Initial <Rd: 0x%x, Wr: 0x%x>",
1634 card->evtbd_rdptr, wrptr);
1635 if (((wrptr & MWIFIEX_EVTBD_MASK) != (card->evtbd_rdptr
1636 & MWIFIEX_EVTBD_MASK)) ||
1637 ((wrptr & reg->evt_rollover_ind) ==
1638 (card->evtbd_rdptr & reg->evt_rollover_ind))) {
1639 struct sk_buff *skb_cmd;
1640 __le16 data_len = 0;
1643 dev_dbg(adapter->dev, "info: Read Index: %d\n", rdptr);
1644 skb_cmd = card->evt_buf_list[rdptr];
1645 MWIFIEX_SKB_PACB(skb_cmd, &buf_pa);
1646 pci_unmap_single(card->dev, buf_pa, MAX_EVENT_SIZE,
1647 PCI_DMA_FROMDEVICE);
1649 /* Take the pointer and set it to event pointer in adapter
1650 and will return back after event handling callback */
1651 card->evt_buf_list[rdptr] = NULL;
1652 desc = card->evtbd_ring[rdptr];
1653 memset(desc, 0, sizeof(*desc));
1655 event = *(u32 *) &skb_cmd->data[INTF_HEADER_LEN];
1656 adapter->event_cause = event;
1657 /* The first 4bytes will be the event transfer header
1658 len is 2 bytes followed by type which is 2 bytes */
1659 memcpy(&data_len, skb_cmd->data, sizeof(__le16));
1660 evt_len = le16_to_cpu(data_len);
1662 skb_pull(skb_cmd, INTF_HEADER_LEN);
1663 dev_dbg(adapter->dev, "info: Event length: %d\n", evt_len);
1665 if ((evt_len > 0) && (evt_len < MAX_EVENT_SIZE))
1666 memcpy(adapter->event_body, skb_cmd->data +
1667 MWIFIEX_EVENT_HEADER_LEN, evt_len -
1668 MWIFIEX_EVENT_HEADER_LEN);
1670 adapter->event_received = true;
1671 adapter->event_skb = skb_cmd;
1673 /* Do not update the event read pointer here, wait till the
1674 buffer is released. This is just to make things simpler,
1675 we need to find a better method of managing these buffers.
1683 * Event processing complete handler
1685 static int mwifiex_pcie_event_complete(struct mwifiex_adapter *adapter,
1686 struct sk_buff *skb)
1688 struct pcie_service_card *card = adapter->card;
1689 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1691 u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1694 struct mwifiex_evt_buf_desc *desc;
1699 if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1700 dev_err(adapter->dev, "event_complete: Invalid rdptr 0x%x\n",
1705 /* Read the event ring write pointer set by firmware */
1706 if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1707 dev_err(adapter->dev,
1708 "event_complete: failed to read reg->evt_wrptr\n");
1712 if (!card->evt_buf_list[rdptr]) {
1713 skb_push(skb, INTF_HEADER_LEN);
1714 if (mwifiex_map_pci_memory(adapter, skb,
1716 PCI_DMA_FROMDEVICE))
1718 MWIFIEX_SKB_PACB(skb, &buf_pa);
1719 card->evt_buf_list[rdptr] = skb;
1720 MWIFIEX_SKB_PACB(skb, &buf_pa);
1721 desc = card->evtbd_ring[rdptr];
1722 desc->paddr = buf_pa;
1723 desc->len = (u16)skb->len;
1727 dev_dbg(adapter->dev,
1728 "info: ERROR: buf still valid at index %d, <%p, %p>\n",
1729 rdptr, card->evt_buf_list[rdptr], skb);
1732 if ((++card->evtbd_rdptr & MWIFIEX_EVTBD_MASK) == MWIFIEX_MAX_EVT_BD) {
1733 card->evtbd_rdptr = ((card->evtbd_rdptr &
1734 reg->evt_rollover_ind) ^
1735 reg->evt_rollover_ind);
1738 dev_dbg(adapter->dev, "info: Updated <Rd: 0x%x, Wr: 0x%x>",
1739 card->evtbd_rdptr, wrptr);
1741 /* Write the event ring read pointer in to reg->evt_rdptr */
1742 if (mwifiex_write_reg(adapter, reg->evt_rdptr,
1743 card->evtbd_rdptr)) {
1744 dev_err(adapter->dev,
1745 "event_complete: failed to read reg->evt_rdptr\n");
1749 dev_dbg(adapter->dev, "info: Check Events Again\n");
1750 ret = mwifiex_pcie_process_event_ready(adapter);
1756 * This function downloads the firmware to the card.
1758 * Firmware is downloaded to the card in blocks. Every block download
1759 * is tested for CRC errors, and retried a number of times before
1760 * returning failure.
1762 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter *adapter,
1763 struct mwifiex_fw_image *fw)
1766 u8 *firmware = fw->fw_buf;
1767 u32 firmware_len = fw->fw_len;
1769 struct sk_buff *skb;
1770 u32 txlen, tx_blocks = 0, tries, len;
1771 u32 block_retry_cnt = 0;
1773 struct pcie_service_card *card = adapter->card;
1774 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1776 if (!firmware || !firmware_len) {
1777 dev_err(adapter->dev,
1778 "No firmware image found! Terminating download\n");
1782 dev_dbg(adapter->dev, "info: Downloading FW image (%d bytes)\n",
1785 if (mwifiex_pcie_disable_host_int(adapter)) {
1786 dev_err(adapter->dev,
1787 "%s: Disabling interrupts failed.\n", __func__);
1791 skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
1797 /* Perform firmware data transfer */
1802 if (offset >= firmware_len)
1805 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
1806 ret = mwifiex_read_reg(adapter, reg->cmd_size,
1809 dev_warn(adapter->dev,
1810 "Failed reading len from boot code\n");
1815 usleep_range(10, 20);
1820 } else if (len > MWIFIEX_UPLD_SIZE) {
1821 pr_err("FW download failure @ %d, invalid length %d\n",
1831 if (block_retry_cnt > MAX_WRITE_IOMEM_RETRY) {
1832 pr_err("FW download failure @ %d, over max "
1833 "retry count\n", offset);
1837 dev_err(adapter->dev, "FW CRC error indicated by the "
1838 "helper: len = 0x%04X, txlen = %d\n",
1841 /* Setting this to 0 to resend from same offset */
1844 block_retry_cnt = 0;
1845 /* Set blocksize to transfer - checking for
1847 if (firmware_len - offset < txlen)
1848 txlen = firmware_len - offset;
1850 dev_dbg(adapter->dev, ".");
1852 tx_blocks = (txlen + card->pcie.blksz_fw_dl - 1) /
1853 card->pcie.blksz_fw_dl;
1855 /* Copy payload to buffer */
1856 memmove(skb->data, &firmware[offset], txlen);
1859 skb_put(skb, MWIFIEX_UPLD_SIZE - skb->len);
1860 skb_trim(skb, tx_blocks * card->pcie.blksz_fw_dl);
1862 /* Send the boot command to device */
1863 if (mwifiex_pcie_send_boot_cmd(adapter, skb)) {
1864 dev_err(adapter->dev,
1865 "Failed to send firmware download command\n");
1870 MWIFIEX_SKB_PACB(skb, &buf_pa);
1872 /* Wait for the command done interrupt */
1874 if (mwifiex_read_reg(adapter, PCIE_CPU_INT_STATUS,
1876 dev_err(adapter->dev, "%s: Failed to read "
1877 "interrupt status during fw dnld.\n",
1879 pci_unmap_single(card->dev, buf_pa, skb->len,
1884 } while ((ireg_intr & CPU_INTR_DOOR_BELL) ==
1885 CPU_INTR_DOOR_BELL);
1887 pci_unmap_single(card->dev, buf_pa, skb->len,
1893 dev_dbg(adapter->dev, "info:\nFW download over, size %d bytes\n",
1899 dev_kfree_skb_any(skb);
1904 * This function checks the firmware status in card.
1906 * The winner interface is also determined by this function.
1909 mwifiex_check_fw_status(struct mwifiex_adapter *adapter, u32 poll_num)
1912 u32 firmware_stat, winner_status;
1913 struct pcie_service_card *card = adapter->card;
1914 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1917 /* Mask spurios interrupts */
1918 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS_MASK,
1920 dev_warn(adapter->dev, "Write register failed\n");
1924 dev_dbg(adapter->dev, "Setting driver ready signature\n");
1925 if (mwifiex_write_reg(adapter, reg->drv_rdy,
1926 FIRMWARE_READY_PCIE)) {
1927 dev_err(adapter->dev,
1928 "Failed to write driver ready signature\n");
1932 /* Wait for firmware initialization event */
1933 for (tries = 0; tries < poll_num; tries++) {
1934 if (mwifiex_read_reg(adapter, reg->fw_status,
1941 if (firmware_stat == FIRMWARE_READY_PCIE) {
1951 if (mwifiex_read_reg(adapter, reg->fw_status,
1954 else if (!winner_status) {
1955 dev_err(adapter->dev, "PCI-E is the winner\n");
1956 adapter->winner = 1;
1958 dev_err(adapter->dev,
1959 "PCI-E is not the winner <%#x,%d>, exit dnld\n",
1960 ret, adapter->winner);
1968 * This function reads the interrupt status from card.
1970 static void mwifiex_interrupt_status(struct mwifiex_adapter *adapter)
1973 unsigned long flags;
1975 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1978 if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS, &pcie_ireg)) {
1979 dev_warn(adapter->dev, "Read register failed\n");
1983 if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
1985 mwifiex_pcie_disable_host_int(adapter);
1987 /* Clear the pending interrupts */
1988 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS,
1990 dev_warn(adapter->dev, "Write register failed\n");
1993 spin_lock_irqsave(&adapter->int_lock, flags);
1994 adapter->int_status |= pcie_ireg;
1995 spin_unlock_irqrestore(&adapter->int_lock, flags);
1997 if (pcie_ireg & HOST_INTR_CMD_DONE) {
1998 if ((adapter->ps_state == PS_STATE_SLEEP_CFM) ||
1999 (adapter->ps_state == PS_STATE_SLEEP)) {
2000 mwifiex_pcie_enable_host_int(adapter);
2001 if (mwifiex_write_reg(adapter,
2003 CPU_INTR_SLEEP_CFM_DONE)
2005 dev_warn(adapter->dev,
2006 "Write register failed\n");
2011 } else if (!adapter->pps_uapsd_mode &&
2012 adapter->ps_state == PS_STATE_SLEEP &&
2013 mwifiex_pcie_ok_to_access_hw(adapter)) {
2014 /* Potentially for PCIe we could get other
2015 * interrupts like shared. Don't change power
2016 * state until cookie is set */
2017 adapter->ps_state = PS_STATE_AWAKE;
2018 adapter->pm_wakeup_fw_try = false;
2024 * Interrupt handler for PCIe root port
2026 * This function reads the interrupt status from firmware and assigns
2027 * the main process in workqueue which will handle the interrupt.
2029 static irqreturn_t mwifiex_pcie_interrupt(int irq, void *context)
2031 struct pci_dev *pdev = (struct pci_dev *)context;
2032 struct pcie_service_card *card;
2033 struct mwifiex_adapter *adapter;
2036 pr_debug("info: %s: pdev is NULL\n", (u8 *)pdev);
2040 card = pci_get_drvdata(pdev);
2041 if (!card || !card->adapter) {
2042 pr_debug("info: %s: card=%p adapter=%p\n", __func__, card,
2043 card ? card->adapter : NULL);
2046 adapter = card->adapter;
2048 if (adapter->surprise_removed)
2051 mwifiex_interrupt_status(adapter);
2052 queue_work(adapter->workqueue, &adapter->main_work);
2059 * This function checks the current interrupt status.
2061 * The following interrupts are checked and handled by this function -
2064 * - Command received
2065 * - Packets received
2068 * In case of Rx packets received, the packets are uploaded from card to
2069 * host and processed accordingly.
2071 static int mwifiex_process_int_status(struct mwifiex_adapter *adapter)
2075 unsigned long flags;
2077 spin_lock_irqsave(&adapter->int_lock, flags);
2078 /* Clear out unused interrupts */
2079 pcie_ireg = adapter->int_status;
2080 adapter->int_status = 0;
2081 spin_unlock_irqrestore(&adapter->int_lock, flags);
2083 while (pcie_ireg & HOST_INTR_MASK) {
2084 if (pcie_ireg & HOST_INTR_DNLD_DONE) {
2085 pcie_ireg &= ~HOST_INTR_DNLD_DONE;
2086 dev_dbg(adapter->dev, "info: TX DNLD Done\n");
2087 ret = mwifiex_pcie_send_data_complete(adapter);
2091 if (pcie_ireg & HOST_INTR_UPLD_RDY) {
2092 pcie_ireg &= ~HOST_INTR_UPLD_RDY;
2093 dev_dbg(adapter->dev, "info: Rx DATA\n");
2094 ret = mwifiex_pcie_process_recv_data(adapter);
2098 if (pcie_ireg & HOST_INTR_EVENT_RDY) {
2099 pcie_ireg &= ~HOST_INTR_EVENT_RDY;
2100 dev_dbg(adapter->dev, "info: Rx EVENT\n");
2101 ret = mwifiex_pcie_process_event_ready(adapter);
2106 if (pcie_ireg & HOST_INTR_CMD_DONE) {
2107 pcie_ireg &= ~HOST_INTR_CMD_DONE;
2108 if (adapter->cmd_sent) {
2109 dev_dbg(adapter->dev,
2110 "info: CMD sent Interrupt\n");
2111 adapter->cmd_sent = false;
2113 /* Handle command response */
2114 ret = mwifiex_pcie_process_cmd_complete(adapter);
2119 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
2120 if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS,
2122 dev_warn(adapter->dev,
2123 "Read register failed\n");
2127 if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
2128 if (mwifiex_write_reg(adapter,
2129 PCIE_HOST_INT_STATUS,
2131 dev_warn(adapter->dev,
2132 "Write register failed\n");
2139 dev_dbg(adapter->dev, "info: cmd_sent=%d data_sent=%d\n",
2140 adapter->cmd_sent, adapter->data_sent);
2141 if (adapter->ps_state != PS_STATE_SLEEP)
2142 mwifiex_pcie_enable_host_int(adapter);
2148 * This function downloads data from driver to card.
2150 * Both commands and data packets are transferred to the card by this
2153 * This function adds the PCIE specific header to the front of the buffer
2154 * before transferring. The header contains the length of the packet and
2155 * the type. The firmware handles the packets based upon this set type.
2157 static int mwifiex_pcie_host_to_card(struct mwifiex_adapter *adapter, u8 type,
2158 struct sk_buff *skb,
2159 struct mwifiex_tx_param *tx_param)
2162 dev_err(adapter->dev, "Passed NULL skb to %s\n", __func__);
2166 if (type == MWIFIEX_TYPE_DATA)
2167 return mwifiex_pcie_send_data(adapter, skb, tx_param);
2168 else if (type == MWIFIEX_TYPE_CMD)
2169 return mwifiex_pcie_send_cmd(adapter, skb);
2175 * This function initializes the PCI-E host memory space, WCB rings, etc.
2177 * The following initializations steps are followed -
2178 * - Allocate TXBD ring buffers
2179 * - Allocate RXBD ring buffers
2180 * - Allocate event BD ring buffers
2181 * - Allocate command response ring buffer
2182 * - Allocate sleep cookie buffer
2184 static int mwifiex_pcie_init(struct mwifiex_adapter *adapter)
2186 struct pcie_service_card *card = adapter->card;
2188 struct pci_dev *pdev = card->dev;
2189 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2191 pci_set_drvdata(pdev, card);
2193 ret = pci_enable_device(pdev);
2195 goto err_enable_dev;
2197 pci_set_master(pdev);
2199 dev_dbg(adapter->dev, "try set_consistent_dma_mask(32)\n");
2200 ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2202 dev_err(adapter->dev, "set_dma_mask(32) failed\n");
2203 goto err_set_dma_mask;
2206 ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
2208 dev_err(adapter->dev, "set_consistent_dma_mask(64) failed\n");
2209 goto err_set_dma_mask;
2212 ret = pci_request_region(pdev, 0, DRV_NAME);
2214 dev_err(adapter->dev, "req_reg(0) error\n");
2215 goto err_req_region0;
2217 card->pci_mmap = pci_iomap(pdev, 0, 0);
2218 if (!card->pci_mmap) {
2219 dev_err(adapter->dev, "iomap(0) error\n");
2223 ret = pci_request_region(pdev, 2, DRV_NAME);
2225 dev_err(adapter->dev, "req_reg(2) error\n");
2226 goto err_req_region2;
2228 card->pci_mmap1 = pci_iomap(pdev, 2, 0);
2229 if (!card->pci_mmap1) {
2230 dev_err(adapter->dev, "iomap(2) error\n");
2235 dev_dbg(adapter->dev,
2236 "PCI memory map Virt0: %p PCI memory map Virt2: %p\n",
2237 card->pci_mmap, card->pci_mmap1);
2239 card->cmdrsp_buf = NULL;
2240 ret = mwifiex_pcie_create_txbd_ring(adapter);
2243 ret = mwifiex_pcie_create_rxbd_ring(adapter);
2246 ret = mwifiex_pcie_create_evtbd_ring(adapter);
2249 ret = mwifiex_pcie_alloc_cmdrsp_buf(adapter);
2251 goto err_alloc_cmdbuf;
2252 if (reg->sleep_cookie) {
2253 ret = mwifiex_pcie_alloc_sleep_cookie_buf(adapter);
2255 goto err_alloc_cookie;
2257 card->sleep_cookie_vbase = NULL;
2262 mwifiex_pcie_delete_cmdrsp_buf(adapter);
2264 mwifiex_pcie_delete_evtbd_ring(adapter);
2266 mwifiex_pcie_delete_rxbd_ring(adapter);
2268 mwifiex_pcie_delete_txbd_ring(adapter);
2270 pci_iounmap(pdev, card->pci_mmap1);
2272 pci_release_region(pdev, 2);
2274 pci_iounmap(pdev, card->pci_mmap);
2276 pci_release_region(pdev, 0);
2279 pci_disable_device(pdev);
2281 pci_set_drvdata(pdev, NULL);
2286 * This function cleans up the allocated card buffers.
2288 * The following are freed by this function -
2289 * - TXBD ring buffers
2290 * - RXBD ring buffers
2291 * - Event BD ring buffers
2292 * - Command response ring buffer
2293 * - Sleep cookie buffer
2295 static void mwifiex_pcie_cleanup(struct mwifiex_adapter *adapter)
2297 struct pcie_service_card *card = adapter->card;
2298 struct pci_dev *pdev = card->dev;
2299 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2302 dev_dbg(adapter->dev, "Clearing driver ready signature\n");
2303 if (mwifiex_write_reg(adapter, reg->drv_rdy, 0x00000000))
2304 dev_err(adapter->dev,
2305 "Failed to write driver not-ready signature\n");
2309 pci_iounmap(pdev, card->pci_mmap);
2310 pci_iounmap(pdev, card->pci_mmap1);
2311 pci_disable_device(pdev);
2312 pci_release_region(pdev, 2);
2313 pci_release_region(pdev, 0);
2314 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);