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;
39 static int mwifiex_pcie_enable_host_int(struct mwifiex_adapter *adapter);
40 static int mwifiex_pcie_resume(struct pci_dev *pdev);
43 mwifiex_map_pci_memory(struct mwifiex_adapter *adapter, struct sk_buff *skb,
46 struct pcie_service_card *card = adapter->card;
49 buf_pa = pci_map_single(card->dev, skb->data, size, flags);
50 if (pci_dma_mapping_error(card->dev, buf_pa)) {
51 dev_err(adapter->dev, "failed to map pci memory!\n");
54 memcpy(skb->cb, &buf_pa, sizeof(dma_addr_t));
59 * This function reads sleep cookie and checks if FW is ready
61 static bool mwifiex_pcie_ok_to_access_hw(struct mwifiex_adapter *adapter)
64 struct pcie_service_card *card = adapter->card;
65 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
67 if (!reg->sleep_cookie)
70 if (card->sleep_cookie_vbase) {
71 cookie_addr = (u32 *)card->sleep_cookie_vbase;
72 dev_dbg(adapter->dev, "info: ACCESS_HW: sleep cookie=0x%x\n",
74 if (*cookie_addr == FW_AWAKE_COOKIE)
82 * This function probes an mwifiex device and registers it. It allocates
83 * the card structure, enables PCIE function number and initiates the
84 * device registration and initialization procedure by adding a logical
87 static int mwifiex_pcie_probe(struct pci_dev *pdev,
88 const struct pci_device_id *ent)
90 struct pcie_service_card *card;
92 pr_debug("info: vendor=0x%4.04X device=0x%4.04X rev=%d\n",
93 pdev->vendor, pdev->device, pdev->revision);
95 card = kzalloc(sizeof(struct pcie_service_card), GFP_KERNEL);
101 if (ent->driver_data) {
102 struct mwifiex_pcie_device *data = (void *)ent->driver_data;
103 card->pcie.firmware = data->firmware;
104 card->pcie.reg = data->reg;
105 card->pcie.blksz_fw_dl = data->blksz_fw_dl;
108 if (mwifiex_add_card(card, &add_remove_card_sem, &pcie_ops,
110 pr_err("%s failed\n", __func__);
119 * This function removes the interface and frees up the card structure.
121 static void mwifiex_pcie_remove(struct pci_dev *pdev)
123 struct pcie_service_card *card;
124 struct mwifiex_adapter *adapter;
125 struct mwifiex_private *priv;
128 card = pci_get_drvdata(pdev);
132 adapter = card->adapter;
133 if (!adapter || !adapter->priv_num)
136 /* In case driver is removed when asynchronous FW load is in progress */
137 wait_for_completion(&adapter->fw_load);
141 if (adapter->is_suspended)
142 mwifiex_pcie_resume(pdev);
145 for (i = 0; i < adapter->priv_num; i++)
146 if ((GET_BSS_ROLE(adapter->priv[i]) ==
147 MWIFIEX_BSS_ROLE_STA) &&
148 adapter->priv[i]->media_connected)
149 mwifiex_deauthenticate(adapter->priv[i], NULL);
151 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
153 mwifiex_disable_auto_ds(priv);
155 mwifiex_init_shutdown_fw(priv, MWIFIEX_FUNC_SHUTDOWN);
158 mwifiex_remove_card(card->adapter, &add_remove_card_sem);
163 * Kernel needs to suspend all functions separately. Therefore all
164 * registered functions must have drivers with suspend and resume
165 * methods. Failing that the kernel simply removes the whole card.
167 * If already not suspended, this function allocates and sends a host
168 * sleep activate request to the firmware and turns off the traffic.
170 static int mwifiex_pcie_suspend(struct pci_dev *pdev, pm_message_t state)
172 struct mwifiex_adapter *adapter;
173 struct pcie_service_card *card;
177 card = (struct pcie_service_card *) pci_get_drvdata(pdev);
178 if (!card || !card->adapter) {
179 pr_err("Card or adapter structure is not valid\n");
183 pr_err("PCIE device is not specified\n");
187 adapter = card->adapter;
189 hs_actived = mwifiex_enable_hs(adapter);
191 /* Indicate device suspended */
192 adapter->is_suspended = true;
198 * Kernel needs to suspend all functions separately. Therefore all
199 * registered functions must have drivers with suspend and resume
200 * methods. Failing that the kernel simply removes the whole card.
202 * If already not resumed, this function turns on the traffic and
203 * sends a host sleep cancel request to the firmware.
205 static int mwifiex_pcie_resume(struct pci_dev *pdev)
207 struct mwifiex_adapter *adapter;
208 struct pcie_service_card *card;
211 card = (struct pcie_service_card *) pci_get_drvdata(pdev);
212 if (!card || !card->adapter) {
213 pr_err("Card or adapter structure is not valid\n");
217 pr_err("PCIE device is not specified\n");
221 adapter = card->adapter;
223 if (!adapter->is_suspended) {
224 dev_warn(adapter->dev, "Device already resumed\n");
228 adapter->is_suspended = false;
230 mwifiex_cancel_hs(mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA),
236 static DEFINE_PCI_DEVICE_TABLE(mwifiex_ids) = {
238 PCIE_VENDOR_ID_MARVELL, PCIE_DEVICE_ID_MARVELL_88W8766P,
239 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
240 .driver_data = (unsigned long) &mwifiex_pcie8766,
243 PCIE_VENDOR_ID_MARVELL, PCIE_DEVICE_ID_MARVELL_88W8897,
244 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
245 .driver_data = (unsigned long) &mwifiex_pcie8897,
250 MODULE_DEVICE_TABLE(pci, mwifiex_ids);
252 /* PCI Device Driver */
253 static struct pci_driver __refdata mwifiex_pcie = {
254 .name = "mwifiex_pcie",
255 .id_table = mwifiex_ids,
256 .probe = mwifiex_pcie_probe,
257 .remove = mwifiex_pcie_remove,
259 /* Power Management Hooks */
260 .suspend = mwifiex_pcie_suspend,
261 .resume = mwifiex_pcie_resume,
266 * This function writes data into PCIE card register.
268 static int mwifiex_write_reg(struct mwifiex_adapter *adapter, int reg, u32 data)
270 struct pcie_service_card *card = adapter->card;
272 iowrite32(data, card->pci_mmap1 + reg);
278 * This function reads data from PCIE card register.
280 static int mwifiex_read_reg(struct mwifiex_adapter *adapter, int reg, u32 *data)
282 struct pcie_service_card *card = adapter->card;
284 *data = ioread32(card->pci_mmap1 + reg);
290 * This function wakes up the card.
292 * A host power up command is written to the card configuration
293 * register to wake up the card.
295 static int mwifiex_pm_wakeup_card(struct mwifiex_adapter *adapter)
298 struct pcie_service_card *card = adapter->card;
299 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
301 while (reg->sleep_cookie && mwifiex_pcie_ok_to_access_hw(adapter)) {
303 usleep_range(10, 20);
309 dev_dbg(adapter->dev, "event: Wakeup device...\n");
311 /* Enable interrupts or any chip access will wakeup device */
312 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK, HOST_INTR_MASK)) {
313 dev_warn(adapter->dev, "Enable host interrupt failed\n");
317 dev_dbg(adapter->dev, "PCIE wakeup: Setting PS_STATE_AWAKE\n");
318 adapter->ps_state = PS_STATE_AWAKE;
324 * This function is called after the card has woken up.
326 * The card configuration register is reset.
328 static int mwifiex_pm_wakeup_card_complete(struct mwifiex_adapter *adapter)
330 dev_dbg(adapter->dev, "cmd: Wakeup device completed\n");
336 * This function disables the host interrupt.
338 * The host interrupt mask is read, the disable bit is reset and
339 * written back to the card host interrupt mask register.
341 static int mwifiex_pcie_disable_host_int(struct mwifiex_adapter *adapter)
343 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
344 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK,
346 dev_warn(adapter->dev, "Disable host interrupt failed\n");
355 * This function enables the host interrupt.
357 * The host interrupt enable mask is written to the card
358 * host interrupt mask register.
360 static int mwifiex_pcie_enable_host_int(struct mwifiex_adapter *adapter)
362 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
363 /* Simply write the mask to the register */
364 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK,
366 dev_warn(adapter->dev, "Enable host interrupt failed\n");
375 * This function initializes TX buffer ring descriptors
377 static int mwifiex_init_txq_ring(struct mwifiex_adapter *adapter)
379 struct pcie_service_card *card = adapter->card;
380 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
381 struct mwifiex_pcie_buf_desc *desc;
382 struct mwifiex_pfu_buf_desc *desc2;
385 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
386 card->tx_buf_list[i] = NULL;
387 if (reg->pfu_enabled) {
388 card->txbd_ring[i] = (void *)card->txbd_ring_vbase +
389 (sizeof(*desc2) * i);
390 desc2 = card->txbd_ring[i];
391 memset(desc2, 0, sizeof(*desc2));
393 card->txbd_ring[i] = (void *)card->txbd_ring_vbase +
395 desc = card->txbd_ring[i];
396 memset(desc, 0, sizeof(*desc));
403 /* This function initializes RX buffer ring descriptors. Each SKB is allocated
404 * here and after mapping PCI memory, its physical address is assigned to
405 * PCIE Rx buffer descriptor's physical address.
407 static int mwifiex_init_rxq_ring(struct mwifiex_adapter *adapter)
409 struct pcie_service_card *card = adapter->card;
410 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
412 struct mwifiex_pcie_buf_desc *desc;
413 struct mwifiex_pfu_buf_desc *desc2;
417 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
418 /* Allocate skb here so that firmware can DMA data from it */
419 skb = dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE);
421 dev_err(adapter->dev,
422 "Unable to allocate skb for RX ring.\n");
423 kfree(card->rxbd_ring_vbase);
427 if (mwifiex_map_pci_memory(adapter, skb,
428 MWIFIEX_RX_DATA_BUF_SIZE,
432 MWIFIEX_SKB_PACB(skb, &buf_pa);
434 dev_dbg(adapter->dev,
435 "info: RX ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
436 skb, skb->len, skb->data, (u32)buf_pa,
437 (u32)((u64)buf_pa >> 32));
439 card->rx_buf_list[i] = skb;
440 if (reg->pfu_enabled) {
441 card->rxbd_ring[i] = (void *)card->rxbd_ring_vbase +
442 (sizeof(*desc2) * i);
443 desc2 = card->rxbd_ring[i];
444 desc2->paddr = buf_pa;
445 desc2->len = (u16)skb->len;
446 desc2->frag_len = (u16)skb->len;
447 desc2->flags = reg->ring_flag_eop | reg->ring_flag_sop;
450 card->rxbd_ring[i] = (void *)(card->rxbd_ring_vbase +
451 (sizeof(*desc) * i));
452 desc = card->rxbd_ring[i];
453 desc->paddr = buf_pa;
454 desc->len = (u16)skb->len;
462 /* This function initializes event buffer ring descriptors. Each SKB is
463 * allocated here and after mapping PCI memory, its physical address is assigned
464 * to PCIE Rx buffer descriptor's physical address
466 static int mwifiex_pcie_init_evt_ring(struct mwifiex_adapter *adapter)
468 struct pcie_service_card *card = adapter->card;
469 struct mwifiex_evt_buf_desc *desc;
474 for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) {
475 /* Allocate skb here so that firmware can DMA data from it */
476 skb = dev_alloc_skb(MAX_EVENT_SIZE);
478 dev_err(adapter->dev,
479 "Unable to allocate skb for EVENT buf.\n");
480 kfree(card->evtbd_ring_vbase);
483 skb_put(skb, MAX_EVENT_SIZE);
485 if (mwifiex_map_pci_memory(adapter, skb, MAX_EVENT_SIZE,
489 MWIFIEX_SKB_PACB(skb, &buf_pa);
491 dev_dbg(adapter->dev,
492 "info: EVT ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
493 skb, skb->len, skb->data, (u32)buf_pa,
494 (u32)((u64)buf_pa >> 32));
496 card->evt_buf_list[i] = skb;
497 card->evtbd_ring[i] = (void *)(card->evtbd_ring_vbase +
498 (sizeof(*desc) * i));
499 desc = card->evtbd_ring[i];
500 desc->paddr = buf_pa;
501 desc->len = (u16)skb->len;
508 /* This function cleans up TX buffer rings. If any of the buffer list has valid
509 * SKB address, associated SKB is freed.
511 static void mwifiex_cleanup_txq_ring(struct mwifiex_adapter *adapter)
513 struct pcie_service_card *card = adapter->card;
514 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
516 struct mwifiex_pcie_buf_desc *desc;
517 struct mwifiex_pfu_buf_desc *desc2;
520 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
521 if (reg->pfu_enabled) {
522 desc2 = card->txbd_ring[i];
523 if (card->tx_buf_list[i]) {
524 skb = card->tx_buf_list[i];
525 pci_unmap_single(card->dev, desc2->paddr,
526 skb->len, PCI_DMA_TODEVICE);
527 dev_kfree_skb_any(skb);
529 memset(desc2, 0, sizeof(*desc2));
531 desc = card->txbd_ring[i];
532 if (card->tx_buf_list[i]) {
533 skb = card->tx_buf_list[i];
534 pci_unmap_single(card->dev, desc->paddr,
535 skb->len, PCI_DMA_TODEVICE);
536 dev_kfree_skb_any(skb);
538 memset(desc, 0, sizeof(*desc));
540 card->tx_buf_list[i] = NULL;
546 /* This function cleans up RX buffer rings. If any of the buffer list has valid
547 * SKB address, associated SKB is freed.
549 static void mwifiex_cleanup_rxq_ring(struct mwifiex_adapter *adapter)
551 struct pcie_service_card *card = adapter->card;
552 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
553 struct mwifiex_pcie_buf_desc *desc;
554 struct mwifiex_pfu_buf_desc *desc2;
558 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
559 if (reg->pfu_enabled) {
560 desc2 = card->rxbd_ring[i];
561 if (card->rx_buf_list[i]) {
562 skb = card->rx_buf_list[i];
563 pci_unmap_single(card->dev, desc2->paddr,
564 skb->len, PCI_DMA_TODEVICE);
565 dev_kfree_skb_any(skb);
567 memset(desc2, 0, sizeof(*desc2));
569 desc = card->rxbd_ring[i];
570 if (card->rx_buf_list[i]) {
571 skb = card->rx_buf_list[i];
572 pci_unmap_single(card->dev, desc->paddr,
573 skb->len, PCI_DMA_TODEVICE);
574 dev_kfree_skb_any(skb);
576 memset(desc, 0, sizeof(*desc));
578 card->rx_buf_list[i] = NULL;
584 /* This function cleans up event buffer rings. If any of the buffer list has
585 * valid SKB address, associated SKB is freed.
587 static void mwifiex_cleanup_evt_ring(struct mwifiex_adapter *adapter)
589 struct pcie_service_card *card = adapter->card;
590 struct mwifiex_evt_buf_desc *desc;
594 for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) {
595 desc = card->evtbd_ring[i];
596 if (card->evt_buf_list[i]) {
597 skb = card->evt_buf_list[i];
598 pci_unmap_single(card->dev, desc->paddr, MAX_EVENT_SIZE,
600 dev_kfree_skb_any(skb);
602 card->evt_buf_list[i] = NULL;
603 memset(desc, 0, sizeof(*desc));
609 /* This function creates buffer descriptor ring for TX
611 static int mwifiex_pcie_create_txbd_ring(struct mwifiex_adapter *adapter)
613 struct pcie_service_card *card = adapter->card;
614 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
617 * driver maintaines the write pointer and firmware maintaines the read
618 * pointer. The write pointer starts at 0 (zero) while the read pointer
619 * starts at zero with rollover bit set
621 card->txbd_wrptr = 0;
623 if (reg->pfu_enabled)
624 card->txbd_rdptr = 0;
626 card->txbd_rdptr |= reg->tx_rollover_ind;
628 /* allocate shared memory for the BD ring and divide the same in to
629 several descriptors */
630 if (reg->pfu_enabled)
631 card->txbd_ring_size = sizeof(struct mwifiex_pfu_buf_desc) *
634 card->txbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
637 dev_dbg(adapter->dev, "info: txbd_ring: Allocating %d bytes\n",
638 card->txbd_ring_size);
639 card->txbd_ring_vbase = pci_alloc_consistent(card->dev,
640 card->txbd_ring_size,
641 &card->txbd_ring_pbase);
642 if (!card->txbd_ring_vbase) {
643 dev_err(adapter->dev,
644 "allocate consistent memory (%d bytes) failed!\n",
645 card->txbd_ring_size);
648 dev_dbg(adapter->dev,
649 "info: txbd_ring - base: %p, pbase: %#x:%x, len: %x\n",
650 card->txbd_ring_vbase, (unsigned int)card->txbd_ring_pbase,
651 (u32)((u64)card->txbd_ring_pbase >> 32), card->txbd_ring_size);
653 return mwifiex_init_txq_ring(adapter);
656 static int mwifiex_pcie_delete_txbd_ring(struct mwifiex_adapter *adapter)
658 struct pcie_service_card *card = adapter->card;
659 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
661 mwifiex_cleanup_txq_ring(adapter);
663 if (card->txbd_ring_vbase)
664 pci_free_consistent(card->dev, card->txbd_ring_size,
665 card->txbd_ring_vbase,
666 card->txbd_ring_pbase);
667 card->txbd_ring_size = 0;
668 card->txbd_wrptr = 0;
669 card->txbd_rdptr = 0 | reg->tx_rollover_ind;
670 card->txbd_ring_vbase = NULL;
671 card->txbd_ring_pbase = 0;
677 * This function creates buffer descriptor ring for RX
679 static int mwifiex_pcie_create_rxbd_ring(struct mwifiex_adapter *adapter)
681 struct pcie_service_card *card = adapter->card;
682 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
685 * driver maintaines the read pointer and firmware maintaines the write
686 * pointer. The write pointer starts at 0 (zero) while the read pointer
687 * starts at zero with rollover bit set
689 card->rxbd_wrptr = 0;
690 card->rxbd_rdptr = reg->rx_rollover_ind;
692 if (reg->pfu_enabled)
693 card->rxbd_ring_size = sizeof(struct mwifiex_pfu_buf_desc) *
696 card->rxbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
699 dev_dbg(adapter->dev, "info: rxbd_ring: Allocating %d bytes\n",
700 card->rxbd_ring_size);
701 card->rxbd_ring_vbase = pci_alloc_consistent(card->dev,
702 card->rxbd_ring_size,
703 &card->rxbd_ring_pbase);
704 if (!card->rxbd_ring_vbase) {
705 dev_err(adapter->dev,
706 "allocate consistent memory (%d bytes) failed!\n",
707 card->rxbd_ring_size);
711 dev_dbg(adapter->dev,
712 "info: rxbd_ring - base: %p, pbase: %#x:%x, len: %#x\n",
713 card->rxbd_ring_vbase, (u32)card->rxbd_ring_pbase,
714 (u32)((u64)card->rxbd_ring_pbase >> 32),
715 card->rxbd_ring_size);
717 return mwifiex_init_rxq_ring(adapter);
721 * This function deletes Buffer descriptor ring for RX
723 static int mwifiex_pcie_delete_rxbd_ring(struct mwifiex_adapter *adapter)
725 struct pcie_service_card *card = adapter->card;
726 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
728 mwifiex_cleanup_rxq_ring(adapter);
730 if (card->rxbd_ring_vbase)
731 pci_free_consistent(card->dev, card->rxbd_ring_size,
732 card->rxbd_ring_vbase,
733 card->rxbd_ring_pbase);
734 card->rxbd_ring_size = 0;
735 card->rxbd_wrptr = 0;
736 card->rxbd_rdptr = 0 | reg->rx_rollover_ind;
737 card->rxbd_ring_vbase = NULL;
738 card->rxbd_ring_pbase = 0;
744 * This function creates buffer descriptor ring for Events
746 static int mwifiex_pcie_create_evtbd_ring(struct mwifiex_adapter *adapter)
748 struct pcie_service_card *card = adapter->card;
749 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
752 * driver maintaines the read pointer and firmware maintaines the write
753 * pointer. The write pointer starts at 0 (zero) while the read pointer
754 * starts at zero with rollover bit set
756 card->evtbd_wrptr = 0;
757 card->evtbd_rdptr = reg->evt_rollover_ind;
759 card->evtbd_ring_size = sizeof(struct mwifiex_evt_buf_desc) *
762 dev_dbg(adapter->dev, "info: evtbd_ring: Allocating %d bytes\n",
763 card->evtbd_ring_size);
764 card->evtbd_ring_vbase = pci_alloc_consistent(card->dev,
765 card->evtbd_ring_size,
766 &card->evtbd_ring_pbase);
767 if (!card->evtbd_ring_vbase) {
768 dev_err(adapter->dev,
769 "allocate consistent memory (%d bytes) failed!\n",
770 card->evtbd_ring_size);
774 dev_dbg(adapter->dev,
775 "info: CMDRSP/EVT bd_ring - base: %p pbase: %#x:%x len: %#x\n",
776 card->evtbd_ring_vbase, (u32)card->evtbd_ring_pbase,
777 (u32)((u64)card->evtbd_ring_pbase >> 32),
778 card->evtbd_ring_size);
780 return mwifiex_pcie_init_evt_ring(adapter);
784 * This function deletes Buffer descriptor ring for Events
786 static int mwifiex_pcie_delete_evtbd_ring(struct mwifiex_adapter *adapter)
788 struct pcie_service_card *card = adapter->card;
789 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
791 mwifiex_cleanup_evt_ring(adapter);
793 if (card->evtbd_ring_vbase)
794 pci_free_consistent(card->dev, card->evtbd_ring_size,
795 card->evtbd_ring_vbase,
796 card->evtbd_ring_pbase);
797 card->evtbd_wrptr = 0;
798 card->evtbd_rdptr = 0 | reg->evt_rollover_ind;
799 card->evtbd_ring_size = 0;
800 card->evtbd_ring_vbase = NULL;
801 card->evtbd_ring_pbase = 0;
807 * This function allocates a buffer for CMDRSP
809 static int mwifiex_pcie_alloc_cmdrsp_buf(struct mwifiex_adapter *adapter)
811 struct pcie_service_card *card = adapter->card;
814 /* Allocate memory for receiving command response data */
815 skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
817 dev_err(adapter->dev,
818 "Unable to allocate skb for command response data.\n");
821 skb_put(skb, MWIFIEX_UPLD_SIZE);
822 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
826 card->cmdrsp_buf = skb;
832 * This function deletes a buffer for CMDRSP
834 static int mwifiex_pcie_delete_cmdrsp_buf(struct mwifiex_adapter *adapter)
836 struct pcie_service_card *card;
842 card = adapter->card;
844 if (card && card->cmdrsp_buf) {
845 MWIFIEX_SKB_PACB(card->cmdrsp_buf, &buf_pa);
846 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
848 dev_kfree_skb_any(card->cmdrsp_buf);
851 if (card && card->cmd_buf) {
852 MWIFIEX_SKB_PACB(card->cmd_buf, &buf_pa);
853 pci_unmap_single(card->dev, buf_pa, MWIFIEX_SIZE_OF_CMD_BUFFER,
855 dev_kfree_skb_any(card->cmd_buf);
861 * This function allocates a buffer for sleep cookie
863 static int mwifiex_pcie_alloc_sleep_cookie_buf(struct mwifiex_adapter *adapter)
865 struct pcie_service_card *card = adapter->card;
867 card->sleep_cookie_vbase = pci_alloc_consistent(card->dev, sizeof(u32),
868 &card->sleep_cookie_pbase);
869 if (!card->sleep_cookie_vbase) {
870 dev_err(adapter->dev, "pci_alloc_consistent failed!\n");
873 /* Init val of Sleep Cookie */
874 *(u32 *)card->sleep_cookie_vbase = FW_AWAKE_COOKIE;
876 dev_dbg(adapter->dev, "alloc_scook: sleep cookie=0x%x\n",
877 *((u32 *)card->sleep_cookie_vbase));
883 * This function deletes buffer for sleep cookie
885 static int mwifiex_pcie_delete_sleep_cookie_buf(struct mwifiex_adapter *adapter)
887 struct pcie_service_card *card;
892 card = adapter->card;
894 if (card && card->sleep_cookie_vbase) {
895 pci_free_consistent(card->dev, sizeof(u32),
896 card->sleep_cookie_vbase,
897 card->sleep_cookie_pbase);
898 card->sleep_cookie_vbase = NULL;
904 /* This function flushes the TX buffer descriptor ring
905 * This function defined as handler is also called while cleaning TXRX
906 * during disconnect/ bss stop.
908 static int mwifiex_clean_pcie_ring_buf(struct mwifiex_adapter *adapter)
910 struct pcie_service_card *card = adapter->card;
912 if (!mwifiex_pcie_txbd_empty(card, card->txbd_rdptr)) {
913 card->txbd_flush = 1;
914 /* write pointer already set at last send
915 * send dnld-rdy intr again, wait for completion.
917 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
918 CPU_INTR_DNLD_RDY)) {
919 dev_err(adapter->dev,
920 "failed to assert dnld-rdy interrupt.\n");
928 * This function unmaps and frees downloaded data buffer
930 static int mwifiex_pcie_send_data_complete(struct mwifiex_adapter *adapter)
934 u32 wrdoneidx, rdptr, num_tx_buffs, unmap_count = 0;
935 struct mwifiex_pcie_buf_desc *desc;
936 struct mwifiex_pfu_buf_desc *desc2;
937 struct pcie_service_card *card = adapter->card;
938 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
940 if (!mwifiex_pcie_ok_to_access_hw(adapter))
941 mwifiex_pm_wakeup_card(adapter);
943 /* Read the TX ring read pointer set by firmware */
944 if (mwifiex_read_reg(adapter, reg->tx_rdptr, &rdptr)) {
945 dev_err(adapter->dev,
946 "SEND COMP: failed to read reg->tx_rdptr\n");
950 dev_dbg(adapter->dev, "SEND COMP: rdptr_prev=0x%x, rdptr=0x%x\n",
951 card->txbd_rdptr, rdptr);
953 num_tx_buffs = MWIFIEX_MAX_TXRX_BD << reg->tx_start_ptr;
954 /* free from previous txbd_rdptr to current txbd_rdptr */
955 while (((card->txbd_rdptr & reg->tx_mask) !=
956 (rdptr & reg->tx_mask)) ||
957 ((card->txbd_rdptr & reg->tx_rollover_ind) !=
958 (rdptr & reg->tx_rollover_ind))) {
959 wrdoneidx = (card->txbd_rdptr & reg->tx_mask) >>
962 skb = card->tx_buf_list[wrdoneidx];
964 dev_dbg(adapter->dev,
965 "SEND COMP: Detach skb %p at txbd_rdidx=%d\n",
967 MWIFIEX_SKB_PACB(skb, &buf_pa);
968 pci_unmap_single(card->dev, buf_pa, skb->len,
973 if (card->txbd_flush)
974 mwifiex_write_data_complete(adapter, skb, 0,
977 mwifiex_write_data_complete(adapter, skb, 0, 0);
980 card->tx_buf_list[wrdoneidx] = NULL;
982 if (reg->pfu_enabled) {
983 desc2 = (void *)card->txbd_ring[wrdoneidx];
984 memset(desc2, 0, sizeof(*desc2));
986 desc = card->txbd_ring[wrdoneidx];
987 memset(desc, 0, sizeof(*desc));
989 switch (card->dev->device) {
990 case PCIE_DEVICE_ID_MARVELL_88W8766P:
993 case PCIE_DEVICE_ID_MARVELL_88W8897:
994 card->txbd_rdptr += reg->ring_tx_start_ptr;
999 if ((card->txbd_rdptr & reg->tx_mask) == num_tx_buffs)
1000 card->txbd_rdptr = ((card->txbd_rdptr &
1001 reg->tx_rollover_ind) ^
1002 reg->tx_rollover_ind);
1006 adapter->data_sent = false;
1008 if (card->txbd_flush) {
1009 if (mwifiex_pcie_txbd_empty(card, card->txbd_rdptr))
1010 card->txbd_flush = 0;
1012 mwifiex_clean_pcie_ring_buf(adapter);
1018 /* This function sends data buffer to device. First 4 bytes of payload
1019 * are filled with payload length and payload type. Then this payload
1020 * is mapped to PCI device memory. Tx ring pointers are advanced accordingly.
1021 * Download ready interrupt to FW is deffered if Tx ring is not full and
1022 * additional payload can be accomodated.
1025 mwifiex_pcie_send_data(struct mwifiex_adapter *adapter, struct sk_buff *skb,
1026 struct mwifiex_tx_param *tx_param)
1028 struct pcie_service_card *card = adapter->card;
1029 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1030 u32 wrindx, num_tx_buffs, rx_val;
1033 struct mwifiex_pcie_buf_desc *desc;
1034 struct mwifiex_pfu_buf_desc *desc2;
1037 if (!(skb->data && skb->len)) {
1038 dev_err(adapter->dev, "%s(): invalid parameter <%p, %#x>\n",
1039 __func__, skb->data, skb->len);
1043 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1044 mwifiex_pm_wakeup_card(adapter);
1046 num_tx_buffs = MWIFIEX_MAX_TXRX_BD << reg->tx_start_ptr;
1047 dev_dbg(adapter->dev, "info: SEND DATA: <Rd: %#x, Wr: %#x>\n",
1048 card->txbd_rdptr, card->txbd_wrptr);
1049 if (mwifiex_pcie_txbd_not_full(card)) {
1052 adapter->data_sent = true;
1053 payload = skb->data;
1054 tmp = (__le16 *)&payload[0];
1055 *tmp = cpu_to_le16((u16)skb->len);
1056 tmp = (__le16 *)&payload[2];
1057 *tmp = cpu_to_le16(MWIFIEX_TYPE_DATA);
1059 if (mwifiex_map_pci_memory(adapter, skb, skb->len ,
1063 wrindx = (card->txbd_wrptr & reg->tx_mask) >> reg->tx_start_ptr;
1064 MWIFIEX_SKB_PACB(skb, &buf_pa);
1065 card->tx_buf_list[wrindx] = skb;
1067 if (reg->pfu_enabled) {
1068 desc2 = (void *)card->txbd_ring[wrindx];
1069 desc2->paddr = buf_pa;
1070 desc2->len = (u16)skb->len;
1071 desc2->frag_len = (u16)skb->len;
1073 desc2->flags = MWIFIEX_BD_FLAG_FIRST_DESC |
1074 MWIFIEX_BD_FLAG_LAST_DESC;
1076 desc = card->txbd_ring[wrindx];
1077 desc->paddr = buf_pa;
1078 desc->len = (u16)skb->len;
1079 desc->flags = MWIFIEX_BD_FLAG_FIRST_DESC |
1080 MWIFIEX_BD_FLAG_LAST_DESC;
1083 switch (card->dev->device) {
1084 case PCIE_DEVICE_ID_MARVELL_88W8766P:
1087 case PCIE_DEVICE_ID_MARVELL_88W8897:
1088 card->txbd_wrptr += reg->ring_tx_start_ptr;
1092 if ((card->txbd_wrptr & reg->tx_mask) == num_tx_buffs)
1093 card->txbd_wrptr = ((card->txbd_wrptr &
1094 reg->tx_rollover_ind) ^
1095 reg->tx_rollover_ind);
1097 rx_val = card->rxbd_rdptr & reg->rx_wrap_mask;
1098 /* Write the TX ring write pointer in to reg->tx_wrptr */
1099 if (mwifiex_write_reg(adapter, reg->tx_wrptr,
1100 card->txbd_wrptr | rx_val)) {
1101 dev_err(adapter->dev,
1102 "SEND DATA: failed to write reg->tx_wrptr\n");
1106 if ((mwifiex_pcie_txbd_not_full(card)) &&
1107 tx_param->next_pkt_len) {
1108 /* have more packets and TxBD still can hold more */
1109 dev_dbg(adapter->dev,
1110 "SEND DATA: delay dnld-rdy interrupt.\n");
1111 adapter->data_sent = false;
1113 /* Send the TX ready interrupt */
1114 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1115 CPU_INTR_DNLD_RDY)) {
1116 dev_err(adapter->dev,
1117 "SEND DATA: failed to assert dnld-rdy interrupt.\n");
1122 dev_dbg(adapter->dev, "info: SEND DATA: Updated <Rd: %#x, Wr: "
1123 "%#x> and sent packet to firmware successfully\n",
1124 card->txbd_rdptr, card->txbd_wrptr);
1126 dev_dbg(adapter->dev,
1127 "info: TX Ring full, can't send packets to fw\n");
1128 adapter->data_sent = true;
1129 /* Send the TX ready interrupt */
1130 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1132 dev_err(adapter->dev,
1133 "SEND DATA: failed to assert door-bell intr\n");
1137 return -EINPROGRESS;
1139 MWIFIEX_SKB_PACB(skb, &buf_pa);
1140 pci_unmap_single(card->dev, buf_pa, skb->len, PCI_DMA_TODEVICE);
1141 card->tx_buf_list[wrindx] = NULL;
1142 if (reg->pfu_enabled)
1143 memset(desc2, 0, sizeof(*desc2));
1145 memset(desc, 0, sizeof(*desc));
1151 * This function handles received buffer ring and
1152 * dispatches packets to upper
1154 static int mwifiex_pcie_process_recv_data(struct mwifiex_adapter *adapter)
1156 struct pcie_service_card *card = adapter->card;
1157 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1158 u32 wrptr, rd_index, tx_val;
1161 struct sk_buff *skb_tmp = NULL;
1162 struct mwifiex_pcie_buf_desc *desc;
1163 struct mwifiex_pfu_buf_desc *desc2;
1165 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1166 mwifiex_pm_wakeup_card(adapter);
1168 /* Read the RX ring Write pointer set by firmware */
1169 if (mwifiex_read_reg(adapter, reg->rx_wrptr, &wrptr)) {
1170 dev_err(adapter->dev,
1171 "RECV DATA: failed to read reg->rx_wrptr\n");
1175 card->rxbd_wrptr = wrptr;
1177 while (((wrptr & reg->rx_mask) !=
1178 (card->rxbd_rdptr & reg->rx_mask)) ||
1179 ((wrptr & reg->rx_rollover_ind) ==
1180 (card->rxbd_rdptr & reg->rx_rollover_ind))) {
1181 struct sk_buff *skb_data;
1185 rd_index = card->rxbd_rdptr & reg->rx_mask;
1186 skb_data = card->rx_buf_list[rd_index];
1188 MWIFIEX_SKB_PACB(skb_data, &buf_pa);
1189 pci_unmap_single(card->dev, buf_pa, MWIFIEX_RX_DATA_BUF_SIZE,
1190 PCI_DMA_FROMDEVICE);
1191 card->rx_buf_list[rd_index] = NULL;
1193 /* Get data length from interface header -
1194 * first 2 bytes for len, next 2 bytes is for type
1196 pkt_len = *((__le16 *)skb_data->data);
1197 rx_len = le16_to_cpu(pkt_len);
1198 skb_put(skb_data, rx_len);
1199 dev_dbg(adapter->dev,
1200 "info: RECV DATA: Rd=%#x, Wr=%#x, Len=%d\n",
1201 card->rxbd_rdptr, wrptr, rx_len);
1202 skb_pull(skb_data, INTF_HEADER_LEN);
1203 mwifiex_handle_rx_packet(adapter, skb_data);
1205 skb_tmp = dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE);
1207 dev_err(adapter->dev,
1208 "Unable to allocate skb.\n");
1212 if (mwifiex_map_pci_memory(adapter, skb_tmp,
1213 MWIFIEX_RX_DATA_BUF_SIZE,
1214 PCI_DMA_FROMDEVICE))
1217 MWIFIEX_SKB_PACB(skb_tmp, &buf_pa);
1219 dev_dbg(adapter->dev,
1220 "RECV DATA: Attach new sk_buff %p at rxbd_rdidx=%d\n",
1222 card->rx_buf_list[rd_index] = skb_tmp;
1224 if (reg->pfu_enabled) {
1225 desc2 = (void *)card->rxbd_ring[rd_index];
1226 desc2->paddr = buf_pa;
1227 desc2->len = skb_tmp->len;
1228 desc2->frag_len = skb_tmp->len;
1230 desc2->flags = reg->ring_flag_sop | reg->ring_flag_eop;
1232 desc = card->rxbd_ring[rd_index];
1233 desc->paddr = buf_pa;
1234 desc->len = skb_tmp->len;
1238 if ((++card->rxbd_rdptr & reg->rx_mask) ==
1239 MWIFIEX_MAX_TXRX_BD) {
1240 card->rxbd_rdptr = ((card->rxbd_rdptr &
1241 reg->rx_rollover_ind) ^
1242 reg->rx_rollover_ind);
1244 dev_dbg(adapter->dev, "info: RECV DATA: <Rd: %#x, Wr: %#x>\n",
1245 card->rxbd_rdptr, wrptr);
1247 tx_val = card->txbd_wrptr & reg->tx_wrap_mask;
1248 /* Write the RX ring read pointer in to reg->rx_rdptr */
1249 if (mwifiex_write_reg(adapter, reg->rx_rdptr,
1250 card->rxbd_rdptr | tx_val)) {
1251 dev_err(adapter->dev,
1252 "RECV DATA: failed to write reg->rx_rdptr\n");
1257 /* Read the RX ring Write pointer set by firmware */
1258 if (mwifiex_read_reg(adapter, reg->rx_wrptr, &wrptr)) {
1259 dev_err(adapter->dev,
1260 "RECV DATA: failed to read reg->rx_wrptr\n");
1264 dev_dbg(adapter->dev,
1265 "info: RECV DATA: Rcvd packet from fw successfully\n");
1266 card->rxbd_wrptr = wrptr;
1274 * This function downloads the boot command to device
1277 mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
1280 struct pcie_service_card *card = adapter->card;
1281 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1283 if (!(skb->data && skb->len)) {
1284 dev_err(adapter->dev,
1285 "Invalid parameter in %s <%p. len %d>\n",
1286 __func__, skb->data, skb->len);
1290 if (mwifiex_map_pci_memory(adapter, skb, skb->len , PCI_DMA_TODEVICE))
1293 MWIFIEX_SKB_PACB(skb, &buf_pa);
1295 /* Write the lower 32bits of the physical address to low command
1296 * address scratch register
1298 if (mwifiex_write_reg(adapter, reg->cmd_addr_lo, (u32)buf_pa)) {
1299 dev_err(adapter->dev,
1300 "%s: failed to write download command to boot code.\n",
1302 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1307 /* Write the upper 32bits of the physical address to high command
1308 * address scratch register
1310 if (mwifiex_write_reg(adapter, reg->cmd_addr_hi,
1311 (u32)((u64)buf_pa >> 32))) {
1312 dev_err(adapter->dev,
1313 "%s: failed to write download command to boot code.\n",
1315 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1320 /* Write the command length to cmd_size scratch register */
1321 if (mwifiex_write_reg(adapter, reg->cmd_size, skb->len)) {
1322 dev_err(adapter->dev,
1323 "%s: failed to write command len to cmd_size scratch reg\n",
1325 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1330 /* Ring the door bell */
1331 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1332 CPU_INTR_DOOR_BELL)) {
1333 dev_err(adapter->dev,
1334 "%s: failed to assert door-bell intr\n", __func__);
1335 pci_unmap_single(card->dev, buf_pa,
1336 MWIFIEX_UPLD_SIZE, PCI_DMA_TODEVICE);
1343 /* This function init rx port in firmware which in turn enables to receive data
1344 * from device before transmitting any packet.
1346 static int mwifiex_pcie_init_fw_port(struct mwifiex_adapter *adapter)
1348 struct pcie_service_card *card = adapter->card;
1349 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1350 int tx_wrap = card->txbd_wrptr & reg->tx_wrap_mask;
1352 /* Write the RX ring read pointer in to reg->rx_rdptr */
1353 if (mwifiex_write_reg(adapter, reg->rx_rdptr, card->rxbd_rdptr |
1355 dev_err(adapter->dev,
1356 "RECV DATA: failed to write reg->rx_rdptr\n");
1362 /* This function downloads commands to the device
1365 mwifiex_pcie_send_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
1367 struct pcie_service_card *card = adapter->card;
1368 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1370 dma_addr_t cmd_buf_pa, cmdrsp_buf_pa;
1371 u8 *payload = (u8 *)skb->data;
1373 if (!(skb->data && skb->len)) {
1374 dev_err(adapter->dev, "Invalid parameter in %s <%p, %#x>\n",
1375 __func__, skb->data, skb->len);
1379 /* Make sure a command response buffer is available */
1380 if (!card->cmdrsp_buf) {
1381 dev_err(adapter->dev,
1382 "No response buffer available, send command failed\n");
1386 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1387 mwifiex_pm_wakeup_card(adapter);
1389 adapter->cmd_sent = true;
1391 *(__le16 *)&payload[0] = cpu_to_le16((u16)skb->len);
1392 *(__le16 *)&payload[2] = cpu_to_le16(MWIFIEX_TYPE_CMD);
1394 if (mwifiex_map_pci_memory(adapter, skb, skb->len, PCI_DMA_TODEVICE))
1397 card->cmd_buf = skb;
1399 /* To send a command, the driver will:
1400 1. Write the 64bit physical address of the data buffer to
1401 cmd response address low + cmd response address high
1402 2. Ring the door bell (i.e. set the door bell interrupt)
1404 In response to door bell interrupt, the firmware will perform
1405 the DMA of the command packet (first header to obtain the total
1406 length and then rest of the command).
1409 if (card->cmdrsp_buf) {
1410 MWIFIEX_SKB_PACB(card->cmdrsp_buf, &cmdrsp_buf_pa);
1411 /* Write the lower 32bits of the cmdrsp buffer physical
1413 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo,
1414 (u32)cmdrsp_buf_pa)) {
1415 dev_err(adapter->dev,
1416 "Failed to write download cmd to boot code.\n");
1420 /* Write the upper 32bits of the cmdrsp buffer physical
1422 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi,
1423 (u32)((u64)cmdrsp_buf_pa >> 32))) {
1424 dev_err(adapter->dev,
1425 "Failed to write download cmd to boot code.\n");
1431 MWIFIEX_SKB_PACB(card->cmd_buf, &cmd_buf_pa);
1432 /* Write the lower 32bits of the physical address to reg->cmd_addr_lo */
1433 if (mwifiex_write_reg(adapter, reg->cmd_addr_lo,
1435 dev_err(adapter->dev,
1436 "Failed to write download cmd to boot code.\n");
1440 /* Write the upper 32bits of the physical address to reg->cmd_addr_hi */
1441 if (mwifiex_write_reg(adapter, reg->cmd_addr_hi,
1442 (u32)((u64)cmd_buf_pa >> 32))) {
1443 dev_err(adapter->dev,
1444 "Failed to write download cmd to boot code.\n");
1449 /* Write the command length to reg->cmd_size */
1450 if (mwifiex_write_reg(adapter, reg->cmd_size,
1451 card->cmd_buf->len)) {
1452 dev_err(adapter->dev,
1453 "Failed to write cmd len to reg->cmd_size\n");
1458 /* Ring the door bell */
1459 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1460 CPU_INTR_DOOR_BELL)) {
1461 dev_err(adapter->dev,
1462 "Failed to assert door-bell intr\n");
1469 adapter->cmd_sent = false;
1475 * This function handles command complete interrupt
1477 static int mwifiex_pcie_process_cmd_complete(struct mwifiex_adapter *adapter)
1479 struct pcie_service_card *card = adapter->card;
1480 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1481 struct sk_buff *skb = card->cmdrsp_buf;
1487 dev_dbg(adapter->dev, "info: Rx CMD Response\n");
1489 MWIFIEX_SKB_PACB(skb, &buf_pa);
1490 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1491 PCI_DMA_FROMDEVICE);
1493 pkt_len = *((__le16 *)skb->data);
1494 rx_len = le16_to_cpu(pkt_len);
1495 skb_trim(skb, rx_len);
1496 skb_pull(skb, INTF_HEADER_LEN);
1498 if (!adapter->curr_cmd) {
1499 if (adapter->ps_state == PS_STATE_SLEEP_CFM) {
1500 mwifiex_process_sleep_confirm_resp(adapter, skb->data,
1502 while (reg->sleep_cookie && (count++ < 10) &&
1503 mwifiex_pcie_ok_to_access_hw(adapter))
1504 usleep_range(50, 60);
1506 dev_err(adapter->dev,
1507 "There is no command but got cmdrsp\n");
1509 memcpy(adapter->upld_buf, skb->data,
1510 min_t(u32, MWIFIEX_SIZE_OF_CMD_BUFFER, skb->len));
1511 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1512 PCI_DMA_FROMDEVICE))
1515 MWIFIEX_SKB_PACB(skb, &buf_pa);
1516 } else if (mwifiex_pcie_ok_to_access_hw(adapter)) {
1517 adapter->curr_cmd->resp_skb = skb;
1518 adapter->cmd_resp_received = true;
1519 /* Take the pointer and set it to CMD node and will
1520 return in the response complete callback */
1521 card->cmdrsp_buf = NULL;
1523 /* Clear the cmd-rsp buffer address in scratch registers. This
1524 will prevent firmware from writing to the same response
1526 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo, 0)) {
1527 dev_err(adapter->dev,
1528 "cmd_done: failed to clear cmd_rsp_addr_lo\n");
1531 /* Write the upper 32bits of the cmdrsp buffer physical
1533 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi, 0)) {
1534 dev_err(adapter->dev,
1535 "cmd_done: failed to clear cmd_rsp_addr_hi\n");
1544 * Command Response processing complete handler
1546 static int mwifiex_pcie_cmdrsp_complete(struct mwifiex_adapter *adapter,
1547 struct sk_buff *skb)
1549 struct pcie_service_card *card = adapter->card;
1551 struct sk_buff *skb_tmp;
1554 card->cmdrsp_buf = skb;
1555 skb_push(card->cmdrsp_buf, INTF_HEADER_LEN);
1556 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1557 PCI_DMA_FROMDEVICE))
1561 skb_tmp = card->cmd_buf;
1563 MWIFIEX_SKB_PACB(skb_tmp, &buf_pa);
1564 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1565 PCI_DMA_FROMDEVICE);
1566 card->cmd_buf = NULL;
1573 * This function handles firmware event ready interrupt
1575 static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter *adapter)
1577 struct pcie_service_card *card = adapter->card;
1578 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1579 u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1582 struct mwifiex_evt_buf_desc *desc;
1584 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1585 mwifiex_pm_wakeup_card(adapter);
1587 if (adapter->event_received) {
1588 dev_dbg(adapter->dev, "info: Event being processed, "
1589 "do not process this interrupt just yet\n");
1593 if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1594 dev_dbg(adapter->dev, "info: Invalid read pointer...\n");
1598 /* Read the event ring write pointer set by firmware */
1599 if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1600 dev_err(adapter->dev,
1601 "EventReady: failed to read reg->evt_wrptr\n");
1605 dev_dbg(adapter->dev, "info: EventReady: Initial <Rd: 0x%x, Wr: 0x%x>",
1606 card->evtbd_rdptr, wrptr);
1607 if (((wrptr & MWIFIEX_EVTBD_MASK) != (card->evtbd_rdptr
1608 & MWIFIEX_EVTBD_MASK)) ||
1609 ((wrptr & reg->evt_rollover_ind) ==
1610 (card->evtbd_rdptr & reg->evt_rollover_ind))) {
1611 struct sk_buff *skb_cmd;
1612 __le16 data_len = 0;
1615 dev_dbg(adapter->dev, "info: Read Index: %d\n", rdptr);
1616 skb_cmd = card->evt_buf_list[rdptr];
1617 MWIFIEX_SKB_PACB(skb_cmd, &buf_pa);
1618 pci_unmap_single(card->dev, buf_pa, MAX_EVENT_SIZE,
1619 PCI_DMA_FROMDEVICE);
1621 /* Take the pointer and set it to event pointer in adapter
1622 and will return back after event handling callback */
1623 card->evt_buf_list[rdptr] = NULL;
1624 desc = card->evtbd_ring[rdptr];
1625 memset(desc, 0, sizeof(*desc));
1627 event = *(u32 *) &skb_cmd->data[INTF_HEADER_LEN];
1628 adapter->event_cause = event;
1629 /* The first 4bytes will be the event transfer header
1630 len is 2 bytes followed by type which is 2 bytes */
1631 memcpy(&data_len, skb_cmd->data, sizeof(__le16));
1632 evt_len = le16_to_cpu(data_len);
1634 skb_pull(skb_cmd, INTF_HEADER_LEN);
1635 dev_dbg(adapter->dev, "info: Event length: %d\n", evt_len);
1637 if ((evt_len > 0) && (evt_len < MAX_EVENT_SIZE))
1638 memcpy(adapter->event_body, skb_cmd->data +
1639 MWIFIEX_EVENT_HEADER_LEN, evt_len -
1640 MWIFIEX_EVENT_HEADER_LEN);
1642 adapter->event_received = true;
1643 adapter->event_skb = skb_cmd;
1645 /* Do not update the event read pointer here, wait till the
1646 buffer is released. This is just to make things simpler,
1647 we need to find a better method of managing these buffers.
1655 * Event processing complete handler
1657 static int mwifiex_pcie_event_complete(struct mwifiex_adapter *adapter,
1658 struct sk_buff *skb)
1660 struct pcie_service_card *card = adapter->card;
1661 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1663 u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1666 struct mwifiex_evt_buf_desc *desc;
1671 if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1672 dev_err(adapter->dev, "event_complete: Invalid rdptr 0x%x\n",
1677 /* Read the event ring write pointer set by firmware */
1678 if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1679 dev_err(adapter->dev,
1680 "event_complete: failed to read reg->evt_wrptr\n");
1684 if (!card->evt_buf_list[rdptr]) {
1685 skb_push(skb, INTF_HEADER_LEN);
1686 if (mwifiex_map_pci_memory(adapter, skb,
1688 PCI_DMA_FROMDEVICE))
1690 MWIFIEX_SKB_PACB(skb, &buf_pa);
1691 card->evt_buf_list[rdptr] = skb;
1692 MWIFIEX_SKB_PACB(skb, &buf_pa);
1693 desc = card->evtbd_ring[rdptr];
1694 desc->paddr = buf_pa;
1695 desc->len = (u16)skb->len;
1699 dev_dbg(adapter->dev,
1700 "info: ERROR: buf still valid at index %d, <%p, %p>\n",
1701 rdptr, card->evt_buf_list[rdptr], skb);
1704 if ((++card->evtbd_rdptr & MWIFIEX_EVTBD_MASK) == MWIFIEX_MAX_EVT_BD) {
1705 card->evtbd_rdptr = ((card->evtbd_rdptr &
1706 reg->evt_rollover_ind) ^
1707 reg->evt_rollover_ind);
1710 dev_dbg(adapter->dev, "info: Updated <Rd: 0x%x, Wr: 0x%x>",
1711 card->evtbd_rdptr, wrptr);
1713 /* Write the event ring read pointer in to reg->evt_rdptr */
1714 if (mwifiex_write_reg(adapter, reg->evt_rdptr,
1715 card->evtbd_rdptr)) {
1716 dev_err(adapter->dev,
1717 "event_complete: failed to read reg->evt_rdptr\n");
1721 dev_dbg(adapter->dev, "info: Check Events Again\n");
1722 ret = mwifiex_pcie_process_event_ready(adapter);
1728 * This function downloads the firmware to the card.
1730 * Firmware is downloaded to the card in blocks. Every block download
1731 * is tested for CRC errors, and retried a number of times before
1732 * returning failure.
1734 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter *adapter,
1735 struct mwifiex_fw_image *fw)
1738 u8 *firmware = fw->fw_buf;
1739 u32 firmware_len = fw->fw_len;
1741 struct sk_buff *skb;
1742 u32 txlen, tx_blocks = 0, tries, len;
1743 u32 block_retry_cnt = 0;
1745 struct pcie_service_card *card = adapter->card;
1746 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1748 if (!firmware || !firmware_len) {
1749 dev_err(adapter->dev,
1750 "No firmware image found! Terminating download\n");
1754 dev_dbg(adapter->dev, "info: Downloading FW image (%d bytes)\n",
1757 if (mwifiex_pcie_disable_host_int(adapter)) {
1758 dev_err(adapter->dev,
1759 "%s: Disabling interrupts failed.\n", __func__);
1763 skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
1769 /* Perform firmware data transfer */
1774 if (offset >= firmware_len)
1777 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
1778 ret = mwifiex_read_reg(adapter, reg->cmd_size,
1781 dev_warn(adapter->dev,
1782 "Failed reading len from boot code\n");
1787 usleep_range(10, 20);
1792 } else if (len > MWIFIEX_UPLD_SIZE) {
1793 pr_err("FW download failure @ %d, invalid length %d\n",
1803 if (block_retry_cnt > MAX_WRITE_IOMEM_RETRY) {
1804 pr_err("FW download failure @ %d, over max "
1805 "retry count\n", offset);
1809 dev_err(adapter->dev, "FW CRC error indicated by the "
1810 "helper: len = 0x%04X, txlen = %d\n",
1813 /* Setting this to 0 to resend from same offset */
1816 block_retry_cnt = 0;
1817 /* Set blocksize to transfer - checking for
1819 if (firmware_len - offset < txlen)
1820 txlen = firmware_len - offset;
1822 dev_dbg(adapter->dev, ".");
1824 tx_blocks = (txlen + card->pcie.blksz_fw_dl - 1) /
1825 card->pcie.blksz_fw_dl;
1827 /* Copy payload to buffer */
1828 memmove(skb->data, &firmware[offset], txlen);
1831 skb_put(skb, MWIFIEX_UPLD_SIZE - skb->len);
1832 skb_trim(skb, tx_blocks * card->pcie.blksz_fw_dl);
1834 /* Send the boot command to device */
1835 if (mwifiex_pcie_send_boot_cmd(adapter, skb)) {
1836 dev_err(adapter->dev,
1837 "Failed to send firmware download command\n");
1842 MWIFIEX_SKB_PACB(skb, &buf_pa);
1844 /* Wait for the command done interrupt */
1846 if (mwifiex_read_reg(adapter, PCIE_CPU_INT_STATUS,
1848 dev_err(adapter->dev, "%s: Failed to read "
1849 "interrupt status during fw dnld.\n",
1851 pci_unmap_single(card->dev, buf_pa, skb->len,
1856 } while ((ireg_intr & CPU_INTR_DOOR_BELL) ==
1857 CPU_INTR_DOOR_BELL);
1859 pci_unmap_single(card->dev, buf_pa, skb->len,
1865 dev_dbg(adapter->dev, "info:\nFW download over, size %d bytes\n",
1871 dev_kfree_skb_any(skb);
1876 * This function checks the firmware status in card.
1878 * The winner interface is also determined by this function.
1881 mwifiex_check_fw_status(struct mwifiex_adapter *adapter, u32 poll_num)
1884 u32 firmware_stat, winner_status;
1885 struct pcie_service_card *card = adapter->card;
1886 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1889 /* Mask spurios interrupts */
1890 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS_MASK,
1892 dev_warn(adapter->dev, "Write register failed\n");
1896 dev_dbg(adapter->dev, "Setting driver ready signature\n");
1897 if (mwifiex_write_reg(adapter, reg->drv_rdy,
1898 FIRMWARE_READY_PCIE)) {
1899 dev_err(adapter->dev,
1900 "Failed to write driver ready signature\n");
1904 /* Wait for firmware initialization event */
1905 for (tries = 0; tries < poll_num; tries++) {
1906 if (mwifiex_read_reg(adapter, reg->fw_status,
1913 if (firmware_stat == FIRMWARE_READY_PCIE) {
1923 if (mwifiex_read_reg(adapter, reg->fw_status,
1926 else if (!winner_status) {
1927 dev_err(adapter->dev, "PCI-E is the winner\n");
1928 adapter->winner = 1;
1931 dev_err(adapter->dev,
1932 "PCI-E is not the winner <%#x,%d>, exit dnld\n",
1933 ret, adapter->winner);
1942 * This function reads the interrupt status from card.
1944 static void mwifiex_interrupt_status(struct mwifiex_adapter *adapter)
1947 unsigned long flags;
1949 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1952 if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS, &pcie_ireg)) {
1953 dev_warn(adapter->dev, "Read register failed\n");
1957 if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
1959 mwifiex_pcie_disable_host_int(adapter);
1961 /* Clear the pending interrupts */
1962 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS,
1964 dev_warn(adapter->dev, "Write register failed\n");
1967 spin_lock_irqsave(&adapter->int_lock, flags);
1968 adapter->int_status |= pcie_ireg;
1969 spin_unlock_irqrestore(&adapter->int_lock, flags);
1971 if (pcie_ireg & HOST_INTR_CMD_DONE) {
1972 if ((adapter->ps_state == PS_STATE_SLEEP_CFM) ||
1973 (adapter->ps_state == PS_STATE_SLEEP)) {
1974 mwifiex_pcie_enable_host_int(adapter);
1975 if (mwifiex_write_reg(adapter,
1977 CPU_INTR_SLEEP_CFM_DONE)
1979 dev_warn(adapter->dev,
1980 "Write register failed\n");
1985 } else if (!adapter->pps_uapsd_mode &&
1986 adapter->ps_state == PS_STATE_SLEEP) {
1987 /* Potentially for PCIe we could get other
1988 * interrupts like shared. Don't change power
1989 * state until cookie is set */
1990 if (mwifiex_pcie_ok_to_access_hw(adapter))
1991 adapter->ps_state = PS_STATE_AWAKE;
1997 * Interrupt handler for PCIe root port
1999 * This function reads the interrupt status from firmware and assigns
2000 * the main process in workqueue which will handle the interrupt.
2002 static irqreturn_t mwifiex_pcie_interrupt(int irq, void *context)
2004 struct pci_dev *pdev = (struct pci_dev *)context;
2005 struct pcie_service_card *card;
2006 struct mwifiex_adapter *adapter;
2009 pr_debug("info: %s: pdev is NULL\n", (u8 *)pdev);
2013 card = (struct pcie_service_card *) pci_get_drvdata(pdev);
2014 if (!card || !card->adapter) {
2015 pr_debug("info: %s: card=%p adapter=%p\n", __func__, card,
2016 card ? card->adapter : NULL);
2019 adapter = card->adapter;
2021 if (adapter->surprise_removed)
2024 mwifiex_interrupt_status(adapter);
2025 queue_work(adapter->workqueue, &adapter->main_work);
2032 * This function checks the current interrupt status.
2034 * The following interrupts are checked and handled by this function -
2037 * - Command received
2038 * - Packets received
2041 * In case of Rx packets received, the packets are uploaded from card to
2042 * host and processed accordingly.
2044 static int mwifiex_process_int_status(struct mwifiex_adapter *adapter)
2048 unsigned long flags;
2050 spin_lock_irqsave(&adapter->int_lock, flags);
2051 /* Clear out unused interrupts */
2052 pcie_ireg = adapter->int_status;
2053 adapter->int_status = 0;
2054 spin_unlock_irqrestore(&adapter->int_lock, flags);
2056 while (pcie_ireg & HOST_INTR_MASK) {
2057 if (pcie_ireg & HOST_INTR_DNLD_DONE) {
2058 pcie_ireg &= ~HOST_INTR_DNLD_DONE;
2059 dev_dbg(adapter->dev, "info: TX DNLD Done\n");
2060 ret = mwifiex_pcie_send_data_complete(adapter);
2064 if (pcie_ireg & HOST_INTR_UPLD_RDY) {
2065 pcie_ireg &= ~HOST_INTR_UPLD_RDY;
2066 dev_dbg(adapter->dev, "info: Rx DATA\n");
2067 ret = mwifiex_pcie_process_recv_data(adapter);
2071 if (pcie_ireg & HOST_INTR_EVENT_RDY) {
2072 pcie_ireg &= ~HOST_INTR_EVENT_RDY;
2073 dev_dbg(adapter->dev, "info: Rx EVENT\n");
2074 ret = mwifiex_pcie_process_event_ready(adapter);
2079 if (pcie_ireg & HOST_INTR_CMD_DONE) {
2080 pcie_ireg &= ~HOST_INTR_CMD_DONE;
2081 if (adapter->cmd_sent) {
2082 dev_dbg(adapter->dev,
2083 "info: CMD sent Interrupt\n");
2084 adapter->cmd_sent = false;
2086 /* Handle command response */
2087 ret = mwifiex_pcie_process_cmd_complete(adapter);
2092 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
2093 if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS,
2095 dev_warn(adapter->dev,
2096 "Read register failed\n");
2100 if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
2101 if (mwifiex_write_reg(adapter,
2102 PCIE_HOST_INT_STATUS,
2104 dev_warn(adapter->dev,
2105 "Write register failed\n");
2112 dev_dbg(adapter->dev, "info: cmd_sent=%d data_sent=%d\n",
2113 adapter->cmd_sent, adapter->data_sent);
2114 mwifiex_pcie_enable_host_int(adapter);
2120 * This function downloads data from driver to card.
2122 * Both commands and data packets are transferred to the card by this
2125 * This function adds the PCIE specific header to the front of the buffer
2126 * before transferring. The header contains the length of the packet and
2127 * the type. The firmware handles the packets based upon this set type.
2129 static int mwifiex_pcie_host_to_card(struct mwifiex_adapter *adapter, u8 type,
2130 struct sk_buff *skb,
2131 struct mwifiex_tx_param *tx_param)
2134 dev_err(adapter->dev, "Passed NULL skb to %s\n", __func__);
2138 if (type == MWIFIEX_TYPE_DATA)
2139 return mwifiex_pcie_send_data(adapter, skb, tx_param);
2140 else if (type == MWIFIEX_TYPE_CMD)
2141 return mwifiex_pcie_send_cmd(adapter, skb);
2147 * This function initializes the PCI-E host memory space, WCB rings, etc.
2149 * The following initializations steps are followed -
2150 * - Allocate TXBD ring buffers
2151 * - Allocate RXBD ring buffers
2152 * - Allocate event BD ring buffers
2153 * - Allocate command response ring buffer
2154 * - Allocate sleep cookie buffer
2156 static int mwifiex_pcie_init(struct mwifiex_adapter *adapter)
2158 struct pcie_service_card *card = adapter->card;
2160 struct pci_dev *pdev = card->dev;
2161 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2163 pci_set_drvdata(pdev, card);
2165 ret = pci_enable_device(pdev);
2167 goto err_enable_dev;
2169 pci_set_master(pdev);
2171 dev_dbg(adapter->dev, "try set_consistent_dma_mask(32)\n");
2172 ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2174 dev_err(adapter->dev, "set_dma_mask(32) failed\n");
2175 goto err_set_dma_mask;
2178 ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
2180 dev_err(adapter->dev, "set_consistent_dma_mask(64) failed\n");
2181 goto err_set_dma_mask;
2184 ret = pci_request_region(pdev, 0, DRV_NAME);
2186 dev_err(adapter->dev, "req_reg(0) error\n");
2187 goto err_req_region0;
2189 card->pci_mmap = pci_iomap(pdev, 0, 0);
2190 if (!card->pci_mmap) {
2191 dev_err(adapter->dev, "iomap(0) error\n");
2195 ret = pci_request_region(pdev, 2, DRV_NAME);
2197 dev_err(adapter->dev, "req_reg(2) error\n");
2198 goto err_req_region2;
2200 card->pci_mmap1 = pci_iomap(pdev, 2, 0);
2201 if (!card->pci_mmap1) {
2202 dev_err(adapter->dev, "iomap(2) error\n");
2207 dev_dbg(adapter->dev,
2208 "PCI memory map Virt0: %p PCI memory map Virt2: %p\n",
2209 card->pci_mmap, card->pci_mmap1);
2211 card->cmdrsp_buf = NULL;
2212 ret = mwifiex_pcie_create_txbd_ring(adapter);
2215 ret = mwifiex_pcie_create_rxbd_ring(adapter);
2218 ret = mwifiex_pcie_create_evtbd_ring(adapter);
2221 ret = mwifiex_pcie_alloc_cmdrsp_buf(adapter);
2223 goto err_alloc_cmdbuf;
2224 if (reg->sleep_cookie) {
2225 ret = mwifiex_pcie_alloc_sleep_cookie_buf(adapter);
2227 goto err_alloc_cookie;
2229 card->sleep_cookie_vbase = NULL;
2234 mwifiex_pcie_delete_cmdrsp_buf(adapter);
2236 mwifiex_pcie_delete_evtbd_ring(adapter);
2238 mwifiex_pcie_delete_rxbd_ring(adapter);
2240 mwifiex_pcie_delete_txbd_ring(adapter);
2242 pci_iounmap(pdev, card->pci_mmap1);
2244 pci_release_region(pdev, 2);
2246 pci_iounmap(pdev, card->pci_mmap);
2248 pci_release_region(pdev, 0);
2251 pci_disable_device(pdev);
2253 pci_set_drvdata(pdev, NULL);
2258 * This function cleans up the allocated card buffers.
2260 * The following are freed by this function -
2261 * - TXBD ring buffers
2262 * - RXBD ring buffers
2263 * - Event BD ring buffers
2264 * - Command response ring buffer
2265 * - Sleep cookie buffer
2267 static void mwifiex_pcie_cleanup(struct mwifiex_adapter *adapter)
2269 struct pcie_service_card *card = adapter->card;
2270 struct pci_dev *pdev = card->dev;
2271 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2274 dev_dbg(adapter->dev, "Clearing driver ready signature\n");
2275 if (mwifiex_write_reg(adapter, reg->drv_rdy, 0x00000000))
2276 dev_err(adapter->dev,
2277 "Failed to write driver not-ready signature\n");
2281 pci_iounmap(pdev, card->pci_mmap);
2282 pci_iounmap(pdev, card->pci_mmap1);
2284 pci_release_regions(pdev);
2285 pci_disable_device(pdev);
2286 pci_set_drvdata(pdev, NULL);
2291 * This function registers the PCIE device.
2293 * PCIE IRQ is claimed, block size is set and driver data is initialized.
2295 static int mwifiex_register_dev(struct mwifiex_adapter *adapter)
2298 struct pcie_service_card *card = adapter->card;
2299 struct pci_dev *pdev = card->dev;
2301 /* save adapter pointer in card */
2302 card->adapter = adapter;
2304 ret = request_irq(pdev->irq, mwifiex_pcie_interrupt, IRQF_SHARED,
2307 pr_err("request_irq failed: ret=%d\n", ret);
2308 adapter->card = NULL;
2312 adapter->dev = &pdev->dev;
2313 strcpy(adapter->fw_name, card->pcie.firmware);
2319 * This function unregisters the PCIE device.
2321 * The PCIE IRQ is released, the function is disabled and driver
2322 * data is set to null.
2324 static void mwifiex_unregister_dev(struct mwifiex_adapter *adapter)
2326 struct pcie_service_card *card = adapter->card;
2327 const struct mwifiex_pcie_card_reg *reg;
2330 dev_dbg(adapter->dev, "%s(): calling free_irq()\n", __func__);
2331 free_irq(card->dev->irq, card->dev);
2333 reg = card->pcie.reg;
2334 if (reg->sleep_cookie)
2335 mwifiex_pcie_delete_sleep_cookie_buf(adapter);
2337 mwifiex_pcie_delete_cmdrsp_buf(adapter);
2338 mwifiex_pcie_delete_evtbd_ring(adapter);
2339 mwifiex_pcie_delete_rxbd_ring(adapter);
2340 mwifiex_pcie_delete_txbd_ring(adapter);
2341 card->cmdrsp_buf = NULL;
2345 static struct mwifiex_if_ops pcie_ops = {
2346 .init_if = mwifiex_pcie_init,
2347 .cleanup_if = mwifiex_pcie_cleanup,
2348 .check_fw_status = mwifiex_check_fw_status,
2349 .prog_fw = mwifiex_prog_fw_w_helper,
2350 .register_dev = mwifiex_register_dev,
2351 .unregister_dev = mwifiex_unregister_dev,
2352 .enable_int = mwifiex_pcie_enable_host_int,
2353 .process_int_status = mwifiex_process_int_status,
2354 .host_to_card = mwifiex_pcie_host_to_card,
2355 .wakeup = mwifiex_pm_wakeup_card,
2356 .wakeup_complete = mwifiex_pm_wakeup_card_complete,
2359 .cmdrsp_complete = mwifiex_pcie_cmdrsp_complete,
2360 .event_complete = mwifiex_pcie_event_complete,
2361 .update_mp_end_port = NULL,
2362 .cleanup_mpa_buf = NULL,
2363 .init_fw_port = mwifiex_pcie_init_fw_port,
2364 .clean_pcie_ring = mwifiex_clean_pcie_ring_buf,
2368 * This function initializes the PCIE driver module.
2370 * This initiates the semaphore and registers the device with
2373 static int mwifiex_pcie_init_module(void)
2377 pr_debug("Marvell PCIe Driver\n");
2379 sema_init(&add_remove_card_sem, 1);
2381 /* Clear the flag in case user removes the card. */
2384 ret = pci_register_driver(&mwifiex_pcie);
2386 pr_err("Driver register failed!\n");
2388 pr_debug("info: Driver registered successfully!\n");
2394 * This function cleans up the PCIE driver.
2396 * The following major steps are followed for cleanup -
2397 * - Resume the device if its suspended
2398 * - Disconnect the device if connected
2399 * - Shutdown the firmware
2400 * - Unregister the device from PCIE bus.
2402 static void mwifiex_pcie_cleanup_module(void)
2404 if (!down_interruptible(&add_remove_card_sem))
2405 up(&add_remove_card_sem);
2407 /* Set the flag as user is removing this module. */
2410 pci_unregister_driver(&mwifiex_pcie);
2413 module_init(mwifiex_pcie_init_module);
2414 module_exit(mwifiex_pcie_cleanup_module);
2416 MODULE_AUTHOR("Marvell International Ltd.");
2417 MODULE_DESCRIPTION("Marvell WiFi-Ex PCI-Express Driver version " PCIE_VERSION);
2418 MODULE_VERSION(PCIE_VERSION);
2419 MODULE_LICENSE("GPL v2");
2420 MODULE_FIRMWARE(PCIE8766_DEFAULT_FW_NAME);
2421 MODULE_FIRMWARE(PCIE8897_DEFAULT_FW_NAME);