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;
128 * Kernel needs to suspend all functions separately. Therefore all
129 * registered functions must have drivers with suspend and resume
130 * methods. Failing that the kernel simply removes the whole card.
132 * If already not resumed, this function turns on the traffic and
133 * sends a host sleep cancel request to the firmware.
135 static int mwifiex_pcie_resume(struct device
*dev
)
137 struct mwifiex_adapter
*adapter
;
138 struct pcie_service_card
*card
;
139 struct pci_dev
*pdev
= to_pci_dev(dev
);
142 card
= pci_get_drvdata(pdev
);
143 if (!card
|| !card
->adapter
) {
144 pr_err("Card or adapter structure is not valid\n");
148 pr_err("PCIE device is not specified\n");
152 adapter
= card
->adapter
;
154 if (!adapter
->is_suspended
) {
155 dev_warn(adapter
->dev
, "Device already resumed\n");
159 adapter
->is_suspended
= false;
161 mwifiex_cancel_hs(mwifiex_get_priv(adapter
, MWIFIEX_BSS_ROLE_STA
),
169 * This function probes an mwifiex device and registers it. It allocates
170 * the card structure, enables PCIE function number and initiates the
171 * device registration and initialization procedure by adding a logical
174 static int mwifiex_pcie_probe(struct pci_dev
*pdev
,
175 const struct pci_device_id
*ent
)
177 struct pcie_service_card
*card
;
179 pr_debug("info: vendor=0x%4.04X device=0x%4.04X rev=%d\n",
180 pdev
->vendor
, pdev
->device
, pdev
->revision
);
182 card
= kzalloc(sizeof(struct pcie_service_card
), GFP_KERNEL
);
188 if (ent
->driver_data
) {
189 struct mwifiex_pcie_device
*data
= (void *)ent
->driver_data
;
190 card
->pcie
.firmware
= data
->firmware
;
191 card
->pcie
.reg
= data
->reg
;
192 card
->pcie
.blksz_fw_dl
= data
->blksz_fw_dl
;
193 card
->pcie
.tx_buf_size
= data
->tx_buf_size
;
196 if (mwifiex_add_card(card
, &add_remove_card_sem
, &pcie_ops
,
198 pr_err("%s failed\n", __func__
);
207 * This function removes the interface and frees up the card structure.
209 static void mwifiex_pcie_remove(struct pci_dev
*pdev
)
211 struct pcie_service_card
*card
;
212 struct mwifiex_adapter
*adapter
;
213 struct mwifiex_private
*priv
;
215 card
= pci_get_drvdata(pdev
);
219 adapter
= card
->adapter
;
220 if (!adapter
|| !adapter
->priv_num
)
223 /* In case driver is removed when asynchronous FW load is in progress */
224 wait_for_completion(&adapter
->fw_load
);
227 #ifdef CONFIG_PM_SLEEP
228 if (adapter
->is_suspended
)
229 mwifiex_pcie_resume(&pdev
->dev
);
232 mwifiex_deauthenticate_all(adapter
);
234 priv
= mwifiex_get_priv(adapter
, MWIFIEX_BSS_ROLE_ANY
);
236 mwifiex_disable_auto_ds(priv
);
238 mwifiex_init_shutdown_fw(priv
, MWIFIEX_FUNC_SHUTDOWN
);
241 mwifiex_remove_card(card
->adapter
, &add_remove_card_sem
);
244 static void mwifiex_pcie_shutdown(struct pci_dev
*pdev
)
247 mwifiex_pcie_remove(pdev
);
252 static DEFINE_PCI_DEVICE_TABLE(mwifiex_ids
) = {
254 PCIE_VENDOR_ID_MARVELL
, PCIE_DEVICE_ID_MARVELL_88W8766P
,
255 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0,
256 .driver_data
= (unsigned long) &mwifiex_pcie8766
,
259 PCIE_VENDOR_ID_MARVELL
, PCIE_DEVICE_ID_MARVELL_88W8897
,
260 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0,
261 .driver_data
= (unsigned long) &mwifiex_pcie8897
,
266 MODULE_DEVICE_TABLE(pci
, mwifiex_ids
);
268 #ifdef CONFIG_PM_SLEEP
269 /* Power Management Hooks */
270 static SIMPLE_DEV_PM_OPS(mwifiex_pcie_pm_ops
, mwifiex_pcie_suspend
,
271 mwifiex_pcie_resume
);
274 /* PCI Device Driver */
275 static struct pci_driver __refdata mwifiex_pcie
= {
276 .name
= "mwifiex_pcie",
277 .id_table
= mwifiex_ids
,
278 .probe
= mwifiex_pcie_probe
,
279 .remove
= mwifiex_pcie_remove
,
280 #ifdef CONFIG_PM_SLEEP
282 .pm
= &mwifiex_pcie_pm_ops
,
285 .shutdown
= mwifiex_pcie_shutdown
,
289 * This function writes data into PCIE card register.
291 static int mwifiex_write_reg(struct mwifiex_adapter
*adapter
, int reg
, u32 data
)
293 struct pcie_service_card
*card
= adapter
->card
;
295 iowrite32(data
, card
->pci_mmap1
+ reg
);
301 * This function reads data from PCIE card register.
303 static int mwifiex_read_reg(struct mwifiex_adapter
*adapter
, int reg
, u32
*data
)
305 struct pcie_service_card
*card
= adapter
->card
;
307 *data
= ioread32(card
->pci_mmap1
+ reg
);
313 * This function adds delay loop to ensure FW is awake before proceeding.
315 static void mwifiex_pcie_dev_wakeup_delay(struct mwifiex_adapter
*adapter
)
319 while (mwifiex_pcie_ok_to_access_hw(adapter
)) {
321 usleep_range(10, 20);
330 static void mwifiex_delay_for_sleep_cookie(struct mwifiex_adapter
*adapter
,
331 u32 max_delay_loop_cnt
)
333 struct pcie_service_card
*card
= adapter
->card
;
335 u32 sleep_cookie
, count
;
337 for (count
= 0; count
< max_delay_loop_cnt
; count
++) {
338 buffer
= card
->cmdrsp_buf
->data
- INTF_HEADER_LEN
;
339 sleep_cookie
= *(u32
*)buffer
;
341 if (sleep_cookie
== MWIFIEX_DEF_SLEEP_COOKIE
) {
342 dev_dbg(adapter
->dev
,
343 "sleep cookie found at count %d\n", count
);
346 usleep_range(20, 30);
349 if (count
>= max_delay_loop_cnt
)
350 dev_dbg(adapter
->dev
,
351 "max count reached while accessing sleep cookie\n");
354 /* This function wakes up the card by reading fw_status register. */
355 static int mwifiex_pm_wakeup_card(struct mwifiex_adapter
*adapter
)
358 struct pcie_service_card
*card
= adapter
->card
;
359 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
361 dev_dbg(adapter
->dev
, "event: Wakeup device...\n");
363 if (reg
->sleep_cookie
)
364 mwifiex_pcie_dev_wakeup_delay(adapter
);
366 /* Reading fw_status register will wakeup device */
367 if (mwifiex_read_reg(adapter
, reg
->fw_status
, &fw_status
)) {
368 dev_warn(adapter
->dev
, "Reading fw_status register failed\n");
372 if (reg
->sleep_cookie
) {
373 mwifiex_pcie_dev_wakeup_delay(adapter
);
374 dev_dbg(adapter
->dev
, "PCIE wakeup: Setting PS_STATE_AWAKE\n");
375 adapter
->ps_state
= PS_STATE_AWAKE
;
382 * This function is called after the card has woken up.
384 * The card configuration register is reset.
386 static int mwifiex_pm_wakeup_card_complete(struct mwifiex_adapter
*adapter
)
388 dev_dbg(adapter
->dev
, "cmd: Wakeup device completed\n");
394 * This function disables the host interrupt.
396 * The host interrupt mask is read, the disable bit is reset and
397 * written back to the card host interrupt mask register.
399 static int mwifiex_pcie_disable_host_int(struct mwifiex_adapter
*adapter
)
401 if (mwifiex_pcie_ok_to_access_hw(adapter
)) {
402 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_MASK
,
404 dev_warn(adapter
->dev
, "Disable host interrupt failed\n");
413 * This function enables the host interrupt.
415 * The host interrupt enable mask is written to the card
416 * host interrupt mask register.
418 static int mwifiex_pcie_enable_host_int(struct mwifiex_adapter
*adapter
)
420 if (mwifiex_pcie_ok_to_access_hw(adapter
)) {
421 /* Simply write the mask to the register */
422 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_MASK
,
424 dev_warn(adapter
->dev
, "Enable host interrupt failed\n");
433 * This function initializes TX buffer ring descriptors
435 static int mwifiex_init_txq_ring(struct mwifiex_adapter
*adapter
)
437 struct pcie_service_card
*card
= adapter
->card
;
438 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
439 struct mwifiex_pcie_buf_desc
*desc
;
440 struct mwifiex_pfu_buf_desc
*desc2
;
443 for (i
= 0; i
< MWIFIEX_MAX_TXRX_BD
; i
++) {
444 card
->tx_buf_list
[i
] = NULL
;
445 if (reg
->pfu_enabled
) {
446 card
->txbd_ring
[i
] = (void *)card
->txbd_ring_vbase
+
447 (sizeof(*desc2
) * i
);
448 desc2
= card
->txbd_ring
[i
];
449 memset(desc2
, 0, sizeof(*desc2
));
451 card
->txbd_ring
[i
] = (void *)card
->txbd_ring_vbase
+
453 desc
= card
->txbd_ring
[i
];
454 memset(desc
, 0, sizeof(*desc
));
461 /* This function initializes RX buffer ring descriptors. Each SKB is allocated
462 * here and after mapping PCI memory, its physical address is assigned to
463 * PCIE Rx buffer descriptor's physical address.
465 static int mwifiex_init_rxq_ring(struct mwifiex_adapter
*adapter
)
467 struct pcie_service_card
*card
= adapter
->card
;
468 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
470 struct mwifiex_pcie_buf_desc
*desc
;
471 struct mwifiex_pfu_buf_desc
*desc2
;
475 for (i
= 0; i
< MWIFIEX_MAX_TXRX_BD
; i
++) {
476 /* Allocate skb here so that firmware can DMA data from it */
477 skb
= dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE
);
479 dev_err(adapter
->dev
,
480 "Unable to allocate skb for RX ring.\n");
481 kfree(card
->rxbd_ring_vbase
);
485 if (mwifiex_map_pci_memory(adapter
, skb
,
486 MWIFIEX_RX_DATA_BUF_SIZE
,
490 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb
);
492 dev_dbg(adapter
->dev
,
493 "info: RX ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
494 skb
, skb
->len
, skb
->data
, (u32
)buf_pa
,
495 (u32
)((u64
)buf_pa
>> 32));
497 card
->rx_buf_list
[i
] = skb
;
498 if (reg
->pfu_enabled
) {
499 card
->rxbd_ring
[i
] = (void *)card
->rxbd_ring_vbase
+
500 (sizeof(*desc2
) * i
);
501 desc2
= card
->rxbd_ring
[i
];
502 desc2
->paddr
= buf_pa
;
503 desc2
->len
= (u16
)skb
->len
;
504 desc2
->frag_len
= (u16
)skb
->len
;
505 desc2
->flags
= reg
->ring_flag_eop
| reg
->ring_flag_sop
;
508 card
->rxbd_ring
[i
] = (void *)(card
->rxbd_ring_vbase
+
509 (sizeof(*desc
) * i
));
510 desc
= card
->rxbd_ring
[i
];
511 desc
->paddr
= buf_pa
;
512 desc
->len
= (u16
)skb
->len
;
520 /* This function initializes event buffer ring descriptors. Each SKB is
521 * allocated here and after mapping PCI memory, its physical address is assigned
522 * to PCIE Rx buffer descriptor's physical address
524 static int mwifiex_pcie_init_evt_ring(struct mwifiex_adapter
*adapter
)
526 struct pcie_service_card
*card
= adapter
->card
;
527 struct mwifiex_evt_buf_desc
*desc
;
532 for (i
= 0; i
< MWIFIEX_MAX_EVT_BD
; i
++) {
533 /* Allocate skb here so that firmware can DMA data from it */
534 skb
= dev_alloc_skb(MAX_EVENT_SIZE
);
536 dev_err(adapter
->dev
,
537 "Unable to allocate skb for EVENT buf.\n");
538 kfree(card
->evtbd_ring_vbase
);
541 skb_put(skb
, MAX_EVENT_SIZE
);
543 if (mwifiex_map_pci_memory(adapter
, skb
, MAX_EVENT_SIZE
,
547 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb
);
549 dev_dbg(adapter
->dev
,
550 "info: EVT ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
551 skb
, skb
->len
, skb
->data
, (u32
)buf_pa
,
552 (u32
)((u64
)buf_pa
>> 32));
554 card
->evt_buf_list
[i
] = skb
;
555 card
->evtbd_ring
[i
] = (void *)(card
->evtbd_ring_vbase
+
556 (sizeof(*desc
) * i
));
557 desc
= card
->evtbd_ring
[i
];
558 desc
->paddr
= buf_pa
;
559 desc
->len
= (u16
)skb
->len
;
566 /* This function cleans up TX buffer rings. If any of the buffer list has valid
567 * SKB address, associated SKB is freed.
569 static void mwifiex_cleanup_txq_ring(struct mwifiex_adapter
*adapter
)
571 struct pcie_service_card
*card
= adapter
->card
;
572 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
574 struct mwifiex_pcie_buf_desc
*desc
;
575 struct mwifiex_pfu_buf_desc
*desc2
;
578 for (i
= 0; i
< MWIFIEX_MAX_TXRX_BD
; i
++) {
579 if (reg
->pfu_enabled
) {
580 desc2
= card
->txbd_ring
[i
];
581 if (card
->tx_buf_list
[i
]) {
582 skb
= card
->tx_buf_list
[i
];
583 mwifiex_unmap_pci_memory(adapter
, skb
,
585 dev_kfree_skb_any(skb
);
587 memset(desc2
, 0, sizeof(*desc2
));
589 desc
= card
->txbd_ring
[i
];
590 if (card
->tx_buf_list
[i
]) {
591 skb
= card
->tx_buf_list
[i
];
592 mwifiex_unmap_pci_memory(adapter
, skb
,
594 dev_kfree_skb_any(skb
);
596 memset(desc
, 0, sizeof(*desc
));
598 card
->tx_buf_list
[i
] = NULL
;
604 /* This function cleans up RX buffer rings. If any of the buffer list has valid
605 * SKB address, associated SKB is freed.
607 static void mwifiex_cleanup_rxq_ring(struct mwifiex_adapter
*adapter
)
609 struct pcie_service_card
*card
= adapter
->card
;
610 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
611 struct mwifiex_pcie_buf_desc
*desc
;
612 struct mwifiex_pfu_buf_desc
*desc2
;
616 for (i
= 0; i
< MWIFIEX_MAX_TXRX_BD
; i
++) {
617 if (reg
->pfu_enabled
) {
618 desc2
= card
->rxbd_ring
[i
];
619 if (card
->rx_buf_list
[i
]) {
620 skb
= card
->rx_buf_list
[i
];
621 mwifiex_unmap_pci_memory(adapter
, skb
,
623 dev_kfree_skb_any(skb
);
625 memset(desc2
, 0, sizeof(*desc2
));
627 desc
= card
->rxbd_ring
[i
];
628 if (card
->rx_buf_list
[i
]) {
629 skb
= card
->rx_buf_list
[i
];
630 mwifiex_unmap_pci_memory(adapter
, skb
,
632 dev_kfree_skb_any(skb
);
634 memset(desc
, 0, sizeof(*desc
));
636 card
->rx_buf_list
[i
] = NULL
;
642 /* This function cleans up event buffer rings. If any of the buffer list has
643 * valid SKB address, associated SKB is freed.
645 static void mwifiex_cleanup_evt_ring(struct mwifiex_adapter
*adapter
)
647 struct pcie_service_card
*card
= adapter
->card
;
648 struct mwifiex_evt_buf_desc
*desc
;
652 for (i
= 0; i
< MWIFIEX_MAX_EVT_BD
; i
++) {
653 desc
= card
->evtbd_ring
[i
];
654 if (card
->evt_buf_list
[i
]) {
655 skb
= card
->evt_buf_list
[i
];
656 mwifiex_unmap_pci_memory(adapter
, skb
,
658 dev_kfree_skb_any(skb
);
660 card
->evt_buf_list
[i
] = NULL
;
661 memset(desc
, 0, sizeof(*desc
));
667 /* This function creates buffer descriptor ring for TX
669 static int mwifiex_pcie_create_txbd_ring(struct mwifiex_adapter
*adapter
)
671 struct pcie_service_card
*card
= adapter
->card
;
672 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
675 * driver maintaines the write pointer and firmware maintaines the read
676 * pointer. The write pointer starts at 0 (zero) while the read pointer
677 * starts at zero with rollover bit set
679 card
->txbd_wrptr
= 0;
681 if (reg
->pfu_enabled
)
682 card
->txbd_rdptr
= 0;
684 card
->txbd_rdptr
|= reg
->tx_rollover_ind
;
686 /* allocate shared memory for the BD ring and divide the same in to
687 several descriptors */
688 if (reg
->pfu_enabled
)
689 card
->txbd_ring_size
= sizeof(struct mwifiex_pfu_buf_desc
) *
692 card
->txbd_ring_size
= sizeof(struct mwifiex_pcie_buf_desc
) *
695 dev_dbg(adapter
->dev
, "info: txbd_ring: Allocating %d bytes\n",
696 card
->txbd_ring_size
);
697 card
->txbd_ring_vbase
= pci_alloc_consistent(card
->dev
,
698 card
->txbd_ring_size
,
699 &card
->txbd_ring_pbase
);
700 if (!card
->txbd_ring_vbase
) {
701 dev_err(adapter
->dev
,
702 "allocate consistent memory (%d bytes) failed!\n",
703 card
->txbd_ring_size
);
706 dev_dbg(adapter
->dev
,
707 "info: txbd_ring - base: %p, pbase: %#x:%x, len: %x\n",
708 card
->txbd_ring_vbase
, (unsigned int)card
->txbd_ring_pbase
,
709 (u32
)((u64
)card
->txbd_ring_pbase
>> 32), card
->txbd_ring_size
);
711 return mwifiex_init_txq_ring(adapter
);
714 static int mwifiex_pcie_delete_txbd_ring(struct mwifiex_adapter
*adapter
)
716 struct pcie_service_card
*card
= adapter
->card
;
717 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
719 mwifiex_cleanup_txq_ring(adapter
);
721 if (card
->txbd_ring_vbase
)
722 pci_free_consistent(card
->dev
, card
->txbd_ring_size
,
723 card
->txbd_ring_vbase
,
724 card
->txbd_ring_pbase
);
725 card
->txbd_ring_size
= 0;
726 card
->txbd_wrptr
= 0;
727 card
->txbd_rdptr
= 0 | reg
->tx_rollover_ind
;
728 card
->txbd_ring_vbase
= NULL
;
729 card
->txbd_ring_pbase
= 0;
735 * This function creates buffer descriptor ring for RX
737 static int mwifiex_pcie_create_rxbd_ring(struct mwifiex_adapter
*adapter
)
739 struct pcie_service_card
*card
= adapter
->card
;
740 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
743 * driver maintaines the read pointer and firmware maintaines the write
744 * pointer. The write pointer starts at 0 (zero) while the read pointer
745 * starts at zero with rollover bit set
747 card
->rxbd_wrptr
= 0;
748 card
->rxbd_rdptr
= reg
->rx_rollover_ind
;
750 if (reg
->pfu_enabled
)
751 card
->rxbd_ring_size
= sizeof(struct mwifiex_pfu_buf_desc
) *
754 card
->rxbd_ring_size
= sizeof(struct mwifiex_pcie_buf_desc
) *
757 dev_dbg(adapter
->dev
, "info: rxbd_ring: Allocating %d bytes\n",
758 card
->rxbd_ring_size
);
759 card
->rxbd_ring_vbase
= pci_alloc_consistent(card
->dev
,
760 card
->rxbd_ring_size
,
761 &card
->rxbd_ring_pbase
);
762 if (!card
->rxbd_ring_vbase
) {
763 dev_err(adapter
->dev
,
764 "allocate consistent memory (%d bytes) failed!\n",
765 card
->rxbd_ring_size
);
769 dev_dbg(adapter
->dev
,
770 "info: rxbd_ring - base: %p, pbase: %#x:%x, len: %#x\n",
771 card
->rxbd_ring_vbase
, (u32
)card
->rxbd_ring_pbase
,
772 (u32
)((u64
)card
->rxbd_ring_pbase
>> 32),
773 card
->rxbd_ring_size
);
775 return mwifiex_init_rxq_ring(adapter
);
779 * This function deletes Buffer descriptor ring for RX
781 static int mwifiex_pcie_delete_rxbd_ring(struct mwifiex_adapter
*adapter
)
783 struct pcie_service_card
*card
= adapter
->card
;
784 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
786 mwifiex_cleanup_rxq_ring(adapter
);
788 if (card
->rxbd_ring_vbase
)
789 pci_free_consistent(card
->dev
, card
->rxbd_ring_size
,
790 card
->rxbd_ring_vbase
,
791 card
->rxbd_ring_pbase
);
792 card
->rxbd_ring_size
= 0;
793 card
->rxbd_wrptr
= 0;
794 card
->rxbd_rdptr
= 0 | reg
->rx_rollover_ind
;
795 card
->rxbd_ring_vbase
= NULL
;
796 card
->rxbd_ring_pbase
= 0;
802 * This function creates buffer descriptor ring for Events
804 static int mwifiex_pcie_create_evtbd_ring(struct mwifiex_adapter
*adapter
)
806 struct pcie_service_card
*card
= adapter
->card
;
807 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
810 * driver maintaines the read pointer and firmware maintaines the write
811 * pointer. The write pointer starts at 0 (zero) while the read pointer
812 * starts at zero with rollover bit set
814 card
->evtbd_wrptr
= 0;
815 card
->evtbd_rdptr
= reg
->evt_rollover_ind
;
817 card
->evtbd_ring_size
= sizeof(struct mwifiex_evt_buf_desc
) *
820 dev_dbg(adapter
->dev
, "info: evtbd_ring: Allocating %d bytes\n",
821 card
->evtbd_ring_size
);
822 card
->evtbd_ring_vbase
= pci_alloc_consistent(card
->dev
,
823 card
->evtbd_ring_size
,
824 &card
->evtbd_ring_pbase
);
825 if (!card
->evtbd_ring_vbase
) {
826 dev_err(adapter
->dev
,
827 "allocate consistent memory (%d bytes) failed!\n",
828 card
->evtbd_ring_size
);
832 dev_dbg(adapter
->dev
,
833 "info: CMDRSP/EVT bd_ring - base: %p pbase: %#x:%x len: %#x\n",
834 card
->evtbd_ring_vbase
, (u32
)card
->evtbd_ring_pbase
,
835 (u32
)((u64
)card
->evtbd_ring_pbase
>> 32),
836 card
->evtbd_ring_size
);
838 return mwifiex_pcie_init_evt_ring(adapter
);
842 * This function deletes Buffer descriptor ring for Events
844 static int mwifiex_pcie_delete_evtbd_ring(struct mwifiex_adapter
*adapter
)
846 struct pcie_service_card
*card
= adapter
->card
;
847 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
849 mwifiex_cleanup_evt_ring(adapter
);
851 if (card
->evtbd_ring_vbase
)
852 pci_free_consistent(card
->dev
, card
->evtbd_ring_size
,
853 card
->evtbd_ring_vbase
,
854 card
->evtbd_ring_pbase
);
855 card
->evtbd_wrptr
= 0;
856 card
->evtbd_rdptr
= 0 | reg
->evt_rollover_ind
;
857 card
->evtbd_ring_size
= 0;
858 card
->evtbd_ring_vbase
= NULL
;
859 card
->evtbd_ring_pbase
= 0;
865 * This function allocates a buffer for CMDRSP
867 static int mwifiex_pcie_alloc_cmdrsp_buf(struct mwifiex_adapter
*adapter
)
869 struct pcie_service_card
*card
= adapter
->card
;
872 /* Allocate memory for receiving command response data */
873 skb
= dev_alloc_skb(MWIFIEX_UPLD_SIZE
);
875 dev_err(adapter
->dev
,
876 "Unable to allocate skb for command response data.\n");
879 skb_put(skb
, MWIFIEX_UPLD_SIZE
);
880 if (mwifiex_map_pci_memory(adapter
, skb
, MWIFIEX_UPLD_SIZE
,
884 card
->cmdrsp_buf
= skb
;
890 * This function deletes a buffer for CMDRSP
892 static int mwifiex_pcie_delete_cmdrsp_buf(struct mwifiex_adapter
*adapter
)
894 struct pcie_service_card
*card
;
899 card
= adapter
->card
;
901 if (card
&& card
->cmdrsp_buf
) {
902 mwifiex_unmap_pci_memory(adapter
, card
->cmdrsp_buf
,
904 dev_kfree_skb_any(card
->cmdrsp_buf
);
907 if (card
&& card
->cmd_buf
) {
908 mwifiex_unmap_pci_memory(adapter
, card
->cmd_buf
,
915 * This function allocates a buffer for sleep cookie
917 static int mwifiex_pcie_alloc_sleep_cookie_buf(struct mwifiex_adapter
*adapter
)
919 struct pcie_service_card
*card
= adapter
->card
;
921 card
->sleep_cookie_vbase
= pci_alloc_consistent(card
->dev
, sizeof(u32
),
922 &card
->sleep_cookie_pbase
);
923 if (!card
->sleep_cookie_vbase
) {
924 dev_err(adapter
->dev
, "pci_alloc_consistent failed!\n");
927 /* Init val of Sleep Cookie */
928 *(u32
*)card
->sleep_cookie_vbase
= FW_AWAKE_COOKIE
;
930 dev_dbg(adapter
->dev
, "alloc_scook: sleep cookie=0x%x\n",
931 *((u32
*)card
->sleep_cookie_vbase
));
937 * This function deletes buffer for sleep cookie
939 static int mwifiex_pcie_delete_sleep_cookie_buf(struct mwifiex_adapter
*adapter
)
941 struct pcie_service_card
*card
;
946 card
= adapter
->card
;
948 if (card
&& card
->sleep_cookie_vbase
) {
949 pci_free_consistent(card
->dev
, sizeof(u32
),
950 card
->sleep_cookie_vbase
,
951 card
->sleep_cookie_pbase
);
952 card
->sleep_cookie_vbase
= NULL
;
958 /* This function flushes the TX buffer descriptor ring
959 * This function defined as handler is also called while cleaning TXRX
960 * during disconnect/ bss stop.
962 static int mwifiex_clean_pcie_ring_buf(struct mwifiex_adapter
*adapter
)
964 struct pcie_service_card
*card
= adapter
->card
;
966 if (!mwifiex_pcie_txbd_empty(card
, card
->txbd_rdptr
)) {
967 card
->txbd_flush
= 1;
968 /* write pointer already set at last send
969 * send dnld-rdy intr again, wait for completion.
971 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
972 CPU_INTR_DNLD_RDY
)) {
973 dev_err(adapter
->dev
,
974 "failed to assert dnld-rdy interrupt.\n");
982 * This function unmaps and frees downloaded data buffer
984 static int mwifiex_pcie_send_data_complete(struct mwifiex_adapter
*adapter
)
987 u32 wrdoneidx
, rdptr
, num_tx_buffs
, unmap_count
= 0;
988 struct mwifiex_pcie_buf_desc
*desc
;
989 struct mwifiex_pfu_buf_desc
*desc2
;
990 struct pcie_service_card
*card
= adapter
->card
;
991 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
993 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
994 mwifiex_pm_wakeup_card(adapter
);
996 /* Read the TX ring read pointer set by firmware */
997 if (mwifiex_read_reg(adapter
, reg
->tx_rdptr
, &rdptr
)) {
998 dev_err(adapter
->dev
,
999 "SEND COMP: failed to read reg->tx_rdptr\n");
1003 dev_dbg(adapter
->dev
, "SEND COMP: rdptr_prev=0x%x, rdptr=0x%x\n",
1004 card
->txbd_rdptr
, rdptr
);
1006 num_tx_buffs
= MWIFIEX_MAX_TXRX_BD
<< reg
->tx_start_ptr
;
1007 /* free from previous txbd_rdptr to current txbd_rdptr */
1008 while (((card
->txbd_rdptr
& reg
->tx_mask
) !=
1009 (rdptr
& reg
->tx_mask
)) ||
1010 ((card
->txbd_rdptr
& reg
->tx_rollover_ind
) !=
1011 (rdptr
& reg
->tx_rollover_ind
))) {
1012 wrdoneidx
= (card
->txbd_rdptr
& reg
->tx_mask
) >>
1015 skb
= card
->tx_buf_list
[wrdoneidx
];
1018 dev_dbg(adapter
->dev
,
1019 "SEND COMP: Detach skb %p at txbd_rdidx=%d\n",
1021 mwifiex_unmap_pci_memory(adapter
, skb
,
1026 if (card
->txbd_flush
)
1027 mwifiex_write_data_complete(adapter
, skb
, 0,
1030 mwifiex_write_data_complete(adapter
, skb
, 0, 0);
1033 card
->tx_buf_list
[wrdoneidx
] = NULL
;
1035 if (reg
->pfu_enabled
) {
1036 desc2
= (void *)card
->txbd_ring
[wrdoneidx
];
1037 memset(desc2
, 0, sizeof(*desc2
));
1039 desc
= card
->txbd_ring
[wrdoneidx
];
1040 memset(desc
, 0, sizeof(*desc
));
1042 switch (card
->dev
->device
) {
1043 case PCIE_DEVICE_ID_MARVELL_88W8766P
:
1046 case PCIE_DEVICE_ID_MARVELL_88W8897
:
1047 card
->txbd_rdptr
+= reg
->ring_tx_start_ptr
;
1052 if ((card
->txbd_rdptr
& reg
->tx_mask
) == num_tx_buffs
)
1053 card
->txbd_rdptr
= ((card
->txbd_rdptr
&
1054 reg
->tx_rollover_ind
) ^
1055 reg
->tx_rollover_ind
);
1059 adapter
->data_sent
= false;
1061 if (card
->txbd_flush
) {
1062 if (mwifiex_pcie_txbd_empty(card
, card
->txbd_rdptr
))
1063 card
->txbd_flush
= 0;
1065 mwifiex_clean_pcie_ring_buf(adapter
);
1071 /* This function sends data buffer to device. First 4 bytes of payload
1072 * are filled with payload length and payload type. Then this payload
1073 * is mapped to PCI device memory. Tx ring pointers are advanced accordingly.
1074 * Download ready interrupt to FW is deffered if Tx ring is not full and
1075 * additional payload can be accomodated.
1078 mwifiex_pcie_send_data(struct mwifiex_adapter
*adapter
, struct sk_buff
*skb
,
1079 struct mwifiex_tx_param
*tx_param
)
1081 struct pcie_service_card
*card
= adapter
->card
;
1082 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1083 u32 wrindx
, num_tx_buffs
, rx_val
;
1086 struct mwifiex_pcie_buf_desc
*desc
= NULL
;
1087 struct mwifiex_pfu_buf_desc
*desc2
= NULL
;
1090 if (!(skb
->data
&& skb
->len
)) {
1091 dev_err(adapter
->dev
, "%s(): invalid parameter <%p, %#x>\n",
1092 __func__
, skb
->data
, skb
->len
);
1096 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1097 mwifiex_pm_wakeup_card(adapter
);
1099 num_tx_buffs
= MWIFIEX_MAX_TXRX_BD
<< reg
->tx_start_ptr
;
1100 dev_dbg(adapter
->dev
, "info: SEND DATA: <Rd: %#x, Wr: %#x>\n",
1101 card
->txbd_rdptr
, card
->txbd_wrptr
);
1102 if (mwifiex_pcie_txbd_not_full(card
)) {
1105 adapter
->data_sent
= true;
1106 payload
= skb
->data
;
1107 tmp
= (__le16
*)&payload
[0];
1108 *tmp
= cpu_to_le16((u16
)skb
->len
);
1109 tmp
= (__le16
*)&payload
[2];
1110 *tmp
= cpu_to_le16(MWIFIEX_TYPE_DATA
);
1112 if (mwifiex_map_pci_memory(adapter
, skb
, skb
->len
,
1116 wrindx
= (card
->txbd_wrptr
& reg
->tx_mask
) >> reg
->tx_start_ptr
;
1117 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb
);
1118 card
->tx_buf_list
[wrindx
] = skb
;
1120 if (reg
->pfu_enabled
) {
1121 desc2
= (void *)card
->txbd_ring
[wrindx
];
1122 desc2
->paddr
= buf_pa
;
1123 desc2
->len
= (u16
)skb
->len
;
1124 desc2
->frag_len
= (u16
)skb
->len
;
1126 desc2
->flags
= MWIFIEX_BD_FLAG_FIRST_DESC
|
1127 MWIFIEX_BD_FLAG_LAST_DESC
;
1129 desc
= card
->txbd_ring
[wrindx
];
1130 desc
->paddr
= buf_pa
;
1131 desc
->len
= (u16
)skb
->len
;
1132 desc
->flags
= MWIFIEX_BD_FLAG_FIRST_DESC
|
1133 MWIFIEX_BD_FLAG_LAST_DESC
;
1136 switch (card
->dev
->device
) {
1137 case PCIE_DEVICE_ID_MARVELL_88W8766P
:
1140 case PCIE_DEVICE_ID_MARVELL_88W8897
:
1141 card
->txbd_wrptr
+= reg
->ring_tx_start_ptr
;
1145 if ((card
->txbd_wrptr
& reg
->tx_mask
) == num_tx_buffs
)
1146 card
->txbd_wrptr
= ((card
->txbd_wrptr
&
1147 reg
->tx_rollover_ind
) ^
1148 reg
->tx_rollover_ind
);
1150 rx_val
= card
->rxbd_rdptr
& reg
->rx_wrap_mask
;
1151 /* Write the TX ring write pointer in to reg->tx_wrptr */
1152 if (mwifiex_write_reg(adapter
, reg
->tx_wrptr
,
1153 card
->txbd_wrptr
| rx_val
)) {
1154 dev_err(adapter
->dev
,
1155 "SEND DATA: failed to write reg->tx_wrptr\n");
1159 if ((mwifiex_pcie_txbd_not_full(card
)) &&
1160 tx_param
->next_pkt_len
) {
1161 /* have more packets and TxBD still can hold more */
1162 dev_dbg(adapter
->dev
,
1163 "SEND DATA: delay dnld-rdy interrupt.\n");
1164 adapter
->data_sent
= false;
1166 /* Send the TX ready interrupt */
1167 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1168 CPU_INTR_DNLD_RDY
)) {
1169 dev_err(adapter
->dev
,
1170 "SEND DATA: failed to assert dnld-rdy interrupt.\n");
1175 dev_dbg(adapter
->dev
, "info: SEND DATA: Updated <Rd: %#x, Wr: "
1176 "%#x> and sent packet to firmware successfully\n",
1177 card
->txbd_rdptr
, card
->txbd_wrptr
);
1179 dev_dbg(adapter
->dev
,
1180 "info: TX Ring full, can't send packets to fw\n");
1181 adapter
->data_sent
= true;
1182 /* Send the TX ready interrupt */
1183 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1185 dev_err(adapter
->dev
,
1186 "SEND DATA: failed to assert door-bell intr\n");
1190 return -EINPROGRESS
;
1192 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1193 card
->tx_buf_list
[wrindx
] = NULL
;
1194 if (reg
->pfu_enabled
)
1195 memset(desc2
, 0, sizeof(*desc2
));
1197 memset(desc
, 0, sizeof(*desc
));
1203 * This function handles received buffer ring and
1204 * dispatches packets to upper
1206 static int mwifiex_pcie_process_recv_data(struct mwifiex_adapter
*adapter
)
1208 struct pcie_service_card
*card
= adapter
->card
;
1209 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1210 u32 wrptr
, rd_index
, tx_val
;
1213 struct sk_buff
*skb_tmp
= NULL
;
1214 struct mwifiex_pcie_buf_desc
*desc
;
1215 struct mwifiex_pfu_buf_desc
*desc2
;
1217 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1218 mwifiex_pm_wakeup_card(adapter
);
1220 /* Read the RX ring Write pointer set by firmware */
1221 if (mwifiex_read_reg(adapter
, reg
->rx_wrptr
, &wrptr
)) {
1222 dev_err(adapter
->dev
,
1223 "RECV DATA: failed to read reg->rx_wrptr\n");
1227 card
->rxbd_wrptr
= wrptr
;
1229 while (((wrptr
& reg
->rx_mask
) !=
1230 (card
->rxbd_rdptr
& reg
->rx_mask
)) ||
1231 ((wrptr
& reg
->rx_rollover_ind
) ==
1232 (card
->rxbd_rdptr
& reg
->rx_rollover_ind
))) {
1233 struct sk_buff
*skb_data
;
1237 rd_index
= card
->rxbd_rdptr
& reg
->rx_mask
;
1238 skb_data
= card
->rx_buf_list
[rd_index
];
1240 /* If skb allocation was failed earlier for Rx packet,
1241 * rx_buf_list[rd_index] would have been left with a NULL.
1246 mwifiex_unmap_pci_memory(adapter
, skb_data
, PCI_DMA_FROMDEVICE
);
1247 card
->rx_buf_list
[rd_index
] = NULL
;
1249 /* Get data length from interface header -
1250 * first 2 bytes for len, next 2 bytes is for type
1252 pkt_len
= *((__le16
*)skb_data
->data
);
1253 rx_len
= le16_to_cpu(pkt_len
);
1254 skb_put(skb_data
, rx_len
);
1255 dev_dbg(adapter
->dev
,
1256 "info: RECV DATA: Rd=%#x, Wr=%#x, Len=%d\n",
1257 card
->rxbd_rdptr
, wrptr
, rx_len
);
1258 skb_pull(skb_data
, INTF_HEADER_LEN
);
1259 mwifiex_handle_rx_packet(adapter
, skb_data
);
1261 skb_tmp
= dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE
);
1263 dev_err(adapter
->dev
,
1264 "Unable to allocate skb.\n");
1268 if (mwifiex_map_pci_memory(adapter
, skb_tmp
,
1269 MWIFIEX_RX_DATA_BUF_SIZE
,
1270 PCI_DMA_FROMDEVICE
))
1273 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb_tmp
);
1275 dev_dbg(adapter
->dev
,
1276 "RECV DATA: Attach new sk_buff %p at rxbd_rdidx=%d\n",
1278 card
->rx_buf_list
[rd_index
] = skb_tmp
;
1280 if (reg
->pfu_enabled
) {
1281 desc2
= (void *)card
->rxbd_ring
[rd_index
];
1282 desc2
->paddr
= buf_pa
;
1283 desc2
->len
= skb_tmp
->len
;
1284 desc2
->frag_len
= skb_tmp
->len
;
1286 desc2
->flags
= reg
->ring_flag_sop
| reg
->ring_flag_eop
;
1288 desc
= card
->rxbd_ring
[rd_index
];
1289 desc
->paddr
= buf_pa
;
1290 desc
->len
= skb_tmp
->len
;
1294 if ((++card
->rxbd_rdptr
& reg
->rx_mask
) ==
1295 MWIFIEX_MAX_TXRX_BD
) {
1296 card
->rxbd_rdptr
= ((card
->rxbd_rdptr
&
1297 reg
->rx_rollover_ind
) ^
1298 reg
->rx_rollover_ind
);
1300 dev_dbg(adapter
->dev
, "info: RECV DATA: <Rd: %#x, Wr: %#x>\n",
1301 card
->rxbd_rdptr
, wrptr
);
1303 tx_val
= card
->txbd_wrptr
& reg
->tx_wrap_mask
;
1304 /* Write the RX ring read pointer in to reg->rx_rdptr */
1305 if (mwifiex_write_reg(adapter
, reg
->rx_rdptr
,
1306 card
->rxbd_rdptr
| tx_val
)) {
1307 dev_err(adapter
->dev
,
1308 "RECV DATA: failed to write reg->rx_rdptr\n");
1313 /* Read the RX ring Write pointer set by firmware */
1314 if (mwifiex_read_reg(adapter
, reg
->rx_wrptr
, &wrptr
)) {
1315 dev_err(adapter
->dev
,
1316 "RECV DATA: failed to read reg->rx_wrptr\n");
1320 dev_dbg(adapter
->dev
,
1321 "info: RECV DATA: Rcvd packet from fw successfully\n");
1322 card
->rxbd_wrptr
= wrptr
;
1330 * This function downloads the boot command to device
1333 mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter
*adapter
, struct sk_buff
*skb
)
1336 struct pcie_service_card
*card
= adapter
->card
;
1337 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1339 if (!(skb
->data
&& skb
->len
)) {
1340 dev_err(adapter
->dev
,
1341 "Invalid parameter in %s <%p. len %d>\n",
1342 __func__
, skb
->data
, skb
->len
);
1346 if (mwifiex_map_pci_memory(adapter
, skb
, skb
->len
, PCI_DMA_TODEVICE
))
1349 buf_pa
= MWIFIEX_SKB_DMA_ADDR(skb
);
1351 /* Write the lower 32bits of the physical address to low command
1352 * address scratch register
1354 if (mwifiex_write_reg(adapter
, reg
->cmd_addr_lo
, (u32
)buf_pa
)) {
1355 dev_err(adapter
->dev
,
1356 "%s: failed to write download command to boot code.\n",
1358 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1362 /* Write the upper 32bits of the physical address to high command
1363 * address scratch register
1365 if (mwifiex_write_reg(adapter
, reg
->cmd_addr_hi
,
1366 (u32
)((u64
)buf_pa
>> 32))) {
1367 dev_err(adapter
->dev
,
1368 "%s: failed to write download command to boot code.\n",
1370 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1374 /* Write the command length to cmd_size scratch register */
1375 if (mwifiex_write_reg(adapter
, reg
->cmd_size
, skb
->len
)) {
1376 dev_err(adapter
->dev
,
1377 "%s: failed to write command len to cmd_size scratch reg\n",
1379 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1383 /* Ring the door bell */
1384 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1385 CPU_INTR_DOOR_BELL
)) {
1386 dev_err(adapter
->dev
,
1387 "%s: failed to assert door-bell intr\n", __func__
);
1388 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1395 /* This function init rx port in firmware which in turn enables to receive data
1396 * from device before transmitting any packet.
1398 static int mwifiex_pcie_init_fw_port(struct mwifiex_adapter
*adapter
)
1400 struct pcie_service_card
*card
= adapter
->card
;
1401 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1402 int tx_wrap
= card
->txbd_wrptr
& reg
->tx_wrap_mask
;
1404 /* Write the RX ring read pointer in to reg->rx_rdptr */
1405 if (mwifiex_write_reg(adapter
, reg
->rx_rdptr
, card
->rxbd_rdptr
|
1407 dev_err(adapter
->dev
,
1408 "RECV DATA: failed to write reg->rx_rdptr\n");
1414 /* This function downloads commands to the device
1417 mwifiex_pcie_send_cmd(struct mwifiex_adapter
*adapter
, struct sk_buff
*skb
)
1419 struct pcie_service_card
*card
= adapter
->card
;
1420 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1422 dma_addr_t cmd_buf_pa
, cmdrsp_buf_pa
;
1423 u8
*payload
= (u8
*)skb
->data
;
1425 if (!(skb
->data
&& skb
->len
)) {
1426 dev_err(adapter
->dev
, "Invalid parameter in %s <%p, %#x>\n",
1427 __func__
, skb
->data
, skb
->len
);
1431 /* Make sure a command response buffer is available */
1432 if (!card
->cmdrsp_buf
) {
1433 dev_err(adapter
->dev
,
1434 "No response buffer available, send command failed\n");
1438 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1439 mwifiex_pm_wakeup_card(adapter
);
1441 adapter
->cmd_sent
= true;
1443 *(__le16
*)&payload
[0] = cpu_to_le16((u16
)skb
->len
);
1444 *(__le16
*)&payload
[2] = cpu_to_le16(MWIFIEX_TYPE_CMD
);
1446 if (mwifiex_map_pci_memory(adapter
, skb
, skb
->len
, PCI_DMA_TODEVICE
))
1449 card
->cmd_buf
= skb
;
1451 /* To send a command, the driver will:
1452 1. Write the 64bit physical address of the data buffer to
1453 cmd response address low + cmd response address high
1454 2. Ring the door bell (i.e. set the door bell interrupt)
1456 In response to door bell interrupt, the firmware will perform
1457 the DMA of the command packet (first header to obtain the total
1458 length and then rest of the command).
1461 if (card
->cmdrsp_buf
) {
1462 cmdrsp_buf_pa
= MWIFIEX_SKB_DMA_ADDR(card
->cmdrsp_buf
);
1463 /* Write the lower 32bits of the cmdrsp buffer physical
1465 if (mwifiex_write_reg(adapter
, reg
->cmdrsp_addr_lo
,
1466 (u32
)cmdrsp_buf_pa
)) {
1467 dev_err(adapter
->dev
,
1468 "Failed to write download cmd to boot code.\n");
1472 /* Write the upper 32bits of the cmdrsp buffer physical
1474 if (mwifiex_write_reg(adapter
, reg
->cmdrsp_addr_hi
,
1475 (u32
)((u64
)cmdrsp_buf_pa
>> 32))) {
1476 dev_err(adapter
->dev
,
1477 "Failed to write download cmd to boot code.\n");
1483 cmd_buf_pa
= MWIFIEX_SKB_DMA_ADDR(card
->cmd_buf
);
1484 /* Write the lower 32bits of the physical address to reg->cmd_addr_lo */
1485 if (mwifiex_write_reg(adapter
, reg
->cmd_addr_lo
,
1487 dev_err(adapter
->dev
,
1488 "Failed to write download cmd to boot code.\n");
1492 /* Write the upper 32bits of the physical address to reg->cmd_addr_hi */
1493 if (mwifiex_write_reg(adapter
, reg
->cmd_addr_hi
,
1494 (u32
)((u64
)cmd_buf_pa
>> 32))) {
1495 dev_err(adapter
->dev
,
1496 "Failed to write download cmd to boot code.\n");
1501 /* Write the command length to reg->cmd_size */
1502 if (mwifiex_write_reg(adapter
, reg
->cmd_size
,
1503 card
->cmd_buf
->len
)) {
1504 dev_err(adapter
->dev
,
1505 "Failed to write cmd len to reg->cmd_size\n");
1510 /* Ring the door bell */
1511 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1512 CPU_INTR_DOOR_BELL
)) {
1513 dev_err(adapter
->dev
,
1514 "Failed to assert door-bell intr\n");
1521 adapter
->cmd_sent
= false;
1527 * This function handles command complete interrupt
1529 static int mwifiex_pcie_process_cmd_complete(struct mwifiex_adapter
*adapter
)
1531 struct pcie_service_card
*card
= adapter
->card
;
1532 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1533 struct sk_buff
*skb
= card
->cmdrsp_buf
;
1538 dev_dbg(adapter
->dev
, "info: Rx CMD Response\n");
1540 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_FROMDEVICE
);
1542 /* Unmap the command as a response has been received. */
1543 if (card
->cmd_buf
) {
1544 mwifiex_unmap_pci_memory(adapter
, card
->cmd_buf
,
1546 card
->cmd_buf
= NULL
;
1549 pkt_len
= *((__le16
*)skb
->data
);
1550 rx_len
= le16_to_cpu(pkt_len
);
1551 skb_trim(skb
, rx_len
);
1552 skb_pull(skb
, INTF_HEADER_LEN
);
1554 if (!adapter
->curr_cmd
) {
1555 if (adapter
->ps_state
== PS_STATE_SLEEP_CFM
) {
1556 mwifiex_process_sleep_confirm_resp(adapter
, skb
->data
,
1558 mwifiex_pcie_enable_host_int(adapter
);
1559 if (mwifiex_write_reg(adapter
,
1561 CPU_INTR_SLEEP_CFM_DONE
)) {
1562 dev_warn(adapter
->dev
,
1563 "Write register failed\n");
1566 mwifiex_delay_for_sleep_cookie(adapter
,
1567 MWIFIEX_MAX_DELAY_COUNT
);
1568 while (reg
->sleep_cookie
&& (count
++ < 10) &&
1569 mwifiex_pcie_ok_to_access_hw(adapter
))
1570 usleep_range(50, 60);
1572 dev_err(adapter
->dev
,
1573 "There is no command but got cmdrsp\n");
1575 memcpy(adapter
->upld_buf
, skb
->data
,
1576 min_t(u32
, MWIFIEX_SIZE_OF_CMD_BUFFER
, skb
->len
));
1577 skb_push(skb
, INTF_HEADER_LEN
);
1578 if (mwifiex_map_pci_memory(adapter
, skb
, MWIFIEX_UPLD_SIZE
,
1579 PCI_DMA_FROMDEVICE
))
1581 } else if (mwifiex_pcie_ok_to_access_hw(adapter
)) {
1582 adapter
->curr_cmd
->resp_skb
= skb
;
1583 adapter
->cmd_resp_received
= true;
1584 /* Take the pointer and set it to CMD node and will
1585 return in the response complete callback */
1586 card
->cmdrsp_buf
= NULL
;
1588 /* Clear the cmd-rsp buffer address in scratch registers. This
1589 will prevent firmware from writing to the same response
1591 if (mwifiex_write_reg(adapter
, reg
->cmdrsp_addr_lo
, 0)) {
1592 dev_err(adapter
->dev
,
1593 "cmd_done: failed to clear cmd_rsp_addr_lo\n");
1596 /* Write the upper 32bits of the cmdrsp buffer physical
1598 if (mwifiex_write_reg(adapter
, reg
->cmdrsp_addr_hi
, 0)) {
1599 dev_err(adapter
->dev
,
1600 "cmd_done: failed to clear cmd_rsp_addr_hi\n");
1609 * Command Response processing complete handler
1611 static int mwifiex_pcie_cmdrsp_complete(struct mwifiex_adapter
*adapter
,
1612 struct sk_buff
*skb
)
1614 struct pcie_service_card
*card
= adapter
->card
;
1617 card
->cmdrsp_buf
= skb
;
1618 skb_push(card
->cmdrsp_buf
, INTF_HEADER_LEN
);
1619 if (mwifiex_map_pci_memory(adapter
, skb
, MWIFIEX_UPLD_SIZE
,
1620 PCI_DMA_FROMDEVICE
))
1628 * This function handles firmware event ready interrupt
1630 static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter
*adapter
)
1632 struct pcie_service_card
*card
= adapter
->card
;
1633 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1634 u32 rdptr
= card
->evtbd_rdptr
& MWIFIEX_EVTBD_MASK
;
1636 struct mwifiex_evt_buf_desc
*desc
;
1638 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1639 mwifiex_pm_wakeup_card(adapter
);
1641 if (adapter
->event_received
) {
1642 dev_dbg(adapter
->dev
, "info: Event being processed, "
1643 "do not process this interrupt just yet\n");
1647 if (rdptr
>= MWIFIEX_MAX_EVT_BD
) {
1648 dev_dbg(adapter
->dev
, "info: Invalid read pointer...\n");
1652 /* Read the event ring write pointer set by firmware */
1653 if (mwifiex_read_reg(adapter
, reg
->evt_wrptr
, &wrptr
)) {
1654 dev_err(adapter
->dev
,
1655 "EventReady: failed to read reg->evt_wrptr\n");
1659 dev_dbg(adapter
->dev
, "info: EventReady: Initial <Rd: 0x%x, Wr: 0x%x>",
1660 card
->evtbd_rdptr
, wrptr
);
1661 if (((wrptr
& MWIFIEX_EVTBD_MASK
) != (card
->evtbd_rdptr
1662 & MWIFIEX_EVTBD_MASK
)) ||
1663 ((wrptr
& reg
->evt_rollover_ind
) ==
1664 (card
->evtbd_rdptr
& reg
->evt_rollover_ind
))) {
1665 struct sk_buff
*skb_cmd
;
1666 __le16 data_len
= 0;
1669 dev_dbg(adapter
->dev
, "info: Read Index: %d\n", rdptr
);
1670 skb_cmd
= card
->evt_buf_list
[rdptr
];
1671 mwifiex_unmap_pci_memory(adapter
, skb_cmd
, PCI_DMA_FROMDEVICE
);
1673 /* Take the pointer and set it to event pointer in adapter
1674 and will return back after event handling callback */
1675 card
->evt_buf_list
[rdptr
] = NULL
;
1676 desc
= card
->evtbd_ring
[rdptr
];
1677 memset(desc
, 0, sizeof(*desc
));
1679 event
= *(u32
*) &skb_cmd
->data
[INTF_HEADER_LEN
];
1680 adapter
->event_cause
= event
;
1681 /* The first 4bytes will be the event transfer header
1682 len is 2 bytes followed by type which is 2 bytes */
1683 memcpy(&data_len
, skb_cmd
->data
, sizeof(__le16
));
1684 evt_len
= le16_to_cpu(data_len
);
1686 skb_pull(skb_cmd
, INTF_HEADER_LEN
);
1687 dev_dbg(adapter
->dev
, "info: Event length: %d\n", evt_len
);
1689 if ((evt_len
> 0) && (evt_len
< MAX_EVENT_SIZE
))
1690 memcpy(adapter
->event_body
, skb_cmd
->data
+
1691 MWIFIEX_EVENT_HEADER_LEN
, evt_len
-
1692 MWIFIEX_EVENT_HEADER_LEN
);
1694 adapter
->event_received
= true;
1695 adapter
->event_skb
= skb_cmd
;
1697 /* Do not update the event read pointer here, wait till the
1698 buffer is released. This is just to make things simpler,
1699 we need to find a better method of managing these buffers.
1707 * Event processing complete handler
1709 static int mwifiex_pcie_event_complete(struct mwifiex_adapter
*adapter
,
1710 struct sk_buff
*skb
)
1712 struct pcie_service_card
*card
= adapter
->card
;
1713 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1715 u32 rdptr
= card
->evtbd_rdptr
& MWIFIEX_EVTBD_MASK
;
1717 struct mwifiex_evt_buf_desc
*desc
;
1722 if (rdptr
>= MWIFIEX_MAX_EVT_BD
) {
1723 dev_err(adapter
->dev
, "event_complete: Invalid rdptr 0x%x\n",
1728 /* Read the event ring write pointer set by firmware */
1729 if (mwifiex_read_reg(adapter
, reg
->evt_wrptr
, &wrptr
)) {
1730 dev_err(adapter
->dev
,
1731 "event_complete: failed to read reg->evt_wrptr\n");
1735 if (!card
->evt_buf_list
[rdptr
]) {
1736 skb_push(skb
, INTF_HEADER_LEN
);
1737 if (mwifiex_map_pci_memory(adapter
, skb
,
1739 PCI_DMA_FROMDEVICE
))
1741 card
->evt_buf_list
[rdptr
] = skb
;
1742 desc
= card
->evtbd_ring
[rdptr
];
1743 desc
->paddr
= MWIFIEX_SKB_DMA_ADDR(skb
);
1744 desc
->len
= (u16
)skb
->len
;
1748 dev_dbg(adapter
->dev
,
1749 "info: ERROR: buf still valid at index %d, <%p, %p>\n",
1750 rdptr
, card
->evt_buf_list
[rdptr
], skb
);
1753 if ((++card
->evtbd_rdptr
& MWIFIEX_EVTBD_MASK
) == MWIFIEX_MAX_EVT_BD
) {
1754 card
->evtbd_rdptr
= ((card
->evtbd_rdptr
&
1755 reg
->evt_rollover_ind
) ^
1756 reg
->evt_rollover_ind
);
1759 dev_dbg(adapter
->dev
, "info: Updated <Rd: 0x%x, Wr: 0x%x>",
1760 card
->evtbd_rdptr
, wrptr
);
1762 /* Write the event ring read pointer in to reg->evt_rdptr */
1763 if (mwifiex_write_reg(adapter
, reg
->evt_rdptr
,
1764 card
->evtbd_rdptr
)) {
1765 dev_err(adapter
->dev
,
1766 "event_complete: failed to read reg->evt_rdptr\n");
1770 dev_dbg(adapter
->dev
, "info: Check Events Again\n");
1771 ret
= mwifiex_pcie_process_event_ready(adapter
);
1777 * This function downloads the firmware to the card.
1779 * Firmware is downloaded to the card in blocks. Every block download
1780 * is tested for CRC errors, and retried a number of times before
1781 * returning failure.
1783 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter
*adapter
,
1784 struct mwifiex_fw_image
*fw
)
1787 u8
*firmware
= fw
->fw_buf
;
1788 u32 firmware_len
= fw
->fw_len
;
1790 struct sk_buff
*skb
;
1791 u32 txlen
, tx_blocks
= 0, tries
, len
;
1792 u32 block_retry_cnt
= 0;
1793 struct pcie_service_card
*card
= adapter
->card
;
1794 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1796 if (!firmware
|| !firmware_len
) {
1797 dev_err(adapter
->dev
,
1798 "No firmware image found! Terminating download\n");
1802 dev_dbg(adapter
->dev
, "info: Downloading FW image (%d bytes)\n",
1805 if (mwifiex_pcie_disable_host_int(adapter
)) {
1806 dev_err(adapter
->dev
,
1807 "%s: Disabling interrupts failed.\n", __func__
);
1811 skb
= dev_alloc_skb(MWIFIEX_UPLD_SIZE
);
1817 /* Perform firmware data transfer */
1822 if (offset
>= firmware_len
)
1825 for (tries
= 0; tries
< MAX_POLL_TRIES
; tries
++) {
1826 ret
= mwifiex_read_reg(adapter
, reg
->cmd_size
,
1829 dev_warn(adapter
->dev
,
1830 "Failed reading len from boot code\n");
1835 usleep_range(10, 20);
1840 } else if (len
> MWIFIEX_UPLD_SIZE
) {
1841 pr_err("FW download failure @ %d, invalid length %d\n",
1851 if (block_retry_cnt
> MAX_WRITE_IOMEM_RETRY
) {
1852 pr_err("FW download failure @ %d, over max "
1853 "retry count\n", offset
);
1857 dev_err(adapter
->dev
, "FW CRC error indicated by the "
1858 "helper: len = 0x%04X, txlen = %d\n",
1861 /* Setting this to 0 to resend from same offset */
1864 block_retry_cnt
= 0;
1865 /* Set blocksize to transfer - checking for
1867 if (firmware_len
- offset
< txlen
)
1868 txlen
= firmware_len
- offset
;
1870 dev_dbg(adapter
->dev
, ".");
1872 tx_blocks
= (txlen
+ card
->pcie
.blksz_fw_dl
- 1) /
1873 card
->pcie
.blksz_fw_dl
;
1875 /* Copy payload to buffer */
1876 memmove(skb
->data
, &firmware
[offset
], txlen
);
1879 skb_put(skb
, MWIFIEX_UPLD_SIZE
- skb
->len
);
1880 skb_trim(skb
, tx_blocks
* card
->pcie
.blksz_fw_dl
);
1882 /* Send the boot command to device */
1883 if (mwifiex_pcie_send_boot_cmd(adapter
, skb
)) {
1884 dev_err(adapter
->dev
,
1885 "Failed to send firmware download command\n");
1890 /* Wait for the command done interrupt */
1892 if (mwifiex_read_reg(adapter
, PCIE_CPU_INT_STATUS
,
1894 dev_err(adapter
->dev
, "%s: Failed to read "
1895 "interrupt status during fw dnld.\n",
1897 mwifiex_unmap_pci_memory(adapter
, skb
,
1902 } while ((ireg_intr
& CPU_INTR_DOOR_BELL
) ==
1903 CPU_INTR_DOOR_BELL
);
1905 mwifiex_unmap_pci_memory(adapter
, skb
, PCI_DMA_TODEVICE
);
1910 dev_dbg(adapter
->dev
, "info:\nFW download over, size %d bytes\n",
1916 dev_kfree_skb_any(skb
);
1921 * This function checks the firmware status in card.
1923 * The winner interface is also determined by this function.
1926 mwifiex_check_fw_status(struct mwifiex_adapter
*adapter
, u32 poll_num
)
1929 u32 firmware_stat
, winner_status
;
1930 struct pcie_service_card
*card
= adapter
->card
;
1931 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
1934 /* Mask spurios interrupts */
1935 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_STATUS_MASK
,
1937 dev_warn(adapter
->dev
, "Write register failed\n");
1941 dev_dbg(adapter
->dev
, "Setting driver ready signature\n");
1942 if (mwifiex_write_reg(adapter
, reg
->drv_rdy
,
1943 FIRMWARE_READY_PCIE
)) {
1944 dev_err(adapter
->dev
,
1945 "Failed to write driver ready signature\n");
1949 /* Wait for firmware initialization event */
1950 for (tries
= 0; tries
< poll_num
; tries
++) {
1951 if (mwifiex_read_reg(adapter
, reg
->fw_status
,
1958 if (firmware_stat
== FIRMWARE_READY_PCIE
) {
1968 if (mwifiex_read_reg(adapter
, reg
->fw_status
,
1971 else if (!winner_status
) {
1972 dev_err(adapter
->dev
, "PCI-E is the winner\n");
1973 adapter
->winner
= 1;
1975 dev_err(adapter
->dev
,
1976 "PCI-E is not the winner <%#x,%d>, exit dnld\n",
1977 ret
, adapter
->winner
);
1985 * This function reads the interrupt status from card.
1987 static void mwifiex_interrupt_status(struct mwifiex_adapter
*adapter
)
1990 unsigned long flags
;
1992 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1995 if (mwifiex_read_reg(adapter
, PCIE_HOST_INT_STATUS
, &pcie_ireg
)) {
1996 dev_warn(adapter
->dev
, "Read register failed\n");
2000 if ((pcie_ireg
!= 0xFFFFFFFF) && (pcie_ireg
)) {
2002 mwifiex_pcie_disable_host_int(adapter
);
2004 /* Clear the pending interrupts */
2005 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_STATUS
,
2007 dev_warn(adapter
->dev
, "Write register failed\n");
2010 spin_lock_irqsave(&adapter
->int_lock
, flags
);
2011 adapter
->int_status
|= pcie_ireg
;
2012 spin_unlock_irqrestore(&adapter
->int_lock
, flags
);
2014 if (!adapter
->pps_uapsd_mode
&&
2015 adapter
->ps_state
== PS_STATE_SLEEP
&&
2016 mwifiex_pcie_ok_to_access_hw(adapter
)) {
2017 /* Potentially for PCIe we could get other
2018 * interrupts like shared. Don't change power
2019 * state until cookie is set */
2020 adapter
->ps_state
= PS_STATE_AWAKE
;
2021 adapter
->pm_wakeup_fw_try
= false;
2027 * Interrupt handler for PCIe root port
2029 * This function reads the interrupt status from firmware and assigns
2030 * the main process in workqueue which will handle the interrupt.
2032 static irqreturn_t
mwifiex_pcie_interrupt(int irq
, void *context
)
2034 struct pci_dev
*pdev
= (struct pci_dev
*)context
;
2035 struct pcie_service_card
*card
;
2036 struct mwifiex_adapter
*adapter
;
2039 pr_debug("info: %s: pdev is NULL\n", (u8
*)pdev
);
2043 card
= pci_get_drvdata(pdev
);
2044 if (!card
|| !card
->adapter
) {
2045 pr_debug("info: %s: card=%p adapter=%p\n", __func__
, card
,
2046 card
? card
->adapter
: NULL
);
2049 adapter
= card
->adapter
;
2051 if (adapter
->surprise_removed
)
2054 mwifiex_interrupt_status(adapter
);
2055 queue_work(adapter
->workqueue
, &adapter
->main_work
);
2062 * This function checks the current interrupt status.
2064 * The following interrupts are checked and handled by this function -
2067 * - Command received
2068 * - Packets received
2071 * In case of Rx packets received, the packets are uploaded from card to
2072 * host and processed accordingly.
2074 static int mwifiex_process_int_status(struct mwifiex_adapter
*adapter
)
2078 unsigned long flags
;
2080 spin_lock_irqsave(&adapter
->int_lock
, flags
);
2081 /* Clear out unused interrupts */
2082 pcie_ireg
= adapter
->int_status
;
2083 adapter
->int_status
= 0;
2084 spin_unlock_irqrestore(&adapter
->int_lock
, flags
);
2086 while (pcie_ireg
& HOST_INTR_MASK
) {
2087 if (pcie_ireg
& HOST_INTR_DNLD_DONE
) {
2088 pcie_ireg
&= ~HOST_INTR_DNLD_DONE
;
2089 dev_dbg(adapter
->dev
, "info: TX DNLD Done\n");
2090 ret
= mwifiex_pcie_send_data_complete(adapter
);
2094 if (pcie_ireg
& HOST_INTR_UPLD_RDY
) {
2095 pcie_ireg
&= ~HOST_INTR_UPLD_RDY
;
2096 dev_dbg(adapter
->dev
, "info: Rx DATA\n");
2097 ret
= mwifiex_pcie_process_recv_data(adapter
);
2101 if (pcie_ireg
& HOST_INTR_EVENT_RDY
) {
2102 pcie_ireg
&= ~HOST_INTR_EVENT_RDY
;
2103 dev_dbg(adapter
->dev
, "info: Rx EVENT\n");
2104 ret
= mwifiex_pcie_process_event_ready(adapter
);
2109 if (pcie_ireg
& HOST_INTR_CMD_DONE
) {
2110 pcie_ireg
&= ~HOST_INTR_CMD_DONE
;
2111 if (adapter
->cmd_sent
) {
2112 dev_dbg(adapter
->dev
,
2113 "info: CMD sent Interrupt\n");
2114 adapter
->cmd_sent
= false;
2116 /* Handle command response */
2117 ret
= mwifiex_pcie_process_cmd_complete(adapter
);
2122 if (mwifiex_pcie_ok_to_access_hw(adapter
)) {
2123 if (mwifiex_read_reg(adapter
, PCIE_HOST_INT_STATUS
,
2125 dev_warn(adapter
->dev
,
2126 "Read register failed\n");
2130 if ((pcie_ireg
!= 0xFFFFFFFF) && (pcie_ireg
)) {
2131 if (mwifiex_write_reg(adapter
,
2132 PCIE_HOST_INT_STATUS
,
2134 dev_warn(adapter
->dev
,
2135 "Write register failed\n");
2142 dev_dbg(adapter
->dev
, "info: cmd_sent=%d data_sent=%d\n",
2143 adapter
->cmd_sent
, adapter
->data_sent
);
2144 if (adapter
->ps_state
!= PS_STATE_SLEEP
)
2145 mwifiex_pcie_enable_host_int(adapter
);
2151 * This function downloads data from driver to card.
2153 * Both commands and data packets are transferred to the card by this
2156 * This function adds the PCIE specific header to the front of the buffer
2157 * before transferring. The header contains the length of the packet and
2158 * the type. The firmware handles the packets based upon this set type.
2160 static int mwifiex_pcie_host_to_card(struct mwifiex_adapter
*adapter
, u8 type
,
2161 struct sk_buff
*skb
,
2162 struct mwifiex_tx_param
*tx_param
)
2165 dev_err(adapter
->dev
, "Passed NULL skb to %s\n", __func__
);
2169 if (type
== MWIFIEX_TYPE_DATA
)
2170 return mwifiex_pcie_send_data(adapter
, skb
, tx_param
);
2171 else if (type
== MWIFIEX_TYPE_CMD
)
2172 return mwifiex_pcie_send_cmd(adapter
, skb
);
2178 * This function initializes the PCI-E host memory space, WCB rings, etc.
2180 * The following initializations steps are followed -
2181 * - Allocate TXBD ring buffers
2182 * - Allocate RXBD ring buffers
2183 * - Allocate event BD ring buffers
2184 * - Allocate command response ring buffer
2185 * - Allocate sleep cookie buffer
2187 static int mwifiex_pcie_init(struct mwifiex_adapter
*adapter
)
2189 struct pcie_service_card
*card
= adapter
->card
;
2191 struct pci_dev
*pdev
= card
->dev
;
2192 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
2194 pci_set_drvdata(pdev
, card
);
2196 ret
= pci_enable_device(pdev
);
2198 goto err_enable_dev
;
2200 pci_set_master(pdev
);
2202 dev_dbg(adapter
->dev
, "try set_consistent_dma_mask(32)\n");
2203 ret
= pci_set_dma_mask(pdev
, DMA_BIT_MASK(32));
2205 dev_err(adapter
->dev
, "set_dma_mask(32) failed\n");
2206 goto err_set_dma_mask
;
2209 ret
= pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(32));
2211 dev_err(adapter
->dev
, "set_consistent_dma_mask(64) failed\n");
2212 goto err_set_dma_mask
;
2215 ret
= pci_request_region(pdev
, 0, DRV_NAME
);
2217 dev_err(adapter
->dev
, "req_reg(0) error\n");
2218 goto err_req_region0
;
2220 card
->pci_mmap
= pci_iomap(pdev
, 0, 0);
2221 if (!card
->pci_mmap
) {
2222 dev_err(adapter
->dev
, "iomap(0) error\n");
2226 ret
= pci_request_region(pdev
, 2, DRV_NAME
);
2228 dev_err(adapter
->dev
, "req_reg(2) error\n");
2229 goto err_req_region2
;
2231 card
->pci_mmap1
= pci_iomap(pdev
, 2, 0);
2232 if (!card
->pci_mmap1
) {
2233 dev_err(adapter
->dev
, "iomap(2) error\n");
2238 dev_dbg(adapter
->dev
,
2239 "PCI memory map Virt0: %p PCI memory map Virt2: %p\n",
2240 card
->pci_mmap
, card
->pci_mmap1
);
2242 card
->cmdrsp_buf
= NULL
;
2243 ret
= mwifiex_pcie_create_txbd_ring(adapter
);
2246 ret
= mwifiex_pcie_create_rxbd_ring(adapter
);
2249 ret
= mwifiex_pcie_create_evtbd_ring(adapter
);
2252 ret
= mwifiex_pcie_alloc_cmdrsp_buf(adapter
);
2254 goto err_alloc_cmdbuf
;
2255 if (reg
->sleep_cookie
) {
2256 ret
= mwifiex_pcie_alloc_sleep_cookie_buf(adapter
);
2258 goto err_alloc_cookie
;
2260 card
->sleep_cookie_vbase
= NULL
;
2265 mwifiex_pcie_delete_cmdrsp_buf(adapter
);
2267 mwifiex_pcie_delete_evtbd_ring(adapter
);
2269 mwifiex_pcie_delete_rxbd_ring(adapter
);
2271 mwifiex_pcie_delete_txbd_ring(adapter
);
2273 pci_iounmap(pdev
, card
->pci_mmap1
);
2275 pci_release_region(pdev
, 2);
2277 pci_iounmap(pdev
, card
->pci_mmap
);
2279 pci_release_region(pdev
, 0);
2282 pci_disable_device(pdev
);
2284 pci_set_drvdata(pdev
, NULL
);
2289 * This function cleans up the allocated card buffers.
2291 * The following are freed by this function -
2292 * - TXBD ring buffers
2293 * - RXBD ring buffers
2294 * - Event BD ring buffers
2295 * - Command response ring buffer
2296 * - Sleep cookie buffer
2298 static void mwifiex_pcie_cleanup(struct mwifiex_adapter
*adapter
)
2300 struct pcie_service_card
*card
= adapter
->card
;
2301 struct pci_dev
*pdev
= card
->dev
;
2302 const struct mwifiex_pcie_card_reg
*reg
= card
->pcie
.reg
;
2305 dev_dbg(adapter
->dev
, "Clearing driver ready signature\n");
2306 if (mwifiex_write_reg(adapter
, reg
->drv_rdy
, 0x00000000))
2307 dev_err(adapter
->dev
,
2308 "Failed to write driver not-ready signature\n");
2312 pci_iounmap(pdev
, card
->pci_mmap
);
2313 pci_iounmap(pdev
, card
->pci_mmap1
);
2314 pci_disable_device(pdev
);
2315 pci_release_region(pdev
, 2);
2316 pci_release_region(pdev
, 0);
2317 pci_set_drvdata(pdev
, NULL
);
2323 * This function registers the PCIE device.
2325 * PCIE IRQ is claimed, block size is set and driver data is initialized.
2327 static int mwifiex_register_dev(struct mwifiex_adapter
*adapter
)
2330 struct pcie_service_card
*card
= adapter
->card
;
2331 struct pci_dev
*pdev
= card
->dev
;
2333 /* save adapter pointer in card */
2334 card
->adapter
= adapter
;
2336 ret
= request_irq(pdev
->irq
, mwifiex_pcie_interrupt
, IRQF_SHARED
,
2339 pr_err("request_irq failed: ret=%d\n", ret
);
2340 adapter
->card
= NULL
;
2344 adapter
->dev
= &pdev
->dev
;
2345 adapter
->tx_buf_size
= card
->pcie
.tx_buf_size
;
2346 strcpy(adapter
->fw_name
, card
->pcie
.firmware
);
2352 * This function unregisters the PCIE device.
2354 * The PCIE IRQ is released, the function is disabled and driver
2355 * data is set to null.
2357 static void mwifiex_unregister_dev(struct mwifiex_adapter
*adapter
)
2359 struct pcie_service_card
*card
= adapter
->card
;
2360 const struct mwifiex_pcie_card_reg
*reg
;
2363 dev_dbg(adapter
->dev
, "%s(): calling free_irq()\n", __func__
);
2364 free_irq(card
->dev
->irq
, card
->dev
);
2366 reg
= card
->pcie
.reg
;
2367 if (reg
->sleep_cookie
)
2368 mwifiex_pcie_delete_sleep_cookie_buf(adapter
);
2370 mwifiex_pcie_delete_cmdrsp_buf(adapter
);
2371 mwifiex_pcie_delete_evtbd_ring(adapter
);
2372 mwifiex_pcie_delete_rxbd_ring(adapter
);
2373 mwifiex_pcie_delete_txbd_ring(adapter
);
2374 card
->cmdrsp_buf
= NULL
;
2378 static struct mwifiex_if_ops pcie_ops
= {
2379 .init_if
= mwifiex_pcie_init
,
2380 .cleanup_if
= mwifiex_pcie_cleanup
,
2381 .check_fw_status
= mwifiex_check_fw_status
,
2382 .prog_fw
= mwifiex_prog_fw_w_helper
,
2383 .register_dev
= mwifiex_register_dev
,
2384 .unregister_dev
= mwifiex_unregister_dev
,
2385 .enable_int
= mwifiex_pcie_enable_host_int
,
2386 .process_int_status
= mwifiex_process_int_status
,
2387 .host_to_card
= mwifiex_pcie_host_to_card
,
2388 .wakeup
= mwifiex_pm_wakeup_card
,
2389 .wakeup_complete
= mwifiex_pm_wakeup_card_complete
,
2392 .cmdrsp_complete
= mwifiex_pcie_cmdrsp_complete
,
2393 .event_complete
= mwifiex_pcie_event_complete
,
2394 .update_mp_end_port
= NULL
,
2395 .cleanup_mpa_buf
= NULL
,
2396 .init_fw_port
= mwifiex_pcie_init_fw_port
,
2397 .clean_pcie_ring
= mwifiex_clean_pcie_ring_buf
,
2401 * This function initializes the PCIE driver module.
2403 * This initiates the semaphore and registers the device with
2406 static int mwifiex_pcie_init_module(void)
2410 pr_debug("Marvell PCIe Driver\n");
2412 sema_init(&add_remove_card_sem
, 1);
2414 /* Clear the flag in case user removes the card. */
2417 ret
= pci_register_driver(&mwifiex_pcie
);
2419 pr_err("Driver register failed!\n");
2421 pr_debug("info: Driver registered successfully!\n");
2427 * This function cleans up the PCIE driver.
2429 * The following major steps are followed for cleanup -
2430 * - Resume the device if its suspended
2431 * - Disconnect the device if connected
2432 * - Shutdown the firmware
2433 * - Unregister the device from PCIE bus.
2435 static void mwifiex_pcie_cleanup_module(void)
2437 if (!down_interruptible(&add_remove_card_sem
))
2438 up(&add_remove_card_sem
);
2440 /* Set the flag as user is removing this module. */
2443 pci_unregister_driver(&mwifiex_pcie
);
2446 module_init(mwifiex_pcie_init_module
);
2447 module_exit(mwifiex_pcie_cleanup_module
);
2449 MODULE_AUTHOR("Marvell International Ltd.");
2450 MODULE_DESCRIPTION("Marvell WiFi-Ex PCI-Express Driver version " PCIE_VERSION
);
2451 MODULE_VERSION(PCIE_VERSION
);
2452 MODULE_LICENSE("GPL v2");
2453 MODULE_FIRMWARE(PCIE8766_DEFAULT_FW_NAME
);
2454 MODULE_FIRMWARE(PCIE8897_DEFAULT_FW_NAME
);