2 * Marvell Wireless LAN device driver: PCIE specific handling
4 * Copyright (C) 2011, Marvell International Ltd.
6 * This software file (the "File") is distributed by Marvell International
7 * Ltd. under the terms of the GNU General Public License Version 2, June 1991
8 * (the "License"). You may use, redistribute and/or modify this File in
9 * accordance with the terms and conditions of the License, a copy of which
10 * is available by writing to the Free Software Foundation, Inc.,
11 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
12 * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
14 * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
16 * ARE EXPRESSLY DISCLAIMED. The License provides additional details about
17 * this warranty disclaimer.
20 #include <linux/firmware.h>
31 #define PCIE_VERSION "1.0"
32 #define DRV_NAME "Marvell mwifiex PCIe"
36 static struct mwifiex_if_ops pcie_ops
;
38 static struct semaphore add_remove_card_sem
;
39 static int mwifiex_pcie_enable_host_int(struct mwifiex_adapter
*adapter
);
40 static int mwifiex_pcie_resume(struct pci_dev
*pdev
);
43 * This function is called after skb allocation to update
44 * "skb->cb" with physical address of data pointer.
46 static phys_addr_t
*mwifiex_update_sk_buff_pa(struct sk_buff
*skb
)
48 phys_addr_t
*buf_pa
= MWIFIEX_SKB_PACB(skb
);
50 *buf_pa
= (phys_addr_t
)virt_to_phys(skb
->data
);
56 * This function reads sleep cookie and checks if FW is ready
58 static bool mwifiex_pcie_ok_to_access_hw(struct mwifiex_adapter
*adapter
)
61 struct pcie_service_card
*card
= adapter
->card
;
63 if (card
->sleep_cookie
) {
64 cookie_addr
= (u32
*)card
->sleep_cookie
->data
;
65 dev_dbg(adapter
->dev
, "info: ACCESS_HW: sleep cookie=0x%x\n",
67 if (*cookie_addr
== FW_AWAKE_COOKIE
)
75 * This function probes an mwifiex device and registers it. It allocates
76 * the card structure, enables PCIE function number and initiates the
77 * device registration and initialization procedure by adding a logical
80 static int mwifiex_pcie_probe(struct pci_dev
*pdev
,
81 const struct pci_device_id
*ent
)
83 struct pcie_service_card
*card
;
85 pr_debug("info: vendor=0x%4.04X device=0x%4.04X rev=%d\n",
86 pdev
->vendor
, pdev
->device
, pdev
->revision
);
88 card
= kzalloc(sizeof(struct pcie_service_card
), GFP_KERNEL
);
94 if (mwifiex_add_card(card
, &add_remove_card_sem
, &pcie_ops
,
96 pr_err("%s failed\n", __func__
);
105 * This function removes the interface and frees up the card structure.
107 static void mwifiex_pcie_remove(struct pci_dev
*pdev
)
109 struct pcie_service_card
*card
;
110 struct mwifiex_adapter
*adapter
;
111 struct mwifiex_private
*priv
;
114 card
= pci_get_drvdata(pdev
);
118 adapter
= card
->adapter
;
119 if (!adapter
|| !adapter
->priv_num
)
124 if (adapter
->is_suspended
)
125 mwifiex_pcie_resume(pdev
);
128 for (i
= 0; i
< adapter
->priv_num
; i
++)
129 if ((GET_BSS_ROLE(adapter
->priv
[i
]) ==
130 MWIFIEX_BSS_ROLE_STA
) &&
131 adapter
->priv
[i
]->media_connected
)
132 mwifiex_deauthenticate(adapter
->priv
[i
], NULL
);
134 priv
= mwifiex_get_priv(adapter
, MWIFIEX_BSS_ROLE_ANY
);
136 mwifiex_disable_auto_ds(priv
);
138 mwifiex_init_shutdown_fw(priv
, MWIFIEX_FUNC_SHUTDOWN
);
141 mwifiex_remove_card(card
->adapter
, &add_remove_card_sem
);
146 * Kernel needs to suspend all functions separately. Therefore all
147 * registered functions must have drivers with suspend and resume
148 * methods. Failing that the kernel simply removes the whole card.
150 * If already not suspended, this function allocates and sends a host
151 * sleep activate request to the firmware and turns off the traffic.
153 static int mwifiex_pcie_suspend(struct pci_dev
*pdev
, pm_message_t state
)
155 struct mwifiex_adapter
*adapter
;
156 struct pcie_service_card
*card
;
160 card
= (struct pcie_service_card
*) pci_get_drvdata(pdev
);
161 if (!card
|| card
->adapter
) {
162 pr_err("Card or adapter structure is not valid\n");
166 pr_err("PCIE device is not specified\n");
170 adapter
= card
->adapter
;
172 hs_actived
= mwifiex_enable_hs(adapter
);
174 /* Indicate device suspended */
175 adapter
->is_suspended
= true;
177 for (i
= 0; i
< adapter
->priv_num
; i
++)
178 netif_carrier_off(adapter
->priv
[i
]->netdev
);
184 * Kernel needs to suspend all functions separately. Therefore all
185 * registered functions must have drivers with suspend and resume
186 * methods. Failing that the kernel simply removes the whole card.
188 * If already not resumed, this function turns on the traffic and
189 * sends a host sleep cancel request to the firmware.
191 static int mwifiex_pcie_resume(struct pci_dev
*pdev
)
193 struct mwifiex_adapter
*adapter
;
194 struct pcie_service_card
*card
;
198 card
= (struct pcie_service_card
*) pci_get_drvdata(pdev
);
199 if (!card
|| !card
->adapter
) {
200 pr_err("Card or adapter structure is not valid\n");
204 pr_err("PCIE device is not specified\n");
208 adapter
= card
->adapter
;
210 if (!adapter
->is_suspended
) {
211 dev_warn(adapter
->dev
, "Device already resumed\n");
215 adapter
->is_suspended
= false;
217 for (i
= 0; i
< adapter
->priv_num
; i
++)
218 if (adapter
->priv
[i
]->media_connected
)
219 netif_carrier_on(adapter
->priv
[i
]->netdev
);
221 mwifiex_cancel_hs(mwifiex_get_priv(adapter
, MWIFIEX_BSS_ROLE_STA
),
227 #define PCIE_VENDOR_ID_MARVELL (0x11ab)
228 #define PCIE_DEVICE_ID_MARVELL_88W8766P (0x2b30)
230 static DEFINE_PCI_DEVICE_TABLE(mwifiex_ids
) = {
232 PCIE_VENDOR_ID_MARVELL
, PCIE_DEVICE_ID_MARVELL_88W8766P
,
233 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0,
238 MODULE_DEVICE_TABLE(pci
, mwifiex_ids
);
240 /* PCI Device Driver */
241 static struct pci_driver __refdata mwifiex_pcie
= {
242 .name
= "mwifiex_pcie",
243 .id_table
= mwifiex_ids
,
244 .probe
= mwifiex_pcie_probe
,
245 .remove
= mwifiex_pcie_remove
,
247 /* Power Management Hooks */
248 .suspend
= mwifiex_pcie_suspend
,
249 .resume
= mwifiex_pcie_resume
,
254 * This function writes data into PCIE card register.
256 static int mwifiex_write_reg(struct mwifiex_adapter
*adapter
, int reg
, u32 data
)
258 struct pcie_service_card
*card
= adapter
->card
;
260 iowrite32(data
, card
->pci_mmap1
+ reg
);
266 * This function reads data from PCIE card register.
268 static int mwifiex_read_reg(struct mwifiex_adapter
*adapter
, int reg
, u32
*data
)
270 struct pcie_service_card
*card
= adapter
->card
;
272 *data
= ioread32(card
->pci_mmap1
+ reg
);
278 * This function wakes up the card.
280 * A host power up command is written to the card configuration
281 * register to wake up the card.
283 static int mwifiex_pm_wakeup_card(struct mwifiex_adapter
*adapter
)
287 while (mwifiex_pcie_ok_to_access_hw(adapter
)) {
289 usleep_range(10, 20);
295 dev_dbg(adapter
->dev
, "event: Wakeup device...\n");
297 /* Enable interrupts or any chip access will wakeup device */
298 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_MASK
, HOST_INTR_MASK
)) {
299 dev_warn(adapter
->dev
, "Enable host interrupt failed\n");
303 dev_dbg(adapter
->dev
, "PCIE wakeup: Setting PS_STATE_AWAKE\n");
304 adapter
->ps_state
= PS_STATE_AWAKE
;
310 * This function is called after the card has woken up.
312 * The card configuration register is reset.
314 static int mwifiex_pm_wakeup_card_complete(struct mwifiex_adapter
*adapter
)
316 dev_dbg(adapter
->dev
, "cmd: Wakeup device completed\n");
322 * This function disables the host interrupt.
324 * The host interrupt mask is read, the disable bit is reset and
325 * written back to the card host interrupt mask register.
327 static int mwifiex_pcie_disable_host_int(struct mwifiex_adapter
*adapter
)
329 if (mwifiex_pcie_ok_to_access_hw(adapter
)) {
330 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_MASK
,
332 dev_warn(adapter
->dev
, "Disable host interrupt failed\n");
341 * This function enables the host interrupt.
343 * The host interrupt enable mask is written to the card
344 * host interrupt mask register.
346 static int mwifiex_pcie_enable_host_int(struct mwifiex_adapter
*adapter
)
348 if (mwifiex_pcie_ok_to_access_hw(adapter
)) {
349 /* Simply write the mask to the register */
350 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_MASK
,
352 dev_warn(adapter
->dev
, "Enable host interrupt failed\n");
361 * This function creates buffer descriptor ring for TX
363 static int mwifiex_pcie_create_txbd_ring(struct mwifiex_adapter
*adapter
)
365 struct pcie_service_card
*card
= adapter
->card
;
371 * driver maintaines the write pointer and firmware maintaines the read
372 * pointer. The write pointer starts at 0 (zero) while the read pointer
373 * starts at zero with rollover bit set
375 card
->txbd_wrptr
= 0;
376 card
->txbd_rdptr
|= MWIFIEX_BD_FLAG_ROLLOVER_IND
;
378 /* allocate shared memory for the BD ring and divide the same in to
379 several descriptors */
380 card
->txbd_ring_size
= sizeof(struct mwifiex_pcie_buf_desc
) *
382 dev_dbg(adapter
->dev
, "info: txbd_ring: Allocating %d bytes\n",
383 card
->txbd_ring_size
);
384 card
->txbd_ring_vbase
= kzalloc(card
->txbd_ring_size
, GFP_KERNEL
);
385 if (!card
->txbd_ring_vbase
) {
386 dev_err(adapter
->dev
, "Unable to alloc buffer for txbd ring\n");
389 card
->txbd_ring_pbase
= virt_to_phys(card
->txbd_ring_vbase
);
391 dev_dbg(adapter
->dev
,
392 "info: txbd_ring - base: %p, pbase: %#x:%x, len: %x\n",
393 card
->txbd_ring_vbase
, (u32
)card
->txbd_ring_pbase
,
394 (u32
)((u64
)card
->txbd_ring_pbase
>> 32), card
->txbd_ring_size
);
396 for (i
= 0; i
< MWIFIEX_MAX_TXRX_BD
; i
++) {
397 card
->txbd_ring
[i
] = (struct mwifiex_pcie_buf_desc
*)
398 (card
->txbd_ring_vbase
+
399 (sizeof(struct mwifiex_pcie_buf_desc
)
402 /* Allocate buffer here so that firmware can DMA data from it */
403 skb
= dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE
);
405 dev_err(adapter
->dev
, "Unable to allocate skb for TX ring.\n");
406 kfree(card
->txbd_ring_vbase
);
409 buf_pa
= mwifiex_update_sk_buff_pa(skb
);
411 skb_put(skb
, MWIFIEX_RX_DATA_BUF_SIZE
);
412 dev_dbg(adapter
->dev
, "info: TX ring: add new skb base: %p, "
413 "buf_base: %p, buf_pbase: %#x:%x, buf_len: %#x\n",
414 skb
, skb
->data
, (u32
)*buf_pa
,
415 (u32
)(((u64
)*buf_pa
>> 32)), skb
->len
);
417 card
->tx_buf_list
[i
] = skb
;
418 card
->txbd_ring
[i
]->paddr
= *buf_pa
;
419 card
->txbd_ring
[i
]->len
= (u16
)skb
->len
;
420 card
->txbd_ring
[i
]->flags
= 0;
426 static int mwifiex_pcie_delete_txbd_ring(struct mwifiex_adapter
*adapter
)
428 struct pcie_service_card
*card
= adapter
->card
;
431 for (i
= 0; i
< MWIFIEX_MAX_TXRX_BD
; i
++) {
432 if (card
->tx_buf_list
[i
])
433 dev_kfree_skb_any(card
->tx_buf_list
[i
]);
434 card
->tx_buf_list
[i
] = NULL
;
435 card
->txbd_ring
[i
]->paddr
= 0;
436 card
->txbd_ring
[i
]->len
= 0;
437 card
->txbd_ring
[i
]->flags
= 0;
438 card
->txbd_ring
[i
] = NULL
;
441 kfree(card
->txbd_ring_vbase
);
442 card
->txbd_ring_size
= 0;
443 card
->txbd_wrptr
= 0;
444 card
->txbd_rdptr
= 0 | MWIFIEX_BD_FLAG_ROLLOVER_IND
;
445 card
->txbd_ring_vbase
= NULL
;
451 * This function creates buffer descriptor ring for RX
453 static int mwifiex_pcie_create_rxbd_ring(struct mwifiex_adapter
*adapter
)
455 struct pcie_service_card
*card
= adapter
->card
;
461 * driver maintaines the read pointer and firmware maintaines the write
462 * pointer. The write pointer starts at 0 (zero) while the read pointer
463 * starts at zero with rollover bit set
465 card
->rxbd_wrptr
= 0;
466 card
->rxbd_rdptr
|= MWIFIEX_BD_FLAG_ROLLOVER_IND
;
468 card
->rxbd_ring_size
= sizeof(struct mwifiex_pcie_buf_desc
) *
470 dev_dbg(adapter
->dev
, "info: rxbd_ring: Allocating %d bytes\n",
471 card
->rxbd_ring_size
);
472 card
->rxbd_ring_vbase
= kzalloc(card
->rxbd_ring_size
, GFP_KERNEL
);
473 if (!card
->rxbd_ring_vbase
) {
474 dev_err(adapter
->dev
, "Unable to allocate buffer for "
478 card
->rxbd_ring_pbase
= virt_to_phys(card
->rxbd_ring_vbase
);
480 dev_dbg(adapter
->dev
,
481 "info: rxbd_ring - base: %p, pbase: %#x:%x, len: %#x\n",
482 card
->rxbd_ring_vbase
, (u32
)card
->rxbd_ring_pbase
,
483 (u32
)((u64
)card
->rxbd_ring_pbase
>> 32),
484 card
->rxbd_ring_size
);
486 for (i
= 0; i
< MWIFIEX_MAX_TXRX_BD
; i
++) {
487 card
->rxbd_ring
[i
] = (struct mwifiex_pcie_buf_desc
*)
488 (card
->rxbd_ring_vbase
+
489 (sizeof(struct mwifiex_pcie_buf_desc
)
492 /* Allocate skb here so that firmware can DMA data from it */
493 skb
= dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE
);
495 dev_err(adapter
->dev
,
496 "Unable to allocate skb for RX ring.\n");
497 kfree(card
->rxbd_ring_vbase
);
500 buf_pa
= mwifiex_update_sk_buff_pa(skb
);
501 skb_put(skb
, MWIFIEX_RX_DATA_BUF_SIZE
);
503 dev_dbg(adapter
->dev
, "info: RX ring: add new skb base: %p, "
504 "buf_base: %p, buf_pbase: %#x:%x, buf_len: %#x\n",
505 skb
, skb
->data
, (u32
)*buf_pa
, (u32
)((u64
)*buf_pa
>> 32),
508 card
->rx_buf_list
[i
] = skb
;
509 card
->rxbd_ring
[i
]->paddr
= *buf_pa
;
510 card
->rxbd_ring
[i
]->len
= (u16
)skb
->len
;
511 card
->rxbd_ring
[i
]->flags
= 0;
518 * This function deletes Buffer descriptor ring for RX
520 static int mwifiex_pcie_delete_rxbd_ring(struct mwifiex_adapter
*adapter
)
522 struct pcie_service_card
*card
= adapter
->card
;
525 for (i
= 0; i
< MWIFIEX_MAX_TXRX_BD
; i
++) {
526 if (card
->rx_buf_list
[i
])
527 dev_kfree_skb_any(card
->rx_buf_list
[i
]);
528 card
->rx_buf_list
[i
] = NULL
;
529 card
->rxbd_ring
[i
]->paddr
= 0;
530 card
->rxbd_ring
[i
]->len
= 0;
531 card
->rxbd_ring
[i
]->flags
= 0;
532 card
->rxbd_ring
[i
] = NULL
;
535 kfree(card
->rxbd_ring_vbase
);
536 card
->rxbd_ring_size
= 0;
537 card
->rxbd_wrptr
= 0;
538 card
->rxbd_rdptr
= 0 | MWIFIEX_BD_FLAG_ROLLOVER_IND
;
539 card
->rxbd_ring_vbase
= NULL
;
545 * This function creates buffer descriptor ring for Events
547 static int mwifiex_pcie_create_evtbd_ring(struct mwifiex_adapter
*adapter
)
549 struct pcie_service_card
*card
= adapter
->card
;
555 * driver maintaines the read pointer and firmware maintaines the write
556 * pointer. The write pointer starts at 0 (zero) while the read pointer
557 * starts at zero with rollover bit set
559 card
->evtbd_wrptr
= 0;
560 card
->evtbd_rdptr
|= MWIFIEX_BD_FLAG_ROLLOVER_IND
;
562 card
->evtbd_ring_size
= sizeof(struct mwifiex_pcie_buf_desc
) *
564 dev_dbg(adapter
->dev
, "info: evtbd_ring: Allocating %d bytes\n",
565 card
->evtbd_ring_size
);
566 card
->evtbd_ring_vbase
= kzalloc(card
->evtbd_ring_size
, GFP_KERNEL
);
567 if (!card
->evtbd_ring_vbase
) {
568 dev_err(adapter
->dev
,
569 "Unable to allocate buffer. Terminating download\n");
572 card
->evtbd_ring_pbase
= virt_to_phys(card
->evtbd_ring_vbase
);
574 dev_dbg(adapter
->dev
,
575 "info: CMDRSP/EVT bd_ring - base: %p pbase: %#x:%x len: %#x\n",
576 card
->evtbd_ring_vbase
, (u32
)card
->evtbd_ring_pbase
,
577 (u32
)((u64
)card
->evtbd_ring_pbase
>> 32),
578 card
->evtbd_ring_size
);
580 for (i
= 0; i
< MWIFIEX_MAX_EVT_BD
; i
++) {
581 card
->evtbd_ring
[i
] = (struct mwifiex_pcie_buf_desc
*)
582 (card
->evtbd_ring_vbase
+
583 (sizeof(struct mwifiex_pcie_buf_desc
)
586 /* Allocate skb here so that firmware can DMA data from it */
587 skb
= dev_alloc_skb(MAX_EVENT_SIZE
);
589 dev_err(adapter
->dev
,
590 "Unable to allocate skb for EVENT buf.\n");
591 kfree(card
->evtbd_ring_vbase
);
594 buf_pa
= mwifiex_update_sk_buff_pa(skb
);
595 skb_put(skb
, MAX_EVENT_SIZE
);
597 dev_dbg(adapter
->dev
, "info: Evt ring: add new skb. base: %p, "
598 "buf_base: %p, buf_pbase: %#x:%x, buf_len: %#x\n",
599 skb
, skb
->data
, (u32
)*buf_pa
, (u32
)((u64
)*buf_pa
>> 32),
602 card
->evt_buf_list
[i
] = skb
;
603 card
->evtbd_ring
[i
]->paddr
= *buf_pa
;
604 card
->evtbd_ring
[i
]->len
= (u16
)skb
->len
;
605 card
->evtbd_ring
[i
]->flags
= 0;
612 * This function deletes Buffer descriptor ring for Events
614 static int mwifiex_pcie_delete_evtbd_ring(struct mwifiex_adapter
*adapter
)
616 struct pcie_service_card
*card
= adapter
->card
;
619 for (i
= 0; i
< MWIFIEX_MAX_EVT_BD
; i
++) {
620 if (card
->evt_buf_list
[i
])
621 dev_kfree_skb_any(card
->evt_buf_list
[i
]);
622 card
->evt_buf_list
[i
] = NULL
;
623 card
->evtbd_ring
[i
]->paddr
= 0;
624 card
->evtbd_ring
[i
]->len
= 0;
625 card
->evtbd_ring
[i
]->flags
= 0;
626 card
->evtbd_ring
[i
] = NULL
;
629 kfree(card
->evtbd_ring_vbase
);
630 card
->evtbd_wrptr
= 0;
631 card
->evtbd_rdptr
= 0 | MWIFIEX_BD_FLAG_ROLLOVER_IND
;
632 card
->evtbd_ring_size
= 0;
633 card
->evtbd_ring_vbase
= NULL
;
639 * This function allocates a buffer for CMDRSP
641 static int mwifiex_pcie_alloc_cmdrsp_buf(struct mwifiex_adapter
*adapter
)
643 struct pcie_service_card
*card
= adapter
->card
;
646 /* Allocate memory for receiving command response data */
647 skb
= dev_alloc_skb(MWIFIEX_UPLD_SIZE
);
649 dev_err(adapter
->dev
,
650 "Unable to allocate skb for command response data.\n");
653 mwifiex_update_sk_buff_pa(skb
);
654 skb_put(skb
, MWIFIEX_UPLD_SIZE
);
655 card
->cmdrsp_buf
= skb
;
658 /* Allocate memory for sending command to firmware */
659 skb
= dev_alloc_skb(MWIFIEX_SIZE_OF_CMD_BUFFER
);
661 dev_err(adapter
->dev
,
662 "Unable to allocate skb for command data.\n");
665 mwifiex_update_sk_buff_pa(skb
);
666 skb_put(skb
, MWIFIEX_SIZE_OF_CMD_BUFFER
);
673 * This function deletes a buffer for CMDRSP
675 static int mwifiex_pcie_delete_cmdrsp_buf(struct mwifiex_adapter
*adapter
)
677 struct pcie_service_card
*card
;
682 card
= adapter
->card
;
684 if (card
&& card
->cmdrsp_buf
)
685 dev_kfree_skb_any(card
->cmdrsp_buf
);
687 if (card
&& card
->cmd_buf
)
688 dev_kfree_skb_any(card
->cmd_buf
);
694 * This function allocates a buffer for sleep cookie
696 static int mwifiex_pcie_alloc_sleep_cookie_buf(struct mwifiex_adapter
*adapter
)
699 struct pcie_service_card
*card
= adapter
->card
;
701 /* Allocate memory for sleep cookie */
702 skb
= dev_alloc_skb(sizeof(u32
));
704 dev_err(adapter
->dev
,
705 "Unable to allocate skb for sleep cookie!\n");
708 mwifiex_update_sk_buff_pa(skb
);
709 skb_put(skb
, sizeof(u32
));
711 /* Init val of Sleep Cookie */
712 *(u32
*)skb
->data
= FW_AWAKE_COOKIE
;
714 dev_dbg(adapter
->dev
, "alloc_scook: sleep cookie=0x%x\n",
715 *((u32
*)skb
->data
));
717 /* Save the sleep cookie */
718 card
->sleep_cookie
= skb
;
724 * This function deletes buffer for sleep cookie
726 static int mwifiex_pcie_delete_sleep_cookie_buf(struct mwifiex_adapter
*adapter
)
728 struct pcie_service_card
*card
;
733 card
= adapter
->card
;
735 if (card
&& card
->sleep_cookie
) {
736 dev_kfree_skb_any(card
->sleep_cookie
);
737 card
->sleep_cookie
= NULL
;
744 * This function sends data buffer to device
747 mwifiex_pcie_send_data(struct mwifiex_adapter
*adapter
, struct sk_buff
*skb
)
749 struct pcie_service_card
*card
= adapter
->card
;
754 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
755 mwifiex_pm_wakeup_card(adapter
);
757 /* Read the TX ring read pointer set by firmware */
758 if (mwifiex_read_reg(adapter
, REG_TXBD_RDPTR
, &rdptr
)) {
759 dev_err(adapter
->dev
,
760 "SEND DATA: failed to read REG_TXBD_RDPTR\n");
764 wrindx
= card
->txbd_wrptr
& MWIFIEX_TXBD_MASK
;
766 dev_dbg(adapter
->dev
, "info: SEND DATA: <Rd: %#x, Wr: %#x>\n", rdptr
,
768 if (((card
->txbd_wrptr
& MWIFIEX_TXBD_MASK
) !=
769 (rdptr
& MWIFIEX_TXBD_MASK
)) ||
770 ((card
->txbd_wrptr
& MWIFIEX_BD_FLAG_ROLLOVER_IND
) !=
771 (rdptr
& MWIFIEX_BD_FLAG_ROLLOVER_IND
))) {
772 struct sk_buff
*skb_data
;
775 adapter
->data_sent
= true;
776 skb_data
= card
->tx_buf_list
[wrindx
];
777 memcpy(skb_data
->data
, skb
->data
, skb
->len
);
778 payload
= skb_data
->data
;
779 tmp
= (__le16
*)&payload
[0];
780 *tmp
= cpu_to_le16((u16
)skb
->len
);
781 tmp
= (__le16
*)&payload
[2];
782 *tmp
= cpu_to_le16(MWIFIEX_TYPE_DATA
);
783 skb_put(skb_data
, MWIFIEX_RX_DATA_BUF_SIZE
- skb_data
->len
);
784 skb_trim(skb_data
, skb
->len
);
785 buf_pa
= MWIFIEX_SKB_PACB(skb_data
);
786 card
->txbd_ring
[wrindx
]->paddr
= *buf_pa
;
787 card
->txbd_ring
[wrindx
]->len
= (u16
)skb_data
->len
;
788 card
->txbd_ring
[wrindx
]->flags
= MWIFIEX_BD_FLAG_FIRST_DESC
|
789 MWIFIEX_BD_FLAG_LAST_DESC
;
791 if ((++card
->txbd_wrptr
& MWIFIEX_TXBD_MASK
) ==
793 card
->txbd_wrptr
= ((card
->txbd_wrptr
&
794 MWIFIEX_BD_FLAG_ROLLOVER_IND
) ^
795 MWIFIEX_BD_FLAG_ROLLOVER_IND
);
797 /* Write the TX ring write pointer in to REG_TXBD_WRPTR */
798 if (mwifiex_write_reg(adapter
, REG_TXBD_WRPTR
,
800 dev_err(adapter
->dev
,
801 "SEND DATA: failed to write REG_TXBD_WRPTR\n");
805 /* Send the TX ready interrupt */
806 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
807 CPU_INTR_DNLD_RDY
)) {
808 dev_err(adapter
->dev
,
809 "SEND DATA: failed to assert door-bell intr\n");
812 dev_dbg(adapter
->dev
, "info: SEND DATA: Updated <Rd: %#x, Wr: "
813 "%#x> and sent packet to firmware successfully\n",
814 rdptr
, card
->txbd_wrptr
);
816 dev_dbg(adapter
->dev
,
817 "info: TX Ring full, can't send packets to fw\n");
818 adapter
->data_sent
= true;
819 /* Send the TX ready interrupt */
820 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
822 dev_err(adapter
->dev
,
823 "SEND DATA: failed to assert door-bell intr\n");
831 * This function handles received buffer ring and
832 * dispatches packets to upper
834 static int mwifiex_pcie_process_recv_data(struct mwifiex_adapter
*adapter
)
836 struct pcie_service_card
*card
= adapter
->card
;
839 struct sk_buff
*skb_tmp
= NULL
;
841 /* Read the RX ring Write pointer set by firmware */
842 if (mwifiex_read_reg(adapter
, REG_RXBD_WRPTR
, &wrptr
)) {
843 dev_err(adapter
->dev
,
844 "RECV DATA: failed to read REG_TXBD_RDPTR\n");
849 while (((wrptr
& MWIFIEX_RXBD_MASK
) !=
850 (card
->rxbd_rdptr
& MWIFIEX_RXBD_MASK
)) ||
851 ((wrptr
& MWIFIEX_BD_FLAG_ROLLOVER_IND
) ==
852 (card
->rxbd_rdptr
& MWIFIEX_BD_FLAG_ROLLOVER_IND
))) {
853 struct sk_buff
*skb_data
;
856 rd_index
= card
->rxbd_rdptr
& MWIFIEX_RXBD_MASK
;
857 skb_data
= card
->rx_buf_list
[rd_index
];
859 /* Get data length from interface header -
860 first byte is len, second byte is type */
861 rx_len
= *((u16
*)skb_data
->data
);
862 dev_dbg(adapter
->dev
,
863 "info: RECV DATA: Rd=%#x, Wr=%#x, Len=%d\n",
864 card
->rxbd_rdptr
, wrptr
, rx_len
);
865 skb_tmp
= dev_alloc_skb(rx_len
);
867 dev_dbg(adapter
->dev
,
868 "info: Failed to alloc skb for RX\n");
873 skb_put(skb_tmp
, rx_len
);
875 memcpy(skb_tmp
->data
, skb_data
->data
+ INTF_HEADER_LEN
, rx_len
);
876 if ((++card
->rxbd_rdptr
& MWIFIEX_RXBD_MASK
) ==
877 MWIFIEX_MAX_TXRX_BD
) {
878 card
->rxbd_rdptr
= ((card
->rxbd_rdptr
&
879 MWIFIEX_BD_FLAG_ROLLOVER_IND
) ^
880 MWIFIEX_BD_FLAG_ROLLOVER_IND
);
882 dev_dbg(adapter
->dev
, "info: RECV DATA: <Rd: %#x, Wr: %#x>\n",
883 card
->rxbd_rdptr
, wrptr
);
885 /* Write the RX ring read pointer in to REG_RXBD_RDPTR */
886 if (mwifiex_write_reg(adapter
, REG_RXBD_RDPTR
,
888 dev_err(adapter
->dev
,
889 "RECV DATA: failed to write REG_RXBD_RDPTR\n");
894 /* Read the RX ring Write pointer set by firmware */
895 if (mwifiex_read_reg(adapter
, REG_RXBD_WRPTR
, &wrptr
)) {
896 dev_err(adapter
->dev
,
897 "RECV DATA: failed to read REG_TXBD_RDPTR\n");
901 dev_dbg(adapter
->dev
,
902 "info: RECV DATA: Rcvd packet from fw successfully\n");
903 mwifiex_handle_rx_packet(adapter
, skb_tmp
);
908 dev_kfree_skb_any(skb_tmp
);
913 * This function downloads the boot command to device
916 mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter
*adapter
, struct sk_buff
*skb
)
918 phys_addr_t
*buf_pa
= MWIFIEX_SKB_PACB(skb
);
920 if (!(skb
->data
&& skb
->len
&& *buf_pa
)) {
921 dev_err(adapter
->dev
,
922 "Invalid parameter in %s <%p, %#x:%x, %x>\n",
923 __func__
, skb
->data
, skb
->len
,
924 (u32
)*buf_pa
, (u32
)((u64
)*buf_pa
>> 32));
928 /* Write the lower 32bits of the physical address to scratch
930 if (mwifiex_write_reg(adapter
, PCIE_SCRATCH_0_REG
, (u32
)*buf_pa
)) {
931 dev_err(adapter
->dev
,
932 "%s: failed to write download command to boot code.\n",
937 /* Write the upper 32bits of the physical address to scratch
939 if (mwifiex_write_reg(adapter
, PCIE_SCRATCH_1_REG
,
940 (u32
)((u64
)*buf_pa
>> 32))) {
941 dev_err(adapter
->dev
,
942 "%s: failed to write download command to boot code.\n",
947 /* Write the command length to scratch register 2 */
948 if (mwifiex_write_reg(adapter
, PCIE_SCRATCH_2_REG
, skb
->len
)) {
949 dev_err(adapter
->dev
,
950 "%s: failed to write command len to scratch reg 2\n",
955 /* Ring the door bell */
956 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
957 CPU_INTR_DOOR_BELL
)) {
958 dev_err(adapter
->dev
,
959 "%s: failed to assert door-bell intr\n", __func__
);
967 * This function downloads commands to the device
970 mwifiex_pcie_send_cmd(struct mwifiex_adapter
*adapter
, struct sk_buff
*skb
)
972 struct pcie_service_card
*card
= adapter
->card
;
974 phys_addr_t
*cmd_buf_pa
;
975 phys_addr_t
*cmdrsp_buf_pa
;
977 if (!(skb
->data
&& skb
->len
)) {
978 dev_err(adapter
->dev
, "Invalid parameter in %s <%p, %#x>\n",
979 __func__
, skb
->data
, skb
->len
);
983 /* Make sure a command response buffer is available */
984 if (!card
->cmdrsp_buf
) {
985 dev_err(adapter
->dev
,
986 "No response buffer available, send command failed\n");
990 /* Make sure a command buffer is available */
991 if (!card
->cmd_buf
) {
992 dev_err(adapter
->dev
, "Command buffer not available\n");
996 adapter
->cmd_sent
= true;
997 /* Copy the given skb in to DMA accessable shared buffer */
998 skb_put(card
->cmd_buf
, MWIFIEX_SIZE_OF_CMD_BUFFER
- card
->cmd_buf
->len
);
999 skb_trim(card
->cmd_buf
, skb
->len
);
1000 memcpy(card
->cmd_buf
->data
, skb
->data
, skb
->len
);
1002 /* To send a command, the driver will:
1003 1. Write the 64bit physical address of the data buffer to
1005 2. Ring the door bell (i.e. set the door bell interrupt)
1007 In response to door bell interrupt, the firmware will perform
1008 the DMA of the command packet (first header to obtain the total
1009 length and then rest of the command).
1012 if (card
->cmdrsp_buf
) {
1013 cmdrsp_buf_pa
= MWIFIEX_SKB_PACB(card
->cmdrsp_buf
);
1014 /* Write the lower 32bits of the cmdrsp buffer physical
1016 if (mwifiex_write_reg(adapter
, REG_CMDRSP_ADDR_LO
,
1017 (u32
)*cmdrsp_buf_pa
)) {
1018 dev_err(adapter
->dev
,
1019 "Failed to write download cmd to boot code.\n");
1023 /* Write the upper 32bits of the cmdrsp buffer physical
1025 if (mwifiex_write_reg(adapter
, REG_CMDRSP_ADDR_HI
,
1026 (u32
)((u64
)*cmdrsp_buf_pa
>> 32))) {
1027 dev_err(adapter
->dev
,
1028 "Failed to write download cmd to boot code.\n");
1034 cmd_buf_pa
= MWIFIEX_SKB_PACB(card
->cmd_buf
);
1035 /* Write the lower 32bits of the physical address to REG_CMD_ADDR_LO */
1036 if (mwifiex_write_reg(adapter
, REG_CMD_ADDR_LO
, (u32
)*cmd_buf_pa
)) {
1037 dev_err(adapter
->dev
,
1038 "Failed to write download cmd to boot code.\n");
1042 /* Write the upper 32bits of the physical address to REG_CMD_ADDR_HI */
1043 if (mwifiex_write_reg(adapter
, REG_CMD_ADDR_HI
,
1044 (u32
)((u64
)*cmd_buf_pa
>> 32))) {
1045 dev_err(adapter
->dev
,
1046 "Failed to write download cmd to boot code.\n");
1051 /* Write the command length to REG_CMD_SIZE */
1052 if (mwifiex_write_reg(adapter
, REG_CMD_SIZE
, card
->cmd_buf
->len
)) {
1053 dev_err(adapter
->dev
,
1054 "Failed to write cmd len to REG_CMD_SIZE\n");
1059 /* Ring the door bell */
1060 if (mwifiex_write_reg(adapter
, PCIE_CPU_INT_EVENT
,
1061 CPU_INTR_DOOR_BELL
)) {
1062 dev_err(adapter
->dev
,
1063 "Failed to assert door-bell intr\n");
1070 adapter
->cmd_sent
= false;
1076 * This function handles command complete interrupt
1078 static int mwifiex_pcie_process_cmd_complete(struct mwifiex_adapter
*adapter
)
1080 struct pcie_service_card
*card
= adapter
->card
;
1081 struct sk_buff
*skb
= card
->cmdrsp_buf
;
1084 dev_dbg(adapter
->dev
, "info: Rx CMD Response\n");
1086 if (!adapter
->curr_cmd
) {
1087 skb_pull(skb
, INTF_HEADER_LEN
);
1088 if (adapter
->ps_state
== PS_STATE_SLEEP_CFM
) {
1089 mwifiex_process_sleep_confirm_resp(adapter
, skb
->data
,
1091 while (mwifiex_pcie_ok_to_access_hw(adapter
) &&
1093 usleep_range(50, 60);
1095 dev_err(adapter
->dev
,
1096 "There is no command but got cmdrsp\n");
1098 memcpy(adapter
->upld_buf
, skb
->data
,
1099 min_t(u32
, MWIFIEX_SIZE_OF_CMD_BUFFER
, skb
->len
));
1100 skb_push(skb
, INTF_HEADER_LEN
);
1101 } else if (mwifiex_pcie_ok_to_access_hw(adapter
)) {
1102 skb_pull(skb
, INTF_HEADER_LEN
);
1103 adapter
->curr_cmd
->resp_skb
= skb
;
1104 adapter
->cmd_resp_received
= true;
1105 /* Take the pointer and set it to CMD node and will
1106 return in the response complete callback */
1107 card
->cmdrsp_buf
= NULL
;
1109 /* Clear the cmd-rsp buffer address in scratch registers. This
1110 will prevent firmware from writing to the same response
1112 if (mwifiex_write_reg(adapter
, REG_CMDRSP_ADDR_LO
, 0)) {
1113 dev_err(adapter
->dev
,
1114 "cmd_done: failed to clear cmd_rsp_addr_lo\n");
1117 /* Write the upper 32bits of the cmdrsp buffer physical
1119 if (mwifiex_write_reg(adapter
, REG_CMDRSP_ADDR_HI
, 0)) {
1120 dev_err(adapter
->dev
,
1121 "cmd_done: failed to clear cmd_rsp_addr_hi\n");
1130 * Command Response processing complete handler
1132 static int mwifiex_pcie_cmdrsp_complete(struct mwifiex_adapter
*adapter
,
1133 struct sk_buff
*skb
)
1135 struct pcie_service_card
*card
= adapter
->card
;
1138 card
->cmdrsp_buf
= skb
;
1139 skb_push(card
->cmdrsp_buf
, INTF_HEADER_LEN
);
1146 * This function handles firmware event ready interrupt
1148 static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter
*adapter
)
1150 struct pcie_service_card
*card
= adapter
->card
;
1151 u32 rdptr
= card
->evtbd_rdptr
& MWIFIEX_EVTBD_MASK
;
1154 if (adapter
->event_received
) {
1155 dev_dbg(adapter
->dev
, "info: Event being processed, "
1156 "do not process this interrupt just yet\n");
1160 if (rdptr
>= MWIFIEX_MAX_EVT_BD
) {
1161 dev_dbg(adapter
->dev
, "info: Invalid read pointer...\n");
1165 /* Read the event ring write pointer set by firmware */
1166 if (mwifiex_read_reg(adapter
, REG_EVTBD_WRPTR
, &wrptr
)) {
1167 dev_err(adapter
->dev
,
1168 "EventReady: failed to read REG_EVTBD_WRPTR\n");
1172 dev_dbg(adapter
->dev
, "info: EventReady: Initial <Rd: 0x%x, Wr: 0x%x>",
1173 card
->evtbd_rdptr
, wrptr
);
1174 if (((wrptr
& MWIFIEX_EVTBD_MASK
) != (card
->evtbd_rdptr
1175 & MWIFIEX_EVTBD_MASK
)) ||
1176 ((wrptr
& MWIFIEX_BD_FLAG_ROLLOVER_IND
) ==
1177 (card
->evtbd_rdptr
& MWIFIEX_BD_FLAG_ROLLOVER_IND
))) {
1178 struct sk_buff
*skb_cmd
;
1179 __le16 data_len
= 0;
1182 dev_dbg(adapter
->dev
, "info: Read Index: %d\n", rdptr
);
1183 skb_cmd
= card
->evt_buf_list
[rdptr
];
1184 /* Take the pointer and set it to event pointer in adapter
1185 and will return back after event handling callback */
1186 card
->evt_buf_list
[rdptr
] = NULL
;
1187 card
->evtbd_ring
[rdptr
]->paddr
= 0;
1188 card
->evtbd_ring
[rdptr
]->len
= 0;
1189 card
->evtbd_ring
[rdptr
]->flags
= 0;
1191 event
= *(u32
*) &skb_cmd
->data
[INTF_HEADER_LEN
];
1192 adapter
->event_cause
= event
;
1193 /* The first 4bytes will be the event transfer header
1194 len is 2 bytes followed by type which is 2 bytes */
1195 memcpy(&data_len
, skb_cmd
->data
, sizeof(__le16
));
1196 evt_len
= le16_to_cpu(data_len
);
1198 skb_pull(skb_cmd
, INTF_HEADER_LEN
);
1199 dev_dbg(adapter
->dev
, "info: Event length: %d\n", evt_len
);
1201 if ((evt_len
> 0) && (evt_len
< MAX_EVENT_SIZE
))
1202 memcpy(adapter
->event_body
, skb_cmd
->data
+
1203 MWIFIEX_EVENT_HEADER_LEN
, evt_len
-
1204 MWIFIEX_EVENT_HEADER_LEN
);
1206 adapter
->event_received
= true;
1207 adapter
->event_skb
= skb_cmd
;
1209 /* Do not update the event read pointer here, wait till the
1210 buffer is released. This is just to make things simpler,
1211 we need to find a better method of managing these buffers.
1219 * Event processing complete handler
1221 static int mwifiex_pcie_event_complete(struct mwifiex_adapter
*adapter
,
1222 struct sk_buff
*skb
)
1224 struct pcie_service_card
*card
= adapter
->card
;
1226 u32 rdptr
= card
->evtbd_rdptr
& MWIFIEX_EVTBD_MASK
;
1228 phys_addr_t
*buf_pa
;
1233 if (rdptr
>= MWIFIEX_MAX_EVT_BD
) {
1234 dev_err(adapter
->dev
, "event_complete: Invalid rdptr 0x%x\n",
1239 /* Read the event ring write pointer set by firmware */
1240 if (mwifiex_read_reg(adapter
, REG_EVTBD_WRPTR
, &wrptr
)) {
1241 dev_err(adapter
->dev
,
1242 "event_complete: failed to read REG_EVTBD_WRPTR\n");
1246 if (!card
->evt_buf_list
[rdptr
]) {
1247 skb_push(skb
, INTF_HEADER_LEN
);
1248 card
->evt_buf_list
[rdptr
] = skb
;
1249 buf_pa
= MWIFIEX_SKB_PACB(skb
);
1250 card
->evtbd_ring
[rdptr
]->paddr
= *buf_pa
;
1251 card
->evtbd_ring
[rdptr
]->len
= (u16
)skb
->len
;
1252 card
->evtbd_ring
[rdptr
]->flags
= 0;
1255 dev_dbg(adapter
->dev
,
1256 "info: ERROR: buf still valid at index %d, <%p, %p>\n",
1257 rdptr
, card
->evt_buf_list
[rdptr
], skb
);
1260 if ((++card
->evtbd_rdptr
& MWIFIEX_EVTBD_MASK
) == MWIFIEX_MAX_EVT_BD
) {
1261 card
->evtbd_rdptr
= ((card
->evtbd_rdptr
&
1262 MWIFIEX_BD_FLAG_ROLLOVER_IND
) ^
1263 MWIFIEX_BD_FLAG_ROLLOVER_IND
);
1266 dev_dbg(adapter
->dev
, "info: Updated <Rd: 0x%x, Wr: 0x%x>",
1267 card
->evtbd_rdptr
, wrptr
);
1269 /* Write the event ring read pointer in to REG_EVTBD_RDPTR */
1270 if (mwifiex_write_reg(adapter
, REG_EVTBD_RDPTR
, card
->evtbd_rdptr
)) {
1271 dev_err(adapter
->dev
,
1272 "event_complete: failed to read REG_EVTBD_RDPTR\n");
1276 dev_dbg(adapter
->dev
, "info: Check Events Again\n");
1277 ret
= mwifiex_pcie_process_event_ready(adapter
);
1283 * This function downloads the firmware to the card.
1285 * Firmware is downloaded to the card in blocks. Every block download
1286 * is tested for CRC errors, and retried a number of times before
1287 * returning failure.
1289 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter
*adapter
,
1290 struct mwifiex_fw_image
*fw
)
1293 u8
*firmware
= fw
->fw_buf
;
1294 u32 firmware_len
= fw
->fw_len
;
1296 struct sk_buff
*skb
;
1297 u32 txlen
, tx_blocks
= 0, tries
, len
;
1298 u32 block_retry_cnt
= 0;
1301 pr_err("adapter structure is not valid\n");
1305 if (!firmware
|| !firmware_len
) {
1306 dev_err(adapter
->dev
,
1307 "No firmware image found! Terminating download\n");
1311 dev_dbg(adapter
->dev
, "info: Downloading FW image (%d bytes)\n",
1314 if (mwifiex_pcie_disable_host_int(adapter
)) {
1315 dev_err(adapter
->dev
,
1316 "%s: Disabling interrupts failed.\n", __func__
);
1320 skb
= dev_alloc_skb(MWIFIEX_UPLD_SIZE
);
1325 mwifiex_update_sk_buff_pa(skb
);
1327 /* Perform firmware data transfer */
1332 if (offset
>= firmware_len
)
1335 for (tries
= 0; tries
< MAX_POLL_TRIES
; tries
++) {
1336 ret
= mwifiex_read_reg(adapter
, PCIE_SCRATCH_2_REG
,
1339 dev_warn(adapter
->dev
,
1340 "Failed reading len from boot code\n");
1345 usleep_range(10, 20);
1350 } else if (len
> MWIFIEX_UPLD_SIZE
) {
1351 pr_err("FW download failure @ %d, invalid length %d\n",
1361 if (block_retry_cnt
> MAX_WRITE_IOMEM_RETRY
) {
1362 pr_err("FW download failure @ %d, over max "
1363 "retry count\n", offset
);
1367 dev_err(adapter
->dev
, "FW CRC error indicated by the "
1368 "helper: len = 0x%04X, txlen = %d\n",
1371 /* Setting this to 0 to resend from same offset */
1374 block_retry_cnt
= 0;
1375 /* Set blocksize to transfer - checking for
1377 if (firmware_len
- offset
< txlen
)
1378 txlen
= firmware_len
- offset
;
1380 dev_dbg(adapter
->dev
, ".");
1382 tx_blocks
= (txlen
+
1383 MWIFIEX_PCIE_BLOCK_SIZE_FW_DNLD
- 1) /
1384 MWIFIEX_PCIE_BLOCK_SIZE_FW_DNLD
;
1386 /* Copy payload to buffer */
1387 memmove(skb
->data
, &firmware
[offset
], txlen
);
1390 skb_put(skb
, MWIFIEX_UPLD_SIZE
- skb
->len
);
1391 skb_trim(skb
, tx_blocks
* MWIFIEX_PCIE_BLOCK_SIZE_FW_DNLD
);
1393 /* Send the boot command to device */
1394 if (mwifiex_pcie_send_boot_cmd(adapter
, skb
)) {
1395 dev_err(adapter
->dev
,
1396 "Failed to send firmware download command\n");
1400 /* Wait for the command done interrupt */
1402 if (mwifiex_read_reg(adapter
, PCIE_CPU_INT_STATUS
,
1404 dev_err(adapter
->dev
, "%s: Failed to read "
1405 "interrupt status during fw dnld.\n",
1410 } while ((ireg_intr
& CPU_INTR_DOOR_BELL
) ==
1411 CPU_INTR_DOOR_BELL
);
1415 dev_dbg(adapter
->dev
, "info:\nFW download over, size %d bytes\n",
1421 dev_kfree_skb_any(skb
);
1426 * This function checks the firmware status in card.
1428 * The winner interface is also determined by this function.
1431 mwifiex_check_fw_status(struct mwifiex_adapter
*adapter
, u32 poll_num
)
1434 u32 firmware_stat
, winner_status
;
1437 /* Mask spurios interrupts */
1438 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_STATUS_MASK
,
1440 dev_warn(adapter
->dev
, "Write register failed\n");
1444 dev_dbg(adapter
->dev
, "Setting driver ready signature\n");
1445 if (mwifiex_write_reg(adapter
, REG_DRV_READY
, FIRMWARE_READY_PCIE
)) {
1446 dev_err(adapter
->dev
,
1447 "Failed to write driver ready signature\n");
1451 /* Wait for firmware initialization event */
1452 for (tries
= 0; tries
< poll_num
; tries
++) {
1453 if (mwifiex_read_reg(adapter
, PCIE_SCRATCH_3_REG
,
1460 if (firmware_stat
== FIRMWARE_READY_PCIE
) {
1470 if (mwifiex_read_reg(adapter
, PCIE_SCRATCH_3_REG
,
1473 else if (!winner_status
) {
1474 dev_err(adapter
->dev
, "PCI-E is the winner\n");
1475 adapter
->winner
= 1;
1478 dev_err(adapter
->dev
,
1479 "PCI-E is not the winner <%#x,%d>, exit dnld\n",
1480 ret
, adapter
->winner
);
1489 * This function reads the interrupt status from card.
1491 static void mwifiex_interrupt_status(struct mwifiex_adapter
*adapter
)
1494 unsigned long flags
;
1496 if (!mwifiex_pcie_ok_to_access_hw(adapter
))
1499 if (mwifiex_read_reg(adapter
, PCIE_HOST_INT_STATUS
, &pcie_ireg
)) {
1500 dev_warn(adapter
->dev
, "Read register failed\n");
1504 if ((pcie_ireg
!= 0xFFFFFFFF) && (pcie_ireg
)) {
1506 mwifiex_pcie_disable_host_int(adapter
);
1508 /* Clear the pending interrupts */
1509 if (mwifiex_write_reg(adapter
, PCIE_HOST_INT_STATUS
,
1511 dev_warn(adapter
->dev
, "Write register failed\n");
1514 spin_lock_irqsave(&adapter
->int_lock
, flags
);
1515 adapter
->int_status
|= pcie_ireg
;
1516 spin_unlock_irqrestore(&adapter
->int_lock
, flags
);
1518 if (pcie_ireg
& HOST_INTR_CMD_DONE
) {
1519 if ((adapter
->ps_state
== PS_STATE_SLEEP_CFM
) ||
1520 (adapter
->ps_state
== PS_STATE_SLEEP
)) {
1521 mwifiex_pcie_enable_host_int(adapter
);
1522 if (mwifiex_write_reg(adapter
,
1524 CPU_INTR_SLEEP_CFM_DONE
)
1526 dev_warn(adapter
->dev
,
1527 "Write register failed\n");
1532 } else if (!adapter
->pps_uapsd_mode
&&
1533 adapter
->ps_state
== PS_STATE_SLEEP
) {
1534 /* Potentially for PCIe we could get other
1535 * interrupts like shared. Don't change power
1536 * state until cookie is set */
1537 if (mwifiex_pcie_ok_to_access_hw(adapter
))
1538 adapter
->ps_state
= PS_STATE_AWAKE
;
1544 * Interrupt handler for PCIe root port
1546 * This function reads the interrupt status from firmware and assigns
1547 * the main process in workqueue which will handle the interrupt.
1549 static irqreturn_t
mwifiex_pcie_interrupt(int irq
, void *context
)
1551 struct pci_dev
*pdev
= (struct pci_dev
*)context
;
1552 struct pcie_service_card
*card
;
1553 struct mwifiex_adapter
*adapter
;
1556 pr_debug("info: %s: pdev is NULL\n", (u8
*)pdev
);
1560 card
= (struct pcie_service_card
*) pci_get_drvdata(pdev
);
1561 if (!card
|| !card
->adapter
) {
1562 pr_debug("info: %s: card=%p adapter=%p\n", __func__
, card
,
1563 card
? card
->adapter
: NULL
);
1566 adapter
= card
->adapter
;
1568 if (adapter
->surprise_removed
)
1571 mwifiex_interrupt_status(adapter
);
1572 queue_work(adapter
->workqueue
, &adapter
->main_work
);
1579 * This function checks the current interrupt status.
1581 * The following interrupts are checked and handled by this function -
1584 * - Command received
1585 * - Packets received
1588 * In case of Rx packets received, the packets are uploaded from card to
1589 * host and processed accordingly.
1591 static int mwifiex_process_int_status(struct mwifiex_adapter
*adapter
)
1595 unsigned long flags
;
1597 spin_lock_irqsave(&adapter
->int_lock
, flags
);
1598 /* Clear out unused interrupts */
1599 adapter
->int_status
&= HOST_INTR_MASK
;
1600 spin_unlock_irqrestore(&adapter
->int_lock
, flags
);
1602 while (adapter
->int_status
& HOST_INTR_MASK
) {
1603 if (adapter
->int_status
& HOST_INTR_DNLD_DONE
) {
1604 adapter
->int_status
&= ~HOST_INTR_DNLD_DONE
;
1605 if (adapter
->data_sent
) {
1606 dev_dbg(adapter
->dev
, "info: DATA sent intr\n");
1607 adapter
->data_sent
= false;
1610 if (adapter
->int_status
& HOST_INTR_UPLD_RDY
) {
1611 adapter
->int_status
&= ~HOST_INTR_UPLD_RDY
;
1612 dev_dbg(adapter
->dev
, "info: Rx DATA\n");
1613 ret
= mwifiex_pcie_process_recv_data(adapter
);
1617 if (adapter
->int_status
& HOST_INTR_EVENT_RDY
) {
1618 adapter
->int_status
&= ~HOST_INTR_EVENT_RDY
;
1619 dev_dbg(adapter
->dev
, "info: Rx EVENT\n");
1620 ret
= mwifiex_pcie_process_event_ready(adapter
);
1625 if (adapter
->int_status
& HOST_INTR_CMD_DONE
) {
1626 adapter
->int_status
&= ~HOST_INTR_CMD_DONE
;
1627 if (adapter
->cmd_sent
) {
1628 dev_dbg(adapter
->dev
,
1629 "info: CMD sent Interrupt\n");
1630 adapter
->cmd_sent
= false;
1632 /* Handle command response */
1633 ret
= mwifiex_pcie_process_cmd_complete(adapter
);
1638 if (mwifiex_pcie_ok_to_access_hw(adapter
)) {
1639 if (mwifiex_read_reg(adapter
, PCIE_HOST_INT_STATUS
,
1641 dev_warn(adapter
->dev
,
1642 "Read register failed\n");
1646 if ((pcie_ireg
!= 0xFFFFFFFF) && (pcie_ireg
)) {
1647 if (mwifiex_write_reg(adapter
,
1648 PCIE_HOST_INT_STATUS
,
1650 dev_warn(adapter
->dev
,
1651 "Write register failed\n");
1654 adapter
->int_status
|= pcie_ireg
;
1655 adapter
->int_status
&= HOST_INTR_MASK
;
1660 dev_dbg(adapter
->dev
, "info: cmd_sent=%d data_sent=%d\n",
1661 adapter
->cmd_sent
, adapter
->data_sent
);
1662 mwifiex_pcie_enable_host_int(adapter
);
1668 * This function downloads data from driver to card.
1670 * Both commands and data packets are transferred to the card by this
1673 * This function adds the PCIE specific header to the front of the buffer
1674 * before transferring. The header contains the length of the packet and
1675 * the type. The firmware handles the packets based upon this set type.
1677 static int mwifiex_pcie_host_to_card(struct mwifiex_adapter
*adapter
, u8 type
,
1678 struct sk_buff
*skb
,
1679 struct mwifiex_tx_param
*tx_param
)
1682 dev_err(adapter
->dev
, "Passed NULL skb to %s\n", __func__
);
1686 if (type
== MWIFIEX_TYPE_DATA
)
1687 return mwifiex_pcie_send_data(adapter
, skb
);
1688 else if (type
== MWIFIEX_TYPE_CMD
)
1689 return mwifiex_pcie_send_cmd(adapter
, skb
);
1695 * This function initializes the PCI-E host memory space, WCB rings, etc.
1697 * The following initializations steps are followed -
1698 * - Allocate TXBD ring buffers
1699 * - Allocate RXBD ring buffers
1700 * - Allocate event BD ring buffers
1701 * - Allocate command response ring buffer
1702 * - Allocate sleep cookie buffer
1704 static int mwifiex_pcie_init(struct mwifiex_adapter
*adapter
)
1706 struct pcie_service_card
*card
= adapter
->card
;
1708 struct pci_dev
*pdev
= card
->dev
;
1710 pci_set_drvdata(pdev
, card
);
1712 ret
= pci_enable_device(pdev
);
1714 goto err_enable_dev
;
1716 pci_set_master(pdev
);
1718 dev_dbg(adapter
->dev
, "try set_consistent_dma_mask(32)\n");
1719 ret
= pci_set_dma_mask(pdev
, DMA_BIT_MASK(32));
1721 dev_err(adapter
->dev
, "set_dma_mask(32) failed\n");
1722 goto err_set_dma_mask
;
1725 ret
= pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(32));
1727 dev_err(adapter
->dev
, "set_consistent_dma_mask(64) failed\n");
1728 goto err_set_dma_mask
;
1731 ret
= pci_request_region(pdev
, 0, DRV_NAME
);
1733 dev_err(adapter
->dev
, "req_reg(0) error\n");
1734 goto err_req_region0
;
1736 card
->pci_mmap
= pci_iomap(pdev
, 0, 0);
1737 if (!card
->pci_mmap
) {
1738 dev_err(adapter
->dev
, "iomap(0) error\n");
1741 ret
= pci_request_region(pdev
, 2, DRV_NAME
);
1743 dev_err(adapter
->dev
, "req_reg(2) error\n");
1744 goto err_req_region2
;
1746 card
->pci_mmap1
= pci_iomap(pdev
, 2, 0);
1747 if (!card
->pci_mmap1
) {
1748 dev_err(adapter
->dev
, "iomap(2) error\n");
1752 dev_dbg(adapter
->dev
,
1753 "PCI memory map Virt0: %p PCI memory map Virt2: %p\n",
1754 card
->pci_mmap
, card
->pci_mmap1
);
1756 card
->cmdrsp_buf
= NULL
;
1757 ret
= mwifiex_pcie_create_txbd_ring(adapter
);
1760 ret
= mwifiex_pcie_create_rxbd_ring(adapter
);
1763 ret
= mwifiex_pcie_create_evtbd_ring(adapter
);
1766 ret
= mwifiex_pcie_alloc_cmdrsp_buf(adapter
);
1768 goto err_alloc_cmdbuf
;
1769 ret
= mwifiex_pcie_alloc_sleep_cookie_buf(adapter
);
1771 goto err_alloc_cookie
;
1776 mwifiex_pcie_delete_cmdrsp_buf(adapter
);
1778 mwifiex_pcie_delete_evtbd_ring(adapter
);
1780 mwifiex_pcie_delete_rxbd_ring(adapter
);
1782 mwifiex_pcie_delete_txbd_ring(adapter
);
1784 pci_iounmap(pdev
, card
->pci_mmap1
);
1786 pci_release_region(pdev
, 2);
1788 pci_iounmap(pdev
, card
->pci_mmap
);
1790 pci_release_region(pdev
, 0);
1793 pci_disable_device(pdev
);
1795 pci_set_drvdata(pdev
, NULL
);
1800 * This function cleans up the allocated card buffers.
1802 * The following are freed by this function -
1803 * - TXBD ring buffers
1804 * - RXBD ring buffers
1805 * - Event BD ring buffers
1806 * - Command response ring buffer
1807 * - Sleep cookie buffer
1809 static void mwifiex_pcie_cleanup(struct mwifiex_adapter
*adapter
)
1811 struct pcie_service_card
*card
= adapter
->card
;
1812 struct pci_dev
*pdev
= card
->dev
;
1814 mwifiex_pcie_delete_sleep_cookie_buf(adapter
);
1815 mwifiex_pcie_delete_cmdrsp_buf(adapter
);
1816 mwifiex_pcie_delete_evtbd_ring(adapter
);
1817 mwifiex_pcie_delete_rxbd_ring(adapter
);
1818 mwifiex_pcie_delete_txbd_ring(adapter
);
1819 card
->cmdrsp_buf
= NULL
;
1821 dev_dbg(adapter
->dev
, "Clearing driver ready signature\n");
1823 if (mwifiex_write_reg(adapter
, REG_DRV_READY
, 0x00000000))
1824 dev_err(adapter
->dev
,
1825 "Failed to write driver not-ready signature\n");
1829 pci_iounmap(pdev
, card
->pci_mmap
);
1830 pci_iounmap(pdev
, card
->pci_mmap1
);
1832 pci_release_regions(pdev
);
1833 pci_disable_device(pdev
);
1834 pci_set_drvdata(pdev
, NULL
);
1839 * This function registers the PCIE device.
1841 * PCIE IRQ is claimed, block size is set and driver data is initialized.
1843 static int mwifiex_register_dev(struct mwifiex_adapter
*adapter
)
1846 struct pcie_service_card
*card
= adapter
->card
;
1847 struct pci_dev
*pdev
= card
->dev
;
1849 /* save adapter pointer in card */
1850 card
->adapter
= adapter
;
1852 ret
= request_irq(pdev
->irq
, mwifiex_pcie_interrupt
, IRQF_SHARED
,
1855 pr_err("request_irq failed: ret=%d\n", ret
);
1856 adapter
->card
= NULL
;
1860 adapter
->dev
= &pdev
->dev
;
1861 strcpy(adapter
->fw_name
, PCIE8766_DEFAULT_FW_NAME
);
1867 * This function unregisters the PCIE device.
1869 * The PCIE IRQ is released, the function is disabled and driver
1870 * data is set to null.
1872 static void mwifiex_unregister_dev(struct mwifiex_adapter
*adapter
)
1874 struct pcie_service_card
*card
= adapter
->card
;
1877 dev_dbg(adapter
->dev
, "%s(): calling free_irq()\n", __func__
);
1878 free_irq(card
->dev
->irq
, card
->dev
);
1882 static struct mwifiex_if_ops pcie_ops
= {
1883 .init_if
= mwifiex_pcie_init
,
1884 .cleanup_if
= mwifiex_pcie_cleanup
,
1885 .check_fw_status
= mwifiex_check_fw_status
,
1886 .prog_fw
= mwifiex_prog_fw_w_helper
,
1887 .register_dev
= mwifiex_register_dev
,
1888 .unregister_dev
= mwifiex_unregister_dev
,
1889 .enable_int
= mwifiex_pcie_enable_host_int
,
1890 .process_int_status
= mwifiex_process_int_status
,
1891 .host_to_card
= mwifiex_pcie_host_to_card
,
1892 .wakeup
= mwifiex_pm_wakeup_card
,
1893 .wakeup_complete
= mwifiex_pm_wakeup_card_complete
,
1896 .cmdrsp_complete
= mwifiex_pcie_cmdrsp_complete
,
1897 .event_complete
= mwifiex_pcie_event_complete
,
1898 .update_mp_end_port
= NULL
,
1899 .cleanup_mpa_buf
= NULL
,
1903 * This function initializes the PCIE driver module.
1905 * This initiates the semaphore and registers the device with
1908 static int mwifiex_pcie_init_module(void)
1912 pr_debug("Marvell 8766 PCIe Driver\n");
1914 sema_init(&add_remove_card_sem
, 1);
1916 /* Clear the flag in case user removes the card. */
1919 ret
= pci_register_driver(&mwifiex_pcie
);
1921 pr_err("Driver register failed!\n");
1923 pr_debug("info: Driver registered successfully!\n");
1929 * This function cleans up the PCIE driver.
1931 * The following major steps are followed for cleanup -
1932 * - Resume the device if its suspended
1933 * - Disconnect the device if connected
1934 * - Shutdown the firmware
1935 * - Unregister the device from PCIE bus.
1937 static void mwifiex_pcie_cleanup_module(void)
1939 if (!down_interruptible(&add_remove_card_sem
))
1940 up(&add_remove_card_sem
);
1942 /* Set the flag as user is removing this module. */
1945 pci_unregister_driver(&mwifiex_pcie
);
1948 module_init(mwifiex_pcie_init_module
);
1949 module_exit(mwifiex_pcie_cleanup_module
);
1951 MODULE_AUTHOR("Marvell International Ltd.");
1952 MODULE_DESCRIPTION("Marvell WiFi-Ex PCI-Express Driver version " PCIE_VERSION
);
1953 MODULE_VERSION(PCIE_VERSION
);
1954 MODULE_LICENSE("GPL v2");
1955 MODULE_FIRMWARE("mrvl/pcie8766_uapsta.bin");