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 skb_push(skb, INTF_HEADER_LEN);
1512 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1513 PCI_DMA_FROMDEVICE))
1516 MWIFIEX_SKB_PACB(skb, &buf_pa);
1517 } else if (mwifiex_pcie_ok_to_access_hw(adapter)) {
1518 adapter->curr_cmd->resp_skb = skb;
1519 adapter->cmd_resp_received = true;
1520 /* Take the pointer and set it to CMD node and will
1521 return in the response complete callback */
1522 card->cmdrsp_buf = NULL;
1524 /* Clear the cmd-rsp buffer address in scratch registers. This
1525 will prevent firmware from writing to the same response
1527 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo, 0)) {
1528 dev_err(adapter->dev,
1529 "cmd_done: failed to clear cmd_rsp_addr_lo\n");
1532 /* Write the upper 32bits of the cmdrsp buffer physical
1534 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi, 0)) {
1535 dev_err(adapter->dev,
1536 "cmd_done: failed to clear cmd_rsp_addr_hi\n");
1545 * Command Response processing complete handler
1547 static int mwifiex_pcie_cmdrsp_complete(struct mwifiex_adapter *adapter,
1548 struct sk_buff *skb)
1550 struct pcie_service_card *card = adapter->card;
1552 struct sk_buff *skb_tmp;
1555 card->cmdrsp_buf = skb;
1556 skb_push(card->cmdrsp_buf, INTF_HEADER_LEN);
1557 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1558 PCI_DMA_FROMDEVICE))
1562 skb_tmp = card->cmd_buf;
1564 MWIFIEX_SKB_PACB(skb_tmp, &buf_pa);
1565 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1566 PCI_DMA_FROMDEVICE);
1567 card->cmd_buf = NULL;
1574 * This function handles firmware event ready interrupt
1576 static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter *adapter)
1578 struct pcie_service_card *card = adapter->card;
1579 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1580 u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1583 struct mwifiex_evt_buf_desc *desc;
1585 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1586 mwifiex_pm_wakeup_card(adapter);
1588 if (adapter->event_received) {
1589 dev_dbg(adapter->dev, "info: Event being processed, "
1590 "do not process this interrupt just yet\n");
1594 if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1595 dev_dbg(adapter->dev, "info: Invalid read pointer...\n");
1599 /* Read the event ring write pointer set by firmware */
1600 if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1601 dev_err(adapter->dev,
1602 "EventReady: failed to read reg->evt_wrptr\n");
1606 dev_dbg(adapter->dev, "info: EventReady: Initial <Rd: 0x%x, Wr: 0x%x>",
1607 card->evtbd_rdptr, wrptr);
1608 if (((wrptr & MWIFIEX_EVTBD_MASK) != (card->evtbd_rdptr
1609 & MWIFIEX_EVTBD_MASK)) ||
1610 ((wrptr & reg->evt_rollover_ind) ==
1611 (card->evtbd_rdptr & reg->evt_rollover_ind))) {
1612 struct sk_buff *skb_cmd;
1613 __le16 data_len = 0;
1616 dev_dbg(adapter->dev, "info: Read Index: %d\n", rdptr);
1617 skb_cmd = card->evt_buf_list[rdptr];
1618 MWIFIEX_SKB_PACB(skb_cmd, &buf_pa);
1619 pci_unmap_single(card->dev, buf_pa, MAX_EVENT_SIZE,
1620 PCI_DMA_FROMDEVICE);
1622 /* Take the pointer and set it to event pointer in adapter
1623 and will return back after event handling callback */
1624 card->evt_buf_list[rdptr] = NULL;
1625 desc = card->evtbd_ring[rdptr];
1626 memset(desc, 0, sizeof(*desc));
1628 event = *(u32 *) &skb_cmd->data[INTF_HEADER_LEN];
1629 adapter->event_cause = event;
1630 /* The first 4bytes will be the event transfer header
1631 len is 2 bytes followed by type which is 2 bytes */
1632 memcpy(&data_len, skb_cmd->data, sizeof(__le16));
1633 evt_len = le16_to_cpu(data_len);
1635 skb_pull(skb_cmd, INTF_HEADER_LEN);
1636 dev_dbg(adapter->dev, "info: Event length: %d\n", evt_len);
1638 if ((evt_len > 0) && (evt_len < MAX_EVENT_SIZE))
1639 memcpy(adapter->event_body, skb_cmd->data +
1640 MWIFIEX_EVENT_HEADER_LEN, evt_len -
1641 MWIFIEX_EVENT_HEADER_LEN);
1643 adapter->event_received = true;
1644 adapter->event_skb = skb_cmd;
1646 /* Do not update the event read pointer here, wait till the
1647 buffer is released. This is just to make things simpler,
1648 we need to find a better method of managing these buffers.
1656 * Event processing complete handler
1658 static int mwifiex_pcie_event_complete(struct mwifiex_adapter *adapter,
1659 struct sk_buff *skb)
1661 struct pcie_service_card *card = adapter->card;
1662 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1664 u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1667 struct mwifiex_evt_buf_desc *desc;
1672 if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1673 dev_err(adapter->dev, "event_complete: Invalid rdptr 0x%x\n",
1678 /* Read the event ring write pointer set by firmware */
1679 if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1680 dev_err(adapter->dev,
1681 "event_complete: failed to read reg->evt_wrptr\n");
1685 if (!card->evt_buf_list[rdptr]) {
1686 skb_push(skb, INTF_HEADER_LEN);
1687 if (mwifiex_map_pci_memory(adapter, skb,
1689 PCI_DMA_FROMDEVICE))
1691 MWIFIEX_SKB_PACB(skb, &buf_pa);
1692 card->evt_buf_list[rdptr] = skb;
1693 MWIFIEX_SKB_PACB(skb, &buf_pa);
1694 desc = card->evtbd_ring[rdptr];
1695 desc->paddr = buf_pa;
1696 desc->len = (u16)skb->len;
1700 dev_dbg(adapter->dev,
1701 "info: ERROR: buf still valid at index %d, <%p, %p>\n",
1702 rdptr, card->evt_buf_list[rdptr], skb);
1705 if ((++card->evtbd_rdptr & MWIFIEX_EVTBD_MASK) == MWIFIEX_MAX_EVT_BD) {
1706 card->evtbd_rdptr = ((card->evtbd_rdptr &
1707 reg->evt_rollover_ind) ^
1708 reg->evt_rollover_ind);
1711 dev_dbg(adapter->dev, "info: Updated <Rd: 0x%x, Wr: 0x%x>",
1712 card->evtbd_rdptr, wrptr);
1714 /* Write the event ring read pointer in to reg->evt_rdptr */
1715 if (mwifiex_write_reg(adapter, reg->evt_rdptr,
1716 card->evtbd_rdptr)) {
1717 dev_err(adapter->dev,
1718 "event_complete: failed to read reg->evt_rdptr\n");
1722 dev_dbg(adapter->dev, "info: Check Events Again\n");
1723 ret = mwifiex_pcie_process_event_ready(adapter);
1729 * This function downloads the firmware to the card.
1731 * Firmware is downloaded to the card in blocks. Every block download
1732 * is tested for CRC errors, and retried a number of times before
1733 * returning failure.
1735 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter *adapter,
1736 struct mwifiex_fw_image *fw)
1739 u8 *firmware = fw->fw_buf;
1740 u32 firmware_len = fw->fw_len;
1742 struct sk_buff *skb;
1743 u32 txlen, tx_blocks = 0, tries, len;
1744 u32 block_retry_cnt = 0;
1746 struct pcie_service_card *card = adapter->card;
1747 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1749 if (!firmware || !firmware_len) {
1750 dev_err(adapter->dev,
1751 "No firmware image found! Terminating download\n");
1755 dev_dbg(adapter->dev, "info: Downloading FW image (%d bytes)\n",
1758 if (mwifiex_pcie_disable_host_int(adapter)) {
1759 dev_err(adapter->dev,
1760 "%s: Disabling interrupts failed.\n", __func__);
1764 skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
1770 /* Perform firmware data transfer */
1775 if (offset >= firmware_len)
1778 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
1779 ret = mwifiex_read_reg(adapter, reg->cmd_size,
1782 dev_warn(adapter->dev,
1783 "Failed reading len from boot code\n");
1788 usleep_range(10, 20);
1793 } else if (len > MWIFIEX_UPLD_SIZE) {
1794 pr_err("FW download failure @ %d, invalid length %d\n",
1804 if (block_retry_cnt > MAX_WRITE_IOMEM_RETRY) {
1805 pr_err("FW download failure @ %d, over max "
1806 "retry count\n", offset);
1810 dev_err(adapter->dev, "FW CRC error indicated by the "
1811 "helper: len = 0x%04X, txlen = %d\n",
1814 /* Setting this to 0 to resend from same offset */
1817 block_retry_cnt = 0;
1818 /* Set blocksize to transfer - checking for
1820 if (firmware_len - offset < txlen)
1821 txlen = firmware_len - offset;
1823 dev_dbg(adapter->dev, ".");
1825 tx_blocks = (txlen + card->pcie.blksz_fw_dl - 1) /
1826 card->pcie.blksz_fw_dl;
1828 /* Copy payload to buffer */
1829 memmove(skb->data, &firmware[offset], txlen);
1832 skb_put(skb, MWIFIEX_UPLD_SIZE - skb->len);
1833 skb_trim(skb, tx_blocks * card->pcie.blksz_fw_dl);
1835 /* Send the boot command to device */
1836 if (mwifiex_pcie_send_boot_cmd(adapter, skb)) {
1837 dev_err(adapter->dev,
1838 "Failed to send firmware download command\n");
1843 MWIFIEX_SKB_PACB(skb, &buf_pa);
1845 /* Wait for the command done interrupt */
1847 if (mwifiex_read_reg(adapter, PCIE_CPU_INT_STATUS,
1849 dev_err(adapter->dev, "%s: Failed to read "
1850 "interrupt status during fw dnld.\n",
1852 pci_unmap_single(card->dev, buf_pa, skb->len,
1857 } while ((ireg_intr & CPU_INTR_DOOR_BELL) ==
1858 CPU_INTR_DOOR_BELL);
1860 pci_unmap_single(card->dev, buf_pa, skb->len,
1866 dev_dbg(adapter->dev, "info:\nFW download over, size %d bytes\n",
1872 dev_kfree_skb_any(skb);
1877 * This function checks the firmware status in card.
1879 * The winner interface is also determined by this function.
1882 mwifiex_check_fw_status(struct mwifiex_adapter *adapter, u32 poll_num)
1885 u32 firmware_stat, winner_status;
1886 struct pcie_service_card *card = adapter->card;
1887 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1890 /* Mask spurios interrupts */
1891 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS_MASK,
1893 dev_warn(adapter->dev, "Write register failed\n");
1897 dev_dbg(adapter->dev, "Setting driver ready signature\n");
1898 if (mwifiex_write_reg(adapter, reg->drv_rdy,
1899 FIRMWARE_READY_PCIE)) {
1900 dev_err(adapter->dev,
1901 "Failed to write driver ready signature\n");
1905 /* Wait for firmware initialization event */
1906 for (tries = 0; tries < poll_num; tries++) {
1907 if (mwifiex_read_reg(adapter, reg->fw_status,
1914 if (firmware_stat == FIRMWARE_READY_PCIE) {
1924 if (mwifiex_read_reg(adapter, reg->fw_status,
1927 else if (!winner_status) {
1928 dev_err(adapter->dev, "PCI-E is the winner\n");
1929 adapter->winner = 1;
1932 dev_err(adapter->dev,
1933 "PCI-E is not the winner <%#x,%d>, exit dnld\n",
1934 ret, adapter->winner);
1943 * This function reads the interrupt status from card.
1945 static void mwifiex_interrupt_status(struct mwifiex_adapter *adapter)
1948 unsigned long flags;
1950 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1953 if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS, &pcie_ireg)) {
1954 dev_warn(adapter->dev, "Read register failed\n");
1958 if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
1960 mwifiex_pcie_disable_host_int(adapter);
1962 /* Clear the pending interrupts */
1963 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS,
1965 dev_warn(adapter->dev, "Write register failed\n");
1968 spin_lock_irqsave(&adapter->int_lock, flags);
1969 adapter->int_status |= pcie_ireg;
1970 spin_unlock_irqrestore(&adapter->int_lock, flags);
1972 if (pcie_ireg & HOST_INTR_CMD_DONE) {
1973 if ((adapter->ps_state == PS_STATE_SLEEP_CFM) ||
1974 (adapter->ps_state == PS_STATE_SLEEP)) {
1975 mwifiex_pcie_enable_host_int(adapter);
1976 if (mwifiex_write_reg(adapter,
1978 CPU_INTR_SLEEP_CFM_DONE)
1980 dev_warn(adapter->dev,
1981 "Write register failed\n");
1986 } else if (!adapter->pps_uapsd_mode &&
1987 adapter->ps_state == PS_STATE_SLEEP) {
1988 /* Potentially for PCIe we could get other
1989 * interrupts like shared. Don't change power
1990 * state until cookie is set */
1991 if (mwifiex_pcie_ok_to_access_hw(adapter))
1992 adapter->ps_state = PS_STATE_AWAKE;
1998 * Interrupt handler for PCIe root port
2000 * This function reads the interrupt status from firmware and assigns
2001 * the main process in workqueue which will handle the interrupt.
2003 static irqreturn_t mwifiex_pcie_interrupt(int irq, void *context)
2005 struct pci_dev *pdev = (struct pci_dev *)context;
2006 struct pcie_service_card *card;
2007 struct mwifiex_adapter *adapter;
2010 pr_debug("info: %s: pdev is NULL\n", (u8 *)pdev);
2014 card = (struct pcie_service_card *) pci_get_drvdata(pdev);
2015 if (!card || !card->adapter) {
2016 pr_debug("info: %s: card=%p adapter=%p\n", __func__, card,
2017 card ? card->adapter : NULL);
2020 adapter = card->adapter;
2022 if (adapter->surprise_removed)
2025 mwifiex_interrupt_status(adapter);
2026 queue_work(adapter->workqueue, &adapter->main_work);
2033 * This function checks the current interrupt status.
2035 * The following interrupts are checked and handled by this function -
2038 * - Command received
2039 * - Packets received
2042 * In case of Rx packets received, the packets are uploaded from card to
2043 * host and processed accordingly.
2045 static int mwifiex_process_int_status(struct mwifiex_adapter *adapter)
2049 unsigned long flags;
2051 spin_lock_irqsave(&adapter->int_lock, flags);
2052 /* Clear out unused interrupts */
2053 pcie_ireg = adapter->int_status;
2054 adapter->int_status = 0;
2055 spin_unlock_irqrestore(&adapter->int_lock, flags);
2057 while (pcie_ireg & HOST_INTR_MASK) {
2058 if (pcie_ireg & HOST_INTR_DNLD_DONE) {
2059 pcie_ireg &= ~HOST_INTR_DNLD_DONE;
2060 dev_dbg(adapter->dev, "info: TX DNLD Done\n");
2061 ret = mwifiex_pcie_send_data_complete(adapter);
2065 if (pcie_ireg & HOST_INTR_UPLD_RDY) {
2066 pcie_ireg &= ~HOST_INTR_UPLD_RDY;
2067 dev_dbg(adapter->dev, "info: Rx DATA\n");
2068 ret = mwifiex_pcie_process_recv_data(adapter);
2072 if (pcie_ireg & HOST_INTR_EVENT_RDY) {
2073 pcie_ireg &= ~HOST_INTR_EVENT_RDY;
2074 dev_dbg(adapter->dev, "info: Rx EVENT\n");
2075 ret = mwifiex_pcie_process_event_ready(adapter);
2080 if (pcie_ireg & HOST_INTR_CMD_DONE) {
2081 pcie_ireg &= ~HOST_INTR_CMD_DONE;
2082 if (adapter->cmd_sent) {
2083 dev_dbg(adapter->dev,
2084 "info: CMD sent Interrupt\n");
2085 adapter->cmd_sent = false;
2087 /* Handle command response */
2088 ret = mwifiex_pcie_process_cmd_complete(adapter);
2093 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
2094 if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS,
2096 dev_warn(adapter->dev,
2097 "Read register failed\n");
2101 if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
2102 if (mwifiex_write_reg(adapter,
2103 PCIE_HOST_INT_STATUS,
2105 dev_warn(adapter->dev,
2106 "Write register failed\n");
2113 dev_dbg(adapter->dev, "info: cmd_sent=%d data_sent=%d\n",
2114 adapter->cmd_sent, adapter->data_sent);
2115 mwifiex_pcie_enable_host_int(adapter);
2121 * This function downloads data from driver to card.
2123 * Both commands and data packets are transferred to the card by this
2126 * This function adds the PCIE specific header to the front of the buffer
2127 * before transferring. The header contains the length of the packet and
2128 * the type. The firmware handles the packets based upon this set type.
2130 static int mwifiex_pcie_host_to_card(struct mwifiex_adapter *adapter, u8 type,
2131 struct sk_buff *skb,
2132 struct mwifiex_tx_param *tx_param)
2135 dev_err(adapter->dev, "Passed NULL skb to %s\n", __func__);
2139 if (type == MWIFIEX_TYPE_DATA)
2140 return mwifiex_pcie_send_data(adapter, skb, tx_param);
2141 else if (type == MWIFIEX_TYPE_CMD)
2142 return mwifiex_pcie_send_cmd(adapter, skb);
2148 * This function initializes the PCI-E host memory space, WCB rings, etc.
2150 * The following initializations steps are followed -
2151 * - Allocate TXBD ring buffers
2152 * - Allocate RXBD ring buffers
2153 * - Allocate event BD ring buffers
2154 * - Allocate command response ring buffer
2155 * - Allocate sleep cookie buffer
2157 static int mwifiex_pcie_init(struct mwifiex_adapter *adapter)
2159 struct pcie_service_card *card = adapter->card;
2161 struct pci_dev *pdev = card->dev;
2162 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2164 pci_set_drvdata(pdev, card);
2166 ret = pci_enable_device(pdev);
2168 goto err_enable_dev;
2170 pci_set_master(pdev);
2172 dev_dbg(adapter->dev, "try set_consistent_dma_mask(32)\n");
2173 ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2175 dev_err(adapter->dev, "set_dma_mask(32) failed\n");
2176 goto err_set_dma_mask;
2179 ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
2181 dev_err(adapter->dev, "set_consistent_dma_mask(64) failed\n");
2182 goto err_set_dma_mask;
2185 ret = pci_request_region(pdev, 0, DRV_NAME);
2187 dev_err(adapter->dev, "req_reg(0) error\n");
2188 goto err_req_region0;
2190 card->pci_mmap = pci_iomap(pdev, 0, 0);
2191 if (!card->pci_mmap) {
2192 dev_err(adapter->dev, "iomap(0) error\n");
2196 ret = pci_request_region(pdev, 2, DRV_NAME);
2198 dev_err(adapter->dev, "req_reg(2) error\n");
2199 goto err_req_region2;
2201 card->pci_mmap1 = pci_iomap(pdev, 2, 0);
2202 if (!card->pci_mmap1) {
2203 dev_err(adapter->dev, "iomap(2) error\n");
2208 dev_dbg(adapter->dev,
2209 "PCI memory map Virt0: %p PCI memory map Virt2: %p\n",
2210 card->pci_mmap, card->pci_mmap1);
2212 card->cmdrsp_buf = NULL;
2213 ret = mwifiex_pcie_create_txbd_ring(adapter);
2216 ret = mwifiex_pcie_create_rxbd_ring(adapter);
2219 ret = mwifiex_pcie_create_evtbd_ring(adapter);
2222 ret = mwifiex_pcie_alloc_cmdrsp_buf(adapter);
2224 goto err_alloc_cmdbuf;
2225 if (reg->sleep_cookie) {
2226 ret = mwifiex_pcie_alloc_sleep_cookie_buf(adapter);
2228 goto err_alloc_cookie;
2230 card->sleep_cookie_vbase = NULL;
2235 mwifiex_pcie_delete_cmdrsp_buf(adapter);
2237 mwifiex_pcie_delete_evtbd_ring(adapter);
2239 mwifiex_pcie_delete_rxbd_ring(adapter);
2241 mwifiex_pcie_delete_txbd_ring(adapter);
2243 pci_iounmap(pdev, card->pci_mmap1);
2245 pci_release_region(pdev, 2);
2247 pci_iounmap(pdev, card->pci_mmap);
2249 pci_release_region(pdev, 0);
2252 pci_disable_device(pdev);
2254 pci_set_drvdata(pdev, NULL);
2259 * This function cleans up the allocated card buffers.
2261 * The following are freed by this function -
2262 * - TXBD ring buffers
2263 * - RXBD ring buffers
2264 * - Event BD ring buffers
2265 * - Command response ring buffer
2266 * - Sleep cookie buffer
2268 static void mwifiex_pcie_cleanup(struct mwifiex_adapter *adapter)
2270 struct pcie_service_card *card = adapter->card;
2271 struct pci_dev *pdev = card->dev;
2272 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2275 dev_dbg(adapter->dev, "Clearing driver ready signature\n");
2276 if (mwifiex_write_reg(adapter, reg->drv_rdy, 0x00000000))
2277 dev_err(adapter->dev,
2278 "Failed to write driver not-ready signature\n");
2282 pci_iounmap(pdev, card->pci_mmap);
2283 pci_iounmap(pdev, card->pci_mmap1);
2285 pci_release_regions(pdev);
2286 pci_disable_device(pdev);
2287 pci_set_drvdata(pdev, NULL);
2292 * This function registers the PCIE device.
2294 * PCIE IRQ is claimed, block size is set and driver data is initialized.
2296 static int mwifiex_register_dev(struct mwifiex_adapter *adapter)
2299 struct pcie_service_card *card = adapter->card;
2300 struct pci_dev *pdev = card->dev;
2302 /* save adapter pointer in card */
2303 card->adapter = adapter;
2305 ret = request_irq(pdev->irq, mwifiex_pcie_interrupt, IRQF_SHARED,
2308 pr_err("request_irq failed: ret=%d\n", ret);
2309 adapter->card = NULL;
2313 adapter->dev = &pdev->dev;
2314 strcpy(adapter->fw_name, card->pcie.firmware);
2320 * This function unregisters the PCIE device.
2322 * The PCIE IRQ is released, the function is disabled and driver
2323 * data is set to null.
2325 static void mwifiex_unregister_dev(struct mwifiex_adapter *adapter)
2327 struct pcie_service_card *card = adapter->card;
2328 const struct mwifiex_pcie_card_reg *reg;
2331 dev_dbg(adapter->dev, "%s(): calling free_irq()\n", __func__);
2332 free_irq(card->dev->irq, card->dev);
2334 reg = card->pcie.reg;
2335 if (reg->sleep_cookie)
2336 mwifiex_pcie_delete_sleep_cookie_buf(adapter);
2338 mwifiex_pcie_delete_cmdrsp_buf(adapter);
2339 mwifiex_pcie_delete_evtbd_ring(adapter);
2340 mwifiex_pcie_delete_rxbd_ring(adapter);
2341 mwifiex_pcie_delete_txbd_ring(adapter);
2342 card->cmdrsp_buf = NULL;
2346 static struct mwifiex_if_ops pcie_ops = {
2347 .init_if = mwifiex_pcie_init,
2348 .cleanup_if = mwifiex_pcie_cleanup,
2349 .check_fw_status = mwifiex_check_fw_status,
2350 .prog_fw = mwifiex_prog_fw_w_helper,
2351 .register_dev = mwifiex_register_dev,
2352 .unregister_dev = mwifiex_unregister_dev,
2353 .enable_int = mwifiex_pcie_enable_host_int,
2354 .process_int_status = mwifiex_process_int_status,
2355 .host_to_card = mwifiex_pcie_host_to_card,
2356 .wakeup = mwifiex_pm_wakeup_card,
2357 .wakeup_complete = mwifiex_pm_wakeup_card_complete,
2360 .cmdrsp_complete = mwifiex_pcie_cmdrsp_complete,
2361 .event_complete = mwifiex_pcie_event_complete,
2362 .update_mp_end_port = NULL,
2363 .cleanup_mpa_buf = NULL,
2364 .init_fw_port = mwifiex_pcie_init_fw_port,
2365 .clean_pcie_ring = mwifiex_clean_pcie_ring_buf,
2369 * This function initializes the PCIE driver module.
2371 * This initiates the semaphore and registers the device with
2374 static int mwifiex_pcie_init_module(void)
2378 pr_debug("Marvell PCIe Driver\n");
2380 sema_init(&add_remove_card_sem, 1);
2382 /* Clear the flag in case user removes the card. */
2385 ret = pci_register_driver(&mwifiex_pcie);
2387 pr_err("Driver register failed!\n");
2389 pr_debug("info: Driver registered successfully!\n");
2395 * This function cleans up the PCIE driver.
2397 * The following major steps are followed for cleanup -
2398 * - Resume the device if its suspended
2399 * - Disconnect the device if connected
2400 * - Shutdown the firmware
2401 * - Unregister the device from PCIE bus.
2403 static void mwifiex_pcie_cleanup_module(void)
2405 if (!down_interruptible(&add_remove_card_sem))
2406 up(&add_remove_card_sem);
2408 /* Set the flag as user is removing this module. */
2411 pci_unregister_driver(&mwifiex_pcie);
2414 module_init(mwifiex_pcie_init_module);
2415 module_exit(mwifiex_pcie_cleanup_module);
2417 MODULE_AUTHOR("Marvell International Ltd.");
2418 MODULE_DESCRIPTION("Marvell WiFi-Ex PCI-Express Driver version " PCIE_VERSION);
2419 MODULE_VERSION(PCIE_VERSION);
2420 MODULE_LICENSE("GPL v2");
2421 MODULE_FIRMWARE(PCIE8766_DEFAULT_FW_NAME);
2422 MODULE_FIRMWARE(PCIE8897_DEFAULT_FW_NAME);