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.
1076 mwifiex_pcie_send_data(struct mwifiex_adapter
*adapter
, struct sk_buff
*skb
,
1077 struct mwifiex_tx_param
*tx_param
)
1079 struct pcie_service_card
*card
= adapter
->card
;
1080 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1081 u32 wrindx
, num_tx_buffs
, rx_val
;
1084 struct mwifiex_pcie_buf_desc
*desc
= NULL
;
1085 struct mwifiex_pfu_buf_desc
*desc2
= NULL
;
1088 if (!(skb
->data
&& skb
->len
)) {
1089 dev_err(adapter
->dev
, "%s(): invalid parameter <%p, %#x>\n",
1090 __func__
, skb
->data
, skb
->len
);
1094 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1095 mwifiex_pm_wakeup_card(adapter
);
1097 num_tx_buffs
= MWIFIEX_MAX_TXRX_BD
<< reg
->tx_start_ptr
;
1098 dev_dbg(adapter
->dev
, "info: SEND DATA: <Rd: %#x, Wr: %#x>\n",
1099 card
->txbd_rdptr
, card
->txbd_wrptr
);
1100 if (mwifiex_pcie_txbd_not_full(card
)) {
1103 adapter
->data_sent
= true;
1104 payload
= skb
->data
;
1105 tmp
= (__le16
*)&payload
[0];
1106 *tmp
= cpu_to_le16((u16
)skb
->len
);
1107 tmp
= (__le16
*)&payload
[2];
1108 *tmp
= cpu_to_le16(MWIFIEX_TYPE_DATA
);
1110 if (mwifiex_map_pci_memory(adapter
, skb
, skb
->len
,
1114 wrindx
= (card
->txbd_wrptr
& reg
->tx_mask
) >> reg
->tx_start_ptr
;
1115 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb
);
1116 card
->tx_buf_list
[wrindx
] = skb
;
1118 if (reg
->pfu_enabled
) {
1119 desc2
= card
->txbd_ring
[wrindx
];
1120 desc2
->paddr
= buf_pa
;
1121 desc2
->len
= (u16
)skb
->len
;
1122 desc2
->frag_len
= (u16
)skb
->len
;
1124 desc2
->flags
= MWIFIEX_BD_FLAG_FIRST_DESC
|
1125 MWIFIEX_BD_FLAG_LAST_DESC
;
1127 desc
= card
->txbd_ring
[wrindx
];
1128 desc
->paddr
= buf_pa
;
1129 desc
->len
= (u16
)skb
->len
;
1130 desc
->flags
= MWIFIEX_BD_FLAG_FIRST_DESC
|
1131 MWIFIEX_BD_FLAG_LAST_DESC
;
1134 switch (card
->dev
->device
) {
1135 case PCIE_DEVICE_ID_MARVELL_88W8766P
:
1138 case PCIE_DEVICE_ID_MARVELL_88W8897
:
1139 card
->txbd_wrptr
+= reg
->ring_tx_start_ptr
;
1143 if ((card
->txbd_wrptr
& reg
->tx_mask
) == num_tx_buffs
)
1144 card
->txbd_wrptr
= ((card
->txbd_wrptr
&
1145 reg
->tx_rollover_ind
) ^
1146 reg
->tx_rollover_ind
);
1148 rx_val
= card
->rxbd_rdptr
& reg
->rx_wrap_mask
;
1149 /* Write the TX ring write pointer in to reg->tx_wrptr */
1150 if (mwifiex_write_reg(adapter
, reg
->tx_wrptr
,
1151 card
->txbd_wrptr
| rx_val
)) {
1152 dev_err(adapter
->dev
,
1153 "SEND DATA: failed to write reg->tx_wrptr\n");
1157 if ((mwifiex_pcie_txbd_not_full(card
)) &&
1158 tx_param
->next_pkt_len
) {
1159 /* have more packets and TxBD still can hold more */
1160 dev_dbg(adapter
->dev
,
1161 "SEND DATA: delay dnld-rdy interrupt.\n");
1162 adapter
->data_sent
= false;
1164 /* Send the TX ready interrupt */
1165 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1166 CPU_INTR_DNLD_RDY
)) {
1167 dev_err(adapter
->dev
,
1168 "SEND DATA: failed to assert dnld-rdy interrupt.\n");
1173 dev_dbg(adapter
->dev
, "info: SEND DATA: Updated <Rd: %#x, Wr: "
1174 "%#x> and sent packet to firmware successfully\n",
1175 card
->txbd_rdptr
, card
->txbd_wrptr
);
1177 dev_dbg(adapter
->dev
,
1178 "info: TX Ring full, can't send packets to fw\n");
1179 adapter
->data_sent
= true;
1180 /* Send the TX ready interrupt */
1181 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1183 dev_err(adapter
->dev
,
1184 "SEND DATA: failed to assert door-bell intr\n");
1188 return -EINPROGRESS
;
1190 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1191 card
->tx_buf_list
[wrindx
] = NULL
;
1192 if (reg
->pfu_enabled
)
1193 memset(desc2
, 0, sizeof(*desc2
));
1195 memset(desc
, 0, sizeof(*desc
));
1201 * This function handles received buffer ring and
1202 * dispatches packets to upper
1204 static int mwifiex_pcie_process_recv_data(struct mwifiex_adapter
*adapter
)
1206 struct pcie_service_card
*card
= adapter
->card
;
1207 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1208 u32 wrptr
, rd_index
, tx_val
;
1211 struct sk_buff
*skb_tmp
= NULL
;
1212 struct mwifiex_pcie_buf_desc
*desc
;
1213 struct mwifiex_pfu_buf_desc
*desc2
;
1215 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1216 mwifiex_pm_wakeup_card(adapter
);
1218 /* Read the RX ring Write pointer set by firmware */
1219 if (mwifiex_read_reg(adapter
, reg
->rx_wrptr
, &wrptr
)) {
1220 dev_err(adapter
->dev
,
1221 "RECV DATA: failed to read reg->rx_wrptr\n");
1225 card
->rxbd_wrptr
= wrptr
;
1227 while (((wrptr
& reg
->rx_mask
) !=
1228 (card
->rxbd_rdptr
& reg
->rx_mask
)) ||
1229 ((wrptr
& reg
->rx_rollover_ind
) ==
1230 (card
->rxbd_rdptr
& reg
->rx_rollover_ind
))) {
1231 struct sk_buff
*skb_data
;
1235 rd_index
= card
->rxbd_rdptr
& reg
->rx_mask
;
1236 skb_data
= card
->rx_buf_list
[rd_index
];
1238 /* If skb allocation was failed earlier for Rx packet,
1239 * rx_buf_list[rd_index] would have been left with a NULL.
1244 mwifiex_unmap_pci_memory(adapter
, skb_data
, PCI_DMA_FROMDEVICE
);
1245 card
->rx_buf_list
[rd_index
] = NULL
;
1247 /* Get data length from interface header -
1248 * first 2 bytes for len, next 2 bytes is for type
1250 pkt_len
= *((__le16
*)skb_data
->data
);
1251 rx_len
= le16_to_cpu(pkt_len
);
1252 skb_put(skb_data
, rx_len
);
1253 dev_dbg(adapter
->dev
,
1254 "info: RECV DATA: Rd=%#x, Wr=%#x, Len=%d\n",
1255 card
->rxbd_rdptr
, wrptr
, rx_len
);
1256 skb_pull(skb_data
, INTF_HEADER_LEN
);
1257 mwifiex_handle_rx_packet(adapter
, skb_data
);
1259 skb_tmp
= dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE
);
1261 dev_err(adapter
->dev
,
1262 "Unable to allocate skb.\n");
1266 if (mwifiex_map_pci_memory(adapter
, skb_tmp
,
1267 MWIFIEX_RX_DATA_BUF_SIZE
,
1268 PCI_DMA_FROMDEVICE
))
1271 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb_tmp
);
1273 dev_dbg(adapter
->dev
,
1274 "RECV DATA: Attach new sk_buff %p at rxbd_rdidx=%d\n",
1276 card
->rx_buf_list
[rd_index
] = skb_tmp
;
1278 if (reg
->pfu_enabled
) {
1279 desc2
= card
->rxbd_ring
[rd_index
];
1280 desc2
->paddr
= buf_pa
;
1281 desc2
->len
= skb_tmp
->len
;
1282 desc2
->frag_len
= skb_tmp
->len
;
1284 desc2
->flags
= reg
->ring_flag_sop
| reg
->ring_flag_eop
;
1286 desc
= card
->rxbd_ring
[rd_index
];
1287 desc
->paddr
= buf_pa
;
1288 desc
->len
= skb_tmp
->len
;
1292 if ((++card
->rxbd_rdptr
& reg
->rx_mask
) ==
1293 MWIFIEX_MAX_TXRX_BD
) {
1294 card
->rxbd_rdptr
= ((card
->rxbd_rdptr
&
1295 reg
->rx_rollover_ind
) ^
1296 reg
->rx_rollover_ind
);
1298 dev_dbg(adapter
->dev
, "info: RECV DATA: <Rd: %#x, Wr: %#x>\n",
1299 card
->rxbd_rdptr
, wrptr
);
1301 tx_val
= card
->txbd_wrptr
& reg
->tx_wrap_mask
;
1302 /* Write the RX ring read pointer in to reg->rx_rdptr */
1303 if (mwifiex_write_reg(adapter
, reg
->rx_rdptr
,
1304 card
->rxbd_rdptr
| tx_val
)) {
1305 dev_err(adapter
->dev
,
1306 "RECV DATA: failed to write reg->rx_rdptr\n");
1311 /* Read the RX ring Write pointer set by firmware */
1312 if (mwifiex_read_reg(adapter
, reg
->rx_wrptr
, &wrptr
)) {
1313 dev_err(adapter
->dev
,
1314 "RECV DATA: failed to read reg->rx_wrptr\n");
1318 dev_dbg(adapter
->dev
,
1319 "info: RECV DATA: Rcvd packet from fw successfully\n");
1320 card
->rxbd_wrptr
= wrptr
;
1328 * This function downloads the boot command to device
1331 mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter
*adapter
, struct sk_buff
*skb
)
1334 struct pcie_service_card
*card
= adapter
->card
;
1335 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1337 if (!(skb
->data
&& skb
->len
)) {
1338 dev_err(adapter
->dev
,
1339 "Invalid parameter in %s <%p. len %d>\n",
1340 __func__
, skb
->data
, skb
->len
);
1344 if (mwifiex_map_pci_memory(adapter
, skb
, skb
->len
, PCI_DMA_TODEVICE
))
1347 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb
);
1349 /* Write the lower 32bits of the physical address to low command
1350 * address scratch register
1352 if (mwifiex_write_reg(adapter
, reg
->cmd_addr_lo
, (u32
)buf_pa
)) {
1353 dev_err(adapter
->dev
,
1354 "%s: failed to write download command to boot code.\n",
1356 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1360 /* Write the upper 32bits of the physical address to high command
1361 * address scratch register
1363 if (mwifiex_write_reg(adapter
, reg
->cmd_addr_hi
,
1364 (u32
)((u64
)buf_pa
>> 32))) {
1365 dev_err(adapter
->dev
,
1366 "%s: failed to write download command to boot code.\n",
1368 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1372 /* Write the command length to cmd_size scratch register */
1373 if (mwifiex_write_reg(adapter
, reg
->cmd_size
, skb
->len
)) {
1374 dev_err(adapter
->dev
,
1375 "%s: failed to write command len to cmd_size scratch reg\n",
1377 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1381 /* Ring the door bell */
1382 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1383 CPU_INTR_DOOR_BELL
)) {
1384 dev_err(adapter
->dev
,
1385 "%s: failed to assert door-bell intr\n", __func__
);
1386 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1393 /* This function init rx port in firmware which in turn enables to receive data
1394 * from device before transmitting any packet.
1396 static int mwifiex_pcie_init_fw_port(struct mwifiex_adapter
*adapter
)
1398 struct pcie_service_card
*card
= adapter
->card
;
1399 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1400 int tx_wrap
= card
->txbd_wrptr
& reg
->tx_wrap_mask
;
1402 /* Write the RX ring read pointer in to reg->rx_rdptr */
1403 if (mwifiex_write_reg(adapter
, reg
->rx_rdptr
, card
->rxbd_rdptr
|
1405 dev_err(adapter
->dev
,
1406 "RECV DATA: failed to write reg->rx_rdptr\n");
1412 /* This function downloads commands to the device
1415 mwifiex_pcie_send_cmd(struct mwifiex_adapter
*adapter
, struct sk_buff
*skb
)
1417 struct pcie_service_card
*card
= adapter
->card
;
1418 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1420 dma_addr_t cmd_buf_pa
, cmdrsp_buf_pa
;
1421 u8
*payload
= (u8
*)skb
->data
;
1423 if (!(skb
->data
&& skb
->len
)) {
1424 dev_err(adapter
->dev
, "Invalid parameter in %s <%p, %#x>\n",
1425 __func__
, skb
->data
, skb
->len
);
1429 /* Make sure a command response buffer is available */
1430 if (!card
->cmdrsp_buf
) {
1431 dev_err(adapter
->dev
,
1432 "No response buffer available, send command failed\n");
1436 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1437 mwifiex_pm_wakeup_card(adapter
);
1439 adapter
->cmd_sent
= true;
1441 *(__le16
*)&payload
[0] = cpu_to_le16((u16
)skb
->len
);
1442 *(__le16
*)&payload
[2] = cpu_to_le16(MWIFIEX_TYPE_CMD
);
1444 if (mwifiex_map_pci_memory(adapter
, skb
, skb
->len
, PCI_DMA_TODEVICE
))
1447 card
->cmd_buf
= skb
;
1449 /* To send a command, the driver will:
1450 1. Write the 64bit physical address of the data buffer to
1451 cmd response address low + cmd response address high
1452 2. Ring the door bell (i.e. set the door bell interrupt)
1454 In response to door bell interrupt, the firmware will perform
1455 the DMA of the command packet (first header to obtain the total
1456 length and then rest of the command).
1459 if (card
->cmdrsp_buf
) {
1460 cmdrsp_buf_pa
= MWIFIEX_SKB_DMA_ADDR(card
->cmdrsp_buf
);
1461 /* Write the lower 32bits of the cmdrsp buffer physical
1463 if (mwifiex_write_reg(adapter
, reg
->cmdrsp_addr_lo
,
1464 (u32
)cmdrsp_buf_pa
)) {
1465 dev_err(adapter
->dev
,
1466 "Failed to write download cmd to boot code.\n");
1470 /* Write the upper 32bits of the cmdrsp buffer physical
1472 if (mwifiex_write_reg(adapter
, reg
->cmdrsp_addr_hi
,
1473 (u32
)((u64
)cmdrsp_buf_pa
>> 32))) {
1474 dev_err(adapter
->dev
,
1475 "Failed to write download cmd to boot code.\n");
1481 cmd_buf_pa
= MWIFIEX_SKB_DMA_ADDR(card
->cmd_buf
);
1482 /* Write the lower 32bits of the physical address to reg->cmd_addr_lo */
1483 if (mwifiex_write_reg(adapter
, reg
->cmd_addr_lo
,
1485 dev_err(adapter
->dev
,
1486 "Failed to write download cmd to boot code.\n");
1490 /* Write the upper 32bits of the physical address to reg->cmd_addr_hi */
1491 if (mwifiex_write_reg(adapter
, reg
->cmd_addr_hi
,
1492 (u32
)((u64
)cmd_buf_pa
>> 32))) {
1493 dev_err(adapter
->dev
,
1494 "Failed to write download cmd to boot code.\n");
1499 /* Write the command length to reg->cmd_size */
1500 if (mwifiex_write_reg(adapter
, reg
->cmd_size
,
1501 card
->cmd_buf
->len
)) {
1502 dev_err(adapter
->dev
,
1503 "Failed to write cmd len to reg->cmd_size\n");
1508 /* Ring the door bell */
1509 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1510 CPU_INTR_DOOR_BELL
)) {
1511 dev_err(adapter
->dev
,
1512 "Failed to assert door-bell intr\n");
1519 adapter
->cmd_sent
= false;
1525 * This function handles command complete interrupt
1527 static int mwifiex_pcie_process_cmd_complete(struct mwifiex_adapter
*adapter
)
1529 struct pcie_service_card
*card
= adapter
->card
;
1530 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1531 struct sk_buff
*skb
= card
->cmdrsp_buf
;
1536 dev_dbg(adapter
->dev
, "info: Rx CMD Response\n");
1538 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_FROMDEVICE
);
1540 /* Unmap the command as a response has been received. */
1541 if (card
->cmd_buf
) {
1542 mwifiex_unmap_pci_memory(adapter
, card
->cmd_buf
,
1544 card
->cmd_buf
= NULL
;
1547 pkt_len
= *((__le16
*)skb
->data
);
1548 rx_len
= le16_to_cpu(pkt_len
);
1549 skb_trim(skb
, rx_len
);
1550 skb_pull(skb
, INTF_HEADER_LEN
);
1552 if (!adapter
->curr_cmd
) {
1553 if (adapter
->ps_state
== PS_STATE_SLEEP_CFM
) {
1554 mwifiex_process_sleep_confirm_resp(adapter
, skb
->data
,
1556 mwifiex_pcie_enable_host_int(adapter
);
1557 if (mwifiex_write_reg(adapter
,
1559 CPU_INTR_SLEEP_CFM_DONE
)) {
1560 dev_warn(adapter
->dev
,
1561 "Write register failed\n");
1564 mwifiex_delay_for_sleep_cookie(adapter
,
1565 MWIFIEX_MAX_DELAY_COUNT
);
1566 while (reg
->sleep_cookie
&& (count
++ < 10) &&
1567 mwifiex_pcie_ok_to_access_hw(adapter
))
1568 usleep_range(50, 60);
1570 dev_err(adapter
->dev
,
1571 "There is no command but got cmdrsp\n");
1573 memcpy(adapter
->upld_buf
, skb
->data
,
1574 min_t(u32
, MWIFIEX_SIZE_OF_CMD_BUFFER
, skb
->len
));
1575 skb_push(skb
, INTF_HEADER_LEN
);
1576 if (mwifiex_map_pci_memory(adapter
, skb
, MWIFIEX_UPLD_SIZE
,
1577 PCI_DMA_FROMDEVICE
))
1579 } else if (mwifiex_pcie_ok_to_access_hw(adapter
)) {
1580 adapter
->curr_cmd
->resp_skb
= skb
;
1581 adapter
->cmd_resp_received
= true;
1582 /* Take the pointer and set it to CMD node and will
1583 return in the response complete callback */
1584 card
->cmdrsp_buf
= NULL
;
1586 /* Clear the cmd-rsp buffer address in scratch registers. This
1587 will prevent firmware from writing to the same response
1589 if (mwifiex_write_reg(adapter
, reg
->cmdrsp_addr_lo
, 0)) {
1590 dev_err(adapter
->dev
,
1591 "cmd_done: failed to clear cmd_rsp_addr_lo\n");
1594 /* Write the upper 32bits of the cmdrsp buffer physical
1596 if (mwifiex_write_reg(adapter
, reg
->cmdrsp_addr_hi
, 0)) {
1597 dev_err(adapter
->dev
,
1598 "cmd_done: failed to clear cmd_rsp_addr_hi\n");
1607 * Command Response processing complete handler
1609 static int mwifiex_pcie_cmdrsp_complete(struct mwifiex_adapter
*adapter
,
1610 struct sk_buff
*skb
)
1612 struct pcie_service_card
*card
= adapter
->card
;
1615 card
->cmdrsp_buf
= skb
;
1616 skb_push(card
->cmdrsp_buf
, INTF_HEADER_LEN
);
1617 if (mwifiex_map_pci_memory(adapter
, skb
, MWIFIEX_UPLD_SIZE
,
1618 PCI_DMA_FROMDEVICE
))
1626 * This function handles firmware event ready interrupt
1628 static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter
*adapter
)
1630 struct pcie_service_card
*card
= adapter
->card
;
1631 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1632 u32 rdptr
= card
->evtbd_rdptr
& MWIFIEX_EVTBD_MASK
;
1634 struct mwifiex_evt_buf_desc
*desc
;
1636 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1637 mwifiex_pm_wakeup_card(adapter
);
1639 if (adapter
->event_received
) {
1640 dev_dbg(adapter
->dev
, "info: Event being processed, "
1641 "do not process this interrupt just yet\n");
1645 if (rdptr
>= MWIFIEX_MAX_EVT_BD
) {
1646 dev_dbg(adapter
->dev
, "info: Invalid read pointer...\n");
1650 /* Read the event ring write pointer set by firmware */
1651 if (mwifiex_read_reg(adapter
, reg
->evt_wrptr
, &wrptr
)) {
1652 dev_err(adapter
->dev
,
1653 "EventReady: failed to read reg->evt_wrptr\n");
1657 dev_dbg(adapter
->dev
, "info: EventReady: Initial <Rd: 0x%x, Wr: 0x%x>",
1658 card
->evtbd_rdptr
, wrptr
);
1659 if (((wrptr
& MWIFIEX_EVTBD_MASK
) != (card
->evtbd_rdptr
1660 & MWIFIEX_EVTBD_MASK
)) ||
1661 ((wrptr
& reg
->evt_rollover_ind
) ==
1662 (card
->evtbd_rdptr
& reg
->evt_rollover_ind
))) {
1663 struct sk_buff
*skb_cmd
;
1664 __le16 data_len
= 0;
1667 dev_dbg(adapter
->dev
, "info: Read Index: %d\n", rdptr
);
1668 skb_cmd
= card
->evt_buf_list
[rdptr
];
1669 mwifiex_unmap_pci_memory(adapter
, skb_cmd
, PCI_DMA_FROMDEVICE
);
1671 /* Take the pointer and set it to event pointer in adapter
1672 and will return back after event handling callback */
1673 card
->evt_buf_list
[rdptr
] = NULL
;
1674 desc
= card
->evtbd_ring
[rdptr
];
1675 memset(desc
, 0, sizeof(*desc
));
1677 event
= *(u32
*) &skb_cmd
->data
[INTF_HEADER_LEN
];
1678 adapter
->event_cause
= event
;
1679 /* The first 4bytes will be the event transfer header
1680 len is 2 bytes followed by type which is 2 bytes */
1681 memcpy(&data_len
, skb_cmd
->data
, sizeof(__le16
));
1682 evt_len
= le16_to_cpu(data_len
);
1684 skb_pull(skb_cmd
, INTF_HEADER_LEN
);
1685 dev_dbg(adapter
->dev
, "info: Event length: %d\n", evt_len
);
1687 if ((evt_len
> 0) && (evt_len
< MAX_EVENT_SIZE
))
1688 memcpy(adapter
->event_body
, skb_cmd
->data
+
1689 MWIFIEX_EVENT_HEADER_LEN
, evt_len
-
1690 MWIFIEX_EVENT_HEADER_LEN
);
1692 adapter
->event_received
= true;
1693 adapter
->event_skb
= skb_cmd
;
1695 /* Do not update the event read pointer here, wait till the
1696 buffer is released. This is just to make things simpler,
1697 we need to find a better method of managing these buffers.
1705 * Event processing complete handler
1707 static int mwifiex_pcie_event_complete(struct mwifiex_adapter
*adapter
,
1708 struct sk_buff
*skb
)
1710 struct pcie_service_card
*card
= adapter
->card
;
1711 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1713 u32 rdptr
= card
->evtbd_rdptr
& MWIFIEX_EVTBD_MASK
;
1715 struct mwifiex_evt_buf_desc
*desc
;
1720 if (rdptr
>= MWIFIEX_MAX_EVT_BD
) {
1721 dev_err(adapter
->dev
, "event_complete: Invalid rdptr 0x%x\n",
1726 /* Read the event ring write pointer set by firmware */
1727 if (mwifiex_read_reg(adapter
, reg
->evt_wrptr
, &wrptr
)) {
1728 dev_err(adapter
->dev
,
1729 "event_complete: failed to read reg->evt_wrptr\n");
1733 if (!card
->evt_buf_list
[rdptr
]) {
1734 skb_push(skb
, INTF_HEADER_LEN
);
1735 if (mwifiex_map_pci_memory(adapter
, skb
,
1737 PCI_DMA_FROMDEVICE
))
1739 card
->evt_buf_list
[rdptr
] = skb
;
1740 desc
= card
->evtbd_ring
[rdptr
];
1741 desc
->paddr
= MWIFIEX_SKB_DMA_ADDR(skb
);
1742 desc
->len
= (u16
)skb
->len
;
1746 dev_dbg(adapter
->dev
,
1747 "info: ERROR: buf still valid at index %d, <%p, %p>\n",
1748 rdptr
, card
->evt_buf_list
[rdptr
], skb
);
1751 if ((++card
->evtbd_rdptr
& MWIFIEX_EVTBD_MASK
) == MWIFIEX_MAX_EVT_BD
) {
1752 card
->evtbd_rdptr
= ((card
->evtbd_rdptr
&
1753 reg
->evt_rollover_ind
) ^
1754 reg
->evt_rollover_ind
);
1757 dev_dbg(adapter
->dev
, "info: Updated <Rd: 0x%x, Wr: 0x%x>",
1758 card
->evtbd_rdptr
, wrptr
);
1760 /* Write the event ring read pointer in to reg->evt_rdptr */
1761 if (mwifiex_write_reg(adapter
, reg
->evt_rdptr
,
1762 card
->evtbd_rdptr
)) {
1763 dev_err(adapter
->dev
,
1764 "event_complete: failed to read reg->evt_rdptr\n");
1768 dev_dbg(adapter
->dev
, "info: Check Events Again\n");
1769 ret
= mwifiex_pcie_process_event_ready(adapter
);
1775 * This function downloads the firmware to the card.
1777 * Firmware is downloaded to the card in blocks. Every block download
1778 * is tested for CRC errors, and retried a number of times before
1779 * returning failure.
1781 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter
*adapter
,
1782 struct mwifiex_fw_image
*fw
)
1785 u8
*firmware
= fw
->fw_buf
;
1786 u32 firmware_len
= fw
->fw_len
;
1788 struct sk_buff
*skb
;
1789 u32 txlen
, tx_blocks
= 0, tries
, len
;
1790 u32 block_retry_cnt
= 0;
1791 struct pcie_service_card
*card
= adapter
->card
;
1792 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1794 if (!firmware
|| !firmware_len
) {
1795 dev_err(adapter
->dev
,
1796 "No firmware image found! Terminating download\n");
1800 dev_dbg(adapter
->dev
, "info: Downloading FW image (%d bytes)\n",
1803 if (mwifiex_pcie_disable_host_int(adapter
)) {
1804 dev_err(adapter
->dev
,
1805 "%s: Disabling interrupts failed.\n", __func__
);
1809 skb
= dev_alloc_skb(MWIFIEX_UPLD_SIZE
);
1815 /* Perform firmware data transfer */
1820 if (offset
>= firmware_len
)
1823 for (tries
= 0; tries
< MAX_POLL_TRIES
; tries
++) {
1824 ret
= mwifiex_read_reg(adapter
, reg
->cmd_size
,
1827 dev_warn(adapter
->dev
,
1828 "Failed reading len from boot code\n");
1833 usleep_range(10, 20);
1838 } else if (len
> MWIFIEX_UPLD_SIZE
) {
1839 pr_err("FW download failure @ %d, invalid length %d\n",
1849 if (block_retry_cnt
> MAX_WRITE_IOMEM_RETRY
) {
1850 pr_err("FW download failure @ %d, over max "
1851 "retry count\n", offset
);
1855 dev_err(adapter
->dev
, "FW CRC error indicated by the "
1856 "helper: len = 0x%04X, txlen = %d\n",
1859 /* Setting this to 0 to resend from same offset */
1862 block_retry_cnt
= 0;
1863 /* Set blocksize to transfer - checking for
1865 if (firmware_len
- offset
< txlen
)
1866 txlen
= firmware_len
- offset
;
1868 dev_dbg(adapter
->dev
, ".");
1870 tx_blocks
= (txlen
+ card
->pcie
.blksz_fw_dl
- 1) /
1871 card
->pcie
.blksz_fw_dl
;
1873 /* Copy payload to buffer */
1874 memmove(skb
->data
, &firmware
[offset
], txlen
);
1877 skb_put(skb
, MWIFIEX_UPLD_SIZE
- skb
->len
);
1878 skb_trim(skb
, tx_blocks
* card
->pcie
.blksz_fw_dl
);
1880 /* Send the boot command to device */
1881 if (mwifiex_pcie_send_boot_cmd(adapter
, skb
)) {
1882 dev_err(adapter
->dev
,
1883 "Failed to send firmware download command\n");
1888 /* Wait for the command done interrupt */
1890 if (mwifiex_read_reg(adapter
, PCIE_CPU_INT_STATUS
,
1892 dev_err(adapter
->dev
, "%s: Failed to read "
1893 "interrupt status during fw dnld.\n",
1895 mwifiex_unmap_pci_memory(adapter
, skb
,
1900 } while ((ireg_intr
& CPU_INTR_DOOR_BELL
) ==
1901 CPU_INTR_DOOR_BELL
);
1903 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1908 dev_dbg(adapter
->dev
, "info:\nFW download over, size %d bytes\n",
1914 dev_kfree_skb_any(skb
);
1919 * This function checks the firmware status in card.
1921 * The winner interface is also determined by this function.
1924 mwifiex_check_fw_status(struct mwifiex_adapter
*adapter
, u32 poll_num
)
1927 u32 firmware_stat
, winner_status
;
1928 struct pcie_service_card
*card
= adapter
->card
;
1929 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1932 /* Mask spurios interrupts */
1933 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_STATUS_MASK
,
1935 dev_warn(adapter
->dev
, "Write register failed\n");
1939 dev_dbg(adapter
->dev
, "Setting driver ready signature\n");
1940 if (mwifiex_write_reg(adapter
, reg
->drv_rdy
,
1941 FIRMWARE_READY_PCIE
)) {
1942 dev_err(adapter
->dev
,
1943 "Failed to write driver ready signature\n");
1947 /* Wait for firmware initialization event */
1948 for (tries
= 0; tries
< poll_num
; tries
++) {
1949 if (mwifiex_read_reg(adapter
, reg
->fw_status
,
1956 if (firmware_stat
== FIRMWARE_READY_PCIE
) {
1966 if (mwifiex_read_reg(adapter
, reg
->fw_status
,
1969 else if (!winner_status
) {
1970 dev_err(adapter
->dev
, "PCI-E is the winner\n");
1971 adapter
->winner
= 1;
1973 dev_err(adapter
->dev
,
1974 "PCI-E is not the winner <%#x,%d>, exit dnld\n",
1975 ret
, adapter
->winner
);
1983 * This function reads the interrupt status from card.
1985 static void mwifiex_interrupt_status(struct mwifiex_adapter
*adapter
)
1988 unsigned long flags
;
1990 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1993 if (mwifiex_read_reg(adapter
, PCIE_HOST_INT_STATUS
, &pcie_ireg
)) {
1994 dev_warn(adapter
->dev
, "Read register failed\n");
1998 if ((pcie_ireg
!= 0xFFFFFFFF) && (pcie_ireg
)) {
2000 mwifiex_pcie_disable_host_int(adapter
);
2002 /* Clear the pending interrupts */
2003 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_STATUS
,
2005 dev_warn(adapter
->dev
, "Write register failed\n");
2008 spin_lock_irqsave(&adapter
->int_lock
, flags
);
2009 adapter
->int_status
|= pcie_ireg
;
2010 spin_unlock_irqrestore(&adapter
->int_lock
, flags
);
2012 if (!adapter
->pps_uapsd_mode
&&
2013 adapter
->ps_state
== PS_STATE_SLEEP
&&
2014 mwifiex_pcie_ok_to_access_hw(adapter
)) {
2015 /* Potentially for PCIe we could get other
2016 * interrupts like shared. Don't change power
2017 * state until cookie is set */
2018 adapter
->ps_state
= PS_STATE_AWAKE
;
2019 adapter
->pm_wakeup_fw_try
= false;
2025 * Interrupt handler for PCIe root port
2027 * This function reads the interrupt status from firmware and assigns
2028 * the main process in workqueue which will handle the interrupt.
2030 static irqreturn_t
mwifiex_pcie_interrupt(int irq
, void *context
)
2032 struct pci_dev
*pdev
= (struct pci_dev
*)context
;
2033 struct pcie_service_card
*card
;
2034 struct mwifiex_adapter
*adapter
;
2037 pr_debug("info: %s: pdev is NULL\n", (u8
*)pdev
);
2041 card
= pci_get_drvdata(pdev
);
2042 if (!card
|| !card
->adapter
) {
2043 pr_debug("info: %s: card=%p adapter=%p\n", __func__
, card
,
2044 card
? card
->adapter
: NULL
);
2047 adapter
= card
->adapter
;
2049 if (adapter
->surprise_removed
)
2052 mwifiex_interrupt_status(adapter
);
2053 queue_work(adapter
->workqueue
, &adapter
->main_work
);
2060 * This function checks the current interrupt status.
2062 * The following interrupts are checked and handled by this function -
2065 * - Command received
2066 * - Packets received
2069 * In case of Rx packets received, the packets are uploaded from card to
2070 * host and processed accordingly.
2072 static int mwifiex_process_int_status(struct mwifiex_adapter
*adapter
)
2076 unsigned long flags
;
2078 spin_lock_irqsave(&adapter
->int_lock
, flags
);
2079 /* Clear out unused interrupts */
2080 pcie_ireg
= adapter
->int_status
;
2081 adapter
->int_status
= 0;
2082 spin_unlock_irqrestore(&adapter
->int_lock
, flags
);
2084 while (pcie_ireg
& HOST_INTR_MASK
) {
2085 if (pcie_ireg
& HOST_INTR_DNLD_DONE
) {
2086 pcie_ireg
&= ~HOST_INTR_DNLD_DONE
;
2087 dev_dbg(adapter
->dev
, "info: TX DNLD Done\n");
2088 ret
= mwifiex_pcie_send_data_complete(adapter
);
2092 if (pcie_ireg
& HOST_INTR_UPLD_RDY
) {
2093 pcie_ireg
&= ~HOST_INTR_UPLD_RDY
;
2094 dev_dbg(adapter
->dev
, "info: Rx DATA\n");
2095 ret
= mwifiex_pcie_process_recv_data(adapter
);
2099 if (pcie_ireg
& HOST_INTR_EVENT_RDY
) {
2100 pcie_ireg
&= ~HOST_INTR_EVENT_RDY
;
2101 dev_dbg(adapter
->dev
, "info: Rx EVENT\n");
2102 ret
= mwifiex_pcie_process_event_ready(adapter
);
2107 if (pcie_ireg
& HOST_INTR_CMD_DONE
) {
2108 pcie_ireg
&= ~HOST_INTR_CMD_DONE
;
2109 if (adapter
->cmd_sent
) {
2110 dev_dbg(adapter
->dev
,
2111 "info: CMD sent Interrupt\n");
2112 adapter
->cmd_sent
= false;
2114 /* Handle command response */
2115 ret
= mwifiex_pcie_process_cmd_complete(adapter
);
2120 if (mwifiex_pcie_ok_to_access_hw(adapter
)) {
2121 if (mwifiex_read_reg(adapter
, PCIE_HOST_INT_STATUS
,
2123 dev_warn(adapter
->dev
,
2124 "Read register failed\n");
2128 if ((pcie_ireg
!= 0xFFFFFFFF) && (pcie_ireg
)) {
2129 if (mwifiex_write_reg(adapter
,
2130 PCIE_HOST_INT_STATUS
,
2132 dev_warn(adapter
->dev
,
2133 "Write register failed\n");
2140 dev_dbg(adapter
->dev
, "info: cmd_sent=%d data_sent=%d\n",
2141 adapter
->cmd_sent
, adapter
->data_sent
);
2142 if (adapter
->ps_state
!= PS_STATE_SLEEP
)
2143 mwifiex_pcie_enable_host_int(adapter
);
2149 * This function downloads data from driver to card.
2151 * Both commands and data packets are transferred to the card by this
2154 * This function adds the PCIE specific header to the front of the buffer
2155 * before transferring. The header contains the length of the packet and
2156 * the type. The firmware handles the packets based upon this set type.
2158 static int mwifiex_pcie_host_to_card(struct mwifiex_adapter
*adapter
, u8 type
,
2159 struct sk_buff
*skb
,
2160 struct mwifiex_tx_param
*tx_param
)
2163 dev_err(adapter
->dev
, "Passed NULL skb to %s\n", __func__
);
2167 if (type
== MWIFIEX_TYPE_DATA
)
2168 return mwifiex_pcie_send_data(adapter
, skb
, tx_param
);
2169 else if (type
== MWIFIEX_TYPE_CMD
)
2170 return mwifiex_pcie_send_cmd(adapter
, skb
);
2176 * This function initializes the PCI-E host memory space, WCB rings, etc.
2178 * The following initializations steps are followed -
2179 * - Allocate TXBD ring buffers
2180 * - Allocate RXBD ring buffers
2181 * - Allocate event BD ring buffers
2182 * - Allocate command response ring buffer
2183 * - Allocate sleep cookie buffer
2185 static int mwifiex_pcie_init(struct mwifiex_adapter
*adapter
)
2187 struct pcie_service_card
*card
= adapter
->card
;
2189 struct pci_dev
*pdev
= card
->dev
;
2190 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
2192 pci_set_drvdata(pdev
, card
);
2194 ret
= pci_enable_device(pdev
);
2196 goto err_enable_dev
;
2198 pci_set_master(pdev
);
2200 dev_dbg(adapter
->dev
, "try set_consistent_dma_mask(32)\n");
2201 ret
= pci_set_dma_mask(pdev
, DMA_BIT_MASK(32));
2203 dev_err(adapter
->dev
, "set_dma_mask(32) failed\n");
2204 goto err_set_dma_mask
;
2207 ret
= pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(32));
2209 dev_err(adapter
->dev
, "set_consistent_dma_mask(64) failed\n");
2210 goto err_set_dma_mask
;
2213 ret
= pci_request_region(pdev
, 0, DRV_NAME
);
2215 dev_err(adapter
->dev
, "req_reg(0) error\n");
2216 goto err_req_region0
;
2218 card
->pci_mmap
= pci_iomap(pdev
, 0, 0);
2219 if (!card
->pci_mmap
) {
2220 dev_err(adapter
->dev
, "iomap(0) error\n");
2224 ret
= pci_request_region(pdev
, 2, DRV_NAME
);
2226 dev_err(adapter
->dev
, "req_reg(2) error\n");
2227 goto err_req_region2
;
2229 card
->pci_mmap1
= pci_iomap(pdev
, 2, 0);
2230 if (!card
->pci_mmap1
) {
2231 dev_err(adapter
->dev
, "iomap(2) error\n");
2236 dev_dbg(adapter
->dev
,
2237 "PCI memory map Virt0: %p PCI memory map Virt2: %p\n",
2238 card
->pci_mmap
, card
->pci_mmap1
);
2240 card
->cmdrsp_buf
= NULL
;
2241 ret
= mwifiex_pcie_create_txbd_ring(adapter
);
2244 ret
= mwifiex_pcie_create_rxbd_ring(adapter
);
2247 ret
= mwifiex_pcie_create_evtbd_ring(adapter
);
2250 ret
= mwifiex_pcie_alloc_cmdrsp_buf(adapter
);
2252 goto err_alloc_cmdbuf
;
2253 if (reg
->sleep_cookie
) {
2254 ret
= mwifiex_pcie_alloc_sleep_cookie_buf(adapter
);
2256 goto err_alloc_cookie
;
2258 card
->sleep_cookie_vbase
= NULL
;
2263 mwifiex_pcie_delete_cmdrsp_buf(adapter
);
2265 mwifiex_pcie_delete_evtbd_ring(adapter
);
2267 mwifiex_pcie_delete_rxbd_ring(adapter
);
2269 mwifiex_pcie_delete_txbd_ring(adapter
);
2271 pci_iounmap(pdev
, card
->pci_mmap1
);
2273 pci_release_region(pdev
, 2);
2275 pci_iounmap(pdev
, card
->pci_mmap
);
2277 pci_release_region(pdev
, 0);
2280 pci_disable_device(pdev
);
2282 pci_set_drvdata(pdev
, NULL
);
2287 * This function cleans up the allocated card buffers.
2289 * The following are freed by this function -
2290 * - TXBD ring buffers
2291 * - RXBD ring buffers
2292 * - Event BD ring buffers
2293 * - Command response ring buffer
2294 * - Sleep cookie buffer
2296 static void mwifiex_pcie_cleanup(struct mwifiex_adapter
*adapter
)
2298 struct pcie_service_card
*card
= adapter
->card
;
2299 struct pci_dev
*pdev
= card
->dev
;
2300 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
2303 dev_dbg(adapter
->dev
, "Clearing driver ready signature\n");
2304 if (mwifiex_write_reg(adapter
, reg
->drv_rdy
, 0x00000000))
2305 dev_err(adapter
->dev
,
2306 "Failed to write driver not-ready signature\n");
2310 pci_iounmap(pdev
, card
->pci_mmap
);
2311 pci_iounmap(pdev
, card
->pci_mmap1
);
2312 pci_disable_device(pdev
);
2313 pci_release_region(pdev
, 2);
2314 pci_release_region(pdev
, 0);
2315 pci_set_drvdata(pdev
, NULL
);
2321 * This function registers the PCIE device.
2323 * PCIE IRQ is claimed, block size is set and driver data is initialized.
2325 static int mwifiex_register_dev(struct mwifiex_adapter
*adapter
)
2328 struct pcie_service_card
*card
= adapter
->card
;
2329 struct pci_dev
*pdev
= card
->dev
;
2331 /* save adapter pointer in card */
2332 card
->adapter
= adapter
;
2334 ret
= request_irq(pdev
->irq
, mwifiex_pcie_interrupt
, IRQF_SHARED
,
2337 pr_err("request_irq failed: ret=%d\n", ret
);
2338 adapter
->card
= NULL
;
2342 adapter
->dev
= &pdev
->dev
;
2343 adapter
->tx_buf_size
= card
->pcie
.tx_buf_size
;
2344 strcpy(adapter
->fw_name
, card
->pcie
.firmware
);
2350 * This function unregisters the PCIE device.
2352 * The PCIE IRQ is released, the function is disabled and driver
2353 * data is set to null.
2355 static void mwifiex_unregister_dev(struct mwifiex_adapter
*adapter
)
2357 struct pcie_service_card
*card
= adapter
->card
;
2358 const struct mwifiex_pcie_card_reg
*reg
;
2361 dev_dbg(adapter
->dev
, "%s(): calling free_irq()\n", __func__
);
2362 free_irq(card
->dev
->irq
, card
->dev
);
2364 reg
= card
->pcie
.reg
;
2365 if (reg
->sleep_cookie
)
2366 mwifiex_pcie_delete_sleep_cookie_buf(adapter
);
2368 mwifiex_pcie_delete_cmdrsp_buf(adapter
);
2369 mwifiex_pcie_delete_evtbd_ring(adapter
);
2370 mwifiex_pcie_delete_rxbd_ring(adapter
);
2371 mwifiex_pcie_delete_txbd_ring(adapter
);
2372 card
->cmdrsp_buf
= NULL
;
2376 static struct mwifiex_if_ops pcie_ops
= {
2377 .init_if
= mwifiex_pcie_init
,
2378 .cleanup_if
= mwifiex_pcie_cleanup
,
2379 .check_fw_status
= mwifiex_check_fw_status
,
2380 .prog_fw
= mwifiex_prog_fw_w_helper
,
2381 .register_dev
= mwifiex_register_dev
,
2382 .unregister_dev
= mwifiex_unregister_dev
,
2383 .enable_int
= mwifiex_pcie_enable_host_int
,
2384 .process_int_status
= mwifiex_process_int_status
,
2385 .host_to_card
= mwifiex_pcie_host_to_card
,
2386 .wakeup
= mwifiex_pm_wakeup_card
,
2387 .wakeup_complete
= mwifiex_pm_wakeup_card_complete
,
2390 .cmdrsp_complete
= mwifiex_pcie_cmdrsp_complete
,
2391 .event_complete
= mwifiex_pcie_event_complete
,
2392 .update_mp_end_port
= NULL
,
2393 .cleanup_mpa_buf
= NULL
,
2394 .init_fw_port
= mwifiex_pcie_init_fw_port
,
2395 .clean_pcie_ring
= mwifiex_clean_pcie_ring_buf
,
2399 * This function initializes the PCIE driver module.
2401 * This initiates the semaphore and registers the device with
2404 static int mwifiex_pcie_init_module(void)
2408 pr_debug("Marvell PCIe Driver\n");
2410 sema_init(&add_remove_card_sem
, 1);
2412 /* Clear the flag in case user removes the card. */
2415 ret
= pci_register_driver(&mwifiex_pcie
);
2417 pr_err("Driver register failed!\n");
2419 pr_debug("info: Driver registered successfully!\n");
2425 * This function cleans up the PCIE driver.
2427 * The following major steps are followed for cleanup -
2428 * - Resume the device if its suspended
2429 * - Disconnect the device if connected
2430 * - Shutdown the firmware
2431 * - Unregister the device from PCIE bus.
2433 static void mwifiex_pcie_cleanup_module(void)
2435 if (!down_interruptible(&add_remove_card_sem
))
2436 up(&add_remove_card_sem
);
2438 /* Set the flag as user is removing this module. */
2441 pci_unregister_driver(&mwifiex_pcie
);
2444 module_init(mwifiex_pcie_init_module
);
2445 module_exit(mwifiex_pcie_cleanup_module
);
2447 MODULE_AUTHOR("Marvell International Ltd.");
2448 MODULE_DESCRIPTION("Marvell WiFi-Ex PCI-Express Driver version " PCIE_VERSION
);
2449 MODULE_VERSION(PCIE_VERSION
);
2450 MODULE_LICENSE("GPL v2");
2451 MODULE_FIRMWARE(PCIE8766_DEFAULT_FW_NAME
);
2452 MODULE_FIRMWARE(PCIE8897_DEFAULT_FW_NAME
);