2 * Marvell Wireless LAN device driver: PCIE specific handling
4 * Copyright (C) 2011-2014, 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
;
40 static struct memory_type_mapping mem_type_mapping_tbl
[] = {
41 {"ITCM", NULL
, 0, 0xF0},
42 {"DTCM", NULL
, 0, 0xF1},
43 {"SQRAM", NULL
, 0, 0xF2},
44 {"IRAM", NULL
, 0, 0xF3},
45 {"APU", NULL
, 0, 0xF4},
46 {"CIU", NULL
, 0, 0xF5},
47 {"ICU", NULL
, 0, 0xF6},
48 {"MAC", NULL
, 0, 0xF7},
52 mwifiex_map_pci_memory(struct mwifiex_adapter
*adapter
, struct sk_buff
*skb
,
53 size_t size
, int flags
)
55 struct pcie_service_card
*card
= adapter
->card
;
56 struct mwifiex_dma_mapping mapping
;
58 mapping
.addr
= pci_map_single(card
->dev
, skb
->data
, size
, flags
);
59 if (pci_dma_mapping_error(card
->dev
, mapping
.addr
)) {
60 dev_err(adapter
->dev
, "failed to map pci memory!\n");
64 mwifiex_store_mapping(skb
, &mapping
);
68 static void mwifiex_unmap_pci_memory(struct mwifiex_adapter
*adapter
,
69 struct sk_buff
*skb
, int flags
)
71 struct pcie_service_card
*card
= adapter
->card
;
72 struct mwifiex_dma_mapping mapping
;
74 mwifiex_get_mapping(skb
, &mapping
);
75 pci_unmap_single(card
->dev
, mapping
.addr
, mapping
.len
, flags
);
79 * This function reads sleep cookie and checks if FW is ready
81 static bool mwifiex_pcie_ok_to_access_hw(struct mwifiex_adapter
*adapter
)
84 struct pcie_service_card
*card
= adapter
->card
;
85 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
87 if (!reg
->sleep_cookie
)
90 if (card
->sleep_cookie_vbase
) {
91 cookie_addr
= (u32
*)card
->sleep_cookie_vbase
;
92 dev_dbg(adapter
->dev
, "info: ACCESS_HW: sleep cookie=0x%x\n",
94 if (*cookie_addr
== FW_AWAKE_COOKIE
)
101 #ifdef CONFIG_PM_SLEEP
103 * Kernel needs to suspend all functions separately. Therefore all
104 * registered functions must have drivers with suspend and resume
105 * methods. Failing that the kernel simply removes the whole card.
107 * If already not suspended, this function allocates and sends a host
108 * sleep activate request to the firmware and turns off the traffic.
110 static int mwifiex_pcie_suspend(struct device
*dev
)
112 struct mwifiex_adapter
*adapter
;
113 struct pcie_service_card
*card
;
115 struct pci_dev
*pdev
= to_pci_dev(dev
);
118 card
= pci_get_drvdata(pdev
);
119 if (!card
|| !card
->adapter
) {
120 pr_err("Card or adapter structure is not valid\n");
124 pr_err("PCIE device is not specified\n");
128 adapter
= card
->adapter
;
130 hs_actived
= mwifiex_enable_hs(adapter
);
132 /* Indicate device suspended */
133 adapter
->is_suspended
= true;
134 adapter
->hs_enabling
= false;
140 * Kernel needs to suspend all functions separately. Therefore all
141 * registered functions must have drivers with suspend and resume
142 * methods. Failing that the kernel simply removes the whole card.
144 * If already not resumed, this function turns on the traffic and
145 * sends a host sleep cancel request to the firmware.
147 static int mwifiex_pcie_resume(struct device
*dev
)
149 struct mwifiex_adapter
*adapter
;
150 struct pcie_service_card
*card
;
151 struct pci_dev
*pdev
= to_pci_dev(dev
);
154 card
= pci_get_drvdata(pdev
);
155 if (!card
|| !card
->adapter
) {
156 pr_err("Card or adapter structure is not valid\n");
160 pr_err("PCIE device is not specified\n");
164 adapter
= card
->adapter
;
166 if (!adapter
->is_suspended
) {
167 dev_warn(adapter
->dev
, "Device already resumed\n");
171 adapter
->is_suspended
= false;
173 mwifiex_cancel_hs(mwifiex_get_priv(adapter
, MWIFIEX_BSS_ROLE_STA
),
181 * This function probes an mwifiex device and registers it. It allocates
182 * the card structure, enables PCIE function number and initiates the
183 * device registration and initialization procedure by adding a logical
186 static int mwifiex_pcie_probe(struct pci_dev
*pdev
,
187 const struct pci_device_id
*ent
)
189 struct pcie_service_card
*card
;
191 pr_debug("info: vendor=0x%4.04X device=0x%4.04X rev=%d\n",
192 pdev
->vendor
, pdev
->device
, pdev
->revision
);
194 card
= kzalloc(sizeof(struct pcie_service_card
), GFP_KERNEL
);
200 if (ent
->driver_data
) {
201 struct mwifiex_pcie_device
*data
= (void *)ent
->driver_data
;
202 card
->pcie
.firmware
= data
->firmware
;
203 card
->pcie
.reg
= data
->reg
;
204 card
->pcie
.blksz_fw_dl
= data
->blksz_fw_dl
;
205 card
->pcie
.tx_buf_size
= data
->tx_buf_size
;
206 card
->pcie
.supports_fw_dump
= data
->supports_fw_dump
;
207 card
->pcie
.can_ext_scan
= data
->can_ext_scan
;
210 if (mwifiex_add_card(card
, &add_remove_card_sem
, &pcie_ops
,
212 pr_err("%s failed\n", __func__
);
221 * This function removes the interface and frees up the card structure.
223 static void mwifiex_pcie_remove(struct pci_dev
*pdev
)
225 struct pcie_service_card
*card
;
226 struct mwifiex_adapter
*adapter
;
227 struct mwifiex_private
*priv
;
229 card
= pci_get_drvdata(pdev
);
233 adapter
= card
->adapter
;
234 if (!adapter
|| !adapter
->priv_num
)
237 cancel_work_sync(&adapter
->iface_work
);
240 #ifdef CONFIG_PM_SLEEP
241 if (adapter
->is_suspended
)
242 mwifiex_pcie_resume(&pdev
->dev
);
245 mwifiex_deauthenticate_all(adapter
);
247 priv
= mwifiex_get_priv(adapter
, MWIFIEX_BSS_ROLE_ANY
);
249 mwifiex_disable_auto_ds(priv
);
251 mwifiex_init_shutdown_fw(priv
, MWIFIEX_FUNC_SHUTDOWN
);
254 mwifiex_remove_card(card
->adapter
, &add_remove_card_sem
);
257 static void mwifiex_pcie_shutdown(struct pci_dev
*pdev
)
260 mwifiex_pcie_remove(pdev
);
265 static const struct pci_device_id mwifiex_ids
[] = {
267 PCIE_VENDOR_ID_MARVELL
, PCIE_DEVICE_ID_MARVELL_88W8766P
,
268 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0,
269 .driver_data
= (unsigned long) &mwifiex_pcie8766
,
272 PCIE_VENDOR_ID_MARVELL
, PCIE_DEVICE_ID_MARVELL_88W8897
,
273 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0,
274 .driver_data
= (unsigned long) &mwifiex_pcie8897
,
279 MODULE_DEVICE_TABLE(pci
, mwifiex_ids
);
281 #ifdef CONFIG_PM_SLEEP
282 /* Power Management Hooks */
283 static SIMPLE_DEV_PM_OPS(mwifiex_pcie_pm_ops
, mwifiex_pcie_suspend
,
284 mwifiex_pcie_resume
);
287 /* PCI Device Driver */
288 static struct pci_driver __refdata mwifiex_pcie
= {
289 .name
= "mwifiex_pcie",
290 .id_table
= mwifiex_ids
,
291 .probe
= mwifiex_pcie_probe
,
292 .remove
= mwifiex_pcie_remove
,
293 #ifdef CONFIG_PM_SLEEP
295 .pm
= &mwifiex_pcie_pm_ops
,
298 .shutdown
= mwifiex_pcie_shutdown
,
302 * This function writes data into PCIE card register.
304 static int mwifiex_write_reg(struct mwifiex_adapter
*adapter
, int reg
, u32 data
)
306 struct pcie_service_card
*card
= adapter
->card
;
308 iowrite32(data
, card
->pci_mmap1
+ reg
);
314 * This function reads data from PCIE card register.
316 static int mwifiex_read_reg(struct mwifiex_adapter
*adapter
, int reg
, u32
*data
)
318 struct pcie_service_card
*card
= adapter
->card
;
320 *data
= ioread32(card
->pci_mmap1
+ reg
);
325 /* This function reads u8 data from PCIE card register. */
326 static int mwifiex_read_reg_byte(struct mwifiex_adapter
*adapter
,
329 struct pcie_service_card
*card
= adapter
->card
;
331 *data
= ioread8(card
->pci_mmap1
+ reg
);
337 * This function adds delay loop to ensure FW is awake before proceeding.
339 static void mwifiex_pcie_dev_wakeup_delay(struct mwifiex_adapter
*adapter
)
343 while (mwifiex_pcie_ok_to_access_hw(adapter
)) {
345 usleep_range(10, 20);
354 static void mwifiex_delay_for_sleep_cookie(struct mwifiex_adapter
*adapter
,
355 u32 max_delay_loop_cnt
)
357 struct pcie_service_card
*card
= adapter
->card
;
359 u32 sleep_cookie
, count
;
361 for (count
= 0; count
< max_delay_loop_cnt
; count
++) {
362 buffer
= card
->cmdrsp_buf
->data
- INTF_HEADER_LEN
;
363 sleep_cookie
= *(u32
*)buffer
;
365 if (sleep_cookie
== MWIFIEX_DEF_SLEEP_COOKIE
) {
366 dev_dbg(adapter
->dev
,
367 "sleep cookie found at count %d\n", count
);
370 usleep_range(20, 30);
373 if (count
>= max_delay_loop_cnt
)
374 dev_dbg(adapter
->dev
,
375 "max count reached while accessing sleep cookie\n");
378 /* This function wakes up the card by reading fw_status register. */
379 static int mwifiex_pm_wakeup_card(struct mwifiex_adapter
*adapter
)
382 struct pcie_service_card
*card
= adapter
->card
;
383 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
385 dev_dbg(adapter
->dev
, "event: Wakeup device...\n");
387 if (reg
->sleep_cookie
)
388 mwifiex_pcie_dev_wakeup_delay(adapter
);
390 /* Reading fw_status register will wakeup device */
391 if (mwifiex_read_reg(adapter
, reg
->fw_status
, &fw_status
)) {
392 dev_warn(adapter
->dev
, "Reading fw_status register failed\n");
396 if (reg
->sleep_cookie
) {
397 mwifiex_pcie_dev_wakeup_delay(adapter
);
398 dev_dbg(adapter
->dev
, "PCIE wakeup: Setting PS_STATE_AWAKE\n");
399 adapter
->ps_state
= PS_STATE_AWAKE
;
406 * This function is called after the card has woken up.
408 * The card configuration register is reset.
410 static int mwifiex_pm_wakeup_card_complete(struct mwifiex_adapter
*adapter
)
412 dev_dbg(adapter
->dev
, "cmd: Wakeup device completed\n");
418 * This function disables the host interrupt.
420 * The host interrupt mask is read, the disable bit is reset and
421 * written back to the card host interrupt mask register.
423 static int mwifiex_pcie_disable_host_int(struct mwifiex_adapter
*adapter
)
425 if (mwifiex_pcie_ok_to_access_hw(adapter
)) {
426 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_MASK
,
428 dev_warn(adapter
->dev
, "Disable host interrupt failed\n");
437 * This function enables the host interrupt.
439 * The host interrupt enable mask is written to the card
440 * host interrupt mask register.
442 static int mwifiex_pcie_enable_host_int(struct mwifiex_adapter
*adapter
)
444 if (mwifiex_pcie_ok_to_access_hw(adapter
)) {
445 /* Simply write the mask to the register */
446 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_MASK
,
448 dev_warn(adapter
->dev
, "Enable host interrupt failed\n");
457 * This function initializes TX buffer ring descriptors
459 static int mwifiex_init_txq_ring(struct mwifiex_adapter
*adapter
)
461 struct pcie_service_card
*card
= adapter
->card
;
462 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
463 struct mwifiex_pcie_buf_desc
*desc
;
464 struct mwifiex_pfu_buf_desc
*desc2
;
467 for (i
= 0; i
< MWIFIEX_MAX_TXRX_BD
; i
++) {
468 card
->tx_buf_list
[i
] = NULL
;
469 if (reg
->pfu_enabled
) {
470 card
->txbd_ring
[i
] = (void *)card
->txbd_ring_vbase
+
471 (sizeof(*desc2
) * i
);
472 desc2
= card
->txbd_ring
[i
];
473 memset(desc2
, 0, sizeof(*desc2
));
475 card
->txbd_ring
[i
] = (void *)card
->txbd_ring_vbase
+
477 desc
= card
->txbd_ring
[i
];
478 memset(desc
, 0, sizeof(*desc
));
485 /* This function initializes RX buffer ring descriptors. Each SKB is allocated
486 * here and after mapping PCI memory, its physical address is assigned to
487 * PCIE Rx buffer descriptor's physical address.
489 static int mwifiex_init_rxq_ring(struct mwifiex_adapter
*adapter
)
491 struct pcie_service_card
*card
= adapter
->card
;
492 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
494 struct mwifiex_pcie_buf_desc
*desc
;
495 struct mwifiex_pfu_buf_desc
*desc2
;
499 for (i
= 0; i
< MWIFIEX_MAX_TXRX_BD
; i
++) {
500 /* Allocate skb here so that firmware can DMA data from it */
501 skb
= dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE
);
503 dev_err(adapter
->dev
,
504 "Unable to allocate skb for RX ring.\n");
505 kfree(card
->rxbd_ring_vbase
);
509 if (mwifiex_map_pci_memory(adapter
, skb
,
510 MWIFIEX_RX_DATA_BUF_SIZE
,
514 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb
);
516 dev_dbg(adapter
->dev
,
517 "info: RX ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
518 skb
, skb
->len
, skb
->data
, (u32
)buf_pa
,
519 (u32
)((u64
)buf_pa
>> 32));
521 card
->rx_buf_list
[i
] = skb
;
522 if (reg
->pfu_enabled
) {
523 card
->rxbd_ring
[i
] = (void *)card
->rxbd_ring_vbase
+
524 (sizeof(*desc2
) * i
);
525 desc2
= card
->rxbd_ring
[i
];
526 desc2
->paddr
= buf_pa
;
527 desc2
->len
= (u16
)skb
->len
;
528 desc2
->frag_len
= (u16
)skb
->len
;
529 desc2
->flags
= reg
->ring_flag_eop
| reg
->ring_flag_sop
;
532 card
->rxbd_ring
[i
] = (void *)(card
->rxbd_ring_vbase
+
533 (sizeof(*desc
) * i
));
534 desc
= card
->rxbd_ring
[i
];
535 desc
->paddr
= buf_pa
;
536 desc
->len
= (u16
)skb
->len
;
544 /* This function initializes event buffer ring descriptors. Each SKB is
545 * allocated here and after mapping PCI memory, its physical address is assigned
546 * to PCIE Rx buffer descriptor's physical address
548 static int mwifiex_pcie_init_evt_ring(struct mwifiex_adapter
*adapter
)
550 struct pcie_service_card
*card
= adapter
->card
;
551 struct mwifiex_evt_buf_desc
*desc
;
556 for (i
= 0; i
< MWIFIEX_MAX_EVT_BD
; i
++) {
557 /* Allocate skb here so that firmware can DMA data from it */
558 skb
= dev_alloc_skb(MAX_EVENT_SIZE
);
560 dev_err(adapter
->dev
,
561 "Unable to allocate skb for EVENT buf.\n");
562 kfree(card
->evtbd_ring_vbase
);
565 skb_put(skb
, MAX_EVENT_SIZE
);
567 if (mwifiex_map_pci_memory(adapter
, skb
, MAX_EVENT_SIZE
,
571 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb
);
573 dev_dbg(adapter
->dev
,
574 "info: EVT ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
575 skb
, skb
->len
, skb
->data
, (u32
)buf_pa
,
576 (u32
)((u64
)buf_pa
>> 32));
578 card
->evt_buf_list
[i
] = skb
;
579 card
->evtbd_ring
[i
] = (void *)(card
->evtbd_ring_vbase
+
580 (sizeof(*desc
) * i
));
581 desc
= card
->evtbd_ring
[i
];
582 desc
->paddr
= buf_pa
;
583 desc
->len
= (u16
)skb
->len
;
590 /* This function cleans up TX buffer rings. If any of the buffer list has valid
591 * SKB address, associated SKB is freed.
593 static void mwifiex_cleanup_txq_ring(struct mwifiex_adapter
*adapter
)
595 struct pcie_service_card
*card
= adapter
->card
;
596 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
598 struct mwifiex_pcie_buf_desc
*desc
;
599 struct mwifiex_pfu_buf_desc
*desc2
;
602 for (i
= 0; i
< MWIFIEX_MAX_TXRX_BD
; i
++) {
603 if (reg
->pfu_enabled
) {
604 desc2
= card
->txbd_ring
[i
];
605 if (card
->tx_buf_list
[i
]) {
606 skb
= card
->tx_buf_list
[i
];
607 mwifiex_unmap_pci_memory(adapter
, skb
,
609 dev_kfree_skb_any(skb
);
611 memset(desc2
, 0, sizeof(*desc2
));
613 desc
= card
->txbd_ring
[i
];
614 if (card
->tx_buf_list
[i
]) {
615 skb
= card
->tx_buf_list
[i
];
616 mwifiex_unmap_pci_memory(adapter
, skb
,
618 dev_kfree_skb_any(skb
);
620 memset(desc
, 0, sizeof(*desc
));
622 card
->tx_buf_list
[i
] = NULL
;
628 /* This function cleans up RX buffer rings. If any of the buffer list has valid
629 * SKB address, associated SKB is freed.
631 static void mwifiex_cleanup_rxq_ring(struct mwifiex_adapter
*adapter
)
633 struct pcie_service_card
*card
= adapter
->card
;
634 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
635 struct mwifiex_pcie_buf_desc
*desc
;
636 struct mwifiex_pfu_buf_desc
*desc2
;
640 for (i
= 0; i
< MWIFIEX_MAX_TXRX_BD
; i
++) {
641 if (reg
->pfu_enabled
) {
642 desc2
= card
->rxbd_ring
[i
];
643 if (card
->rx_buf_list
[i
]) {
644 skb
= card
->rx_buf_list
[i
];
645 mwifiex_unmap_pci_memory(adapter
, skb
,
647 dev_kfree_skb_any(skb
);
649 memset(desc2
, 0, sizeof(*desc2
));
651 desc
= card
->rxbd_ring
[i
];
652 if (card
->rx_buf_list
[i
]) {
653 skb
= card
->rx_buf_list
[i
];
654 mwifiex_unmap_pci_memory(adapter
, skb
,
656 dev_kfree_skb_any(skb
);
658 memset(desc
, 0, sizeof(*desc
));
660 card
->rx_buf_list
[i
] = NULL
;
666 /* This function cleans up event buffer rings. If any of the buffer list has
667 * valid SKB address, associated SKB is freed.
669 static void mwifiex_cleanup_evt_ring(struct mwifiex_adapter
*adapter
)
671 struct pcie_service_card
*card
= adapter
->card
;
672 struct mwifiex_evt_buf_desc
*desc
;
676 for (i
= 0; i
< MWIFIEX_MAX_EVT_BD
; i
++) {
677 desc
= card
->evtbd_ring
[i
];
678 if (card
->evt_buf_list
[i
]) {
679 skb
= card
->evt_buf_list
[i
];
680 mwifiex_unmap_pci_memory(adapter
, skb
,
682 dev_kfree_skb_any(skb
);
684 card
->evt_buf_list
[i
] = NULL
;
685 memset(desc
, 0, sizeof(*desc
));
691 /* This function creates buffer descriptor ring for TX
693 static int mwifiex_pcie_create_txbd_ring(struct mwifiex_adapter
*adapter
)
695 struct pcie_service_card
*card
= adapter
->card
;
696 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
699 * driver maintaines the write pointer and firmware maintaines the read
700 * pointer. The write pointer starts at 0 (zero) while the read pointer
701 * starts at zero with rollover bit set
703 card
->txbd_wrptr
= 0;
705 if (reg
->pfu_enabled
)
706 card
->txbd_rdptr
= 0;
708 card
->txbd_rdptr
|= reg
->tx_rollover_ind
;
710 /* allocate shared memory for the BD ring and divide the same in to
711 several descriptors */
712 if (reg
->pfu_enabled
)
713 card
->txbd_ring_size
= sizeof(struct mwifiex_pfu_buf_desc
) *
716 card
->txbd_ring_size
= sizeof(struct mwifiex_pcie_buf_desc
) *
719 dev_dbg(adapter
->dev
, "info: txbd_ring: Allocating %d bytes\n",
720 card
->txbd_ring_size
);
721 card
->txbd_ring_vbase
= pci_alloc_consistent(card
->dev
,
722 card
->txbd_ring_size
,
723 &card
->txbd_ring_pbase
);
724 if (!card
->txbd_ring_vbase
) {
725 dev_err(adapter
->dev
,
726 "allocate consistent memory (%d bytes) failed!\n",
727 card
->txbd_ring_size
);
730 dev_dbg(adapter
->dev
,
731 "info: txbd_ring - base: %p, pbase: %#x:%x, len: %x\n",
732 card
->txbd_ring_vbase
, (unsigned int)card
->txbd_ring_pbase
,
733 (u32
)((u64
)card
->txbd_ring_pbase
>> 32), card
->txbd_ring_size
);
735 return mwifiex_init_txq_ring(adapter
);
738 static int mwifiex_pcie_delete_txbd_ring(struct mwifiex_adapter
*adapter
)
740 struct pcie_service_card
*card
= adapter
->card
;
741 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
743 mwifiex_cleanup_txq_ring(adapter
);
745 if (card
->txbd_ring_vbase
)
746 pci_free_consistent(card
->dev
, card
->txbd_ring_size
,
747 card
->txbd_ring_vbase
,
748 card
->txbd_ring_pbase
);
749 card
->txbd_ring_size
= 0;
750 card
->txbd_wrptr
= 0;
751 card
->txbd_rdptr
= 0 | reg
->tx_rollover_ind
;
752 card
->txbd_ring_vbase
= NULL
;
753 card
->txbd_ring_pbase
= 0;
759 * This function creates buffer descriptor ring for RX
761 static int mwifiex_pcie_create_rxbd_ring(struct mwifiex_adapter
*adapter
)
763 struct pcie_service_card
*card
= adapter
->card
;
764 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
767 * driver maintaines the read pointer and firmware maintaines the write
768 * pointer. The write pointer starts at 0 (zero) while the read pointer
769 * starts at zero with rollover bit set
771 card
->rxbd_wrptr
= 0;
772 card
->rxbd_rdptr
= reg
->rx_rollover_ind
;
774 if (reg
->pfu_enabled
)
775 card
->rxbd_ring_size
= sizeof(struct mwifiex_pfu_buf_desc
) *
778 card
->rxbd_ring_size
= sizeof(struct mwifiex_pcie_buf_desc
) *
781 dev_dbg(adapter
->dev
, "info: rxbd_ring: Allocating %d bytes\n",
782 card
->rxbd_ring_size
);
783 card
->rxbd_ring_vbase
= pci_alloc_consistent(card
->dev
,
784 card
->rxbd_ring_size
,
785 &card
->rxbd_ring_pbase
);
786 if (!card
->rxbd_ring_vbase
) {
787 dev_err(adapter
->dev
,
788 "allocate consistent memory (%d bytes) failed!\n",
789 card
->rxbd_ring_size
);
793 dev_dbg(adapter
->dev
,
794 "info: rxbd_ring - base: %p, pbase: %#x:%x, len: %#x\n",
795 card
->rxbd_ring_vbase
, (u32
)card
->rxbd_ring_pbase
,
796 (u32
)((u64
)card
->rxbd_ring_pbase
>> 32),
797 card
->rxbd_ring_size
);
799 return mwifiex_init_rxq_ring(adapter
);
803 * This function deletes Buffer descriptor ring for RX
805 static int mwifiex_pcie_delete_rxbd_ring(struct mwifiex_adapter
*adapter
)
807 struct pcie_service_card
*card
= adapter
->card
;
808 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
810 mwifiex_cleanup_rxq_ring(adapter
);
812 if (card
->rxbd_ring_vbase
)
813 pci_free_consistent(card
->dev
, card
->rxbd_ring_size
,
814 card
->rxbd_ring_vbase
,
815 card
->rxbd_ring_pbase
);
816 card
->rxbd_ring_size
= 0;
817 card
->rxbd_wrptr
= 0;
818 card
->rxbd_rdptr
= 0 | reg
->rx_rollover_ind
;
819 card
->rxbd_ring_vbase
= NULL
;
820 card
->rxbd_ring_pbase
= 0;
826 * This function creates buffer descriptor ring for Events
828 static int mwifiex_pcie_create_evtbd_ring(struct mwifiex_adapter
*adapter
)
830 struct pcie_service_card
*card
= adapter
->card
;
831 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
834 * driver maintaines the read pointer and firmware maintaines the write
835 * pointer. The write pointer starts at 0 (zero) while the read pointer
836 * starts at zero with rollover bit set
838 card
->evtbd_wrptr
= 0;
839 card
->evtbd_rdptr
= reg
->evt_rollover_ind
;
841 card
->evtbd_ring_size
= sizeof(struct mwifiex_evt_buf_desc
) *
844 dev_dbg(adapter
->dev
, "info: evtbd_ring: Allocating %d bytes\n",
845 card
->evtbd_ring_size
);
846 card
->evtbd_ring_vbase
= pci_alloc_consistent(card
->dev
,
847 card
->evtbd_ring_size
,
848 &card
->evtbd_ring_pbase
);
849 if (!card
->evtbd_ring_vbase
) {
850 dev_err(adapter
->dev
,
851 "allocate consistent memory (%d bytes) failed!\n",
852 card
->evtbd_ring_size
);
856 dev_dbg(adapter
->dev
,
857 "info: CMDRSP/EVT bd_ring - base: %p pbase: %#x:%x len: %#x\n",
858 card
->evtbd_ring_vbase
, (u32
)card
->evtbd_ring_pbase
,
859 (u32
)((u64
)card
->evtbd_ring_pbase
>> 32),
860 card
->evtbd_ring_size
);
862 return mwifiex_pcie_init_evt_ring(adapter
);
866 * This function deletes Buffer descriptor ring for Events
868 static int mwifiex_pcie_delete_evtbd_ring(struct mwifiex_adapter
*adapter
)
870 struct pcie_service_card
*card
= adapter
->card
;
871 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
873 mwifiex_cleanup_evt_ring(adapter
);
875 if (card
->evtbd_ring_vbase
)
876 pci_free_consistent(card
->dev
, card
->evtbd_ring_size
,
877 card
->evtbd_ring_vbase
,
878 card
->evtbd_ring_pbase
);
879 card
->evtbd_wrptr
= 0;
880 card
->evtbd_rdptr
= 0 | reg
->evt_rollover_ind
;
881 card
->evtbd_ring_size
= 0;
882 card
->evtbd_ring_vbase
= NULL
;
883 card
->evtbd_ring_pbase
= 0;
889 * This function allocates a buffer for CMDRSP
891 static int mwifiex_pcie_alloc_cmdrsp_buf(struct mwifiex_adapter
*adapter
)
893 struct pcie_service_card
*card
= adapter
->card
;
896 /* Allocate memory for receiving command response data */
897 skb
= dev_alloc_skb(MWIFIEX_UPLD_SIZE
);
899 dev_err(adapter
->dev
,
900 "Unable to allocate skb for command response data.\n");
903 skb_put(skb
, MWIFIEX_UPLD_SIZE
);
904 if (mwifiex_map_pci_memory(adapter
, skb
, MWIFIEX_UPLD_SIZE
,
908 card
->cmdrsp_buf
= skb
;
914 * This function deletes a buffer for CMDRSP
916 static int mwifiex_pcie_delete_cmdrsp_buf(struct mwifiex_adapter
*adapter
)
918 struct pcie_service_card
*card
;
923 card
= adapter
->card
;
925 if (card
&& card
->cmdrsp_buf
) {
926 mwifiex_unmap_pci_memory(adapter
, card
->cmdrsp_buf
,
928 dev_kfree_skb_any(card
->cmdrsp_buf
);
931 if (card
&& card
->cmd_buf
) {
932 mwifiex_unmap_pci_memory(adapter
, card
->cmd_buf
,
939 * This function allocates a buffer for sleep cookie
941 static int mwifiex_pcie_alloc_sleep_cookie_buf(struct mwifiex_adapter
*adapter
)
943 struct pcie_service_card
*card
= adapter
->card
;
945 card
->sleep_cookie_vbase
= pci_alloc_consistent(card
->dev
, sizeof(u32
),
946 &card
->sleep_cookie_pbase
);
947 if (!card
->sleep_cookie_vbase
) {
948 dev_err(adapter
->dev
, "pci_alloc_consistent failed!\n");
951 /* Init val of Sleep Cookie */
952 *(u32
*)card
->sleep_cookie_vbase
= FW_AWAKE_COOKIE
;
954 dev_dbg(adapter
->dev
, "alloc_scook: sleep cookie=0x%x\n",
955 *((u32
*)card
->sleep_cookie_vbase
));
961 * This function deletes buffer for sleep cookie
963 static int mwifiex_pcie_delete_sleep_cookie_buf(struct mwifiex_adapter
*adapter
)
965 struct pcie_service_card
*card
;
970 card
= adapter
->card
;
972 if (card
&& card
->sleep_cookie_vbase
) {
973 pci_free_consistent(card
->dev
, sizeof(u32
),
974 card
->sleep_cookie_vbase
,
975 card
->sleep_cookie_pbase
);
976 card
->sleep_cookie_vbase
= NULL
;
982 /* This function flushes the TX buffer descriptor ring
983 * This function defined as handler is also called while cleaning TXRX
984 * during disconnect/ bss stop.
986 static int mwifiex_clean_pcie_ring_buf(struct mwifiex_adapter
*adapter
)
988 struct pcie_service_card
*card
= adapter
->card
;
990 if (!mwifiex_pcie_txbd_empty(card
, card
->txbd_rdptr
)) {
991 card
->txbd_flush
= 1;
992 /* write pointer already set at last send
993 * send dnld-rdy intr again, wait for completion.
995 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
996 CPU_INTR_DNLD_RDY
)) {
997 dev_err(adapter
->dev
,
998 "failed to assert dnld-rdy interrupt.\n");
1006 * This function unmaps and frees downloaded data buffer
1008 static int mwifiex_pcie_send_data_complete(struct mwifiex_adapter
*adapter
)
1010 struct sk_buff
*skb
;
1011 u32 wrdoneidx
, rdptr
, num_tx_buffs
, unmap_count
= 0;
1012 struct mwifiex_pcie_buf_desc
*desc
;
1013 struct mwifiex_pfu_buf_desc
*desc2
;
1014 struct pcie_service_card
*card
= adapter
->card
;
1015 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1017 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1018 mwifiex_pm_wakeup_card(adapter
);
1020 /* Read the TX ring read pointer set by firmware */
1021 if (mwifiex_read_reg(adapter
, reg
->tx_rdptr
, &rdptr
)) {
1022 dev_err(adapter
->dev
,
1023 "SEND COMP: failed to read reg->tx_rdptr\n");
1027 dev_dbg(adapter
->dev
, "SEND COMP: rdptr_prev=0x%x, rdptr=0x%x\n",
1028 card
->txbd_rdptr
, rdptr
);
1030 num_tx_buffs
= MWIFIEX_MAX_TXRX_BD
<< reg
->tx_start_ptr
;
1031 /* free from previous txbd_rdptr to current txbd_rdptr */
1032 while (((card
->txbd_rdptr
& reg
->tx_mask
) !=
1033 (rdptr
& reg
->tx_mask
)) ||
1034 ((card
->txbd_rdptr
& reg
->tx_rollover_ind
) !=
1035 (rdptr
& reg
->tx_rollover_ind
))) {
1036 wrdoneidx
= (card
->txbd_rdptr
& reg
->tx_mask
) >>
1039 skb
= card
->tx_buf_list
[wrdoneidx
];
1042 dev_dbg(adapter
->dev
,
1043 "SEND COMP: Detach skb %p at txbd_rdidx=%d\n",
1045 mwifiex_unmap_pci_memory(adapter
, skb
,
1050 if (card
->txbd_flush
)
1051 mwifiex_write_data_complete(adapter
, skb
, 0,
1054 mwifiex_write_data_complete(adapter
, skb
, 0, 0);
1057 card
->tx_buf_list
[wrdoneidx
] = NULL
;
1059 if (reg
->pfu_enabled
) {
1060 desc2
= card
->txbd_ring
[wrdoneidx
];
1061 memset(desc2
, 0, sizeof(*desc2
));
1063 desc
= card
->txbd_ring
[wrdoneidx
];
1064 memset(desc
, 0, sizeof(*desc
));
1066 switch (card
->dev
->device
) {
1067 case PCIE_DEVICE_ID_MARVELL_88W8766P
:
1070 case PCIE_DEVICE_ID_MARVELL_88W8897
:
1071 card
->txbd_rdptr
+= reg
->ring_tx_start_ptr
;
1076 if ((card
->txbd_rdptr
& reg
->tx_mask
) == num_tx_buffs
)
1077 card
->txbd_rdptr
= ((card
->txbd_rdptr
&
1078 reg
->tx_rollover_ind
) ^
1079 reg
->tx_rollover_ind
);
1083 adapter
->data_sent
= false;
1085 if (card
->txbd_flush
) {
1086 if (mwifiex_pcie_txbd_empty(card
, card
->txbd_rdptr
))
1087 card
->txbd_flush
= 0;
1089 mwifiex_clean_pcie_ring_buf(adapter
);
1095 /* This function sends data buffer to device. First 4 bytes of payload
1096 * are filled with payload length and payload type. Then this payload
1097 * is mapped to PCI device memory. Tx ring pointers are advanced accordingly.
1098 * Download ready interrupt to FW is deffered if Tx ring is not full and
1099 * additional payload can be accomodated.
1100 * Caller must ensure tx_param parameter to this function is not NULL.
1103 mwifiex_pcie_send_data(struct mwifiex_adapter
*adapter
, struct sk_buff
*skb
,
1104 struct mwifiex_tx_param
*tx_param
)
1106 struct pcie_service_card
*card
= adapter
->card
;
1107 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1108 u32 wrindx
, num_tx_buffs
, rx_val
;
1111 struct mwifiex_pcie_buf_desc
*desc
= NULL
;
1112 struct mwifiex_pfu_buf_desc
*desc2
= NULL
;
1115 if (!(skb
->data
&& skb
->len
)) {
1116 dev_err(adapter
->dev
, "%s(): invalid parameter <%p, %#x>\n",
1117 __func__
, skb
->data
, skb
->len
);
1121 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1122 mwifiex_pm_wakeup_card(adapter
);
1124 num_tx_buffs
= MWIFIEX_MAX_TXRX_BD
<< reg
->tx_start_ptr
;
1125 dev_dbg(adapter
->dev
, "info: SEND DATA: <Rd: %#x, Wr: %#x>\n",
1126 card
->txbd_rdptr
, card
->txbd_wrptr
);
1127 if (mwifiex_pcie_txbd_not_full(card
)) {
1130 adapter
->data_sent
= true;
1131 payload
= skb
->data
;
1132 tmp
= (__le16
*)&payload
[0];
1133 *tmp
= cpu_to_le16((u16
)skb
->len
);
1134 tmp
= (__le16
*)&payload
[2];
1135 *tmp
= cpu_to_le16(MWIFIEX_TYPE_DATA
);
1137 if (mwifiex_map_pci_memory(adapter
, skb
, skb
->len
,
1141 wrindx
= (card
->txbd_wrptr
& reg
->tx_mask
) >> reg
->tx_start_ptr
;
1142 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb
);
1143 card
->tx_buf_list
[wrindx
] = skb
;
1145 if (reg
->pfu_enabled
) {
1146 desc2
= card
->txbd_ring
[wrindx
];
1147 desc2
->paddr
= buf_pa
;
1148 desc2
->len
= (u16
)skb
->len
;
1149 desc2
->frag_len
= (u16
)skb
->len
;
1151 desc2
->flags
= MWIFIEX_BD_FLAG_FIRST_DESC
|
1152 MWIFIEX_BD_FLAG_LAST_DESC
;
1154 desc
= card
->txbd_ring
[wrindx
];
1155 desc
->paddr
= buf_pa
;
1156 desc
->len
= (u16
)skb
->len
;
1157 desc
->flags
= MWIFIEX_BD_FLAG_FIRST_DESC
|
1158 MWIFIEX_BD_FLAG_LAST_DESC
;
1161 switch (card
->dev
->device
) {
1162 case PCIE_DEVICE_ID_MARVELL_88W8766P
:
1165 case PCIE_DEVICE_ID_MARVELL_88W8897
:
1166 card
->txbd_wrptr
+= reg
->ring_tx_start_ptr
;
1170 if ((card
->txbd_wrptr
& reg
->tx_mask
) == num_tx_buffs
)
1171 card
->txbd_wrptr
= ((card
->txbd_wrptr
&
1172 reg
->tx_rollover_ind
) ^
1173 reg
->tx_rollover_ind
);
1175 rx_val
= card
->rxbd_rdptr
& reg
->rx_wrap_mask
;
1176 /* Write the TX ring write pointer in to reg->tx_wrptr */
1177 if (mwifiex_write_reg(adapter
, reg
->tx_wrptr
,
1178 card
->txbd_wrptr
| rx_val
)) {
1179 dev_err(adapter
->dev
,
1180 "SEND DATA: failed to write reg->tx_wrptr\n");
1184 if ((mwifiex_pcie_txbd_not_full(card
)) &&
1185 tx_param
->next_pkt_len
) {
1186 /* have more packets and TxBD still can hold more */
1187 dev_dbg(adapter
->dev
,
1188 "SEND DATA: delay dnld-rdy interrupt.\n");
1189 adapter
->data_sent
= false;
1191 /* Send the TX ready interrupt */
1192 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1193 CPU_INTR_DNLD_RDY
)) {
1194 dev_err(adapter
->dev
,
1195 "SEND DATA: failed to assert dnld-rdy interrupt.\n");
1200 dev_dbg(adapter
->dev
, "info: SEND DATA: Updated <Rd: %#x, Wr: "
1201 "%#x> and sent packet to firmware successfully\n",
1202 card
->txbd_rdptr
, card
->txbd_wrptr
);
1204 dev_dbg(adapter
->dev
,
1205 "info: TX Ring full, can't send packets to fw\n");
1206 adapter
->data_sent
= true;
1207 /* Send the TX ready interrupt */
1208 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1210 dev_err(adapter
->dev
,
1211 "SEND DATA: failed to assert door-bell intr\n");
1215 return -EINPROGRESS
;
1217 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1218 card
->tx_buf_list
[wrindx
] = NULL
;
1219 if (reg
->pfu_enabled
)
1220 memset(desc2
, 0, sizeof(*desc2
));
1222 memset(desc
, 0, sizeof(*desc
));
1228 * This function handles received buffer ring and
1229 * dispatches packets to upper
1231 static int mwifiex_pcie_process_recv_data(struct mwifiex_adapter
*adapter
)
1233 struct pcie_service_card
*card
= adapter
->card
;
1234 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1235 u32 wrptr
, rd_index
, tx_val
;
1238 struct sk_buff
*skb_tmp
= NULL
;
1239 struct mwifiex_pcie_buf_desc
*desc
;
1240 struct mwifiex_pfu_buf_desc
*desc2
;
1242 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1243 mwifiex_pm_wakeup_card(adapter
);
1245 /* Read the RX ring Write pointer set by firmware */
1246 if (mwifiex_read_reg(adapter
, reg
->rx_wrptr
, &wrptr
)) {
1247 dev_err(adapter
->dev
,
1248 "RECV DATA: failed to read reg->rx_wrptr\n");
1252 card
->rxbd_wrptr
= wrptr
;
1254 while (((wrptr
& reg
->rx_mask
) !=
1255 (card
->rxbd_rdptr
& reg
->rx_mask
)) ||
1256 ((wrptr
& reg
->rx_rollover_ind
) ==
1257 (card
->rxbd_rdptr
& reg
->rx_rollover_ind
))) {
1258 struct sk_buff
*skb_data
;
1262 rd_index
= card
->rxbd_rdptr
& reg
->rx_mask
;
1263 skb_data
= card
->rx_buf_list
[rd_index
];
1265 /* If skb allocation was failed earlier for Rx packet,
1266 * rx_buf_list[rd_index] would have been left with a NULL.
1271 mwifiex_unmap_pci_memory(adapter
, skb_data
, PCI_DMA_FROMDEVICE
);
1272 card
->rx_buf_list
[rd_index
] = NULL
;
1274 /* Get data length from interface header -
1275 * first 2 bytes for len, next 2 bytes is for type
1277 pkt_len
= *((__le16
*)skb_data
->data
);
1278 rx_len
= le16_to_cpu(pkt_len
);
1279 if (WARN_ON(rx_len
<= INTF_HEADER_LEN
||
1280 rx_len
> MWIFIEX_RX_DATA_BUF_SIZE
)) {
1281 dev_err(adapter
->dev
,
1282 "Invalid RX len %d, Rd=%#x, Wr=%#x\n",
1283 rx_len
, card
->rxbd_rdptr
, wrptr
);
1284 dev_kfree_skb_any(skb_data
);
1286 skb_put(skb_data
, rx_len
);
1287 dev_dbg(adapter
->dev
,
1288 "info: RECV DATA: Rd=%#x, Wr=%#x, Len=%d\n",
1289 card
->rxbd_rdptr
, wrptr
, rx_len
);
1290 skb_pull(skb_data
, INTF_HEADER_LEN
);
1291 if (adapter
->rx_work_enabled
) {
1292 skb_queue_tail(&adapter
->rx_data_q
, skb_data
);
1293 adapter
->data_received
= true;
1294 atomic_inc(&adapter
->rx_pending
);
1296 mwifiex_handle_rx_packet(adapter
, skb_data
);
1300 skb_tmp
= dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE
);
1302 dev_err(adapter
->dev
,
1303 "Unable to allocate skb.\n");
1307 if (mwifiex_map_pci_memory(adapter
, skb_tmp
,
1308 MWIFIEX_RX_DATA_BUF_SIZE
,
1309 PCI_DMA_FROMDEVICE
))
1312 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb_tmp
);
1314 dev_dbg(adapter
->dev
,
1315 "RECV DATA: Attach new sk_buff %p at rxbd_rdidx=%d\n",
1317 card
->rx_buf_list
[rd_index
] = skb_tmp
;
1319 if (reg
->pfu_enabled
) {
1320 desc2
= card
->rxbd_ring
[rd_index
];
1321 desc2
->paddr
= buf_pa
;
1322 desc2
->len
= skb_tmp
->len
;
1323 desc2
->frag_len
= skb_tmp
->len
;
1325 desc2
->flags
= reg
->ring_flag_sop
| reg
->ring_flag_eop
;
1327 desc
= card
->rxbd_ring
[rd_index
];
1328 desc
->paddr
= buf_pa
;
1329 desc
->len
= skb_tmp
->len
;
1333 if ((++card
->rxbd_rdptr
& reg
->rx_mask
) ==
1334 MWIFIEX_MAX_TXRX_BD
) {
1335 card
->rxbd_rdptr
= ((card
->rxbd_rdptr
&
1336 reg
->rx_rollover_ind
) ^
1337 reg
->rx_rollover_ind
);
1339 dev_dbg(adapter
->dev
, "info: RECV DATA: <Rd: %#x, Wr: %#x>\n",
1340 card
->rxbd_rdptr
, wrptr
);
1342 tx_val
= card
->txbd_wrptr
& reg
->tx_wrap_mask
;
1343 /* Write the RX ring read pointer in to reg->rx_rdptr */
1344 if (mwifiex_write_reg(adapter
, reg
->rx_rdptr
,
1345 card
->rxbd_rdptr
| tx_val
)) {
1346 dev_err(adapter
->dev
,
1347 "RECV DATA: failed to write reg->rx_rdptr\n");
1352 /* Read the RX ring Write pointer set by firmware */
1353 if (mwifiex_read_reg(adapter
, reg
->rx_wrptr
, &wrptr
)) {
1354 dev_err(adapter
->dev
,
1355 "RECV DATA: failed to read reg->rx_wrptr\n");
1359 dev_dbg(adapter
->dev
,
1360 "info: RECV DATA: Rcvd packet from fw successfully\n");
1361 card
->rxbd_wrptr
= wrptr
;
1369 * This function downloads the boot command to device
1372 mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter
*adapter
, struct sk_buff
*skb
)
1375 struct pcie_service_card
*card
= adapter
->card
;
1376 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1378 if (!(skb
->data
&& skb
->len
)) {
1379 dev_err(adapter
->dev
,
1380 "Invalid parameter in %s <%p. len %d>\n",
1381 __func__
, skb
->data
, skb
->len
);
1385 if (mwifiex_map_pci_memory(adapter
, skb
, skb
->len
, PCI_DMA_TODEVICE
))
1388 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb
);
1390 /* Write the lower 32bits of the physical address to low command
1391 * address scratch register
1393 if (mwifiex_write_reg(adapter
, reg
->cmd_addr_lo
, (u32
)buf_pa
)) {
1394 dev_err(adapter
->dev
,
1395 "%s: failed to write download command to boot code.\n",
1397 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1401 /* Write the upper 32bits of the physical address to high command
1402 * address scratch register
1404 if (mwifiex_write_reg(adapter
, reg
->cmd_addr_hi
,
1405 (u32
)((u64
)buf_pa
>> 32))) {
1406 dev_err(adapter
->dev
,
1407 "%s: failed to write download command to boot code.\n",
1409 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1413 /* Write the command length to cmd_size scratch register */
1414 if (mwifiex_write_reg(adapter
, reg
->cmd_size
, skb
->len
)) {
1415 dev_err(adapter
->dev
,
1416 "%s: failed to write command len to cmd_size scratch reg\n",
1418 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1422 /* Ring the door bell */
1423 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1424 CPU_INTR_DOOR_BELL
)) {
1425 dev_err(adapter
->dev
,
1426 "%s: failed to assert door-bell intr\n", __func__
);
1427 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1434 /* This function init rx port in firmware which in turn enables to receive data
1435 * from device before transmitting any packet.
1437 static int mwifiex_pcie_init_fw_port(struct mwifiex_adapter
*adapter
)
1439 struct pcie_service_card
*card
= adapter
->card
;
1440 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1441 int tx_wrap
= card
->txbd_wrptr
& reg
->tx_wrap_mask
;
1443 /* Write the RX ring read pointer in to reg->rx_rdptr */
1444 if (mwifiex_write_reg(adapter
, reg
->rx_rdptr
, card
->rxbd_rdptr
|
1446 dev_err(adapter
->dev
,
1447 "RECV DATA: failed to write reg->rx_rdptr\n");
1453 /* This function downloads commands to the device
1456 mwifiex_pcie_send_cmd(struct mwifiex_adapter
*adapter
, struct sk_buff
*skb
)
1458 struct pcie_service_card
*card
= adapter
->card
;
1459 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1461 dma_addr_t cmd_buf_pa
, cmdrsp_buf_pa
;
1462 u8
*payload
= (u8
*)skb
->data
;
1464 if (!(skb
->data
&& skb
->len
)) {
1465 dev_err(adapter
->dev
, "Invalid parameter in %s <%p, %#x>\n",
1466 __func__
, skb
->data
, skb
->len
);
1470 /* Make sure a command response buffer is available */
1471 if (!card
->cmdrsp_buf
) {
1472 dev_err(adapter
->dev
,
1473 "No response buffer available, send command failed\n");
1477 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1478 mwifiex_pm_wakeup_card(adapter
);
1480 adapter
->cmd_sent
= true;
1482 *(__le16
*)&payload
[0] = cpu_to_le16((u16
)skb
->len
);
1483 *(__le16
*)&payload
[2] = cpu_to_le16(MWIFIEX_TYPE_CMD
);
1485 if (mwifiex_map_pci_memory(adapter
, skb
, skb
->len
, PCI_DMA_TODEVICE
))
1488 card
->cmd_buf
= skb
;
1490 /* To send a command, the driver will:
1491 1. Write the 64bit physical address of the data buffer to
1492 cmd response address low + cmd response address high
1493 2. Ring the door bell (i.e. set the door bell interrupt)
1495 In response to door bell interrupt, the firmware will perform
1496 the DMA of the command packet (first header to obtain the total
1497 length and then rest of the command).
1500 if (card
->cmdrsp_buf
) {
1501 cmdrsp_buf_pa
= MWIFIEX_SKB_DMA_ADDR(card
->cmdrsp_buf
);
1502 /* Write the lower 32bits of the cmdrsp buffer physical
1504 if (mwifiex_write_reg(adapter
, reg
->cmdrsp_addr_lo
,
1505 (u32
)cmdrsp_buf_pa
)) {
1506 dev_err(adapter
->dev
,
1507 "Failed to write download cmd to boot code.\n");
1511 /* Write the upper 32bits of the cmdrsp buffer physical
1513 if (mwifiex_write_reg(adapter
, reg
->cmdrsp_addr_hi
,
1514 (u32
)((u64
)cmdrsp_buf_pa
>> 32))) {
1515 dev_err(adapter
->dev
,
1516 "Failed to write download cmd to boot code.\n");
1522 cmd_buf_pa
= MWIFIEX_SKB_DMA_ADDR(card
->cmd_buf
);
1523 /* Write the lower 32bits of the physical address to reg->cmd_addr_lo */
1524 if (mwifiex_write_reg(adapter
, reg
->cmd_addr_lo
,
1526 dev_err(adapter
->dev
,
1527 "Failed to write download cmd to boot code.\n");
1531 /* Write the upper 32bits of the physical address to reg->cmd_addr_hi */
1532 if (mwifiex_write_reg(adapter
, reg
->cmd_addr_hi
,
1533 (u32
)((u64
)cmd_buf_pa
>> 32))) {
1534 dev_err(adapter
->dev
,
1535 "Failed to write download cmd to boot code.\n");
1540 /* Write the command length to reg->cmd_size */
1541 if (mwifiex_write_reg(adapter
, reg
->cmd_size
,
1542 card
->cmd_buf
->len
)) {
1543 dev_err(adapter
->dev
,
1544 "Failed to write cmd len to reg->cmd_size\n");
1549 /* Ring the door bell */
1550 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1551 CPU_INTR_DOOR_BELL
)) {
1552 dev_err(adapter
->dev
,
1553 "Failed to assert door-bell intr\n");
1560 adapter
->cmd_sent
= false;
1566 * This function handles command complete interrupt
1568 static int mwifiex_pcie_process_cmd_complete(struct mwifiex_adapter
*adapter
)
1570 struct pcie_service_card
*card
= adapter
->card
;
1571 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1572 struct sk_buff
*skb
= card
->cmdrsp_buf
;
1577 dev_dbg(adapter
->dev
, "info: Rx CMD Response\n");
1579 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_FROMDEVICE
);
1581 /* Unmap the command as a response has been received. */
1582 if (card
->cmd_buf
) {
1583 mwifiex_unmap_pci_memory(adapter
, card
->cmd_buf
,
1585 card
->cmd_buf
= NULL
;
1588 pkt_len
= *((__le16
*)skb
->data
);
1589 rx_len
= le16_to_cpu(pkt_len
);
1590 skb_trim(skb
, rx_len
);
1591 skb_pull(skb
, INTF_HEADER_LEN
);
1593 if (!adapter
->curr_cmd
) {
1594 if (adapter
->ps_state
== PS_STATE_SLEEP_CFM
) {
1595 mwifiex_process_sleep_confirm_resp(adapter
, skb
->data
,
1597 mwifiex_pcie_enable_host_int(adapter
);
1598 if (mwifiex_write_reg(adapter
,
1600 CPU_INTR_SLEEP_CFM_DONE
)) {
1601 dev_warn(adapter
->dev
,
1602 "Write register failed\n");
1605 mwifiex_delay_for_sleep_cookie(adapter
,
1606 MWIFIEX_MAX_DELAY_COUNT
);
1607 while (reg
->sleep_cookie
&& (count
++ < 10) &&
1608 mwifiex_pcie_ok_to_access_hw(adapter
))
1609 usleep_range(50, 60);
1611 dev_err(adapter
->dev
,
1612 "There is no command but got cmdrsp\n");
1614 memcpy(adapter
->upld_buf
, skb
->data
,
1615 min_t(u32
, MWIFIEX_SIZE_OF_CMD_BUFFER
, skb
->len
));
1616 skb_push(skb
, INTF_HEADER_LEN
);
1617 if (mwifiex_map_pci_memory(adapter
, skb
, MWIFIEX_UPLD_SIZE
,
1618 PCI_DMA_FROMDEVICE
))
1620 } else if (mwifiex_pcie_ok_to_access_hw(adapter
)) {
1621 adapter
->curr_cmd
->resp_skb
= skb
;
1622 adapter
->cmd_resp_received
= true;
1623 /* Take the pointer and set it to CMD node and will
1624 return in the response complete callback */
1625 card
->cmdrsp_buf
= NULL
;
1627 /* Clear the cmd-rsp buffer address in scratch registers. This
1628 will prevent firmware from writing to the same response
1630 if (mwifiex_write_reg(adapter
, reg
->cmdrsp_addr_lo
, 0)) {
1631 dev_err(adapter
->dev
,
1632 "cmd_done: failed to clear cmd_rsp_addr_lo\n");
1635 /* Write the upper 32bits of the cmdrsp buffer physical
1637 if (mwifiex_write_reg(adapter
, reg
->cmdrsp_addr_hi
, 0)) {
1638 dev_err(adapter
->dev
,
1639 "cmd_done: failed to clear cmd_rsp_addr_hi\n");
1648 * Command Response processing complete handler
1650 static int mwifiex_pcie_cmdrsp_complete(struct mwifiex_adapter
*adapter
,
1651 struct sk_buff
*skb
)
1653 struct pcie_service_card
*card
= adapter
->card
;
1656 card
->cmdrsp_buf
= skb
;
1657 skb_push(card
->cmdrsp_buf
, INTF_HEADER_LEN
);
1658 if (mwifiex_map_pci_memory(adapter
, skb
, MWIFIEX_UPLD_SIZE
,
1659 PCI_DMA_FROMDEVICE
))
1667 * This function handles firmware event ready interrupt
1669 static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter
*adapter
)
1671 struct pcie_service_card
*card
= adapter
->card
;
1672 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1673 u32 rdptr
= card
->evtbd_rdptr
& MWIFIEX_EVTBD_MASK
;
1675 struct mwifiex_evt_buf_desc
*desc
;
1677 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1678 mwifiex_pm_wakeup_card(adapter
);
1680 if (adapter
->event_received
) {
1681 dev_dbg(adapter
->dev
, "info: Event being processed, "
1682 "do not process this interrupt just yet\n");
1686 if (rdptr
>= MWIFIEX_MAX_EVT_BD
) {
1687 dev_dbg(adapter
->dev
, "info: Invalid read pointer...\n");
1691 /* Read the event ring write pointer set by firmware */
1692 if (mwifiex_read_reg(adapter
, reg
->evt_wrptr
, &wrptr
)) {
1693 dev_err(adapter
->dev
,
1694 "EventReady: failed to read reg->evt_wrptr\n");
1698 dev_dbg(adapter
->dev
, "info: EventReady: Initial <Rd: 0x%x, Wr: 0x%x>",
1699 card
->evtbd_rdptr
, wrptr
);
1700 if (((wrptr
& MWIFIEX_EVTBD_MASK
) != (card
->evtbd_rdptr
1701 & MWIFIEX_EVTBD_MASK
)) ||
1702 ((wrptr
& reg
->evt_rollover_ind
) ==
1703 (card
->evtbd_rdptr
& reg
->evt_rollover_ind
))) {
1704 struct sk_buff
*skb_cmd
;
1705 __le16 data_len
= 0;
1708 dev_dbg(adapter
->dev
, "info: Read Index: %d\n", rdptr
);
1709 skb_cmd
= card
->evt_buf_list
[rdptr
];
1710 mwifiex_unmap_pci_memory(adapter
, skb_cmd
, PCI_DMA_FROMDEVICE
);
1712 /* Take the pointer and set it to event pointer in adapter
1713 and will return back after event handling callback */
1714 card
->evt_buf_list
[rdptr
] = NULL
;
1715 desc
= card
->evtbd_ring
[rdptr
];
1716 memset(desc
, 0, sizeof(*desc
));
1718 event
= *(u32
*) &skb_cmd
->data
[INTF_HEADER_LEN
];
1719 adapter
->event_cause
= event
;
1720 /* The first 4bytes will be the event transfer header
1721 len is 2 bytes followed by type which is 2 bytes */
1722 memcpy(&data_len
, skb_cmd
->data
, sizeof(__le16
));
1723 evt_len
= le16_to_cpu(data_len
);
1725 skb_pull(skb_cmd
, INTF_HEADER_LEN
);
1726 dev_dbg(adapter
->dev
, "info: Event length: %d\n", evt_len
);
1728 if ((evt_len
> 0) && (evt_len
< MAX_EVENT_SIZE
))
1729 memcpy(adapter
->event_body
, skb_cmd
->data
+
1730 MWIFIEX_EVENT_HEADER_LEN
, evt_len
-
1731 MWIFIEX_EVENT_HEADER_LEN
);
1733 adapter
->event_received
= true;
1734 adapter
->event_skb
= skb_cmd
;
1736 /* Do not update the event read pointer here, wait till the
1737 buffer is released. This is just to make things simpler,
1738 we need to find a better method of managing these buffers.
1741 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1742 CPU_INTR_EVENT_DONE
)) {
1743 dev_warn(adapter
->dev
,
1744 "Write register failed\n");
1753 * Event processing complete handler
1755 static int mwifiex_pcie_event_complete(struct mwifiex_adapter
*adapter
,
1756 struct sk_buff
*skb
)
1758 struct pcie_service_card
*card
= adapter
->card
;
1759 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1761 u32 rdptr
= card
->evtbd_rdptr
& MWIFIEX_EVTBD_MASK
;
1763 struct mwifiex_evt_buf_desc
*desc
;
1768 if (rdptr
>= MWIFIEX_MAX_EVT_BD
) {
1769 dev_err(adapter
->dev
, "event_complete: Invalid rdptr 0x%x\n",
1774 /* Read the event ring write pointer set by firmware */
1775 if (mwifiex_read_reg(adapter
, reg
->evt_wrptr
, &wrptr
)) {
1776 dev_err(adapter
->dev
,
1777 "event_complete: failed to read reg->evt_wrptr\n");
1781 if (!card
->evt_buf_list
[rdptr
]) {
1782 skb_push(skb
, INTF_HEADER_LEN
);
1783 if (mwifiex_map_pci_memory(adapter
, skb
,
1785 PCI_DMA_FROMDEVICE
))
1787 card
->evt_buf_list
[rdptr
] = skb
;
1788 desc
= card
->evtbd_ring
[rdptr
];
1789 desc
->paddr
= MWIFIEX_SKB_DMA_ADDR(skb
);
1790 desc
->len
= (u16
)skb
->len
;
1794 dev_dbg(adapter
->dev
,
1795 "info: ERROR: buf still valid at index %d, <%p, %p>\n",
1796 rdptr
, card
->evt_buf_list
[rdptr
], skb
);
1799 if ((++card
->evtbd_rdptr
& MWIFIEX_EVTBD_MASK
) == MWIFIEX_MAX_EVT_BD
) {
1800 card
->evtbd_rdptr
= ((card
->evtbd_rdptr
&
1801 reg
->evt_rollover_ind
) ^
1802 reg
->evt_rollover_ind
);
1805 dev_dbg(adapter
->dev
, "info: Updated <Rd: 0x%x, Wr: 0x%x>",
1806 card
->evtbd_rdptr
, wrptr
);
1808 /* Write the event ring read pointer in to reg->evt_rdptr */
1809 if (mwifiex_write_reg(adapter
, reg
->evt_rdptr
,
1810 card
->evtbd_rdptr
)) {
1811 dev_err(adapter
->dev
,
1812 "event_complete: failed to read reg->evt_rdptr\n");
1816 dev_dbg(adapter
->dev
, "info: Check Events Again\n");
1817 ret
= mwifiex_pcie_process_event_ready(adapter
);
1823 * This function downloads the firmware to the card.
1825 * Firmware is downloaded to the card in blocks. Every block download
1826 * is tested for CRC errors, and retried a number of times before
1827 * returning failure.
1829 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter
*adapter
,
1830 struct mwifiex_fw_image
*fw
)
1833 u8
*firmware
= fw
->fw_buf
;
1834 u32 firmware_len
= fw
->fw_len
;
1836 struct sk_buff
*skb
;
1837 u32 txlen
, tx_blocks
= 0, tries
, len
;
1838 u32 block_retry_cnt
= 0;
1839 struct pcie_service_card
*card
= adapter
->card
;
1840 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1842 if (!firmware
|| !firmware_len
) {
1843 dev_err(adapter
->dev
,
1844 "No firmware image found! Terminating download\n");
1848 dev_dbg(adapter
->dev
, "info: Downloading FW image (%d bytes)\n",
1851 if (mwifiex_pcie_disable_host_int(adapter
)) {
1852 dev_err(adapter
->dev
,
1853 "%s: Disabling interrupts failed.\n", __func__
);
1857 skb
= dev_alloc_skb(MWIFIEX_UPLD_SIZE
);
1863 /* Perform firmware data transfer */
1868 if (offset
>= firmware_len
)
1871 for (tries
= 0; tries
< MAX_POLL_TRIES
; tries
++) {
1872 ret
= mwifiex_read_reg(adapter
, reg
->cmd_size
,
1875 dev_warn(adapter
->dev
,
1876 "Failed reading len from boot code\n");
1881 usleep_range(10, 20);
1886 } else if (len
> MWIFIEX_UPLD_SIZE
) {
1887 pr_err("FW download failure @ %d, invalid length %d\n",
1897 if (block_retry_cnt
> MAX_WRITE_IOMEM_RETRY
) {
1898 pr_err("FW download failure @ %d, over max "
1899 "retry count\n", offset
);
1903 dev_err(adapter
->dev
, "FW CRC error indicated by the "
1904 "helper: len = 0x%04X, txlen = %d\n",
1907 /* Setting this to 0 to resend from same offset */
1910 block_retry_cnt
= 0;
1911 /* Set blocksize to transfer - checking for
1913 if (firmware_len
- offset
< txlen
)
1914 txlen
= firmware_len
- offset
;
1916 dev_dbg(adapter
->dev
, ".");
1918 tx_blocks
= (txlen
+ card
->pcie
.blksz_fw_dl
- 1) /
1919 card
->pcie
.blksz_fw_dl
;
1921 /* Copy payload to buffer */
1922 memmove(skb
->data
, &firmware
[offset
], txlen
);
1925 skb_put(skb
, MWIFIEX_UPLD_SIZE
- skb
->len
);
1926 skb_trim(skb
, tx_blocks
* card
->pcie
.blksz_fw_dl
);
1928 /* Send the boot command to device */
1929 if (mwifiex_pcie_send_boot_cmd(adapter
, skb
)) {
1930 dev_err(adapter
->dev
,
1931 "Failed to send firmware download command\n");
1936 /* Wait for the command done interrupt */
1938 if (mwifiex_read_reg(adapter
, PCIE_CPU_INT_STATUS
,
1940 dev_err(adapter
->dev
, "%s: Failed to read "
1941 "interrupt status during fw dnld.\n",
1943 mwifiex_unmap_pci_memory(adapter
, skb
,
1948 } while ((ireg_intr
& CPU_INTR_DOOR_BELL
) ==
1949 CPU_INTR_DOOR_BELL
);
1951 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1956 dev_notice(adapter
->dev
,
1957 "info: FW download over, size %d bytes\n", offset
);
1962 dev_kfree_skb_any(skb
);
1967 * This function checks the firmware status in card.
1969 * The winner interface is also determined by this function.
1972 mwifiex_check_fw_status(struct mwifiex_adapter
*adapter
, u32 poll_num
)
1975 u32 firmware_stat
, winner_status
;
1976 struct pcie_service_card
*card
= adapter
->card
;
1977 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1980 /* Mask spurios interrupts */
1981 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_STATUS_MASK
,
1983 dev_warn(adapter
->dev
, "Write register failed\n");
1987 dev_dbg(adapter
->dev
, "Setting driver ready signature\n");
1988 if (mwifiex_write_reg(adapter
, reg
->drv_rdy
,
1989 FIRMWARE_READY_PCIE
)) {
1990 dev_err(adapter
->dev
,
1991 "Failed to write driver ready signature\n");
1995 /* Wait for firmware initialization event */
1996 for (tries
= 0; tries
< poll_num
; tries
++) {
1997 if (mwifiex_read_reg(adapter
, reg
->fw_status
,
2004 if (firmware_stat
== FIRMWARE_READY_PCIE
) {
2014 if (mwifiex_read_reg(adapter
, reg
->fw_status
,
2017 else if (!winner_status
) {
2018 dev_err(adapter
->dev
, "PCI-E is the winner\n");
2019 adapter
->winner
= 1;
2021 dev_err(adapter
->dev
,
2022 "PCI-E is not the winner <%#x,%d>, exit dnld\n",
2023 ret
, adapter
->winner
);
2031 * This function reads the interrupt status from card.
2033 static void mwifiex_interrupt_status(struct mwifiex_adapter
*adapter
)
2036 unsigned long flags
;
2038 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
2041 if (mwifiex_read_reg(adapter
, PCIE_HOST_INT_STATUS
, &pcie_ireg
)) {
2042 dev_warn(adapter
->dev
, "Read register failed\n");
2046 if ((pcie_ireg
!= 0xFFFFFFFF) && (pcie_ireg
)) {
2048 mwifiex_pcie_disable_host_int(adapter
);
2050 /* Clear the pending interrupts */
2051 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_STATUS
,
2053 dev_warn(adapter
->dev
, "Write register failed\n");
2056 spin_lock_irqsave(&adapter
->int_lock
, flags
);
2057 adapter
->int_status
|= pcie_ireg
;
2058 spin_unlock_irqrestore(&adapter
->int_lock
, flags
);
2060 if (!adapter
->pps_uapsd_mode
&&
2061 adapter
->ps_state
== PS_STATE_SLEEP
&&
2062 mwifiex_pcie_ok_to_access_hw(adapter
)) {
2063 /* Potentially for PCIe we could get other
2064 * interrupts like shared. Don't change power
2065 * state until cookie is set */
2066 adapter
->ps_state
= PS_STATE_AWAKE
;
2067 adapter
->pm_wakeup_fw_try
= false;
2068 del_timer(&adapter
->wakeup_timer
);
2074 * Interrupt handler for PCIe root port
2076 * This function reads the interrupt status from firmware and assigns
2077 * the main process in workqueue which will handle the interrupt.
2079 static irqreturn_t
mwifiex_pcie_interrupt(int irq
, void *context
)
2081 struct pci_dev
*pdev
= (struct pci_dev
*)context
;
2082 struct pcie_service_card
*card
;
2083 struct mwifiex_adapter
*adapter
;
2086 pr_debug("info: %s: pdev is NULL\n", (u8
*)pdev
);
2090 card
= pci_get_drvdata(pdev
);
2091 if (!card
|| !card
->adapter
) {
2092 pr_debug("info: %s: card=%p adapter=%p\n", __func__
, card
,
2093 card
? card
->adapter
: NULL
);
2096 adapter
= card
->adapter
;
2098 if (adapter
->surprise_removed
)
2101 mwifiex_interrupt_status(adapter
);
2102 queue_work(adapter
->workqueue
, &adapter
->main_work
);
2109 * This function checks the current interrupt status.
2111 * The following interrupts are checked and handled by this function -
2114 * - Command received
2115 * - Packets received
2118 * In case of Rx packets received, the packets are uploaded from card to
2119 * host and processed accordingly.
2121 static int mwifiex_process_int_status(struct mwifiex_adapter
*adapter
)
2125 unsigned long flags
;
2127 spin_lock_irqsave(&adapter
->int_lock
, flags
);
2128 /* Clear out unused interrupts */
2129 pcie_ireg
= adapter
->int_status
;
2130 adapter
->int_status
= 0;
2131 spin_unlock_irqrestore(&adapter
->int_lock
, flags
);
2133 while (pcie_ireg
& HOST_INTR_MASK
) {
2134 if (pcie_ireg
& HOST_INTR_DNLD_DONE
) {
2135 pcie_ireg
&= ~HOST_INTR_DNLD_DONE
;
2136 dev_dbg(adapter
->dev
, "info: TX DNLD Done\n");
2137 ret
= mwifiex_pcie_send_data_complete(adapter
);
2141 if (pcie_ireg
& HOST_INTR_UPLD_RDY
) {
2142 pcie_ireg
&= ~HOST_INTR_UPLD_RDY
;
2143 dev_dbg(adapter
->dev
, "info: Rx DATA\n");
2144 ret
= mwifiex_pcie_process_recv_data(adapter
);
2148 if (pcie_ireg
& HOST_INTR_EVENT_RDY
) {
2149 pcie_ireg
&= ~HOST_INTR_EVENT_RDY
;
2150 dev_dbg(adapter
->dev
, "info: Rx EVENT\n");
2151 ret
= mwifiex_pcie_process_event_ready(adapter
);
2156 if (pcie_ireg
& HOST_INTR_CMD_DONE
) {
2157 pcie_ireg
&= ~HOST_INTR_CMD_DONE
;
2158 if (adapter
->cmd_sent
) {
2159 dev_dbg(adapter
->dev
,
2160 "info: CMD sent Interrupt\n");
2161 adapter
->cmd_sent
= false;
2163 /* Handle command response */
2164 ret
= mwifiex_pcie_process_cmd_complete(adapter
);
2169 if (mwifiex_pcie_ok_to_access_hw(adapter
)) {
2170 if (mwifiex_read_reg(adapter
, PCIE_HOST_INT_STATUS
,
2172 dev_warn(adapter
->dev
,
2173 "Read register failed\n");
2177 if ((pcie_ireg
!= 0xFFFFFFFF) && (pcie_ireg
)) {
2178 if (mwifiex_write_reg(adapter
,
2179 PCIE_HOST_INT_STATUS
,
2181 dev_warn(adapter
->dev
,
2182 "Write register failed\n");
2189 dev_dbg(adapter
->dev
, "info: cmd_sent=%d data_sent=%d\n",
2190 adapter
->cmd_sent
, adapter
->data_sent
);
2191 if (adapter
->ps_state
!= PS_STATE_SLEEP
)
2192 mwifiex_pcie_enable_host_int(adapter
);
2198 * This function downloads data from driver to card.
2200 * Both commands and data packets are transferred to the card by this
2203 * This function adds the PCIE specific header to the front of the buffer
2204 * before transferring. The header contains the length of the packet and
2205 * the type. The firmware handles the packets based upon this set type.
2207 static int mwifiex_pcie_host_to_card(struct mwifiex_adapter
*adapter
, u8 type
,
2208 struct sk_buff
*skb
,
2209 struct mwifiex_tx_param
*tx_param
)
2212 dev_err(adapter
->dev
, "Passed NULL skb to %s\n", __func__
);
2216 if (type
== MWIFIEX_TYPE_DATA
)
2217 return mwifiex_pcie_send_data(adapter
, skb
, tx_param
);
2218 else if (type
== MWIFIEX_TYPE_CMD
)
2219 return mwifiex_pcie_send_cmd(adapter
, skb
);
2224 /* This function read/write firmware */
2225 static enum rdwr_status
2226 mwifiex_pcie_rdwr_firmware(struct mwifiex_adapter
*adapter
, u8 doneflag
)
2230 struct pcie_service_card
*card
= adapter
->card
;
2231 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
2233 ret
= mwifiex_write_reg(adapter
, reg
->fw_dump_ctrl
, FW_DUMP_HOST_READY
);
2235 dev_err(adapter
->dev
, "PCIE write err\n");
2236 return RDWR_STATUS_FAILURE
;
2239 for (tries
= 0; tries
< MAX_POLL_TRIES
; tries
++) {
2240 mwifiex_read_reg_byte(adapter
, reg
->fw_dump_ctrl
, &ctrl_data
);
2241 if (ctrl_data
== FW_DUMP_DONE
)
2242 return RDWR_STATUS_SUCCESS
;
2243 if (doneflag
&& ctrl_data
== doneflag
)
2244 return RDWR_STATUS_DONE
;
2245 if (ctrl_data
!= FW_DUMP_HOST_READY
) {
2246 dev_info(adapter
->dev
,
2247 "The ctrl reg was changed, re-try again!\n");
2248 ret
= mwifiex_write_reg(adapter
, reg
->fw_dump_ctrl
,
2249 FW_DUMP_HOST_READY
);
2251 dev_err(adapter
->dev
, "PCIE write err\n");
2252 return RDWR_STATUS_FAILURE
;
2255 usleep_range(100, 200);
2258 dev_err(adapter
->dev
, "Fail to pull ctrl_data\n");
2259 return RDWR_STATUS_FAILURE
;
2262 /* This function dump firmware memory to file */
2263 static void mwifiex_pcie_fw_dump_work(struct mwifiex_adapter
*adapter
)
2265 struct pcie_service_card
*card
= adapter
->card
;
2266 const struct mwifiex_pcie_card_reg
*creg
= card
->pcie
.reg
;
2267 unsigned int reg
, reg_start
, reg_end
;
2268 u8
*dbg_ptr
, *end_ptr
, dump_num
, idx
, i
, read_reg
, doneflag
= 0;
2269 enum rdwr_status stat
;
2272 static char *env
[] = { "DRIVER=mwifiex_pcie", "EVENT=fw_dump", NULL
};
2274 if (!card
->pcie
.supports_fw_dump
)
2277 for (idx
= 0; idx
< ARRAY_SIZE(mem_type_mapping_tbl
); idx
++) {
2278 struct memory_type_mapping
*entry
= &mem_type_mapping_tbl
[idx
];
2280 if (entry
->mem_ptr
) {
2281 vfree(entry
->mem_ptr
);
2282 entry
->mem_ptr
= NULL
;
2284 entry
->mem_size
= 0;
2287 dev_info(adapter
->dev
, "== mwifiex firmware dump start ==\n");
2289 /* Read the number of the memories which will dump */
2290 stat
= mwifiex_pcie_rdwr_firmware(adapter
, doneflag
);
2291 if (stat
== RDWR_STATUS_FAILURE
)
2294 reg
= creg
->fw_dump_start
;
2295 mwifiex_read_reg_byte(adapter
, reg
, &dump_num
);
2297 /* Read the length of every memory which will dump */
2298 for (idx
= 0; idx
< dump_num
; idx
++) {
2299 struct memory_type_mapping
*entry
= &mem_type_mapping_tbl
[idx
];
2301 stat
= mwifiex_pcie_rdwr_firmware(adapter
, doneflag
);
2302 if (stat
== RDWR_STATUS_FAILURE
)
2306 reg
= creg
->fw_dump_start
;
2307 for (i
= 0; i
< 4; i
++) {
2308 mwifiex_read_reg_byte(adapter
, reg
, &read_reg
);
2309 memory_size
|= (read_reg
<< (i
* 8));
2313 if (memory_size
== 0) {
2314 dev_info(adapter
->dev
, "Firmware dump Finished!\n");
2315 ret
= mwifiex_write_reg(adapter
, creg
->fw_dump_ctrl
,
2318 dev_err(adapter
->dev
, "PCIE write err\n");
2324 dev_info(adapter
->dev
,
2325 "%s_SIZE=0x%x\n", entry
->mem_name
, memory_size
);
2326 entry
->mem_ptr
= vmalloc(memory_size
+ 1);
2327 entry
->mem_size
= memory_size
;
2328 if (!entry
->mem_ptr
) {
2329 dev_err(adapter
->dev
,
2330 "Vmalloc %s failed\n", entry
->mem_name
);
2333 dbg_ptr
= entry
->mem_ptr
;
2334 end_ptr
= dbg_ptr
+ memory_size
;
2336 doneflag
= entry
->done_flag
;
2337 dev_info(adapter
->dev
, "Start %s output, please wait...\n",
2341 stat
= mwifiex_pcie_rdwr_firmware(adapter
, doneflag
);
2342 if (RDWR_STATUS_FAILURE
== stat
)
2345 reg_start
= creg
->fw_dump_start
;
2346 reg_end
= creg
->fw_dump_end
;
2347 for (reg
= reg_start
; reg
<= reg_end
; reg
++) {
2348 mwifiex_read_reg_byte(adapter
, reg
, dbg_ptr
);
2349 if (dbg_ptr
< end_ptr
) {
2352 dev_err(adapter
->dev
,
2353 "Allocated buf not enough\n");
2358 if (stat
!= RDWR_STATUS_DONE
)
2361 dev_info(adapter
->dev
, "%s done: size=0x%tx\n",
2362 entry
->mem_name
, dbg_ptr
- entry
->mem_ptr
);
2366 dev_info(adapter
->dev
, "== mwifiex firmware dump end ==\n");
2368 kobject_uevent_env(&adapter
->wiphy
->dev
.kobj
, KOBJ_CHANGE
, env
);
2371 adapter
->curr_mem_idx
= 0;
2374 static void mwifiex_pcie_work(struct work_struct
*work
)
2376 struct mwifiex_adapter
*adapter
=
2377 container_of(work
, struct mwifiex_adapter
, iface_work
);
2379 if (test_and_clear_bit(MWIFIEX_IFACE_WORK_FW_DUMP
,
2380 &adapter
->iface_work_flags
))
2381 mwifiex_pcie_fw_dump_work(adapter
);
2384 /* This function dumps FW information */
2385 static void mwifiex_pcie_fw_dump(struct mwifiex_adapter
*adapter
)
2387 if (test_bit(MWIFIEX_IFACE_WORK_FW_DUMP
, &adapter
->iface_work_flags
))
2390 set_bit(MWIFIEX_IFACE_WORK_FW_DUMP
, &adapter
->iface_work_flags
);
2392 schedule_work(&adapter
->iface_work
);
2396 * This function initializes the PCI-E host memory space, WCB rings, etc.
2398 * The following initializations steps are followed -
2399 * - Allocate TXBD ring buffers
2400 * - Allocate RXBD ring buffers
2401 * - Allocate event BD ring buffers
2402 * - Allocate command response ring buffer
2403 * - Allocate sleep cookie buffer
2405 static int mwifiex_pcie_init(struct mwifiex_adapter
*adapter
)
2407 struct pcie_service_card
*card
= adapter
->card
;
2409 struct pci_dev
*pdev
= card
->dev
;
2410 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
2412 pci_set_drvdata(pdev
, card
);
2414 ret
= pci_enable_device(pdev
);
2416 goto err_enable_dev
;
2418 pci_set_master(pdev
);
2420 dev_dbg(adapter
->dev
, "try set_consistent_dma_mask(32)\n");
2421 ret
= pci_set_dma_mask(pdev
, DMA_BIT_MASK(32));
2423 dev_err(adapter
->dev
, "set_dma_mask(32) failed\n");
2424 goto err_set_dma_mask
;
2427 ret
= pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(32));
2429 dev_err(adapter
->dev
, "set_consistent_dma_mask(64) failed\n");
2430 goto err_set_dma_mask
;
2433 ret
= pci_request_region(pdev
, 0, DRV_NAME
);
2435 dev_err(adapter
->dev
, "req_reg(0) error\n");
2436 goto err_req_region0
;
2438 card
->pci_mmap
= pci_iomap(pdev
, 0, 0);
2439 if (!card
->pci_mmap
) {
2440 dev_err(adapter
->dev
, "iomap(0) error\n");
2444 ret
= pci_request_region(pdev
, 2, DRV_NAME
);
2446 dev_err(adapter
->dev
, "req_reg(2) error\n");
2447 goto err_req_region2
;
2449 card
->pci_mmap1
= pci_iomap(pdev
, 2, 0);
2450 if (!card
->pci_mmap1
) {
2451 dev_err(adapter
->dev
, "iomap(2) error\n");
2456 dev_dbg(adapter
->dev
,
2457 "PCI memory map Virt0: %p PCI memory map Virt2: %p\n",
2458 card
->pci_mmap
, card
->pci_mmap1
);
2460 card
->cmdrsp_buf
= NULL
;
2461 ret
= mwifiex_pcie_create_txbd_ring(adapter
);
2464 ret
= mwifiex_pcie_create_rxbd_ring(adapter
);
2467 ret
= mwifiex_pcie_create_evtbd_ring(adapter
);
2470 ret
= mwifiex_pcie_alloc_cmdrsp_buf(adapter
);
2472 goto err_alloc_cmdbuf
;
2473 if (reg
->sleep_cookie
) {
2474 ret
= mwifiex_pcie_alloc_sleep_cookie_buf(adapter
);
2476 goto err_alloc_cookie
;
2478 card
->sleep_cookie_vbase
= NULL
;
2483 mwifiex_pcie_delete_cmdrsp_buf(adapter
);
2485 mwifiex_pcie_delete_evtbd_ring(adapter
);
2487 mwifiex_pcie_delete_rxbd_ring(adapter
);
2489 mwifiex_pcie_delete_txbd_ring(adapter
);
2491 pci_iounmap(pdev
, card
->pci_mmap1
);
2493 pci_release_region(pdev
, 2);
2495 pci_iounmap(pdev
, card
->pci_mmap
);
2497 pci_release_region(pdev
, 0);
2500 pci_disable_device(pdev
);
2502 pci_set_drvdata(pdev
, NULL
);
2507 * This function cleans up the allocated card buffers.
2509 * The following are freed by this function -
2510 * - TXBD ring buffers
2511 * - RXBD ring buffers
2512 * - Event BD ring buffers
2513 * - Command response ring buffer
2514 * - Sleep cookie buffer
2516 static void mwifiex_pcie_cleanup(struct mwifiex_adapter
*adapter
)
2518 struct pcie_service_card
*card
= adapter
->card
;
2519 struct pci_dev
*pdev
= card
->dev
;
2520 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
2523 dev_dbg(adapter
->dev
, "Clearing driver ready signature\n");
2524 if (mwifiex_write_reg(adapter
, reg
->drv_rdy
, 0x00000000))
2525 dev_err(adapter
->dev
,
2526 "Failed to write driver not-ready signature\n");
2530 pci_iounmap(pdev
, card
->pci_mmap
);
2531 pci_iounmap(pdev
, card
->pci_mmap1
);
2532 pci_disable_device(pdev
);
2533 pci_release_region(pdev
, 2);
2534 pci_release_region(pdev
, 0);
2535 pci_set_drvdata(pdev
, NULL
);
2541 * This function registers the PCIE device.
2543 * PCIE IRQ is claimed, block size is set and driver data is initialized.
2545 static int mwifiex_register_dev(struct mwifiex_adapter
*adapter
)
2548 struct pcie_service_card
*card
= adapter
->card
;
2549 struct pci_dev
*pdev
= card
->dev
;
2551 /* save adapter pointer in card */
2552 card
->adapter
= adapter
;
2554 ret
= request_irq(pdev
->irq
, mwifiex_pcie_interrupt
, IRQF_SHARED
,
2557 pr_err("request_irq failed: ret=%d\n", ret
);
2558 adapter
->card
= NULL
;
2562 adapter
->dev
= &pdev
->dev
;
2563 adapter
->tx_buf_size
= card
->pcie
.tx_buf_size
;
2564 adapter
->mem_type_mapping_tbl
= mem_type_mapping_tbl
;
2565 adapter
->num_mem_types
= ARRAY_SIZE(mem_type_mapping_tbl
);
2566 strcpy(adapter
->fw_name
, card
->pcie
.firmware
);
2567 adapter
->ext_scan
= card
->pcie
.can_ext_scan
;
2573 * This function unregisters the PCIE device.
2575 * The PCIE IRQ is released, the function is disabled and driver
2576 * data is set to null.
2578 static void mwifiex_unregister_dev(struct mwifiex_adapter
*adapter
)
2580 struct pcie_service_card
*card
= adapter
->card
;
2581 const struct mwifiex_pcie_card_reg
*reg
;
2584 dev_dbg(adapter
->dev
, "%s(): calling free_irq()\n", __func__
);
2585 free_irq(card
->dev
->irq
, card
->dev
);
2587 reg
= card
->pcie
.reg
;
2588 if (reg
->sleep_cookie
)
2589 mwifiex_pcie_delete_sleep_cookie_buf(adapter
);
2591 mwifiex_pcie_delete_cmdrsp_buf(adapter
);
2592 mwifiex_pcie_delete_evtbd_ring(adapter
);
2593 mwifiex_pcie_delete_rxbd_ring(adapter
);
2594 mwifiex_pcie_delete_txbd_ring(adapter
);
2595 card
->cmdrsp_buf
= NULL
;
2599 static struct mwifiex_if_ops pcie_ops
= {
2600 .init_if
= mwifiex_pcie_init
,
2601 .cleanup_if
= mwifiex_pcie_cleanup
,
2602 .check_fw_status
= mwifiex_check_fw_status
,
2603 .prog_fw
= mwifiex_prog_fw_w_helper
,
2604 .register_dev
= mwifiex_register_dev
,
2605 .unregister_dev
= mwifiex_unregister_dev
,
2606 .enable_int
= mwifiex_pcie_enable_host_int
,
2607 .process_int_status
= mwifiex_process_int_status
,
2608 .host_to_card
= mwifiex_pcie_host_to_card
,
2609 .wakeup
= mwifiex_pm_wakeup_card
,
2610 .wakeup_complete
= mwifiex_pm_wakeup_card_complete
,
2613 .cmdrsp_complete
= mwifiex_pcie_cmdrsp_complete
,
2614 .event_complete
= mwifiex_pcie_event_complete
,
2615 .update_mp_end_port
= NULL
,
2616 .cleanup_mpa_buf
= NULL
,
2617 .init_fw_port
= mwifiex_pcie_init_fw_port
,
2618 .clean_pcie_ring
= mwifiex_clean_pcie_ring_buf
,
2619 .fw_dump
= mwifiex_pcie_fw_dump
,
2620 .iface_work
= mwifiex_pcie_work
,
2624 * This function initializes the PCIE driver module.
2626 * This initiates the semaphore and registers the device with
2629 static int mwifiex_pcie_init_module(void)
2633 pr_debug("Marvell PCIe Driver\n");
2635 sema_init(&add_remove_card_sem
, 1);
2637 /* Clear the flag in case user removes the card. */
2640 ret
= pci_register_driver(&mwifiex_pcie
);
2642 pr_err("Driver register failed!\n");
2644 pr_debug("info: Driver registered successfully!\n");
2650 * This function cleans up the PCIE driver.
2652 * The following major steps are followed for cleanup -
2653 * - Resume the device if its suspended
2654 * - Disconnect the device if connected
2655 * - Shutdown the firmware
2656 * - Unregister the device from PCIE bus.
2658 static void mwifiex_pcie_cleanup_module(void)
2660 if (!down_interruptible(&add_remove_card_sem
))
2661 up(&add_remove_card_sem
);
2663 /* Set the flag as user is removing this module. */
2666 pci_unregister_driver(&mwifiex_pcie
);
2669 module_init(mwifiex_pcie_init_module
);
2670 module_exit(mwifiex_pcie_cleanup_module
);
2672 MODULE_AUTHOR("Marvell International Ltd.");
2673 MODULE_DESCRIPTION("Marvell WiFi-Ex PCI-Express Driver version " PCIE_VERSION
);
2674 MODULE_VERSION(PCIE_VERSION
);
2675 MODULE_LICENSE("GPL v2");
2676 MODULE_FIRMWARE(PCIE8766_DEFAULT_FW_NAME
);
2677 MODULE_FIRMWARE(PCIE8897_DEFAULT_FW_NAME
);