2 * Marvell Wireless LAN device driver: PCIE specific handling
4 * Copyright (C) 2011, Marvell International Ltd.
6 * This software file (the "File") is distributed by Marvell International
7 * Ltd. under the terms of the GNU General Public License Version 2, June 1991
8 * (the "License"). You may use, redistribute and/or modify this File in
9 * accordance with the terms and conditions of the License, a copy of which
10 * is available by writing to the Free Software Foundation, Inc.,
11 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
12 * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
14 * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
16 * ARE EXPRESSLY DISCLAIMED. The License provides additional details about
17 * this warranty disclaimer.
20 #include <linux/firmware.h>
31 #define PCIE_VERSION "1.0"
32 #define DRV_NAME "Marvell mwifiex PCIe"
36 static struct mwifiex_if_ops pcie_ops
;
38 static struct semaphore add_remove_card_sem
;
41 mwifiex_map_pci_memory(struct mwifiex_adapter
*adapter
, struct sk_buff
*skb
,
42 size_t size
, int flags
)
44 struct pcie_service_card
*card
= adapter
->card
;
45 struct mwifiex_dma_mapping mapping
;
47 mapping
.addr
= pci_map_single(card
->dev
, skb
->data
, size
, flags
);
48 if (pci_dma_mapping_error(card
->dev
, mapping
.addr
)) {
49 dev_err(adapter
->dev
, "failed to map pci memory!\n");
53 memcpy(skb
->cb
, &mapping
, sizeof(mapping
));
57 static void mwifiex_unmap_pci_memory(struct mwifiex_adapter
*adapter
,
58 struct sk_buff
*skb
, int flags
)
60 struct pcie_service_card
*card
= adapter
->card
;
61 struct mwifiex_dma_mapping mapping
;
63 MWIFIEX_SKB_PACB(skb
, &mapping
);
64 pci_unmap_single(card
->dev
, mapping
.addr
, mapping
.len
, flags
);
68 * This function reads sleep cookie and checks if FW is ready
70 static bool mwifiex_pcie_ok_to_access_hw(struct mwifiex_adapter
*adapter
)
73 struct pcie_service_card
*card
= adapter
->card
;
74 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
76 if (!reg
->sleep_cookie
)
79 if (card
->sleep_cookie_vbase
) {
80 cookie_addr
= (u32
*)card
->sleep_cookie_vbase
;
81 dev_dbg(adapter
->dev
, "info: ACCESS_HW: sleep cookie=0x%x\n",
83 if (*cookie_addr
== FW_AWAKE_COOKIE
)
90 #ifdef CONFIG_PM_SLEEP
92 * Kernel needs to suspend all functions separately. Therefore all
93 * registered functions must have drivers with suspend and resume
94 * methods. Failing that the kernel simply removes the whole card.
96 * If already not suspended, this function allocates and sends a host
97 * sleep activate request to the firmware and turns off the traffic.
99 static int mwifiex_pcie_suspend(struct device
*dev
)
101 struct mwifiex_adapter
*adapter
;
102 struct pcie_service_card
*card
;
104 struct pci_dev
*pdev
= to_pci_dev(dev
);
107 card
= pci_get_drvdata(pdev
);
108 if (!card
|| !card
->adapter
) {
109 pr_err("Card or adapter structure is not valid\n");
113 pr_err("PCIE device is not specified\n");
117 adapter
= card
->adapter
;
119 hs_actived
= mwifiex_enable_hs(adapter
);
121 /* Indicate device suspended */
122 adapter
->is_suspended
= true;
123 adapter
->hs_enabling
= false;
129 * Kernel needs to suspend all functions separately. Therefore all
130 * registered functions must have drivers with suspend and resume
131 * methods. Failing that the kernel simply removes the whole card.
133 * If already not resumed, this function turns on the traffic and
134 * sends a host sleep cancel request to the firmware.
136 static int mwifiex_pcie_resume(struct device
*dev
)
138 struct mwifiex_adapter
*adapter
;
139 struct pcie_service_card
*card
;
140 struct pci_dev
*pdev
= to_pci_dev(dev
);
143 card
= pci_get_drvdata(pdev
);
144 if (!card
|| !card
->adapter
) {
145 pr_err("Card or adapter structure is not valid\n");
149 pr_err("PCIE device is not specified\n");
153 adapter
= card
->adapter
;
155 if (!adapter
->is_suspended
) {
156 dev_warn(adapter
->dev
, "Device already resumed\n");
160 adapter
->is_suspended
= false;
162 mwifiex_cancel_hs(mwifiex_get_priv(adapter
, MWIFIEX_BSS_ROLE_STA
),
170 * This function probes an mwifiex device and registers it. It allocates
171 * the card structure, enables PCIE function number and initiates the
172 * device registration and initialization procedure by adding a logical
175 static int mwifiex_pcie_probe(struct pci_dev
*pdev
,
176 const struct pci_device_id
*ent
)
178 struct pcie_service_card
*card
;
180 pr_debug("info: vendor=0x%4.04X device=0x%4.04X rev=%d\n",
181 pdev
->vendor
, pdev
->device
, pdev
->revision
);
183 card
= kzalloc(sizeof(struct pcie_service_card
), GFP_KERNEL
);
189 if (ent
->driver_data
) {
190 struct mwifiex_pcie_device
*data
= (void *)ent
->driver_data
;
191 card
->pcie
.firmware
= data
->firmware
;
192 card
->pcie
.reg
= data
->reg
;
193 card
->pcie
.blksz_fw_dl
= data
->blksz_fw_dl
;
194 card
->pcie
.tx_buf_size
= data
->tx_buf_size
;
197 if (mwifiex_add_card(card
, &add_remove_card_sem
, &pcie_ops
,
199 pr_err("%s failed\n", __func__
);
208 * This function removes the interface and frees up the card structure.
210 static void mwifiex_pcie_remove(struct pci_dev
*pdev
)
212 struct pcie_service_card
*card
;
213 struct mwifiex_adapter
*adapter
;
214 struct mwifiex_private
*priv
;
216 card
= pci_get_drvdata(pdev
);
220 adapter
= card
->adapter
;
221 if (!adapter
|| !adapter
->priv_num
)
225 #ifdef CONFIG_PM_SLEEP
226 if (adapter
->is_suspended
)
227 mwifiex_pcie_resume(&pdev
->dev
);
230 mwifiex_deauthenticate_all(adapter
);
232 priv
= mwifiex_get_priv(adapter
, MWIFIEX_BSS_ROLE_ANY
);
234 mwifiex_disable_auto_ds(priv
);
236 mwifiex_init_shutdown_fw(priv
, MWIFIEX_FUNC_SHUTDOWN
);
239 mwifiex_remove_card(card
->adapter
, &add_remove_card_sem
);
242 static void mwifiex_pcie_shutdown(struct pci_dev
*pdev
)
245 mwifiex_pcie_remove(pdev
);
250 static DEFINE_PCI_DEVICE_TABLE(mwifiex_ids
) = {
252 PCIE_VENDOR_ID_MARVELL
, PCIE_DEVICE_ID_MARVELL_88W8766P
,
253 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0,
254 .driver_data
= (unsigned long) &mwifiex_pcie8766
,
257 PCIE_VENDOR_ID_MARVELL
, PCIE_DEVICE_ID_MARVELL_88W8897
,
258 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0,
259 .driver_data
= (unsigned long) &mwifiex_pcie8897
,
264 MODULE_DEVICE_TABLE(pci
, mwifiex_ids
);
266 #ifdef CONFIG_PM_SLEEP
267 /* Power Management Hooks */
268 static SIMPLE_DEV_PM_OPS(mwifiex_pcie_pm_ops
, mwifiex_pcie_suspend
,
269 mwifiex_pcie_resume
);
272 /* PCI Device Driver */
273 static struct pci_driver __refdata mwifiex_pcie
= {
274 .name
= "mwifiex_pcie",
275 .id_table
= mwifiex_ids
,
276 .probe
= mwifiex_pcie_probe
,
277 .remove
= mwifiex_pcie_remove
,
278 #ifdef CONFIG_PM_SLEEP
280 .pm
= &mwifiex_pcie_pm_ops
,
283 .shutdown
= mwifiex_pcie_shutdown
,
287 * This function writes data into PCIE card register.
289 static int mwifiex_write_reg(struct mwifiex_adapter
*adapter
, int reg
, u32 data
)
291 struct pcie_service_card
*card
= adapter
->card
;
293 iowrite32(data
, card
->pci_mmap1
+ reg
);
299 * This function reads data from PCIE card register.
301 static int mwifiex_read_reg(struct mwifiex_adapter
*adapter
, int reg
, u32
*data
)
303 struct pcie_service_card
*card
= adapter
->card
;
305 *data
= ioread32(card
->pci_mmap1
+ reg
);
311 * This function adds delay loop to ensure FW is awake before proceeding.
313 static void mwifiex_pcie_dev_wakeup_delay(struct mwifiex_adapter
*adapter
)
317 while (mwifiex_pcie_ok_to_access_hw(adapter
)) {
319 usleep_range(10, 20);
328 static void mwifiex_delay_for_sleep_cookie(struct mwifiex_adapter
*adapter
,
329 u32 max_delay_loop_cnt
)
331 struct pcie_service_card
*card
= adapter
->card
;
333 u32 sleep_cookie
, count
;
335 for (count
= 0; count
< max_delay_loop_cnt
; count
++) {
336 buffer
= card
->cmdrsp_buf
->data
- INTF_HEADER_LEN
;
337 sleep_cookie
= *(u32
*)buffer
;
339 if (sleep_cookie
== MWIFIEX_DEF_SLEEP_COOKIE
) {
340 dev_dbg(adapter
->dev
,
341 "sleep cookie found at count %d\n", count
);
344 usleep_range(20, 30);
347 if (count
>= max_delay_loop_cnt
)
348 dev_dbg(adapter
->dev
,
349 "max count reached while accessing sleep cookie\n");
352 /* This function wakes up the card by reading fw_status register. */
353 static int mwifiex_pm_wakeup_card(struct mwifiex_adapter
*adapter
)
356 struct pcie_service_card
*card
= adapter
->card
;
357 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
359 dev_dbg(adapter
->dev
, "event: Wakeup device...\n");
361 if (reg
->sleep_cookie
)
362 mwifiex_pcie_dev_wakeup_delay(adapter
);
364 /* Reading fw_status register will wakeup device */
365 if (mwifiex_read_reg(adapter
, reg
->fw_status
, &fw_status
)) {
366 dev_warn(adapter
->dev
, "Reading fw_status register failed\n");
370 if (reg
->sleep_cookie
) {
371 mwifiex_pcie_dev_wakeup_delay(adapter
);
372 dev_dbg(adapter
->dev
, "PCIE wakeup: Setting PS_STATE_AWAKE\n");
373 adapter
->ps_state
= PS_STATE_AWAKE
;
380 * This function is called after the card has woken up.
382 * The card configuration register is reset.
384 static int mwifiex_pm_wakeup_card_complete(struct mwifiex_adapter
*adapter
)
386 dev_dbg(adapter
->dev
, "cmd: Wakeup device completed\n");
392 * This function disables the host interrupt.
394 * The host interrupt mask is read, the disable bit is reset and
395 * written back to the card host interrupt mask register.
397 static int mwifiex_pcie_disable_host_int(struct mwifiex_adapter
*adapter
)
399 if (mwifiex_pcie_ok_to_access_hw(adapter
)) {
400 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_MASK
,
402 dev_warn(adapter
->dev
, "Disable host interrupt failed\n");
411 * This function enables the host interrupt.
413 * The host interrupt enable mask is written to the card
414 * host interrupt mask register.
416 static int mwifiex_pcie_enable_host_int(struct mwifiex_adapter
*adapter
)
418 if (mwifiex_pcie_ok_to_access_hw(adapter
)) {
419 /* Simply write the mask to the register */
420 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_MASK
,
422 dev_warn(adapter
->dev
, "Enable host interrupt failed\n");
431 * This function initializes TX buffer ring descriptors
433 static int mwifiex_init_txq_ring(struct mwifiex_adapter
*adapter
)
435 struct pcie_service_card
*card
= adapter
->card
;
436 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
437 struct mwifiex_pcie_buf_desc
*desc
;
438 struct mwifiex_pfu_buf_desc
*desc2
;
441 for (i
= 0; i
< MWIFIEX_MAX_TXRX_BD
; i
++) {
442 card
->tx_buf_list
[i
] = NULL
;
443 if (reg
->pfu_enabled
) {
444 card
->txbd_ring
[i
] = (void *)card
->txbd_ring_vbase
+
445 (sizeof(*desc2
) * i
);
446 desc2
= card
->txbd_ring
[i
];
447 memset(desc2
, 0, sizeof(*desc2
));
449 card
->txbd_ring
[i
] = (void *)card
->txbd_ring_vbase
+
451 desc
= card
->txbd_ring
[i
];
452 memset(desc
, 0, sizeof(*desc
));
459 /* This function initializes RX buffer ring descriptors. Each SKB is allocated
460 * here and after mapping PCI memory, its physical address is assigned to
461 * PCIE Rx buffer descriptor's physical address.
463 static int mwifiex_init_rxq_ring(struct mwifiex_adapter
*adapter
)
465 struct pcie_service_card
*card
= adapter
->card
;
466 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
468 struct mwifiex_pcie_buf_desc
*desc
;
469 struct mwifiex_pfu_buf_desc
*desc2
;
473 for (i
= 0; i
< MWIFIEX_MAX_TXRX_BD
; i
++) {
474 /* Allocate skb here so that firmware can DMA data from it */
475 skb
= dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE
);
477 dev_err(adapter
->dev
,
478 "Unable to allocate skb for RX ring.\n");
479 kfree(card
->rxbd_ring_vbase
);
483 if (mwifiex_map_pci_memory(adapter
, skb
,
484 MWIFIEX_RX_DATA_BUF_SIZE
,
488 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb
);
490 dev_dbg(adapter
->dev
,
491 "info: RX ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
492 skb
, skb
->len
, skb
->data
, (u32
)buf_pa
,
493 (u32
)((u64
)buf_pa
>> 32));
495 card
->rx_buf_list
[i
] = skb
;
496 if (reg
->pfu_enabled
) {
497 card
->rxbd_ring
[i
] = (void *)card
->rxbd_ring_vbase
+
498 (sizeof(*desc2
) * i
);
499 desc2
= card
->rxbd_ring
[i
];
500 desc2
->paddr
= buf_pa
;
501 desc2
->len
= (u16
)skb
->len
;
502 desc2
->frag_len
= (u16
)skb
->len
;
503 desc2
->flags
= reg
->ring_flag_eop
| reg
->ring_flag_sop
;
506 card
->rxbd_ring
[i
] = (void *)(card
->rxbd_ring_vbase
+
507 (sizeof(*desc
) * i
));
508 desc
= card
->rxbd_ring
[i
];
509 desc
->paddr
= buf_pa
;
510 desc
->len
= (u16
)skb
->len
;
518 /* This function initializes event buffer ring descriptors. Each SKB is
519 * allocated here and after mapping PCI memory, its physical address is assigned
520 * to PCIE Rx buffer descriptor's physical address
522 static int mwifiex_pcie_init_evt_ring(struct mwifiex_adapter
*adapter
)
524 struct pcie_service_card
*card
= adapter
->card
;
525 struct mwifiex_evt_buf_desc
*desc
;
530 for (i
= 0; i
< MWIFIEX_MAX_EVT_BD
; i
++) {
531 /* Allocate skb here so that firmware can DMA data from it */
532 skb
= dev_alloc_skb(MAX_EVENT_SIZE
);
534 dev_err(adapter
->dev
,
535 "Unable to allocate skb for EVENT buf.\n");
536 kfree(card
->evtbd_ring_vbase
);
539 skb_put(skb
, MAX_EVENT_SIZE
);
541 if (mwifiex_map_pci_memory(adapter
, skb
, MAX_EVENT_SIZE
,
545 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb
);
547 dev_dbg(adapter
->dev
,
548 "info: EVT ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
549 skb
, skb
->len
, skb
->data
, (u32
)buf_pa
,
550 (u32
)((u64
)buf_pa
>> 32));
552 card
->evt_buf_list
[i
] = skb
;
553 card
->evtbd_ring
[i
] = (void *)(card
->evtbd_ring_vbase
+
554 (sizeof(*desc
) * i
));
555 desc
= card
->evtbd_ring
[i
];
556 desc
->paddr
= buf_pa
;
557 desc
->len
= (u16
)skb
->len
;
564 /* This function cleans up TX buffer rings. If any of the buffer list has valid
565 * SKB address, associated SKB is freed.
567 static void mwifiex_cleanup_txq_ring(struct mwifiex_adapter
*adapter
)
569 struct pcie_service_card
*card
= adapter
->card
;
570 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
572 struct mwifiex_pcie_buf_desc
*desc
;
573 struct mwifiex_pfu_buf_desc
*desc2
;
576 for (i
= 0; i
< MWIFIEX_MAX_TXRX_BD
; i
++) {
577 if (reg
->pfu_enabled
) {
578 desc2
= card
->txbd_ring
[i
];
579 if (card
->tx_buf_list
[i
]) {
580 skb
= card
->tx_buf_list
[i
];
581 mwifiex_unmap_pci_memory(adapter
, skb
,
583 dev_kfree_skb_any(skb
);
585 memset(desc2
, 0, sizeof(*desc2
));
587 desc
= card
->txbd_ring
[i
];
588 if (card
->tx_buf_list
[i
]) {
589 skb
= card
->tx_buf_list
[i
];
590 mwifiex_unmap_pci_memory(adapter
, skb
,
592 dev_kfree_skb_any(skb
);
594 memset(desc
, 0, sizeof(*desc
));
596 card
->tx_buf_list
[i
] = NULL
;
602 /* This function cleans up RX buffer rings. If any of the buffer list has valid
603 * SKB address, associated SKB is freed.
605 static void mwifiex_cleanup_rxq_ring(struct mwifiex_adapter
*adapter
)
607 struct pcie_service_card
*card
= adapter
->card
;
608 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
609 struct mwifiex_pcie_buf_desc
*desc
;
610 struct mwifiex_pfu_buf_desc
*desc2
;
614 for (i
= 0; i
< MWIFIEX_MAX_TXRX_BD
; i
++) {
615 if (reg
->pfu_enabled
) {
616 desc2
= card
->rxbd_ring
[i
];
617 if (card
->rx_buf_list
[i
]) {
618 skb
= card
->rx_buf_list
[i
];
619 mwifiex_unmap_pci_memory(adapter
, skb
,
621 dev_kfree_skb_any(skb
);
623 memset(desc2
, 0, sizeof(*desc2
));
625 desc
= card
->rxbd_ring
[i
];
626 if (card
->rx_buf_list
[i
]) {
627 skb
= card
->rx_buf_list
[i
];
628 mwifiex_unmap_pci_memory(adapter
, skb
,
630 dev_kfree_skb_any(skb
);
632 memset(desc
, 0, sizeof(*desc
));
634 card
->rx_buf_list
[i
] = NULL
;
640 /* This function cleans up event buffer rings. If any of the buffer list has
641 * valid SKB address, associated SKB is freed.
643 static void mwifiex_cleanup_evt_ring(struct mwifiex_adapter
*adapter
)
645 struct pcie_service_card
*card
= adapter
->card
;
646 struct mwifiex_evt_buf_desc
*desc
;
650 for (i
= 0; i
< MWIFIEX_MAX_EVT_BD
; i
++) {
651 desc
= card
->evtbd_ring
[i
];
652 if (card
->evt_buf_list
[i
]) {
653 skb
= card
->evt_buf_list
[i
];
654 mwifiex_unmap_pci_memory(adapter
, skb
,
656 dev_kfree_skb_any(skb
);
658 card
->evt_buf_list
[i
] = NULL
;
659 memset(desc
, 0, sizeof(*desc
));
665 /* This function creates buffer descriptor ring for TX
667 static int mwifiex_pcie_create_txbd_ring(struct mwifiex_adapter
*adapter
)
669 struct pcie_service_card
*card
= adapter
->card
;
670 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
673 * driver maintaines the write pointer and firmware maintaines the read
674 * pointer. The write pointer starts at 0 (zero) while the read pointer
675 * starts at zero with rollover bit set
677 card
->txbd_wrptr
= 0;
679 if (reg
->pfu_enabled
)
680 card
->txbd_rdptr
= 0;
682 card
->txbd_rdptr
|= reg
->tx_rollover_ind
;
684 /* allocate shared memory for the BD ring and divide the same in to
685 several descriptors */
686 if (reg
->pfu_enabled
)
687 card
->txbd_ring_size
= sizeof(struct mwifiex_pfu_buf_desc
) *
690 card
->txbd_ring_size
= sizeof(struct mwifiex_pcie_buf_desc
) *
693 dev_dbg(adapter
->dev
, "info: txbd_ring: Allocating %d bytes\n",
694 card
->txbd_ring_size
);
695 card
->txbd_ring_vbase
= pci_alloc_consistent(card
->dev
,
696 card
->txbd_ring_size
,
697 &card
->txbd_ring_pbase
);
698 if (!card
->txbd_ring_vbase
) {
699 dev_err(adapter
->dev
,
700 "allocate consistent memory (%d bytes) failed!\n",
701 card
->txbd_ring_size
);
704 dev_dbg(adapter
->dev
,
705 "info: txbd_ring - base: %p, pbase: %#x:%x, len: %x\n",
706 card
->txbd_ring_vbase
, (unsigned int)card
->txbd_ring_pbase
,
707 (u32
)((u64
)card
->txbd_ring_pbase
>> 32), card
->txbd_ring_size
);
709 return mwifiex_init_txq_ring(adapter
);
712 static int mwifiex_pcie_delete_txbd_ring(struct mwifiex_adapter
*adapter
)
714 struct pcie_service_card
*card
= adapter
->card
;
715 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
717 mwifiex_cleanup_txq_ring(adapter
);
719 if (card
->txbd_ring_vbase
)
720 pci_free_consistent(card
->dev
, card
->txbd_ring_size
,
721 card
->txbd_ring_vbase
,
722 card
->txbd_ring_pbase
);
723 card
->txbd_ring_size
= 0;
724 card
->txbd_wrptr
= 0;
725 card
->txbd_rdptr
= 0 | reg
->tx_rollover_ind
;
726 card
->txbd_ring_vbase
= NULL
;
727 card
->txbd_ring_pbase
= 0;
733 * This function creates buffer descriptor ring for RX
735 static int mwifiex_pcie_create_rxbd_ring(struct mwifiex_adapter
*adapter
)
737 struct pcie_service_card
*card
= adapter
->card
;
738 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
741 * driver maintaines the read pointer and firmware maintaines the write
742 * pointer. The write pointer starts at 0 (zero) while the read pointer
743 * starts at zero with rollover bit set
745 card
->rxbd_wrptr
= 0;
746 card
->rxbd_rdptr
= reg
->rx_rollover_ind
;
748 if (reg
->pfu_enabled
)
749 card
->rxbd_ring_size
= sizeof(struct mwifiex_pfu_buf_desc
) *
752 card
->rxbd_ring_size
= sizeof(struct mwifiex_pcie_buf_desc
) *
755 dev_dbg(adapter
->dev
, "info: rxbd_ring: Allocating %d bytes\n",
756 card
->rxbd_ring_size
);
757 card
->rxbd_ring_vbase
= pci_alloc_consistent(card
->dev
,
758 card
->rxbd_ring_size
,
759 &card
->rxbd_ring_pbase
);
760 if (!card
->rxbd_ring_vbase
) {
761 dev_err(adapter
->dev
,
762 "allocate consistent memory (%d bytes) failed!\n",
763 card
->rxbd_ring_size
);
767 dev_dbg(adapter
->dev
,
768 "info: rxbd_ring - base: %p, pbase: %#x:%x, len: %#x\n",
769 card
->rxbd_ring_vbase
, (u32
)card
->rxbd_ring_pbase
,
770 (u32
)((u64
)card
->rxbd_ring_pbase
>> 32),
771 card
->rxbd_ring_size
);
773 return mwifiex_init_rxq_ring(adapter
);
777 * This function deletes Buffer descriptor ring for RX
779 static int mwifiex_pcie_delete_rxbd_ring(struct mwifiex_adapter
*adapter
)
781 struct pcie_service_card
*card
= adapter
->card
;
782 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
784 mwifiex_cleanup_rxq_ring(adapter
);
786 if (card
->rxbd_ring_vbase
)
787 pci_free_consistent(card
->dev
, card
->rxbd_ring_size
,
788 card
->rxbd_ring_vbase
,
789 card
->rxbd_ring_pbase
);
790 card
->rxbd_ring_size
= 0;
791 card
->rxbd_wrptr
= 0;
792 card
->rxbd_rdptr
= 0 | reg
->rx_rollover_ind
;
793 card
->rxbd_ring_vbase
= NULL
;
794 card
->rxbd_ring_pbase
= 0;
800 * This function creates buffer descriptor ring for Events
802 static int mwifiex_pcie_create_evtbd_ring(struct mwifiex_adapter
*adapter
)
804 struct pcie_service_card
*card
= adapter
->card
;
805 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
808 * driver maintaines the read pointer and firmware maintaines the write
809 * pointer. The write pointer starts at 0 (zero) while the read pointer
810 * starts at zero with rollover bit set
812 card
->evtbd_wrptr
= 0;
813 card
->evtbd_rdptr
= reg
->evt_rollover_ind
;
815 card
->evtbd_ring_size
= sizeof(struct mwifiex_evt_buf_desc
) *
818 dev_dbg(adapter
->dev
, "info: evtbd_ring: Allocating %d bytes\n",
819 card
->evtbd_ring_size
);
820 card
->evtbd_ring_vbase
= pci_alloc_consistent(card
->dev
,
821 card
->evtbd_ring_size
,
822 &card
->evtbd_ring_pbase
);
823 if (!card
->evtbd_ring_vbase
) {
824 dev_err(adapter
->dev
,
825 "allocate consistent memory (%d bytes) failed!\n",
826 card
->evtbd_ring_size
);
830 dev_dbg(adapter
->dev
,
831 "info: CMDRSP/EVT bd_ring - base: %p pbase: %#x:%x len: %#x\n",
832 card
->evtbd_ring_vbase
, (u32
)card
->evtbd_ring_pbase
,
833 (u32
)((u64
)card
->evtbd_ring_pbase
>> 32),
834 card
->evtbd_ring_size
);
836 return mwifiex_pcie_init_evt_ring(adapter
);
840 * This function deletes Buffer descriptor ring for Events
842 static int mwifiex_pcie_delete_evtbd_ring(struct mwifiex_adapter
*adapter
)
844 struct pcie_service_card
*card
= adapter
->card
;
845 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
847 mwifiex_cleanup_evt_ring(adapter
);
849 if (card
->evtbd_ring_vbase
)
850 pci_free_consistent(card
->dev
, card
->evtbd_ring_size
,
851 card
->evtbd_ring_vbase
,
852 card
->evtbd_ring_pbase
);
853 card
->evtbd_wrptr
= 0;
854 card
->evtbd_rdptr
= 0 | reg
->evt_rollover_ind
;
855 card
->evtbd_ring_size
= 0;
856 card
->evtbd_ring_vbase
= NULL
;
857 card
->evtbd_ring_pbase
= 0;
863 * This function allocates a buffer for CMDRSP
865 static int mwifiex_pcie_alloc_cmdrsp_buf(struct mwifiex_adapter
*adapter
)
867 struct pcie_service_card
*card
= adapter
->card
;
870 /* Allocate memory for receiving command response data */
871 skb
= dev_alloc_skb(MWIFIEX_UPLD_SIZE
);
873 dev_err(adapter
->dev
,
874 "Unable to allocate skb for command response data.\n");
877 skb_put(skb
, MWIFIEX_UPLD_SIZE
);
878 if (mwifiex_map_pci_memory(adapter
, skb
, MWIFIEX_UPLD_SIZE
,
882 card
->cmdrsp_buf
= skb
;
888 * This function deletes a buffer for CMDRSP
890 static int mwifiex_pcie_delete_cmdrsp_buf(struct mwifiex_adapter
*adapter
)
892 struct pcie_service_card
*card
;
897 card
= adapter
->card
;
899 if (card
&& card
->cmdrsp_buf
) {
900 mwifiex_unmap_pci_memory(adapter
, card
->cmdrsp_buf
,
902 dev_kfree_skb_any(card
->cmdrsp_buf
);
905 if (card
&& card
->cmd_buf
) {
906 mwifiex_unmap_pci_memory(adapter
, card
->cmd_buf
,
913 * This function allocates a buffer for sleep cookie
915 static int mwifiex_pcie_alloc_sleep_cookie_buf(struct mwifiex_adapter
*adapter
)
917 struct pcie_service_card
*card
= adapter
->card
;
919 card
->sleep_cookie_vbase
= pci_alloc_consistent(card
->dev
, sizeof(u32
),
920 &card
->sleep_cookie_pbase
);
921 if (!card
->sleep_cookie_vbase
) {
922 dev_err(adapter
->dev
, "pci_alloc_consistent failed!\n");
925 /* Init val of Sleep Cookie */
926 *(u32
*)card
->sleep_cookie_vbase
= FW_AWAKE_COOKIE
;
928 dev_dbg(adapter
->dev
, "alloc_scook: sleep cookie=0x%x\n",
929 *((u32
*)card
->sleep_cookie_vbase
));
935 * This function deletes buffer for sleep cookie
937 static int mwifiex_pcie_delete_sleep_cookie_buf(struct mwifiex_adapter
*adapter
)
939 struct pcie_service_card
*card
;
944 card
= adapter
->card
;
946 if (card
&& card
->sleep_cookie_vbase
) {
947 pci_free_consistent(card
->dev
, sizeof(u32
),
948 card
->sleep_cookie_vbase
,
949 card
->sleep_cookie_pbase
);
950 card
->sleep_cookie_vbase
= NULL
;
956 /* This function flushes the TX buffer descriptor ring
957 * This function defined as handler is also called while cleaning TXRX
958 * during disconnect/ bss stop.
960 static int mwifiex_clean_pcie_ring_buf(struct mwifiex_adapter
*adapter
)
962 struct pcie_service_card
*card
= adapter
->card
;
964 if (!mwifiex_pcie_txbd_empty(card
, card
->txbd_rdptr
)) {
965 card
->txbd_flush
= 1;
966 /* write pointer already set at last send
967 * send dnld-rdy intr again, wait for completion.
969 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
970 CPU_INTR_DNLD_RDY
)) {
971 dev_err(adapter
->dev
,
972 "failed to assert dnld-rdy interrupt.\n");
980 * This function unmaps and frees downloaded data buffer
982 static int mwifiex_pcie_send_data_complete(struct mwifiex_adapter
*adapter
)
985 u32 wrdoneidx
, rdptr
, num_tx_buffs
, unmap_count
= 0;
986 struct mwifiex_pcie_buf_desc
*desc
;
987 struct mwifiex_pfu_buf_desc
*desc2
;
988 struct pcie_service_card
*card
= adapter
->card
;
989 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
991 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
992 mwifiex_pm_wakeup_card(adapter
);
994 /* Read the TX ring read pointer set by firmware */
995 if (mwifiex_read_reg(adapter
, reg
->tx_rdptr
, &rdptr
)) {
996 dev_err(adapter
->dev
,
997 "SEND COMP: failed to read reg->tx_rdptr\n");
1001 dev_dbg(adapter
->dev
, "SEND COMP: rdptr_prev=0x%x, rdptr=0x%x\n",
1002 card
->txbd_rdptr
, rdptr
);
1004 num_tx_buffs
= MWIFIEX_MAX_TXRX_BD
<< reg
->tx_start_ptr
;
1005 /* free from previous txbd_rdptr to current txbd_rdptr */
1006 while (((card
->txbd_rdptr
& reg
->tx_mask
) !=
1007 (rdptr
& reg
->tx_mask
)) ||
1008 ((card
->txbd_rdptr
& reg
->tx_rollover_ind
) !=
1009 (rdptr
& reg
->tx_rollover_ind
))) {
1010 wrdoneidx
= (card
->txbd_rdptr
& reg
->tx_mask
) >>
1013 skb
= card
->tx_buf_list
[wrdoneidx
];
1016 dev_dbg(adapter
->dev
,
1017 "SEND COMP: Detach skb %p at txbd_rdidx=%d\n",
1019 mwifiex_unmap_pci_memory(adapter
, skb
,
1024 if (card
->txbd_flush
)
1025 mwifiex_write_data_complete(adapter
, skb
, 0,
1028 mwifiex_write_data_complete(adapter
, skb
, 0, 0);
1031 card
->tx_buf_list
[wrdoneidx
] = NULL
;
1033 if (reg
->pfu_enabled
) {
1034 desc2
= card
->txbd_ring
[wrdoneidx
];
1035 memset(desc2
, 0, sizeof(*desc2
));
1037 desc
= card
->txbd_ring
[wrdoneidx
];
1038 memset(desc
, 0, sizeof(*desc
));
1040 switch (card
->dev
->device
) {
1041 case PCIE_DEVICE_ID_MARVELL_88W8766P
:
1044 case PCIE_DEVICE_ID_MARVELL_88W8897
:
1045 card
->txbd_rdptr
+= reg
->ring_tx_start_ptr
;
1050 if ((card
->txbd_rdptr
& reg
->tx_mask
) == num_tx_buffs
)
1051 card
->txbd_rdptr
= ((card
->txbd_rdptr
&
1052 reg
->tx_rollover_ind
) ^
1053 reg
->tx_rollover_ind
);
1057 adapter
->data_sent
= false;
1059 if (card
->txbd_flush
) {
1060 if (mwifiex_pcie_txbd_empty(card
, card
->txbd_rdptr
))
1061 card
->txbd_flush
= 0;
1063 mwifiex_clean_pcie_ring_buf(adapter
);
1069 /* This function sends data buffer to device. First 4 bytes of payload
1070 * are filled with payload length and payload type. Then this payload
1071 * is mapped to PCI device memory. Tx ring pointers are advanced accordingly.
1072 * Download ready interrupt to FW is deffered if Tx ring is not full and
1073 * additional payload can be accomodated.
1074 * Caller must ensure tx_param parameter to this function is not NULL.
1077 mwifiex_pcie_send_data(struct mwifiex_adapter
*adapter
, struct sk_buff
*skb
,
1078 struct mwifiex_tx_param
*tx_param
)
1080 struct pcie_service_card
*card
= adapter
->card
;
1081 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1082 u32 wrindx
, num_tx_buffs
, rx_val
;
1085 struct mwifiex_pcie_buf_desc
*desc
= NULL
;
1086 struct mwifiex_pfu_buf_desc
*desc2
= NULL
;
1089 if (!(skb
->data
&& skb
->len
)) {
1090 dev_err(adapter
->dev
, "%s(): invalid parameter <%p, %#x>\n",
1091 __func__
, skb
->data
, skb
->len
);
1095 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1096 mwifiex_pm_wakeup_card(adapter
);
1098 num_tx_buffs
= MWIFIEX_MAX_TXRX_BD
<< reg
->tx_start_ptr
;
1099 dev_dbg(adapter
->dev
, "info: SEND DATA: <Rd: %#x, Wr: %#x>\n",
1100 card
->txbd_rdptr
, card
->txbd_wrptr
);
1101 if (mwifiex_pcie_txbd_not_full(card
)) {
1104 adapter
->data_sent
= true;
1105 payload
= skb
->data
;
1106 tmp
= (__le16
*)&payload
[0];
1107 *tmp
= cpu_to_le16((u16
)skb
->len
);
1108 tmp
= (__le16
*)&payload
[2];
1109 *tmp
= cpu_to_le16(MWIFIEX_TYPE_DATA
);
1111 if (mwifiex_map_pci_memory(adapter
, skb
, skb
->len
,
1115 wrindx
= (card
->txbd_wrptr
& reg
->tx_mask
) >> reg
->tx_start_ptr
;
1116 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb
);
1117 card
->tx_buf_list
[wrindx
] = skb
;
1119 if (reg
->pfu_enabled
) {
1120 desc2
= card
->txbd_ring
[wrindx
];
1121 desc2
->paddr
= buf_pa
;
1122 desc2
->len
= (u16
)skb
->len
;
1123 desc2
->frag_len
= (u16
)skb
->len
;
1125 desc2
->flags
= MWIFIEX_BD_FLAG_FIRST_DESC
|
1126 MWIFIEX_BD_FLAG_LAST_DESC
;
1128 desc
= card
->txbd_ring
[wrindx
];
1129 desc
->paddr
= buf_pa
;
1130 desc
->len
= (u16
)skb
->len
;
1131 desc
->flags
= MWIFIEX_BD_FLAG_FIRST_DESC
|
1132 MWIFIEX_BD_FLAG_LAST_DESC
;
1135 switch (card
->dev
->device
) {
1136 case PCIE_DEVICE_ID_MARVELL_88W8766P
:
1139 case PCIE_DEVICE_ID_MARVELL_88W8897
:
1140 card
->txbd_wrptr
+= reg
->ring_tx_start_ptr
;
1144 if ((card
->txbd_wrptr
& reg
->tx_mask
) == num_tx_buffs
)
1145 card
->txbd_wrptr
= ((card
->txbd_wrptr
&
1146 reg
->tx_rollover_ind
) ^
1147 reg
->tx_rollover_ind
);
1149 rx_val
= card
->rxbd_rdptr
& reg
->rx_wrap_mask
;
1150 /* Write the TX ring write pointer in to reg->tx_wrptr */
1151 if (mwifiex_write_reg(adapter
, reg
->tx_wrptr
,
1152 card
->txbd_wrptr
| rx_val
)) {
1153 dev_err(adapter
->dev
,
1154 "SEND DATA: failed to write reg->tx_wrptr\n");
1158 if ((mwifiex_pcie_txbd_not_full(card
)) &&
1159 tx_param
->next_pkt_len
) {
1160 /* have more packets and TxBD still can hold more */
1161 dev_dbg(adapter
->dev
,
1162 "SEND DATA: delay dnld-rdy interrupt.\n");
1163 adapter
->data_sent
= false;
1165 /* Send the TX ready interrupt */
1166 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1167 CPU_INTR_DNLD_RDY
)) {
1168 dev_err(adapter
->dev
,
1169 "SEND DATA: failed to assert dnld-rdy interrupt.\n");
1174 dev_dbg(adapter
->dev
, "info: SEND DATA: Updated <Rd: %#x, Wr: "
1175 "%#x> and sent packet to firmware successfully\n",
1176 card
->txbd_rdptr
, card
->txbd_wrptr
);
1178 dev_dbg(adapter
->dev
,
1179 "info: TX Ring full, can't send packets to fw\n");
1180 adapter
->data_sent
= true;
1181 /* Send the TX ready interrupt */
1182 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1184 dev_err(adapter
->dev
,
1185 "SEND DATA: failed to assert door-bell intr\n");
1189 return -EINPROGRESS
;
1191 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1192 card
->tx_buf_list
[wrindx
] = NULL
;
1193 if (reg
->pfu_enabled
)
1194 memset(desc2
, 0, sizeof(*desc2
));
1196 memset(desc
, 0, sizeof(*desc
));
1202 * This function handles received buffer ring and
1203 * dispatches packets to upper
1205 static int mwifiex_pcie_process_recv_data(struct mwifiex_adapter
*adapter
)
1207 struct pcie_service_card
*card
= adapter
->card
;
1208 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1209 u32 wrptr
, rd_index
, tx_val
;
1212 struct sk_buff
*skb_tmp
= NULL
;
1213 struct mwifiex_pcie_buf_desc
*desc
;
1214 struct mwifiex_pfu_buf_desc
*desc2
;
1216 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1217 mwifiex_pm_wakeup_card(adapter
);
1219 /* Read the RX ring Write pointer set by firmware */
1220 if (mwifiex_read_reg(adapter
, reg
->rx_wrptr
, &wrptr
)) {
1221 dev_err(adapter
->dev
,
1222 "RECV DATA: failed to read reg->rx_wrptr\n");
1226 card
->rxbd_wrptr
= wrptr
;
1228 while (((wrptr
& reg
->rx_mask
) !=
1229 (card
->rxbd_rdptr
& reg
->rx_mask
)) ||
1230 ((wrptr
& reg
->rx_rollover_ind
) ==
1231 (card
->rxbd_rdptr
& reg
->rx_rollover_ind
))) {
1232 struct sk_buff
*skb_data
;
1236 rd_index
= card
->rxbd_rdptr
& reg
->rx_mask
;
1237 skb_data
= card
->rx_buf_list
[rd_index
];
1239 /* If skb allocation was failed earlier for Rx packet,
1240 * rx_buf_list[rd_index] would have been left with a NULL.
1245 mwifiex_unmap_pci_memory(adapter
, skb_data
, PCI_DMA_FROMDEVICE
);
1246 card
->rx_buf_list
[rd_index
] = NULL
;
1248 /* Get data length from interface header -
1249 * first 2 bytes for len, next 2 bytes is for type
1251 pkt_len
= *((__le16
*)skb_data
->data
);
1252 rx_len
= le16_to_cpu(pkt_len
);
1253 skb_put(skb_data
, rx_len
);
1254 dev_dbg(adapter
->dev
,
1255 "info: RECV DATA: Rd=%#x, Wr=%#x, Len=%d\n",
1256 card
->rxbd_rdptr
, wrptr
, rx_len
);
1257 skb_pull(skb_data
, INTF_HEADER_LEN
);
1258 mwifiex_handle_rx_packet(adapter
, skb_data
);
1260 skb_tmp
= dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE
);
1262 dev_err(adapter
->dev
,
1263 "Unable to allocate skb.\n");
1267 if (mwifiex_map_pci_memory(adapter
, skb_tmp
,
1268 MWIFIEX_RX_DATA_BUF_SIZE
,
1269 PCI_DMA_FROMDEVICE
))
1272 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb_tmp
);
1274 dev_dbg(adapter
->dev
,
1275 "RECV DATA: Attach new sk_buff %p at rxbd_rdidx=%d\n",
1277 card
->rx_buf_list
[rd_index
] = skb_tmp
;
1279 if (reg
->pfu_enabled
) {
1280 desc2
= card
->rxbd_ring
[rd_index
];
1281 desc2
->paddr
= buf_pa
;
1282 desc2
->len
= skb_tmp
->len
;
1283 desc2
->frag_len
= skb_tmp
->len
;
1285 desc2
->flags
= reg
->ring_flag_sop
| reg
->ring_flag_eop
;
1287 desc
= card
->rxbd_ring
[rd_index
];
1288 desc
->paddr
= buf_pa
;
1289 desc
->len
= skb_tmp
->len
;
1293 if ((++card
->rxbd_rdptr
& reg
->rx_mask
) ==
1294 MWIFIEX_MAX_TXRX_BD
) {
1295 card
->rxbd_rdptr
= ((card
->rxbd_rdptr
&
1296 reg
->rx_rollover_ind
) ^
1297 reg
->rx_rollover_ind
);
1299 dev_dbg(adapter
->dev
, "info: RECV DATA: <Rd: %#x, Wr: %#x>\n",
1300 card
->rxbd_rdptr
, wrptr
);
1302 tx_val
= card
->txbd_wrptr
& reg
->tx_wrap_mask
;
1303 /* Write the RX ring read pointer in to reg->rx_rdptr */
1304 if (mwifiex_write_reg(adapter
, reg
->rx_rdptr
,
1305 card
->rxbd_rdptr
| tx_val
)) {
1306 dev_err(adapter
->dev
,
1307 "RECV DATA: failed to write reg->rx_rdptr\n");
1312 /* Read the RX ring Write pointer set by firmware */
1313 if (mwifiex_read_reg(adapter
, reg
->rx_wrptr
, &wrptr
)) {
1314 dev_err(adapter
->dev
,
1315 "RECV DATA: failed to read reg->rx_wrptr\n");
1319 dev_dbg(adapter
->dev
,
1320 "info: RECV DATA: Rcvd packet from fw successfully\n");
1321 card
->rxbd_wrptr
= wrptr
;
1329 * This function downloads the boot command to device
1332 mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter
*adapter
, struct sk_buff
*skb
)
1335 struct pcie_service_card
*card
= adapter
->card
;
1336 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1338 if (!(skb
->data
&& skb
->len
)) {
1339 dev_err(adapter
->dev
,
1340 "Invalid parameter in %s <%p. len %d>\n",
1341 __func__
, skb
->data
, skb
->len
);
1345 if (mwifiex_map_pci_memory(adapter
, skb
, skb
->len
, PCI_DMA_TODEVICE
))
1348 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb
);
1350 /* Write the lower 32bits of the physical address to low command
1351 * address scratch register
1353 if (mwifiex_write_reg(adapter
, reg
->cmd_addr_lo
, (u32
)buf_pa
)) {
1354 dev_err(adapter
->dev
,
1355 "%s: failed to write download command to boot code.\n",
1357 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1361 /* Write the upper 32bits of the physical address to high command
1362 * address scratch register
1364 if (mwifiex_write_reg(adapter
, reg
->cmd_addr_hi
,
1365 (u32
)((u64
)buf_pa
>> 32))) {
1366 dev_err(adapter
->dev
,
1367 "%s: failed to write download command to boot code.\n",
1369 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1373 /* Write the command length to cmd_size scratch register */
1374 if (mwifiex_write_reg(adapter
, reg
->cmd_size
, skb
->len
)) {
1375 dev_err(adapter
->dev
,
1376 "%s: failed to write command len to cmd_size scratch reg\n",
1378 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1382 /* Ring the door bell */
1383 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1384 CPU_INTR_DOOR_BELL
)) {
1385 dev_err(adapter
->dev
,
1386 "%s: failed to assert door-bell intr\n", __func__
);
1387 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1394 /* This function init rx port in firmware which in turn enables to receive data
1395 * from device before transmitting any packet.
1397 static int mwifiex_pcie_init_fw_port(struct mwifiex_adapter
*adapter
)
1399 struct pcie_service_card
*card
= adapter
->card
;
1400 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1401 int tx_wrap
= card
->txbd_wrptr
& reg
->tx_wrap_mask
;
1403 /* Write the RX ring read pointer in to reg->rx_rdptr */
1404 if (mwifiex_write_reg(adapter
, reg
->rx_rdptr
, card
->rxbd_rdptr
|
1406 dev_err(adapter
->dev
,
1407 "RECV DATA: failed to write reg->rx_rdptr\n");
1413 /* This function downloads commands to the device
1416 mwifiex_pcie_send_cmd(struct mwifiex_adapter
*adapter
, struct sk_buff
*skb
)
1418 struct pcie_service_card
*card
= adapter
->card
;
1419 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1421 dma_addr_t cmd_buf_pa
, cmdrsp_buf_pa
;
1422 u8
*payload
= (u8
*)skb
->data
;
1424 if (!(skb
->data
&& skb
->len
)) {
1425 dev_err(adapter
->dev
, "Invalid parameter in %s <%p, %#x>\n",
1426 __func__
, skb
->data
, skb
->len
);
1430 /* Make sure a command response buffer is available */
1431 if (!card
->cmdrsp_buf
) {
1432 dev_err(adapter
->dev
,
1433 "No response buffer available, send command failed\n");
1437 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1438 mwifiex_pm_wakeup_card(adapter
);
1440 adapter
->cmd_sent
= true;
1442 *(__le16
*)&payload
[0] = cpu_to_le16((u16
)skb
->len
);
1443 *(__le16
*)&payload
[2] = cpu_to_le16(MWIFIEX_TYPE_CMD
);
1445 if (mwifiex_map_pci_memory(adapter
, skb
, skb
->len
, PCI_DMA_TODEVICE
))
1448 card
->cmd_buf
= skb
;
1450 /* To send a command, the driver will:
1451 1. Write the 64bit physical address of the data buffer to
1452 cmd response address low + cmd response address high
1453 2. Ring the door bell (i.e. set the door bell interrupt)
1455 In response to door bell interrupt, the firmware will perform
1456 the DMA of the command packet (first header to obtain the total
1457 length and then rest of the command).
1460 if (card
->cmdrsp_buf
) {
1461 cmdrsp_buf_pa
= MWIFIEX_SKB_DMA_ADDR(card
->cmdrsp_buf
);
1462 /* Write the lower 32bits of the cmdrsp buffer physical
1464 if (mwifiex_write_reg(adapter
, reg
->cmdrsp_addr_lo
,
1465 (u32
)cmdrsp_buf_pa
)) {
1466 dev_err(adapter
->dev
,
1467 "Failed to write download cmd to boot code.\n");
1471 /* Write the upper 32bits of the cmdrsp buffer physical
1473 if (mwifiex_write_reg(adapter
, reg
->cmdrsp_addr_hi
,
1474 (u32
)((u64
)cmdrsp_buf_pa
>> 32))) {
1475 dev_err(adapter
->dev
,
1476 "Failed to write download cmd to boot code.\n");
1482 cmd_buf_pa
= MWIFIEX_SKB_DMA_ADDR(card
->cmd_buf
);
1483 /* Write the lower 32bits of the physical address to reg->cmd_addr_lo */
1484 if (mwifiex_write_reg(adapter
, reg
->cmd_addr_lo
,
1486 dev_err(adapter
->dev
,
1487 "Failed to write download cmd to boot code.\n");
1491 /* Write the upper 32bits of the physical address to reg->cmd_addr_hi */
1492 if (mwifiex_write_reg(adapter
, reg
->cmd_addr_hi
,
1493 (u32
)((u64
)cmd_buf_pa
>> 32))) {
1494 dev_err(adapter
->dev
,
1495 "Failed to write download cmd to boot code.\n");
1500 /* Write the command length to reg->cmd_size */
1501 if (mwifiex_write_reg(adapter
, reg
->cmd_size
,
1502 card
->cmd_buf
->len
)) {
1503 dev_err(adapter
->dev
,
1504 "Failed to write cmd len to reg->cmd_size\n");
1509 /* Ring the door bell */
1510 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1511 CPU_INTR_DOOR_BELL
)) {
1512 dev_err(adapter
->dev
,
1513 "Failed to assert door-bell intr\n");
1520 adapter
->cmd_sent
= false;
1526 * This function handles command complete interrupt
1528 static int mwifiex_pcie_process_cmd_complete(struct mwifiex_adapter
*adapter
)
1530 struct pcie_service_card
*card
= adapter
->card
;
1531 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1532 struct sk_buff
*skb
= card
->cmdrsp_buf
;
1537 dev_dbg(adapter
->dev
, "info: Rx CMD Response\n");
1539 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_FROMDEVICE
);
1541 /* Unmap the command as a response has been received. */
1542 if (card
->cmd_buf
) {
1543 mwifiex_unmap_pci_memory(adapter
, card
->cmd_buf
,
1545 card
->cmd_buf
= NULL
;
1548 pkt_len
= *((__le16
*)skb
->data
);
1549 rx_len
= le16_to_cpu(pkt_len
);
1550 skb_trim(skb
, rx_len
);
1551 skb_pull(skb
, INTF_HEADER_LEN
);
1553 if (!adapter
->curr_cmd
) {
1554 if (adapter
->ps_state
== PS_STATE_SLEEP_CFM
) {
1555 mwifiex_process_sleep_confirm_resp(adapter
, skb
->data
,
1557 mwifiex_pcie_enable_host_int(adapter
);
1558 if (mwifiex_write_reg(adapter
,
1560 CPU_INTR_SLEEP_CFM_DONE
)) {
1561 dev_warn(adapter
->dev
,
1562 "Write register failed\n");
1565 mwifiex_delay_for_sleep_cookie(adapter
,
1566 MWIFIEX_MAX_DELAY_COUNT
);
1567 while (reg
->sleep_cookie
&& (count
++ < 10) &&
1568 mwifiex_pcie_ok_to_access_hw(adapter
))
1569 usleep_range(50, 60);
1571 dev_err(adapter
->dev
,
1572 "There is no command but got cmdrsp\n");
1574 memcpy(adapter
->upld_buf
, skb
->data
,
1575 min_t(u32
, MWIFIEX_SIZE_OF_CMD_BUFFER
, skb
->len
));
1576 skb_push(skb
, INTF_HEADER_LEN
);
1577 if (mwifiex_map_pci_memory(adapter
, skb
, MWIFIEX_UPLD_SIZE
,
1578 PCI_DMA_FROMDEVICE
))
1580 } else if (mwifiex_pcie_ok_to_access_hw(adapter
)) {
1581 adapter
->curr_cmd
->resp_skb
= skb
;
1582 adapter
->cmd_resp_received
= true;
1583 /* Take the pointer and set it to CMD node and will
1584 return in the response complete callback */
1585 card
->cmdrsp_buf
= NULL
;
1587 /* Clear the cmd-rsp buffer address in scratch registers. This
1588 will prevent firmware from writing to the same response
1590 if (mwifiex_write_reg(adapter
, reg
->cmdrsp_addr_lo
, 0)) {
1591 dev_err(adapter
->dev
,
1592 "cmd_done: failed to clear cmd_rsp_addr_lo\n");
1595 /* Write the upper 32bits of the cmdrsp buffer physical
1597 if (mwifiex_write_reg(adapter
, reg
->cmdrsp_addr_hi
, 0)) {
1598 dev_err(adapter
->dev
,
1599 "cmd_done: failed to clear cmd_rsp_addr_hi\n");
1608 * Command Response processing complete handler
1610 static int mwifiex_pcie_cmdrsp_complete(struct mwifiex_adapter
*adapter
,
1611 struct sk_buff
*skb
)
1613 struct pcie_service_card
*card
= adapter
->card
;
1616 card
->cmdrsp_buf
= skb
;
1617 skb_push(card
->cmdrsp_buf
, INTF_HEADER_LEN
);
1618 if (mwifiex_map_pci_memory(adapter
, skb
, MWIFIEX_UPLD_SIZE
,
1619 PCI_DMA_FROMDEVICE
))
1627 * This function handles firmware event ready interrupt
1629 static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter
*adapter
)
1631 struct pcie_service_card
*card
= adapter
->card
;
1632 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1633 u32 rdptr
= card
->evtbd_rdptr
& MWIFIEX_EVTBD_MASK
;
1635 struct mwifiex_evt_buf_desc
*desc
;
1637 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1638 mwifiex_pm_wakeup_card(adapter
);
1640 if (adapter
->event_received
) {
1641 dev_dbg(adapter
->dev
, "info: Event being processed, "
1642 "do not process this interrupt just yet\n");
1646 if (rdptr
>= MWIFIEX_MAX_EVT_BD
) {
1647 dev_dbg(adapter
->dev
, "info: Invalid read pointer...\n");
1651 /* Read the event ring write pointer set by firmware */
1652 if (mwifiex_read_reg(adapter
, reg
->evt_wrptr
, &wrptr
)) {
1653 dev_err(adapter
->dev
,
1654 "EventReady: failed to read reg->evt_wrptr\n");
1658 dev_dbg(adapter
->dev
, "info: EventReady: Initial <Rd: 0x%x, Wr: 0x%x>",
1659 card
->evtbd_rdptr
, wrptr
);
1660 if (((wrptr
& MWIFIEX_EVTBD_MASK
) != (card
->evtbd_rdptr
1661 & MWIFIEX_EVTBD_MASK
)) ||
1662 ((wrptr
& reg
->evt_rollover_ind
) ==
1663 (card
->evtbd_rdptr
& reg
->evt_rollover_ind
))) {
1664 struct sk_buff
*skb_cmd
;
1665 __le16 data_len
= 0;
1668 dev_dbg(adapter
->dev
, "info: Read Index: %d\n", rdptr
);
1669 skb_cmd
= card
->evt_buf_list
[rdptr
];
1670 mwifiex_unmap_pci_memory(adapter
, skb_cmd
, PCI_DMA_FROMDEVICE
);
1672 /* Take the pointer and set it to event pointer in adapter
1673 and will return back after event handling callback */
1674 card
->evt_buf_list
[rdptr
] = NULL
;
1675 desc
= card
->evtbd_ring
[rdptr
];
1676 memset(desc
, 0, sizeof(*desc
));
1678 event
= *(u32
*) &skb_cmd
->data
[INTF_HEADER_LEN
];
1679 adapter
->event_cause
= event
;
1680 /* The first 4bytes will be the event transfer header
1681 len is 2 bytes followed by type which is 2 bytes */
1682 memcpy(&data_len
, skb_cmd
->data
, sizeof(__le16
));
1683 evt_len
= le16_to_cpu(data_len
);
1685 skb_pull(skb_cmd
, INTF_HEADER_LEN
);
1686 dev_dbg(adapter
->dev
, "info: Event length: %d\n", evt_len
);
1688 if ((evt_len
> 0) && (evt_len
< MAX_EVENT_SIZE
))
1689 memcpy(adapter
->event_body
, skb_cmd
->data
+
1690 MWIFIEX_EVENT_HEADER_LEN
, evt_len
-
1691 MWIFIEX_EVENT_HEADER_LEN
);
1693 adapter
->event_received
= true;
1694 adapter
->event_skb
= skb_cmd
;
1696 /* Do not update the event read pointer here, wait till the
1697 buffer is released. This is just to make things simpler,
1698 we need to find a better method of managing these buffers.
1706 * Event processing complete handler
1708 static int mwifiex_pcie_event_complete(struct mwifiex_adapter
*adapter
,
1709 struct sk_buff
*skb
)
1711 struct pcie_service_card
*card
= adapter
->card
;
1712 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1714 u32 rdptr
= card
->evtbd_rdptr
& MWIFIEX_EVTBD_MASK
;
1716 struct mwifiex_evt_buf_desc
*desc
;
1721 if (rdptr
>= MWIFIEX_MAX_EVT_BD
) {
1722 dev_err(adapter
->dev
, "event_complete: Invalid rdptr 0x%x\n",
1727 /* Read the event ring write pointer set by firmware */
1728 if (mwifiex_read_reg(adapter
, reg
->evt_wrptr
, &wrptr
)) {
1729 dev_err(adapter
->dev
,
1730 "event_complete: failed to read reg->evt_wrptr\n");
1734 if (!card
->evt_buf_list
[rdptr
]) {
1735 skb_push(skb
, INTF_HEADER_LEN
);
1736 if (mwifiex_map_pci_memory(adapter
, skb
,
1738 PCI_DMA_FROMDEVICE
))
1740 card
->evt_buf_list
[rdptr
] = skb
;
1741 desc
= card
->evtbd_ring
[rdptr
];
1742 desc
->paddr
= MWIFIEX_SKB_DMA_ADDR(skb
);
1743 desc
->len
= (u16
)skb
->len
;
1747 dev_dbg(adapter
->dev
,
1748 "info: ERROR: buf still valid at index %d, <%p, %p>\n",
1749 rdptr
, card
->evt_buf_list
[rdptr
], skb
);
1752 if ((++card
->evtbd_rdptr
& MWIFIEX_EVTBD_MASK
) == MWIFIEX_MAX_EVT_BD
) {
1753 card
->evtbd_rdptr
= ((card
->evtbd_rdptr
&
1754 reg
->evt_rollover_ind
) ^
1755 reg
->evt_rollover_ind
);
1758 dev_dbg(adapter
->dev
, "info: Updated <Rd: 0x%x, Wr: 0x%x>",
1759 card
->evtbd_rdptr
, wrptr
);
1761 /* Write the event ring read pointer in to reg->evt_rdptr */
1762 if (mwifiex_write_reg(adapter
, reg
->evt_rdptr
,
1763 card
->evtbd_rdptr
)) {
1764 dev_err(adapter
->dev
,
1765 "event_complete: failed to read reg->evt_rdptr\n");
1769 dev_dbg(adapter
->dev
, "info: Check Events Again\n");
1770 ret
= mwifiex_pcie_process_event_ready(adapter
);
1776 * This function downloads the firmware to the card.
1778 * Firmware is downloaded to the card in blocks. Every block download
1779 * is tested for CRC errors, and retried a number of times before
1780 * returning failure.
1782 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter
*adapter
,
1783 struct mwifiex_fw_image
*fw
)
1786 u8
*firmware
= fw
->fw_buf
;
1787 u32 firmware_len
= fw
->fw_len
;
1789 struct sk_buff
*skb
;
1790 u32 txlen
, tx_blocks
= 0, tries
, len
;
1791 u32 block_retry_cnt
= 0;
1792 struct pcie_service_card
*card
= adapter
->card
;
1793 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1795 if (!firmware
|| !firmware_len
) {
1796 dev_err(adapter
->dev
,
1797 "No firmware image found! Terminating download\n");
1801 dev_dbg(adapter
->dev
, "info: Downloading FW image (%d bytes)\n",
1804 if (mwifiex_pcie_disable_host_int(adapter
)) {
1805 dev_err(adapter
->dev
,
1806 "%s: Disabling interrupts failed.\n", __func__
);
1810 skb
= dev_alloc_skb(MWIFIEX_UPLD_SIZE
);
1816 /* Perform firmware data transfer */
1821 if (offset
>= firmware_len
)
1824 for (tries
= 0; tries
< MAX_POLL_TRIES
; tries
++) {
1825 ret
= mwifiex_read_reg(adapter
, reg
->cmd_size
,
1828 dev_warn(adapter
->dev
,
1829 "Failed reading len from boot code\n");
1834 usleep_range(10, 20);
1839 } else if (len
> MWIFIEX_UPLD_SIZE
) {
1840 pr_err("FW download failure @ %d, invalid length %d\n",
1850 if (block_retry_cnt
> MAX_WRITE_IOMEM_RETRY
) {
1851 pr_err("FW download failure @ %d, over max "
1852 "retry count\n", offset
);
1856 dev_err(adapter
->dev
, "FW CRC error indicated by the "
1857 "helper: len = 0x%04X, txlen = %d\n",
1860 /* Setting this to 0 to resend from same offset */
1863 block_retry_cnt
= 0;
1864 /* Set blocksize to transfer - checking for
1866 if (firmware_len
- offset
< txlen
)
1867 txlen
= firmware_len
- offset
;
1869 dev_dbg(adapter
->dev
, ".");
1871 tx_blocks
= (txlen
+ card
->pcie
.blksz_fw_dl
- 1) /
1872 card
->pcie
.blksz_fw_dl
;
1874 /* Copy payload to buffer */
1875 memmove(skb
->data
, &firmware
[offset
], txlen
);
1878 skb_put(skb
, MWIFIEX_UPLD_SIZE
- skb
->len
);
1879 skb_trim(skb
, tx_blocks
* card
->pcie
.blksz_fw_dl
);
1881 /* Send the boot command to device */
1882 if (mwifiex_pcie_send_boot_cmd(adapter
, skb
)) {
1883 dev_err(adapter
->dev
,
1884 "Failed to send firmware download command\n");
1889 /* Wait for the command done interrupt */
1891 if (mwifiex_read_reg(adapter
, PCIE_CPU_INT_STATUS
,
1893 dev_err(adapter
->dev
, "%s: Failed to read "
1894 "interrupt status during fw dnld.\n",
1896 mwifiex_unmap_pci_memory(adapter
, skb
,
1901 } while ((ireg_intr
& CPU_INTR_DOOR_BELL
) ==
1902 CPU_INTR_DOOR_BELL
);
1904 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1909 dev_dbg(adapter
->dev
, "info:\nFW download over, size %d bytes\n",
1915 dev_kfree_skb_any(skb
);
1920 * This function checks the firmware status in card.
1922 * The winner interface is also determined by this function.
1925 mwifiex_check_fw_status(struct mwifiex_adapter
*adapter
, u32 poll_num
)
1928 u32 firmware_stat
, winner_status
;
1929 struct pcie_service_card
*card
= adapter
->card
;
1930 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1933 /* Mask spurios interrupts */
1934 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_STATUS_MASK
,
1936 dev_warn(adapter
->dev
, "Write register failed\n");
1940 dev_dbg(adapter
->dev
, "Setting driver ready signature\n");
1941 if (mwifiex_write_reg(adapter
, reg
->drv_rdy
,
1942 FIRMWARE_READY_PCIE
)) {
1943 dev_err(adapter
->dev
,
1944 "Failed to write driver ready signature\n");
1948 /* Wait for firmware initialization event */
1949 for (tries
= 0; tries
< poll_num
; tries
++) {
1950 if (mwifiex_read_reg(adapter
, reg
->fw_status
,
1957 if (firmware_stat
== FIRMWARE_READY_PCIE
) {
1967 if (mwifiex_read_reg(adapter
, reg
->fw_status
,
1970 else if (!winner_status
) {
1971 dev_err(adapter
->dev
, "PCI-E is the winner\n");
1972 adapter
->winner
= 1;
1974 dev_err(adapter
->dev
,
1975 "PCI-E is not the winner <%#x,%d>, exit dnld\n",
1976 ret
, adapter
->winner
);
1984 * This function reads the interrupt status from card.
1986 static void mwifiex_interrupt_status(struct mwifiex_adapter
*adapter
)
1989 unsigned long flags
;
1991 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1994 if (mwifiex_read_reg(adapter
, PCIE_HOST_INT_STATUS
, &pcie_ireg
)) {
1995 dev_warn(adapter
->dev
, "Read register failed\n");
1999 if ((pcie_ireg
!= 0xFFFFFFFF) && (pcie_ireg
)) {
2001 mwifiex_pcie_disable_host_int(adapter
);
2003 /* Clear the pending interrupts */
2004 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_STATUS
,
2006 dev_warn(adapter
->dev
, "Write register failed\n");
2009 spin_lock_irqsave(&adapter
->int_lock
, flags
);
2010 adapter
->int_status
|= pcie_ireg
;
2011 spin_unlock_irqrestore(&adapter
->int_lock
, flags
);
2013 if (!adapter
->pps_uapsd_mode
&&
2014 adapter
->ps_state
== PS_STATE_SLEEP
&&
2015 mwifiex_pcie_ok_to_access_hw(adapter
)) {
2016 /* Potentially for PCIe we could get other
2017 * interrupts like shared. Don't change power
2018 * state until cookie is set */
2019 adapter
->ps_state
= PS_STATE_AWAKE
;
2020 adapter
->pm_wakeup_fw_try
= false;
2026 * Interrupt handler for PCIe root port
2028 * This function reads the interrupt status from firmware and assigns
2029 * the main process in workqueue which will handle the interrupt.
2031 static irqreturn_t
mwifiex_pcie_interrupt(int irq
, void *context
)
2033 struct pci_dev
*pdev
= (struct pci_dev
*)context
;
2034 struct pcie_service_card
*card
;
2035 struct mwifiex_adapter
*adapter
;
2038 pr_debug("info: %s: pdev is NULL\n", (u8
*)pdev
);
2042 card
= pci_get_drvdata(pdev
);
2043 if (!card
|| !card
->adapter
) {
2044 pr_debug("info: %s: card=%p adapter=%p\n", __func__
, card
,
2045 card
? card
->adapter
: NULL
);
2048 adapter
= card
->adapter
;
2050 if (adapter
->surprise_removed
)
2053 mwifiex_interrupt_status(adapter
);
2054 queue_work(adapter
->workqueue
, &adapter
->main_work
);
2061 * This function checks the current interrupt status.
2063 * The following interrupts are checked and handled by this function -
2066 * - Command received
2067 * - Packets received
2070 * In case of Rx packets received, the packets are uploaded from card to
2071 * host and processed accordingly.
2073 static int mwifiex_process_int_status(struct mwifiex_adapter
*adapter
)
2077 unsigned long flags
;
2079 spin_lock_irqsave(&adapter
->int_lock
, flags
);
2080 /* Clear out unused interrupts */
2081 pcie_ireg
= adapter
->int_status
;
2082 adapter
->int_status
= 0;
2083 spin_unlock_irqrestore(&adapter
->int_lock
, flags
);
2085 while (pcie_ireg
& HOST_INTR_MASK
) {
2086 if (pcie_ireg
& HOST_INTR_DNLD_DONE
) {
2087 pcie_ireg
&= ~HOST_INTR_DNLD_DONE
;
2088 dev_dbg(adapter
->dev
, "info: TX DNLD Done\n");
2089 ret
= mwifiex_pcie_send_data_complete(adapter
);
2093 if (pcie_ireg
& HOST_INTR_UPLD_RDY
) {
2094 pcie_ireg
&= ~HOST_INTR_UPLD_RDY
;
2095 dev_dbg(adapter
->dev
, "info: Rx DATA\n");
2096 ret
= mwifiex_pcie_process_recv_data(adapter
);
2100 if (pcie_ireg
& HOST_INTR_EVENT_RDY
) {
2101 pcie_ireg
&= ~HOST_INTR_EVENT_RDY
;
2102 dev_dbg(adapter
->dev
, "info: Rx EVENT\n");
2103 ret
= mwifiex_pcie_process_event_ready(adapter
);
2108 if (pcie_ireg
& HOST_INTR_CMD_DONE
) {
2109 pcie_ireg
&= ~HOST_INTR_CMD_DONE
;
2110 if (adapter
->cmd_sent
) {
2111 dev_dbg(adapter
->dev
,
2112 "info: CMD sent Interrupt\n");
2113 adapter
->cmd_sent
= false;
2115 /* Handle command response */
2116 ret
= mwifiex_pcie_process_cmd_complete(adapter
);
2121 if (mwifiex_pcie_ok_to_access_hw(adapter
)) {
2122 if (mwifiex_read_reg(adapter
, PCIE_HOST_INT_STATUS
,
2124 dev_warn(adapter
->dev
,
2125 "Read register failed\n");
2129 if ((pcie_ireg
!= 0xFFFFFFFF) && (pcie_ireg
)) {
2130 if (mwifiex_write_reg(adapter
,
2131 PCIE_HOST_INT_STATUS
,
2133 dev_warn(adapter
->dev
,
2134 "Write register failed\n");
2141 dev_dbg(adapter
->dev
, "info: cmd_sent=%d data_sent=%d\n",
2142 adapter
->cmd_sent
, adapter
->data_sent
);
2143 if (adapter
->ps_state
!= PS_STATE_SLEEP
)
2144 mwifiex_pcie_enable_host_int(adapter
);
2150 * This function downloads data from driver to card.
2152 * Both commands and data packets are transferred to the card by this
2155 * This function adds the PCIE specific header to the front of the buffer
2156 * before transferring. The header contains the length of the packet and
2157 * the type. The firmware handles the packets based upon this set type.
2159 static int mwifiex_pcie_host_to_card(struct mwifiex_adapter
*adapter
, u8 type
,
2160 struct sk_buff
*skb
,
2161 struct mwifiex_tx_param
*tx_param
)
2164 dev_err(adapter
->dev
, "Passed NULL skb to %s\n", __func__
);
2168 if (type
== MWIFIEX_TYPE_DATA
)
2169 return mwifiex_pcie_send_data(adapter
, skb
, tx_param
);
2170 else if (type
== MWIFIEX_TYPE_CMD
)
2171 return mwifiex_pcie_send_cmd(adapter
, skb
);
2177 * This function initializes the PCI-E host memory space, WCB rings, etc.
2179 * The following initializations steps are followed -
2180 * - Allocate TXBD ring buffers
2181 * - Allocate RXBD ring buffers
2182 * - Allocate event BD ring buffers
2183 * - Allocate command response ring buffer
2184 * - Allocate sleep cookie buffer
2186 static int mwifiex_pcie_init(struct mwifiex_adapter
*adapter
)
2188 struct pcie_service_card
*card
= adapter
->card
;
2190 struct pci_dev
*pdev
= card
->dev
;
2191 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
2193 pci_set_drvdata(pdev
, card
);
2195 ret
= pci_enable_device(pdev
);
2197 goto err_enable_dev
;
2199 pci_set_master(pdev
);
2201 dev_dbg(adapter
->dev
, "try set_consistent_dma_mask(32)\n");
2202 ret
= pci_set_dma_mask(pdev
, DMA_BIT_MASK(32));
2204 dev_err(adapter
->dev
, "set_dma_mask(32) failed\n");
2205 goto err_set_dma_mask
;
2208 ret
= pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(32));
2210 dev_err(adapter
->dev
, "set_consistent_dma_mask(64) failed\n");
2211 goto err_set_dma_mask
;
2214 ret
= pci_request_region(pdev
, 0, DRV_NAME
);
2216 dev_err(adapter
->dev
, "req_reg(0) error\n");
2217 goto err_req_region0
;
2219 card
->pci_mmap
= pci_iomap(pdev
, 0, 0);
2220 if (!card
->pci_mmap
) {
2221 dev_err(adapter
->dev
, "iomap(0) error\n");
2225 ret
= pci_request_region(pdev
, 2, DRV_NAME
);
2227 dev_err(adapter
->dev
, "req_reg(2) error\n");
2228 goto err_req_region2
;
2230 card
->pci_mmap1
= pci_iomap(pdev
, 2, 0);
2231 if (!card
->pci_mmap1
) {
2232 dev_err(adapter
->dev
, "iomap(2) error\n");
2237 dev_dbg(adapter
->dev
,
2238 "PCI memory map Virt0: %p PCI memory map Virt2: %p\n",
2239 card
->pci_mmap
, card
->pci_mmap1
);
2241 card
->cmdrsp_buf
= NULL
;
2242 ret
= mwifiex_pcie_create_txbd_ring(adapter
);
2245 ret
= mwifiex_pcie_create_rxbd_ring(adapter
);
2248 ret
= mwifiex_pcie_create_evtbd_ring(adapter
);
2251 ret
= mwifiex_pcie_alloc_cmdrsp_buf(adapter
);
2253 goto err_alloc_cmdbuf
;
2254 if (reg
->sleep_cookie
) {
2255 ret
= mwifiex_pcie_alloc_sleep_cookie_buf(adapter
);
2257 goto err_alloc_cookie
;
2259 card
->sleep_cookie_vbase
= NULL
;
2264 mwifiex_pcie_delete_cmdrsp_buf(adapter
);
2266 mwifiex_pcie_delete_evtbd_ring(adapter
);
2268 mwifiex_pcie_delete_rxbd_ring(adapter
);
2270 mwifiex_pcie_delete_txbd_ring(adapter
);
2272 pci_iounmap(pdev
, card
->pci_mmap1
);
2274 pci_release_region(pdev
, 2);
2276 pci_iounmap(pdev
, card
->pci_mmap
);
2278 pci_release_region(pdev
, 0);
2281 pci_disable_device(pdev
);
2283 pci_set_drvdata(pdev
, NULL
);
2288 * This function cleans up the allocated card buffers.
2290 * The following are freed by this function -
2291 * - TXBD ring buffers
2292 * - RXBD ring buffers
2293 * - Event BD ring buffers
2294 * - Command response ring buffer
2295 * - Sleep cookie buffer
2297 static void mwifiex_pcie_cleanup(struct mwifiex_adapter
*adapter
)
2299 struct pcie_service_card
*card
= adapter
->card
;
2300 struct pci_dev
*pdev
= card
->dev
;
2301 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
2304 dev_dbg(adapter
->dev
, "Clearing driver ready signature\n");
2305 if (mwifiex_write_reg(adapter
, reg
->drv_rdy
, 0x00000000))
2306 dev_err(adapter
->dev
,
2307 "Failed to write driver not-ready signature\n");
2311 pci_iounmap(pdev
, card
->pci_mmap
);
2312 pci_iounmap(pdev
, card
->pci_mmap1
);
2313 pci_disable_device(pdev
);
2314 pci_release_region(pdev
, 2);
2315 pci_release_region(pdev
, 0);
2316 pci_set_drvdata(pdev
, NULL
);
2322 * This function registers the PCIE device.
2324 * PCIE IRQ is claimed, block size is set and driver data is initialized.
2326 static int mwifiex_register_dev(struct mwifiex_adapter
*adapter
)
2329 struct pcie_service_card
*card
= adapter
->card
;
2330 struct pci_dev
*pdev
= card
->dev
;
2332 /* save adapter pointer in card */
2333 card
->adapter
= adapter
;
2335 ret
= request_irq(pdev
->irq
, mwifiex_pcie_interrupt
, IRQF_SHARED
,
2338 pr_err("request_irq failed: ret=%d\n", ret
);
2339 adapter
->card
= NULL
;
2343 adapter
->dev
= &pdev
->dev
;
2344 adapter
->tx_buf_size
= card
->pcie
.tx_buf_size
;
2345 strcpy(adapter
->fw_name
, card
->pcie
.firmware
);
2351 * This function unregisters the PCIE device.
2353 * The PCIE IRQ is released, the function is disabled and driver
2354 * data is set to null.
2356 static void mwifiex_unregister_dev(struct mwifiex_adapter
*adapter
)
2358 struct pcie_service_card
*card
= adapter
->card
;
2359 const struct mwifiex_pcie_card_reg
*reg
;
2362 dev_dbg(adapter
->dev
, "%s(): calling free_irq()\n", __func__
);
2363 free_irq(card
->dev
->irq
, card
->dev
);
2365 reg
= card
->pcie
.reg
;
2366 if (reg
->sleep_cookie
)
2367 mwifiex_pcie_delete_sleep_cookie_buf(adapter
);
2369 mwifiex_pcie_delete_cmdrsp_buf(adapter
);
2370 mwifiex_pcie_delete_evtbd_ring(adapter
);
2371 mwifiex_pcie_delete_rxbd_ring(adapter
);
2372 mwifiex_pcie_delete_txbd_ring(adapter
);
2373 card
->cmdrsp_buf
= NULL
;
2377 static struct mwifiex_if_ops pcie_ops
= {
2378 .init_if
= mwifiex_pcie_init
,
2379 .cleanup_if
= mwifiex_pcie_cleanup
,
2380 .check_fw_status
= mwifiex_check_fw_status
,
2381 .prog_fw
= mwifiex_prog_fw_w_helper
,
2382 .register_dev
= mwifiex_register_dev
,
2383 .unregister_dev
= mwifiex_unregister_dev
,
2384 .enable_int
= mwifiex_pcie_enable_host_int
,
2385 .process_int_status
= mwifiex_process_int_status
,
2386 .host_to_card
= mwifiex_pcie_host_to_card
,
2387 .wakeup
= mwifiex_pm_wakeup_card
,
2388 .wakeup_complete
= mwifiex_pm_wakeup_card_complete
,
2391 .cmdrsp_complete
= mwifiex_pcie_cmdrsp_complete
,
2392 .event_complete
= mwifiex_pcie_event_complete
,
2393 .update_mp_end_port
= NULL
,
2394 .cleanup_mpa_buf
= NULL
,
2395 .init_fw_port
= mwifiex_pcie_init_fw_port
,
2396 .clean_pcie_ring
= mwifiex_clean_pcie_ring_buf
,
2400 * This function initializes the PCIE driver module.
2402 * This initiates the semaphore and registers the device with
2405 static int mwifiex_pcie_init_module(void)
2409 pr_debug("Marvell PCIe Driver\n");
2411 sema_init(&add_remove_card_sem
, 1);
2413 /* Clear the flag in case user removes the card. */
2416 ret
= pci_register_driver(&mwifiex_pcie
);
2418 pr_err("Driver register failed!\n");
2420 pr_debug("info: Driver registered successfully!\n");
2426 * This function cleans up the PCIE driver.
2428 * The following major steps are followed for cleanup -
2429 * - Resume the device if its suspended
2430 * - Disconnect the device if connected
2431 * - Shutdown the firmware
2432 * - Unregister the device from PCIE bus.
2434 static void mwifiex_pcie_cleanup_module(void)
2436 if (!down_interruptible(&add_remove_card_sem
))
2437 up(&add_remove_card_sem
);
2439 /* Set the flag as user is removing this module. */
2442 pci_unregister_driver(&mwifiex_pcie
);
2445 module_init(mwifiex_pcie_init_module
);
2446 module_exit(mwifiex_pcie_cleanup_module
);
2448 MODULE_AUTHOR("Marvell International Ltd.");
2449 MODULE_DESCRIPTION("Marvell WiFi-Ex PCI-Express Driver version " PCIE_VERSION
);
2450 MODULE_VERSION(PCIE_VERSION
);
2451 MODULE_LICENSE("GPL v2");
2452 MODULE_FIRMWARE(PCIE8766_DEFAULT_FW_NAME
);
2453 MODULE_FIRMWARE(PCIE8897_DEFAULT_FW_NAME
);