?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fix a kmap leak in virtio_console
[linux/fpc-iii.git] / drivers / net / wireless / mwifiex / pcie.c
blob03688aa14e8adb8575163e3a40aeda4a70a32c19
1 /*
2 * Marvell Wireless LAN device driver: PCIE specific handling
3 *
4 * Copyright (C) 2011, Marvell International Ltd.
5 *
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.
13 *
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.
18 */
19
20 #include <linux/firmware.h>
21
22 #include "decl.h"
23 #include "ioctl.h"
24 #include "util.h"
25 #include "fw.h"
26 #include "main.h"
27 #include "wmm.h"
28 #include "11n.h"
29 #include "pcie.h"
30
31 #define PCIE_VERSION "1.0"
32 #define DRV_NAME "Marvell mwifiex PCIe"
33
34 static u8 user_rmmod;
35
36 static struct mwifiex_if_ops pcie_ops;
37
38 static struct semaphore add_remove_card_sem;
39
40 static int
41 mwifiex_map_pci_memory(struct mwifiex_adapter *adapter, struct sk_buff *skb,
42 int size, int flags)
43 {
44 struct pcie_service_card *card = adapter->card;
45 dma_addr_t buf_pa;
46
47 buf_pa = pci_map_single(card->dev, skb->data, size, flags);
48 if (pci_dma_mapping_error(card->dev, buf_pa)) {
49 dev_err(adapter->dev, "failed to map pci memory!\n");
50 return -1;
51 }
52 memcpy(skb->cb, &buf_pa, sizeof(dma_addr_t));
53 return 0;
54 }
55
56 /*
57 * This function reads sleep cookie and checks if FW is ready
58 */
59 static bool mwifiex_pcie_ok_to_access_hw(struct mwifiex_adapter *adapter)
60 {
61 u32 *cookie_addr;
62 struct pcie_service_card *card = adapter->card;
63 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
64
65 if (!reg->sleep_cookie)
66 return true;
67
68 if (card->sleep_cookie_vbase) {
69 cookie_addr = (u32 *)card->sleep_cookie_vbase;
70 dev_dbg(adapter->dev, "info: ACCESS_HW: sleep cookie=0x%x\n",
71 *cookie_addr);
72 if (*cookie_addr == FW_AWAKE_COOKIE)
73 return true;
74 }
75
76 return false;
77 }
78
79 #ifdef CONFIG_PM_SLEEP
80 /*
81 * Kernel needs to suspend all functions separately. Therefore all
82 * registered functions must have drivers with suspend and resume
83 * methods. Failing that the kernel simply removes the whole card.
84 *
85 * If already not suspended, this function allocates and sends a host
86 * sleep activate request to the firmware and turns off the traffic.
87 */
88 static int mwifiex_pcie_suspend(struct device *dev)
89 {
90 struct mwifiex_adapter *adapter;
91 struct pcie_service_card *card;
92 int hs_actived;
93 struct pci_dev *pdev = to_pci_dev(dev);
94
95 if (pdev) {
96 card = pci_get_drvdata(pdev);
97 if (!card || !card->adapter) {
98 pr_err("Card or adapter structure is not valid\n");
99 return 0;
100 }
101 } else {
102 pr_err("PCIE device is not specified\n");
103 return 0;
104 }
105
106 adapter = card->adapter;
107
108 hs_actived = mwifiex_enable_hs(adapter);
109
110 /* Indicate device suspended */
111 adapter->is_suspended = true;
112
113 return 0;
114 }
115
116 /*
117 * Kernel needs to suspend all functions separately. Therefore all
118 * registered functions must have drivers with suspend and resume
119 * methods. Failing that the kernel simply removes the whole card.
120 *
121 * If already not resumed, this function turns on the traffic and
122 * sends a host sleep cancel request to the firmware.
123 */
124 static int mwifiex_pcie_resume(struct device *dev)
125 {
126 struct mwifiex_adapter *adapter;
127 struct pcie_service_card *card;
128 struct pci_dev *pdev = to_pci_dev(dev);
129
130 if (pdev) {
131 card = pci_get_drvdata(pdev);
132 if (!card || !card->adapter) {
133 pr_err("Card or adapter structure is not valid\n");
134 return 0;
135 }
136 } else {
137 pr_err("PCIE device is not specified\n");
138 return 0;
139 }
140
141 adapter = card->adapter;
142
143 if (!adapter->is_suspended) {
144 dev_warn(adapter->dev, "Device already resumed\n");
145 return 0;
146 }
147
148 adapter->is_suspended = false;
149
150 mwifiex_cancel_hs(mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA),
151 MWIFIEX_ASYNC_CMD);
152
153 return 0;
154 }
155 #endif
156
157 /*
158 * This function probes an mwifiex device and registers it. It allocates
159 * the card structure, enables PCIE function number and initiates the
160 * device registration and initialization procedure by adding a logical
161 * interface.
162 */
163 static int mwifiex_pcie_probe(struct pci_dev *pdev,
164 const struct pci_device_id *ent)
165 {
166 struct pcie_service_card *card;
167
168 pr_debug("info: vendor=0x%4.04X device=0x%4.04X rev=%d\n",
169 pdev->vendor, pdev->device, pdev->revision);
170
171 card = kzalloc(sizeof(struct pcie_service_card), GFP_KERNEL);
172 if (!card)
173 return -ENOMEM;
174
175 card->dev = pdev;
176
177 if (ent->driver_data) {
178 struct mwifiex_pcie_device *data = (void *)ent->driver_data;
179 card->pcie.firmware = data->firmware;
180 card->pcie.reg = data->reg;
181 card->pcie.blksz_fw_dl = data->blksz_fw_dl;
182 }
183
184 if (mwifiex_add_card(card, &add_remove_card_sem, &pcie_ops,
185 MWIFIEX_PCIE)) {
186 pr_err("%s failed\n", __func__);
187 kfree(card);
188 return -1;
189 }
190
191 return 0;
192 }
193
194 /*
195 * This function removes the interface and frees up the card structure.
196 */
197 static void mwifiex_pcie_remove(struct pci_dev *pdev)
198 {
199 struct pcie_service_card *card;
200 struct mwifiex_adapter *adapter;
201 struct mwifiex_private *priv;
202 int i;
203
204 card = pci_get_drvdata(pdev);
205 if (!card)
206 return;
207
208 adapter = card->adapter;
209 if (!adapter || !adapter->priv_num)
210 return;
211
212 /* In case driver is removed when asynchronous FW load is in progress */
213 wait_for_completion(&adapter->fw_load);
214
215 if (user_rmmod) {
216 #ifdef CONFIG_PM_SLEEP
217 if (adapter->is_suspended)
218 mwifiex_pcie_resume(&pdev->dev);
219 #endif
220
221 for (i = 0; i < adapter->priv_num; i++)
222 if ((GET_BSS_ROLE(adapter->priv[i]) ==
223 MWIFIEX_BSS_ROLE_STA) &&
224 adapter->priv[i]->media_connected)
225 mwifiex_deauthenticate(adapter->priv[i], NULL);
226
227 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
228
229 mwifiex_disable_auto_ds(priv);
230
231 mwifiex_init_shutdown_fw(priv, MWIFIEX_FUNC_SHUTDOWN);
232 }
233
234 mwifiex_remove_card(card->adapter, &add_remove_card_sem);
235 }
236
237 static void mwifiex_pcie_shutdown(struct pci_dev *pdev)
238 {
239 user_rmmod = 1;
240 mwifiex_pcie_remove(pdev);
241
242 return;
243 }
244
245 static DEFINE_PCI_DEVICE_TABLE(mwifiex_ids) = {
246 {
247 PCIE_VENDOR_ID_MARVELL, PCIE_DEVICE_ID_MARVELL_88W8766P,
248 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
249 .driver_data = (unsigned long) &mwifiex_pcie8766,
250 },
251 {
252 PCIE_VENDOR_ID_MARVELL, PCIE_DEVICE_ID_MARVELL_88W8897,
253 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
254 .driver_data = (unsigned long) &mwifiex_pcie8897,
255 },
256 {},
257 };
258
259 MODULE_DEVICE_TABLE(pci, mwifiex_ids);
260
261 #ifdef CONFIG_PM_SLEEP
262 /* Power Management Hooks */
263 static SIMPLE_DEV_PM_OPS(mwifiex_pcie_pm_ops, mwifiex_pcie_suspend,
264 mwifiex_pcie_resume);
265 #endif
266
267 /* PCI Device Driver */
268 static struct pci_driver __refdata mwifiex_pcie = {
269 .name = "mwifiex_pcie",
270 .id_table = mwifiex_ids,
271 .probe = mwifiex_pcie_probe,
272 .remove = mwifiex_pcie_remove,
273 #ifdef CONFIG_PM_SLEEP
274 .driver = {
275 .pm = &mwifiex_pcie_pm_ops,
276 },
277 #endif
278 .shutdown = mwifiex_pcie_shutdown,
279 };
280
281 /*
282 * This function writes data into PCIE card register.
283 */
284 static int mwifiex_write_reg(struct mwifiex_adapter *adapter, int reg, u32 data)
285 {
286 struct pcie_service_card *card = adapter->card;
287
288 iowrite32(data, card->pci_mmap1 + reg);
289
290 return 0;
291 }
292
293 /*
294 * This function reads data from PCIE card register.
295 */
296 static int mwifiex_read_reg(struct mwifiex_adapter *adapter, int reg, u32 *data)
297 {
298 struct pcie_service_card *card = adapter->card;
299
300 *data = ioread32(card->pci_mmap1 + reg);
301
302 return 0;
303 }
304
305 /*
306 * This function adds delay loop to ensure FW is awake before proceeding.
307 */
308 static void mwifiex_pcie_dev_wakeup_delay(struct mwifiex_adapter *adapter)
309 {
310 int i = 0;
311
312 while (mwifiex_pcie_ok_to_access_hw(adapter)) {
313 i++;
314 usleep_range(10, 20);
315 /* 50ms max wait */
316 if (i == 5000)
317 break;
318 }
319
320 return;
321 }
322
323 /* This function wakes up the card by reading fw_status register. */
324 static int mwifiex_pm_wakeup_card(struct mwifiex_adapter *adapter)
325 {
326 u32 fw_status;
327 struct pcie_service_card *card = adapter->card;
328 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
329
330 dev_dbg(adapter->dev, "event: Wakeup device...\n");
331
332 if (reg->sleep_cookie)
333 mwifiex_pcie_dev_wakeup_delay(adapter);
334
335 /* Reading fw_status register will wakeup device */
336 if (mwifiex_read_reg(adapter, reg->fw_status, &fw_status)) {
337 dev_warn(adapter->dev, "Reading fw_status register failed\n");
338 return -1;
339 }
340
341 if (reg->sleep_cookie) {
342 mwifiex_pcie_dev_wakeup_delay(adapter);
343 dev_dbg(adapter->dev, "PCIE wakeup: Setting PS_STATE_AWAKE\n");
344 adapter->ps_state = PS_STATE_AWAKE;
345 }
346
347 return 0;
348 }
349
350 /*
351 * This function is called after the card has woken up.
352 *
353 * The card configuration register is reset.
354 */
355 static int mwifiex_pm_wakeup_card_complete(struct mwifiex_adapter *adapter)
356 {
357 dev_dbg(adapter->dev, "cmd: Wakeup device completed\n");
358
359 return 0;
360 }
361
362 /*
363 * This function disables the host interrupt.
364 *
365 * The host interrupt mask is read, the disable bit is reset and
366 * written back to the card host interrupt mask register.
367 */
368 static int mwifiex_pcie_disable_host_int(struct mwifiex_adapter *adapter)
369 {
370 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
371 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK,
372 0x00000000)) {
373 dev_warn(adapter->dev, "Disable host interrupt failed\n");
374 return -1;
375 }
376 }
377
378 return 0;
379 }
380
381 /*
382 * This function enables the host interrupt.
383 *
384 * The host interrupt enable mask is written to the card
385 * host interrupt mask register.
386 */
387 static int mwifiex_pcie_enable_host_int(struct mwifiex_adapter *adapter)
388 {
389 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
390 /* Simply write the mask to the register */
391 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK,
392 HOST_INTR_MASK)) {
393 dev_warn(adapter->dev, "Enable host interrupt failed\n");
394 return -1;
395 }
396 }
397
398 return 0;
399 }
400
401 /*
402 * This function initializes TX buffer ring descriptors
403 */
404 static int mwifiex_init_txq_ring(struct mwifiex_adapter *adapter)
405 {
406 struct pcie_service_card *card = adapter->card;
407 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
408 struct mwifiex_pcie_buf_desc *desc;
409 struct mwifiex_pfu_buf_desc *desc2;
410 int i;
411
412 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
413 card->tx_buf_list[i] = NULL;
414 if (reg->pfu_enabled) {
415 card->txbd_ring[i] = (void *)card->txbd_ring_vbase +
416 (sizeof(*desc2) * i);
417 desc2 = card->txbd_ring[i];
418 memset(desc2, 0, sizeof(*desc2));
419 } else {
420 card->txbd_ring[i] = (void *)card->txbd_ring_vbase +
421 (sizeof(*desc) * i);
422 desc = card->txbd_ring[i];
423 memset(desc, 0, sizeof(*desc));
424 }
425 }
426
427 return 0;
428 }
429
430 /* This function initializes RX buffer ring descriptors. Each SKB is allocated
431 * here and after mapping PCI memory, its physical address is assigned to
432 * PCIE Rx buffer descriptor's physical address.
433 */
434 static int mwifiex_init_rxq_ring(struct mwifiex_adapter *adapter)
435 {
436 struct pcie_service_card *card = adapter->card;
437 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
438 struct sk_buff *skb;
439 struct mwifiex_pcie_buf_desc *desc;
440 struct mwifiex_pfu_buf_desc *desc2;
441 dma_addr_t buf_pa;
442 int i;
443
444 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
445 /* Allocate skb here so that firmware can DMA data from it */
446 skb = dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE);
447 if (!skb) {
448 dev_err(adapter->dev,
449 "Unable to allocate skb for RX ring.\n");
450 kfree(card->rxbd_ring_vbase);
451 return -ENOMEM;
452 }
453
454 if (mwifiex_map_pci_memory(adapter, skb,
455 MWIFIEX_RX_DATA_BUF_SIZE,
456 PCI_DMA_FROMDEVICE))
457 return -1;
458
459 MWIFIEX_SKB_PACB(skb, &buf_pa);
460
461 dev_dbg(adapter->dev,
462 "info: RX ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
463 skb, skb->len, skb->data, (u32)buf_pa,
464 (u32)((u64)buf_pa >> 32));
465
466 card->rx_buf_list[i] = skb;
467 if (reg->pfu_enabled) {
468 card->rxbd_ring[i] = (void *)card->rxbd_ring_vbase +
469 (sizeof(*desc2) * i);
470 desc2 = card->rxbd_ring[i];
471 desc2->paddr = buf_pa;
472 desc2->len = (u16)skb->len;
473 desc2->frag_len = (u16)skb->len;
474 desc2->flags = reg->ring_flag_eop | reg->ring_flag_sop;
475 desc2->offset = 0;
476 } else {
477 card->rxbd_ring[i] = (void *)(card->rxbd_ring_vbase +
478 (sizeof(*desc) * i));
479 desc = card->rxbd_ring[i];
480 desc->paddr = buf_pa;
481 desc->len = (u16)skb->len;
482 desc->flags = 0;
483 }
484 }
485
486 return 0;
487 }
488
489 /* This function initializes event buffer ring descriptors. Each SKB is
490 * allocated here and after mapping PCI memory, its physical address is assigned
491 * to PCIE Rx buffer descriptor's physical address
492 */
493 static int mwifiex_pcie_init_evt_ring(struct mwifiex_adapter *adapter)
494 {
495 struct pcie_service_card *card = adapter->card;
496 struct mwifiex_evt_buf_desc *desc;
497 struct sk_buff *skb;
498 dma_addr_t buf_pa;
499 int i;
500
501 for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) {
502 /* Allocate skb here so that firmware can DMA data from it */
503 skb = dev_alloc_skb(MAX_EVENT_SIZE);
504 if (!skb) {
505 dev_err(adapter->dev,
506 "Unable to allocate skb for EVENT buf.\n");
507 kfree(card->evtbd_ring_vbase);
508 return -ENOMEM;
509 }
510 skb_put(skb, MAX_EVENT_SIZE);
511
512 if (mwifiex_map_pci_memory(adapter, skb, MAX_EVENT_SIZE,
513 PCI_DMA_FROMDEVICE))
514 return -1;
515
516 MWIFIEX_SKB_PACB(skb, &buf_pa);
517
518 dev_dbg(adapter->dev,
519 "info: EVT ring: skb=%p len=%d data=%p buf_pa=%#x:%x\n",
520 skb, skb->len, skb->data, (u32)buf_pa,
521 (u32)((u64)buf_pa >> 32));
522
523 card->evt_buf_list[i] = skb;
524 card->evtbd_ring[i] = (void *)(card->evtbd_ring_vbase +
525 (sizeof(*desc) * i));
526 desc = card->evtbd_ring[i];
527 desc->paddr = buf_pa;
528 desc->len = (u16)skb->len;
529 desc->flags = 0;
530 }
531
532 return 0;
533 }
534
535 /* This function cleans up TX buffer rings. If any of the buffer list has valid
536 * SKB address, associated SKB is freed.
537 */
538 static void mwifiex_cleanup_txq_ring(struct mwifiex_adapter *adapter)
539 {
540 struct pcie_service_card *card = adapter->card;
541 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
542 struct sk_buff *skb;
543 struct mwifiex_pcie_buf_desc *desc;
544 struct mwifiex_pfu_buf_desc *desc2;
545 int i;
546
547 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
548 if (reg->pfu_enabled) {
549 desc2 = card->txbd_ring[i];
550 if (card->tx_buf_list[i]) {
551 skb = card->tx_buf_list[i];
552 pci_unmap_single(card->dev, desc2->paddr,
553 skb->len, PCI_DMA_TODEVICE);
554 dev_kfree_skb_any(skb);
555 }
556 memset(desc2, 0, sizeof(*desc2));
557 } else {
558 desc = card->txbd_ring[i];
559 if (card->tx_buf_list[i]) {
560 skb = card->tx_buf_list[i];
561 pci_unmap_single(card->dev, desc->paddr,
562 skb->len, PCI_DMA_TODEVICE);
563 dev_kfree_skb_any(skb);
564 }
565 memset(desc, 0, sizeof(*desc));
566 }
567 card->tx_buf_list[i] = NULL;
568 }
569
570 return;
571 }
572
573 /* This function cleans up RX buffer rings. If any of the buffer list has valid
574 * SKB address, associated SKB is freed.
575 */
576 static void mwifiex_cleanup_rxq_ring(struct mwifiex_adapter *adapter)
577 {
578 struct pcie_service_card *card = adapter->card;
579 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
580 struct mwifiex_pcie_buf_desc *desc;
581 struct mwifiex_pfu_buf_desc *desc2;
582 struct sk_buff *skb;
583 int i;
584
585 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
586 if (reg->pfu_enabled) {
587 desc2 = card->rxbd_ring[i];
588 if (card->rx_buf_list[i]) {
589 skb = card->rx_buf_list[i];
590 pci_unmap_single(card->dev, desc2->paddr,
591 skb->len, PCI_DMA_FROMDEVICE);
592 dev_kfree_skb_any(skb);
593 }
594 memset(desc2, 0, sizeof(*desc2));
595 } else {
596 desc = card->rxbd_ring[i];
597 if (card->rx_buf_list[i]) {
598 skb = card->rx_buf_list[i];
599 pci_unmap_single(card->dev, desc->paddr,
600 skb->len, PCI_DMA_FROMDEVICE);
601 dev_kfree_skb_any(skb);
602 }
603 memset(desc, 0, sizeof(*desc));
604 }
605 card->rx_buf_list[i] = NULL;
606 }
607
608 return;
609 }
610
611 /* This function cleans up event buffer rings. If any of the buffer list has
612 * valid SKB address, associated SKB is freed.
613 */
614 static void mwifiex_cleanup_evt_ring(struct mwifiex_adapter *adapter)
615 {
616 struct pcie_service_card *card = adapter->card;
617 struct mwifiex_evt_buf_desc *desc;
618 struct sk_buff *skb;
619 int i;
620
621 for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) {
622 desc = card->evtbd_ring[i];
623 if (card->evt_buf_list[i]) {
624 skb = card->evt_buf_list[i];
625 pci_unmap_single(card->dev, desc->paddr, MAX_EVENT_SIZE,
626 PCI_DMA_FROMDEVICE);
627 dev_kfree_skb_any(skb);
628 }
629 card->evt_buf_list[i] = NULL;
630 memset(desc, 0, sizeof(*desc));
631 }
632
633 return;
634 }
635
636 /* This function creates buffer descriptor ring for TX
637 */
638 static int mwifiex_pcie_create_txbd_ring(struct mwifiex_adapter *adapter)
639 {
640 struct pcie_service_card *card = adapter->card;
641 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
642
643 /*
644 * driver maintaines the write pointer and firmware maintaines the read
645 * pointer. The write pointer starts at 0 (zero) while the read pointer
646 * starts at zero with rollover bit set
647 */
648 card->txbd_wrptr = 0;
649
650 if (reg->pfu_enabled)
651 card->txbd_rdptr = 0;
652 else
653 card->txbd_rdptr |= reg->tx_rollover_ind;
654
655 /* allocate shared memory for the BD ring and divide the same in to
656 several descriptors */
657 if (reg->pfu_enabled)
658 card->txbd_ring_size = sizeof(struct mwifiex_pfu_buf_desc) *
659 MWIFIEX_MAX_TXRX_BD;
660 else
661 card->txbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
662 MWIFIEX_MAX_TXRX_BD;
663
664 dev_dbg(adapter->dev, "info: txbd_ring: Allocating %d bytes\n",
665 card->txbd_ring_size);
666 card->txbd_ring_vbase = pci_alloc_consistent(card->dev,
667 card->txbd_ring_size,
668 &card->txbd_ring_pbase);
669 if (!card->txbd_ring_vbase) {
670 dev_err(adapter->dev,
671 "allocate consistent memory (%d bytes) failed!\n",
672 card->txbd_ring_size);
673 return -ENOMEM;
674 }
675 dev_dbg(adapter->dev,
676 "info: txbd_ring - base: %p, pbase: %#x:%x, len: %x\n",
677 card->txbd_ring_vbase, (unsigned int)card->txbd_ring_pbase,
678 (u32)((u64)card->txbd_ring_pbase >> 32), card->txbd_ring_size);
679
680 return mwifiex_init_txq_ring(adapter);
681 }
682
683 static int mwifiex_pcie_delete_txbd_ring(struct mwifiex_adapter *adapter)
684 {
685 struct pcie_service_card *card = adapter->card;
686 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
687
688 mwifiex_cleanup_txq_ring(adapter);
689
690 if (card->txbd_ring_vbase)
691 pci_free_consistent(card->dev, card->txbd_ring_size,
692 card->txbd_ring_vbase,
693 card->txbd_ring_pbase);
694 card->txbd_ring_size = 0;
695 card->txbd_wrptr = 0;
696 card->txbd_rdptr = 0 | reg->tx_rollover_ind;
697 card->txbd_ring_vbase = NULL;
698 card->txbd_ring_pbase = 0;
699
700 return 0;
701 }
702
703 /*
704 * This function creates buffer descriptor ring for RX
705 */
706 static int mwifiex_pcie_create_rxbd_ring(struct mwifiex_adapter *adapter)
707 {
708 struct pcie_service_card *card = adapter->card;
709 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
710
711 /*
712 * driver maintaines the read pointer and firmware maintaines the write
713 * pointer. The write pointer starts at 0 (zero) while the read pointer
714 * starts at zero with rollover bit set
715 */
716 card->rxbd_wrptr = 0;
717 card->rxbd_rdptr = reg->rx_rollover_ind;
718
719 if (reg->pfu_enabled)
720 card->rxbd_ring_size = sizeof(struct mwifiex_pfu_buf_desc) *
721 MWIFIEX_MAX_TXRX_BD;
722 else
723 card->rxbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
724 MWIFIEX_MAX_TXRX_BD;
725
726 dev_dbg(adapter->dev, "info: rxbd_ring: Allocating %d bytes\n",
727 card->rxbd_ring_size);
728 card->rxbd_ring_vbase = pci_alloc_consistent(card->dev,
729 card->rxbd_ring_size,
730 &card->rxbd_ring_pbase);
731 if (!card->rxbd_ring_vbase) {
732 dev_err(adapter->dev,
733 "allocate consistent memory (%d bytes) failed!\n",
734 card->rxbd_ring_size);
735 return -ENOMEM;
736 }
737
738 dev_dbg(adapter->dev,
739 "info: rxbd_ring - base: %p, pbase: %#x:%x, len: %#x\n",
740 card->rxbd_ring_vbase, (u32)card->rxbd_ring_pbase,
741 (u32)((u64)card->rxbd_ring_pbase >> 32),
742 card->rxbd_ring_size);
743
744 return mwifiex_init_rxq_ring(adapter);
745 }
746
747 /*
748 * This function deletes Buffer descriptor ring for RX
749 */
750 static int mwifiex_pcie_delete_rxbd_ring(struct mwifiex_adapter *adapter)
751 {
752 struct pcie_service_card *card = adapter->card;
753 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
754
755 mwifiex_cleanup_rxq_ring(adapter);
756
757 if (card->rxbd_ring_vbase)
758 pci_free_consistent(card->dev, card->rxbd_ring_size,
759 card->rxbd_ring_vbase,
760 card->rxbd_ring_pbase);
761 card->rxbd_ring_size = 0;
762 card->rxbd_wrptr = 0;
763 card->rxbd_rdptr = 0 | reg->rx_rollover_ind;
764 card->rxbd_ring_vbase = NULL;
765 card->rxbd_ring_pbase = 0;
766
767 return 0;
768 }
769
770 /*
771 * This function creates buffer descriptor ring for Events
772 */
773 static int mwifiex_pcie_create_evtbd_ring(struct mwifiex_adapter *adapter)
774 {
775 struct pcie_service_card *card = adapter->card;
776 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
777
778 /*
779 * driver maintaines the read pointer and firmware maintaines the write
780 * pointer. The write pointer starts at 0 (zero) while the read pointer
781 * starts at zero with rollover bit set
782 */
783 card->evtbd_wrptr = 0;
784 card->evtbd_rdptr = reg->evt_rollover_ind;
785
786 card->evtbd_ring_size = sizeof(struct mwifiex_evt_buf_desc) *
787 MWIFIEX_MAX_EVT_BD;
788
789 dev_dbg(adapter->dev, "info: evtbd_ring: Allocating %d bytes\n",
790 card->evtbd_ring_size);
791 card->evtbd_ring_vbase = pci_alloc_consistent(card->dev,
792 card->evtbd_ring_size,
793 &card->evtbd_ring_pbase);
794 if (!card->evtbd_ring_vbase) {
795 dev_err(adapter->dev,
796 "allocate consistent memory (%d bytes) failed!\n",
797 card->evtbd_ring_size);
798 return -ENOMEM;
799 }
800
801 dev_dbg(adapter->dev,
802 "info: CMDRSP/EVT bd_ring - base: %p pbase: %#x:%x len: %#x\n",
803 card->evtbd_ring_vbase, (u32)card->evtbd_ring_pbase,
804 (u32)((u64)card->evtbd_ring_pbase >> 32),
805 card->evtbd_ring_size);
806
807 return mwifiex_pcie_init_evt_ring(adapter);
808 }
809
810 /*
811 * This function deletes Buffer descriptor ring for Events
812 */
813 static int mwifiex_pcie_delete_evtbd_ring(struct mwifiex_adapter *adapter)
814 {
815 struct pcie_service_card *card = adapter->card;
816 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
817
818 mwifiex_cleanup_evt_ring(adapter);
819
820 if (card->evtbd_ring_vbase)
821 pci_free_consistent(card->dev, card->evtbd_ring_size,
822 card->evtbd_ring_vbase,
823 card->evtbd_ring_pbase);
824 card->evtbd_wrptr = 0;
825 card->evtbd_rdptr = 0 | reg->evt_rollover_ind;
826 card->evtbd_ring_size = 0;
827 card->evtbd_ring_vbase = NULL;
828 card->evtbd_ring_pbase = 0;
829
830 return 0;
831 }
832
833 /*
834 * This function allocates a buffer for CMDRSP
835 */
836 static int mwifiex_pcie_alloc_cmdrsp_buf(struct mwifiex_adapter *adapter)
837 {
838 struct pcie_service_card *card = adapter->card;
839 struct sk_buff *skb;
840
841 /* Allocate memory for receiving command response data */
842 skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
843 if (!skb) {
844 dev_err(adapter->dev,
845 "Unable to allocate skb for command response data.\n");
846 return -ENOMEM;
847 }
848 skb_put(skb, MWIFIEX_UPLD_SIZE);
849 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
850 PCI_DMA_FROMDEVICE))
851 return -1;
852
853 card->cmdrsp_buf = skb;
854
855 return 0;
856 }
857
858 /*
859 * This function deletes a buffer for CMDRSP
860 */
861 static int mwifiex_pcie_delete_cmdrsp_buf(struct mwifiex_adapter *adapter)
862 {
863 struct pcie_service_card *card;
864 dma_addr_t buf_pa;
865
866 if (!adapter)
867 return 0;
868
869 card = adapter->card;
870
871 if (card && card->cmdrsp_buf) {
872 MWIFIEX_SKB_PACB(card->cmdrsp_buf, &buf_pa);
873 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
874 PCI_DMA_FROMDEVICE);
875 dev_kfree_skb_any(card->cmdrsp_buf);
876 }
877
878 if (card && card->cmd_buf) {
879 MWIFIEX_SKB_PACB(card->cmd_buf, &buf_pa);
880 pci_unmap_single(card->dev, buf_pa, card->cmd_buf->len,
881 PCI_DMA_TODEVICE);
882 }
883 return 0;
884 }
885
886 /*
887 * This function allocates a buffer for sleep cookie
888 */
889 static int mwifiex_pcie_alloc_sleep_cookie_buf(struct mwifiex_adapter *adapter)
890 {
891 struct pcie_service_card *card = adapter->card;
892
893 card->sleep_cookie_vbase = pci_alloc_consistent(card->dev, sizeof(u32),
894 &card->sleep_cookie_pbase);
895 if (!card->sleep_cookie_vbase) {
896 dev_err(adapter->dev, "pci_alloc_consistent failed!\n");
897 return -ENOMEM;
898 }
899 /* Init val of Sleep Cookie */
900 *(u32 *)card->sleep_cookie_vbase = FW_AWAKE_COOKIE;
901
902 dev_dbg(adapter->dev, "alloc_scook: sleep cookie=0x%x\n",
903 *((u32 *)card->sleep_cookie_vbase));
904
905 return 0;
906 }
907
908 /*
909 * This function deletes buffer for sleep cookie
910 */
911 static int mwifiex_pcie_delete_sleep_cookie_buf(struct mwifiex_adapter *adapter)
912 {
913 struct pcie_service_card *card;
914
915 if (!adapter)
916 return 0;
917
918 card = adapter->card;
919
920 if (card && card->sleep_cookie_vbase) {
921 pci_free_consistent(card->dev, sizeof(u32),
922 card->sleep_cookie_vbase,
923 card->sleep_cookie_pbase);
924 card->sleep_cookie_vbase = NULL;
925 }
926
927 return 0;
928 }
929
930 /* This function flushes the TX buffer descriptor ring
931 * This function defined as handler is also called while cleaning TXRX
932 * during disconnect/ bss stop.
933 */
934 static int mwifiex_clean_pcie_ring_buf(struct mwifiex_adapter *adapter)
935 {
936 struct pcie_service_card *card = adapter->card;
937
938 if (!mwifiex_pcie_txbd_empty(card, card->txbd_rdptr)) {
939 card->txbd_flush = 1;
940 /* write pointer already set at last send
941 * send dnld-rdy intr again, wait for completion.
942 */
943 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
944 CPU_INTR_DNLD_RDY)) {
945 dev_err(adapter->dev,
946 "failed to assert dnld-rdy interrupt.\n");
947 return -1;
948 }
949 }
950 return 0;
951 }
952
953 /*
954 * This function unmaps and frees downloaded data buffer
955 */
956 static int mwifiex_pcie_send_data_complete(struct mwifiex_adapter *adapter)
957 {
958 struct sk_buff *skb;
959 dma_addr_t buf_pa;
960 u32 wrdoneidx, rdptr, num_tx_buffs, unmap_count = 0;
961 struct mwifiex_pcie_buf_desc *desc;
962 struct mwifiex_pfu_buf_desc *desc2;
963 struct pcie_service_card *card = adapter->card;
964 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
965
966 if (!mwifiex_pcie_ok_to_access_hw(adapter))
967 mwifiex_pm_wakeup_card(adapter);
968
969 /* Read the TX ring read pointer set by firmware */
970 if (mwifiex_read_reg(adapter, reg->tx_rdptr, &rdptr)) {
971 dev_err(adapter->dev,
972 "SEND COMP: failed to read reg->tx_rdptr\n");
973 return -1;
974 }
975
976 dev_dbg(adapter->dev, "SEND COMP: rdptr_prev=0x%x, rdptr=0x%x\n",
977 card->txbd_rdptr, rdptr);
978
979 num_tx_buffs = MWIFIEX_MAX_TXRX_BD << reg->tx_start_ptr;
980 /* free from previous txbd_rdptr to current txbd_rdptr */
981 while (((card->txbd_rdptr & reg->tx_mask) !=
982 (rdptr & reg->tx_mask)) ||
983 ((card->txbd_rdptr & reg->tx_rollover_ind) !=
984 (rdptr & reg->tx_rollover_ind))) {
985 wrdoneidx = (card->txbd_rdptr & reg->tx_mask) >>
986 reg->tx_start_ptr;
987
988 skb = card->tx_buf_list[wrdoneidx];
989 if (skb) {
990 dev_dbg(adapter->dev,
991 "SEND COMP: Detach skb %p at txbd_rdidx=%d\n",
992 skb, wrdoneidx);
993 MWIFIEX_SKB_PACB(skb, &buf_pa);
994 pci_unmap_single(card->dev, buf_pa, skb->len,
995 PCI_DMA_TODEVICE);
996
997 unmap_count++;
998
999 if (card->txbd_flush)
1000 mwifiex_write_data_complete(adapter, skb, 0,
1001 -1);
1002 else
1003 mwifiex_write_data_complete(adapter, skb, 0, 0);
1004 }
1005
1006 card->tx_buf_list[wrdoneidx] = NULL;
1007
1008 if (reg->pfu_enabled) {
1009 desc2 = (void *)card->txbd_ring[wrdoneidx];
1010 memset(desc2, 0, sizeof(*desc2));
1011 } else {
1012 desc = card->txbd_ring[wrdoneidx];
1013 memset(desc, 0, sizeof(*desc));
1014 }
1015 switch (card->dev->device) {
1016 case PCIE_DEVICE_ID_MARVELL_88W8766P:
1017 card->txbd_rdptr++;
1018 break;
1019 case PCIE_DEVICE_ID_MARVELL_88W8897:
1020 card->txbd_rdptr += reg->ring_tx_start_ptr;
1021 break;
1022 }
1023
1024
1025 if ((card->txbd_rdptr & reg->tx_mask) == num_tx_buffs)
1026 card->txbd_rdptr = ((card->txbd_rdptr &
1027 reg->tx_rollover_ind) ^
1028 reg->tx_rollover_ind);
1029 }
1030
1031 if (unmap_count)
1032 adapter->data_sent = false;
1033
1034 if (card->txbd_flush) {
1035 if (mwifiex_pcie_txbd_empty(card, card->txbd_rdptr))
1036 card->txbd_flush = 0;
1037 else
1038 mwifiex_clean_pcie_ring_buf(adapter);
1039 }
1040
1041 return 0;
1042 }
1043
1044 /* This function sends data buffer to device. First 4 bytes of payload
1045 * are filled with payload length and payload type. Then this payload
1046 * is mapped to PCI device memory. Tx ring pointers are advanced accordingly.
1047 * Download ready interrupt to FW is deffered if Tx ring is not full and
1048 * additional payload can be accomodated.
1049 */
1050 static int
1051 mwifiex_pcie_send_data(struct mwifiex_adapter *adapter, struct sk_buff *skb,
1052 struct mwifiex_tx_param *tx_param)
1053 {
1054 struct pcie_service_card *card = adapter->card;
1055 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1056 u32 wrindx, num_tx_buffs, rx_val;
1057 int ret;
1058 dma_addr_t buf_pa;
1059 struct mwifiex_pcie_buf_desc *desc = NULL;
1060 struct mwifiex_pfu_buf_desc *desc2 = NULL;
1061 __le16 *tmp;
1062
1063 if (!(skb->data && skb->len)) {
1064 dev_err(adapter->dev, "%s(): invalid parameter <%p, %#x>\n",
1065 __func__, skb->data, skb->len);
1066 return -1;
1067 }
1068
1069 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1070 mwifiex_pm_wakeup_card(adapter);
1071
1072 num_tx_buffs = MWIFIEX_MAX_TXRX_BD << reg->tx_start_ptr;
1073 dev_dbg(adapter->dev, "info: SEND DATA: <Rd: %#x, Wr: %#x>\n",
1074 card->txbd_rdptr, card->txbd_wrptr);
1075 if (mwifiex_pcie_txbd_not_full(card)) {
1076 u8 *payload;
1077
1078 adapter->data_sent = true;
1079 payload = skb->data;
1080 tmp = (__le16 *)&payload[0];
1081 *tmp = cpu_to_le16((u16)skb->len);
1082 tmp = (__le16 *)&payload[2];
1083 *tmp = cpu_to_le16(MWIFIEX_TYPE_DATA);
1084
1085 if (mwifiex_map_pci_memory(adapter, skb, skb->len ,
1086 PCI_DMA_TODEVICE))
1087 return -1;
1088
1089 wrindx = (card->txbd_wrptr & reg->tx_mask) >> reg->tx_start_ptr;
1090 MWIFIEX_SKB_PACB(skb, &buf_pa);
1091 card->tx_buf_list[wrindx] = skb;
1092
1093 if (reg->pfu_enabled) {
1094 desc2 = (void *)card->txbd_ring[wrindx];
1095 desc2->paddr = buf_pa;
1096 desc2->len = (u16)skb->len;
1097 desc2->frag_len = (u16)skb->len;
1098 desc2->offset = 0;
1099 desc2->flags = MWIFIEX_BD_FLAG_FIRST_DESC |
1100 MWIFIEX_BD_FLAG_LAST_DESC;
1101 } else {
1102 desc = card->txbd_ring[wrindx];
1103 desc->paddr = buf_pa;
1104 desc->len = (u16)skb->len;
1105 desc->flags = MWIFIEX_BD_FLAG_FIRST_DESC |
1106 MWIFIEX_BD_FLAG_LAST_DESC;
1107 }
1108
1109 switch (card->dev->device) {
1110 case PCIE_DEVICE_ID_MARVELL_88W8766P:
1111 card->txbd_wrptr++;
1112 break;
1113 case PCIE_DEVICE_ID_MARVELL_88W8897:
1114 card->txbd_wrptr += reg->ring_tx_start_ptr;
1115 break;
1116 }
1117
1118 if ((card->txbd_wrptr & reg->tx_mask) == num_tx_buffs)
1119 card->txbd_wrptr = ((card->txbd_wrptr &
1120 reg->tx_rollover_ind) ^
1121 reg->tx_rollover_ind);
1122
1123 rx_val = card->rxbd_rdptr & reg->rx_wrap_mask;
1124 /* Write the TX ring write pointer in to reg->tx_wrptr */
1125 if (mwifiex_write_reg(adapter, reg->tx_wrptr,
1126 card->txbd_wrptr | rx_val)) {
1127 dev_err(adapter->dev,
1128 "SEND DATA: failed to write reg->tx_wrptr\n");
1129 ret = -1;
1130 goto done_unmap;
1131 }
1132 if ((mwifiex_pcie_txbd_not_full(card)) &&
1133 tx_param->next_pkt_len) {
1134 /* have more packets and TxBD still can hold more */
1135 dev_dbg(adapter->dev,
1136 "SEND DATA: delay dnld-rdy interrupt.\n");
1137 adapter->data_sent = false;
1138 } else {
1139 /* Send the TX ready interrupt */
1140 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1141 CPU_INTR_DNLD_RDY)) {
1142 dev_err(adapter->dev,
1143 "SEND DATA: failed to assert dnld-rdy interrupt.\n");
1144 ret = -1;
1145 goto done_unmap;
1146 }
1147 }
1148 dev_dbg(adapter->dev, "info: SEND DATA: Updated <Rd: %#x, Wr: "
1149 "%#x> and sent packet to firmware successfully\n",
1150 card->txbd_rdptr, card->txbd_wrptr);
1151 } else {
1152 dev_dbg(adapter->dev,
1153 "info: TX Ring full, can't send packets to fw\n");
1154 adapter->data_sent = true;
1155 /* Send the TX ready interrupt */
1156 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1157 CPU_INTR_DNLD_RDY))
1158 dev_err(adapter->dev,
1159 "SEND DATA: failed to assert door-bell intr\n");
1160 return -EBUSY;
1161 }
1162
1163 return -EINPROGRESS;
1164 done_unmap:
1165 MWIFIEX_SKB_PACB(skb, &buf_pa);
1166 pci_unmap_single(card->dev, buf_pa, skb->len, PCI_DMA_TODEVICE);
1167 card->tx_buf_list[wrindx] = NULL;
1168 if (reg->pfu_enabled)
1169 memset(desc2, 0, sizeof(*desc2));
1170 else
1171 memset(desc, 0, sizeof(*desc));
1172
1173 return ret;
1174 }
1175
1176 /*
1177 * This function handles received buffer ring and
1178 * dispatches packets to upper
1179 */
1180 static int mwifiex_pcie_process_recv_data(struct mwifiex_adapter *adapter)
1181 {
1182 struct pcie_service_card *card = adapter->card;
1183 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1184 u32 wrptr, rd_index, tx_val;
1185 dma_addr_t buf_pa;
1186 int ret = 0;
1187 struct sk_buff *skb_tmp = NULL;
1188 struct mwifiex_pcie_buf_desc *desc;
1189 struct mwifiex_pfu_buf_desc *desc2;
1190
1191 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1192 mwifiex_pm_wakeup_card(adapter);
1193
1194 /* Read the RX ring Write pointer set by firmware */
1195 if (mwifiex_read_reg(adapter, reg->rx_wrptr, &wrptr)) {
1196 dev_err(adapter->dev,
1197 "RECV DATA: failed to read reg->rx_wrptr\n");
1198 ret = -1;
1199 goto done;
1200 }
1201 card->rxbd_wrptr = wrptr;
1202
1203 while (((wrptr & reg->rx_mask) !=
1204 (card->rxbd_rdptr & reg->rx_mask)) ||
1205 ((wrptr & reg->rx_rollover_ind) ==
1206 (card->rxbd_rdptr & reg->rx_rollover_ind))) {
1207 struct sk_buff *skb_data;
1208 u16 rx_len;
1209 __le16 pkt_len;
1210
1211 rd_index = card->rxbd_rdptr & reg->rx_mask;
1212 skb_data = card->rx_buf_list[rd_index];
1213
1214 MWIFIEX_SKB_PACB(skb_data, &buf_pa);
1215 pci_unmap_single(card->dev, buf_pa, MWIFIEX_RX_DATA_BUF_SIZE,
1216 PCI_DMA_FROMDEVICE);
1217 card->rx_buf_list[rd_index] = NULL;
1218
1219 /* Get data length from interface header -
1220 * first 2 bytes for len, next 2 bytes is for type
1221 */
1222 pkt_len = *((__le16 *)skb_data->data);
1223 rx_len = le16_to_cpu(pkt_len);
1224 skb_put(skb_data, rx_len);
1225 dev_dbg(adapter->dev,
1226 "info: RECV DATA: Rd=%#x, Wr=%#x, Len=%d\n",
1227 card->rxbd_rdptr, wrptr, rx_len);
1228 skb_pull(skb_data, INTF_HEADER_LEN);
1229 mwifiex_handle_rx_packet(adapter, skb_data);
1230
1231 skb_tmp = dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE);
1232 if (!skb_tmp) {
1233 dev_err(adapter->dev,
1234 "Unable to allocate skb.\n");
1235 return -ENOMEM;
1236 }
1237
1238 if (mwifiex_map_pci_memory(adapter, skb_tmp,
1239 MWIFIEX_RX_DATA_BUF_SIZE,
1240 PCI_DMA_FROMDEVICE))
1241 return -1;
1242
1243 MWIFIEX_SKB_PACB(skb_tmp, &buf_pa);
1244
1245 dev_dbg(adapter->dev,
1246 "RECV DATA: Attach new sk_buff %p at rxbd_rdidx=%d\n",
1247 skb_tmp, rd_index);
1248 card->rx_buf_list[rd_index] = skb_tmp;
1249
1250 if (reg->pfu_enabled) {
1251 desc2 = (void *)card->rxbd_ring[rd_index];
1252 desc2->paddr = buf_pa;
1253 desc2->len = skb_tmp->len;
1254 desc2->frag_len = skb_tmp->len;
1255 desc2->offset = 0;
1256 desc2->flags = reg->ring_flag_sop | reg->ring_flag_eop;
1257 } else {
1258 desc = card->rxbd_ring[rd_index];
1259 desc->paddr = buf_pa;
1260 desc->len = skb_tmp->len;
1261 desc->flags = 0;
1262 }
1263
1264 if ((++card->rxbd_rdptr & reg->rx_mask) ==
1265 MWIFIEX_MAX_TXRX_BD) {
1266 card->rxbd_rdptr = ((card->rxbd_rdptr &
1267 reg->rx_rollover_ind) ^
1268 reg->rx_rollover_ind);
1269 }
1270 dev_dbg(adapter->dev, "info: RECV DATA: <Rd: %#x, Wr: %#x>\n",
1271 card->rxbd_rdptr, wrptr);
1272
1273 tx_val = card->txbd_wrptr & reg->tx_wrap_mask;
1274 /* Write the RX ring read pointer in to reg->rx_rdptr */
1275 if (mwifiex_write_reg(adapter, reg->rx_rdptr,
1276 card->rxbd_rdptr | tx_val)) {
1277 dev_err(adapter->dev,
1278 "RECV DATA: failed to write reg->rx_rdptr\n");
1279 ret = -1;
1280 goto done;
1281 }
1282
1283 /* Read the RX ring Write pointer set by firmware */
1284 if (mwifiex_read_reg(adapter, reg->rx_wrptr, &wrptr)) {
1285 dev_err(adapter->dev,
1286 "RECV DATA: failed to read reg->rx_wrptr\n");
1287 ret = -1;
1288 goto done;
1289 }
1290 dev_dbg(adapter->dev,
1291 "info: RECV DATA: Rcvd packet from fw successfully\n");
1292 card->rxbd_wrptr = wrptr;
1293 }
1294
1295 done:
1296 return ret;
1297 }
1298
1299 /*
1300 * This function downloads the boot command to device
1301 */
1302 static int
1303 mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
1304 {
1305 dma_addr_t buf_pa;
1306 struct pcie_service_card *card = adapter->card;
1307 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1308
1309 if (!(skb->data && skb->len)) {
1310 dev_err(adapter->dev,
1311 "Invalid parameter in %s <%p. len %d>\n",
1312 __func__, skb->data, skb->len);
1313 return -1;
1314 }
1315
1316 if (mwifiex_map_pci_memory(adapter, skb, skb->len , PCI_DMA_TODEVICE))
1317 return -1;
1318
1319 MWIFIEX_SKB_PACB(skb, &buf_pa);
1320
1321 /* Write the lower 32bits of the physical address to low command
1322 * address scratch register
1323 */
1324 if (mwifiex_write_reg(adapter, reg->cmd_addr_lo, (u32)buf_pa)) {
1325 dev_err(adapter->dev,
1326 "%s: failed to write download command to boot code.\n",
1327 __func__);
1328 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1329 PCI_DMA_TODEVICE);
1330 return -1;
1331 }
1332
1333 /* Write the upper 32bits of the physical address to high command
1334 * address scratch register
1335 */
1336 if (mwifiex_write_reg(adapter, reg->cmd_addr_hi,
1337 (u32)((u64)buf_pa >> 32))) {
1338 dev_err(adapter->dev,
1339 "%s: failed to write download command to boot code.\n",
1340 __func__);
1341 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1342 PCI_DMA_TODEVICE);
1343 return -1;
1344 }
1345
1346 /* Write the command length to cmd_size scratch register */
1347 if (mwifiex_write_reg(adapter, reg->cmd_size, skb->len)) {
1348 dev_err(adapter->dev,
1349 "%s: failed to write command len to cmd_size scratch reg\n",
1350 __func__);
1351 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1352 PCI_DMA_TODEVICE);
1353 return -1;
1354 }
1355
1356 /* Ring the door bell */
1357 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1358 CPU_INTR_DOOR_BELL)) {
1359 dev_err(adapter->dev,
1360 "%s: failed to assert door-bell intr\n", __func__);
1361 pci_unmap_single(card->dev, buf_pa,
1362 MWIFIEX_UPLD_SIZE, PCI_DMA_TODEVICE);
1363 return -1;
1364 }
1365
1366 return 0;
1367 }
1368
1369 /* This function init rx port in firmware which in turn enables to receive data
1370 * from device before transmitting any packet.
1371 */
1372 static int mwifiex_pcie_init_fw_port(struct mwifiex_adapter *adapter)
1373 {
1374 struct pcie_service_card *card = adapter->card;
1375 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1376 int tx_wrap = card->txbd_wrptr & reg->tx_wrap_mask;
1377
1378 /* Write the RX ring read pointer in to reg->rx_rdptr */
1379 if (mwifiex_write_reg(adapter, reg->rx_rdptr, card->rxbd_rdptr |
1380 tx_wrap)) {
1381 dev_err(adapter->dev,
1382 "RECV DATA: failed to write reg->rx_rdptr\n");
1383 return -1;
1384 }
1385 return 0;
1386 }
1387
1388 /* This function downloads commands to the device
1389 */
1390 static int
1391 mwifiex_pcie_send_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
1392 {
1393 struct pcie_service_card *card = adapter->card;
1394 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1395 int ret = 0;
1396 dma_addr_t cmd_buf_pa, cmdrsp_buf_pa;
1397 u8 *payload = (u8 *)skb->data;
1398
1399 if (!(skb->data && skb->len)) {
1400 dev_err(adapter->dev, "Invalid parameter in %s <%p, %#x>\n",
1401 __func__, skb->data, skb->len);
1402 return -1;
1403 }
1404
1405 /* Make sure a command response buffer is available */
1406 if (!card->cmdrsp_buf) {
1407 dev_err(adapter->dev,
1408 "No response buffer available, send command failed\n");
1409 return -EBUSY;
1410 }
1411
1412 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1413 mwifiex_pm_wakeup_card(adapter);
1414
1415 adapter->cmd_sent = true;
1416
1417 *(__le16 *)&payload[0] = cpu_to_le16((u16)skb->len);
1418 *(__le16 *)&payload[2] = cpu_to_le16(MWIFIEX_TYPE_CMD);
1419
1420 if (mwifiex_map_pci_memory(adapter, skb, skb->len, PCI_DMA_TODEVICE))
1421 return -1;
1422
1423 card->cmd_buf = skb;
1424
1425 /* To send a command, the driver will:
1426 1. Write the 64bit physical address of the data buffer to
1427 cmd response address low + cmd response address high
1428 2. Ring the door bell (i.e. set the door bell interrupt)
1429
1430 In response to door bell interrupt, the firmware will perform
1431 the DMA of the command packet (first header to obtain the total
1432 length and then rest of the command).
1433 */
1434
1435 if (card->cmdrsp_buf) {
1436 MWIFIEX_SKB_PACB(card->cmdrsp_buf, &cmdrsp_buf_pa);
1437 /* Write the lower 32bits of the cmdrsp buffer physical
1438 address */
1439 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo,
1440 (u32)cmdrsp_buf_pa)) {
1441 dev_err(adapter->dev,
1442 "Failed to write download cmd to boot code.\n");
1443 ret = -1;
1444 goto done;
1445 }
1446 /* Write the upper 32bits of the cmdrsp buffer physical
1447 address */
1448 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi,
1449 (u32)((u64)cmdrsp_buf_pa >> 32))) {
1450 dev_err(adapter->dev,
1451 "Failed to write download cmd to boot code.\n");
1452 ret = -1;
1453 goto done;
1454 }
1455 }
1456
1457 MWIFIEX_SKB_PACB(card->cmd_buf, &cmd_buf_pa);
1458 /* Write the lower 32bits of the physical address to reg->cmd_addr_lo */
1459 if (mwifiex_write_reg(adapter, reg->cmd_addr_lo,
1460 (u32)cmd_buf_pa)) {
1461 dev_err(adapter->dev,
1462 "Failed to write download cmd to boot code.\n");
1463 ret = -1;
1464 goto done;
1465 }
1466 /* Write the upper 32bits of the physical address to reg->cmd_addr_hi */
1467 if (mwifiex_write_reg(adapter, reg->cmd_addr_hi,
1468 (u32)((u64)cmd_buf_pa >> 32))) {
1469 dev_err(adapter->dev,
1470 "Failed to write download cmd to boot code.\n");
1471 ret = -1;
1472 goto done;
1473 }
1474
1475 /* Write the command length to reg->cmd_size */
1476 if (mwifiex_write_reg(adapter, reg->cmd_size,
1477 card->cmd_buf->len)) {
1478 dev_err(adapter->dev,
1479 "Failed to write cmd len to reg->cmd_size\n");
1480 ret = -1;
1481 goto done;
1482 }
1483
1484 /* Ring the door bell */
1485 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1486 CPU_INTR_DOOR_BELL)) {
1487 dev_err(adapter->dev,
1488 "Failed to assert door-bell intr\n");
1489 ret = -1;
1490 goto done;
1491 }
1492
1493 done:
1494 if (ret)
1495 adapter->cmd_sent = false;
1496
1497 return 0;
1498 }
1499
1500 /*
1501 * This function handles command complete interrupt
1502 */
1503 static int mwifiex_pcie_process_cmd_complete(struct mwifiex_adapter *adapter)
1504 {
1505 struct pcie_service_card *card = adapter->card;
1506 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1507 struct sk_buff *skb = card->cmdrsp_buf;
1508 int count = 0;
1509 u16 rx_len;
1510 __le16 pkt_len;
1511 dma_addr_t buf_pa;
1512
1513 dev_dbg(adapter->dev, "info: Rx CMD Response\n");
1514
1515 MWIFIEX_SKB_PACB(skb, &buf_pa);
1516 pci_unmap_single(card->dev, buf_pa, MWIFIEX_UPLD_SIZE,
1517 PCI_DMA_FROMDEVICE);
1518
1519 pkt_len = *((__le16 *)skb->data);
1520 rx_len = le16_to_cpu(pkt_len);
1521 skb_trim(skb, rx_len);
1522 skb_pull(skb, INTF_HEADER_LEN);
1523
1524 if (!adapter->curr_cmd) {
1525 if (adapter->ps_state == PS_STATE_SLEEP_CFM) {
1526 mwifiex_process_sleep_confirm_resp(adapter, skb->data,
1527 skb->len);
1528 while (reg->sleep_cookie && (count++ < 10) &&
1529 mwifiex_pcie_ok_to_access_hw(adapter))
1530 usleep_range(50, 60);
1531 } else {
1532 dev_err(adapter->dev,
1533 "There is no command but got cmdrsp\n");
1534 }
1535 memcpy(adapter->upld_buf, skb->data,
1536 min_t(u32, MWIFIEX_SIZE_OF_CMD_BUFFER, skb->len));
1537 skb_push(skb, INTF_HEADER_LEN);
1538 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1539 PCI_DMA_FROMDEVICE))
1540 return -1;
1541
1542 MWIFIEX_SKB_PACB(skb, &buf_pa);
1543 } else if (mwifiex_pcie_ok_to_access_hw(adapter)) {
1544 adapter->curr_cmd->resp_skb = skb;
1545 adapter->cmd_resp_received = true;
1546 /* Take the pointer and set it to CMD node and will
1547 return in the response complete callback */
1548 card->cmdrsp_buf = NULL;
1549
1550 /* Clear the cmd-rsp buffer address in scratch registers. This
1551 will prevent firmware from writing to the same response
1552 buffer again. */
1553 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_lo, 0)) {
1554 dev_err(adapter->dev,
1555 "cmd_done: failed to clear cmd_rsp_addr_lo\n");
1556 return -1;
1557 }
1558 /* Write the upper 32bits of the cmdrsp buffer physical
1559 address */
1560 if (mwifiex_write_reg(adapter, reg->cmdrsp_addr_hi, 0)) {
1561 dev_err(adapter->dev,
1562 "cmd_done: failed to clear cmd_rsp_addr_hi\n");
1563 return -1;
1564 }
1565 }
1566
1567 return 0;
1568 }
1569
1570 /*
1571 * Command Response processing complete handler
1572 */
1573 static int mwifiex_pcie_cmdrsp_complete(struct mwifiex_adapter *adapter,
1574 struct sk_buff *skb)
1575 {
1576 struct pcie_service_card *card = adapter->card;
1577 dma_addr_t buf_pa;
1578 struct sk_buff *skb_tmp;
1579
1580 if (skb) {
1581 card->cmdrsp_buf = skb;
1582 skb_push(card->cmdrsp_buf, INTF_HEADER_LEN);
1583 if (mwifiex_map_pci_memory(adapter, skb, MWIFIEX_UPLD_SIZE,
1584 PCI_DMA_FROMDEVICE))
1585 return -1;
1586 }
1587
1588 skb_tmp = card->cmd_buf;
1589 if (skb_tmp) {
1590 MWIFIEX_SKB_PACB(skb_tmp, &buf_pa);
1591 pci_unmap_single(card->dev, buf_pa, skb_tmp->len,
1592 PCI_DMA_FROMDEVICE);
1593 card->cmd_buf = NULL;
1594 }
1595
1596 return 0;
1597 }
1598
1599 /*
1600 * This function handles firmware event ready interrupt
1601 */
1602 static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter *adapter)
1603 {
1604 struct pcie_service_card *card = adapter->card;
1605 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1606 u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1607 u32 wrptr, event;
1608 dma_addr_t buf_pa;
1609 struct mwifiex_evt_buf_desc *desc;
1610
1611 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1612 mwifiex_pm_wakeup_card(adapter);
1613
1614 if (adapter->event_received) {
1615 dev_dbg(adapter->dev, "info: Event being processed, "
1616 "do not process this interrupt just yet\n");
1617 return 0;
1618 }
1619
1620 if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1621 dev_dbg(adapter->dev, "info: Invalid read pointer...\n");
1622 return -1;
1623 }
1624
1625 /* Read the event ring write pointer set by firmware */
1626 if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1627 dev_err(adapter->dev,
1628 "EventReady: failed to read reg->evt_wrptr\n");
1629 return -1;
1630 }
1631
1632 dev_dbg(adapter->dev, "info: EventReady: Initial <Rd: 0x%x, Wr: 0x%x>",
1633 card->evtbd_rdptr, wrptr);
1634 if (((wrptr & MWIFIEX_EVTBD_MASK) != (card->evtbd_rdptr
1635 & MWIFIEX_EVTBD_MASK)) ||
1636 ((wrptr & reg->evt_rollover_ind) ==
1637 (card->evtbd_rdptr & reg->evt_rollover_ind))) {
1638 struct sk_buff *skb_cmd;
1639 __le16 data_len = 0;
1640 u16 evt_len;
1641
1642 dev_dbg(adapter->dev, "info: Read Index: %d\n", rdptr);
1643 skb_cmd = card->evt_buf_list[rdptr];
1644 MWIFIEX_SKB_PACB(skb_cmd, &buf_pa);
1645 pci_unmap_single(card->dev, buf_pa, MAX_EVENT_SIZE,
1646 PCI_DMA_FROMDEVICE);
1647
1648 /* Take the pointer and set it to event pointer in adapter
1649 and will return back after event handling callback */
1650 card->evt_buf_list[rdptr] = NULL;
1651 desc = card->evtbd_ring[rdptr];
1652 memset(desc, 0, sizeof(*desc));
1653
1654 event = *(u32 *) &skb_cmd->data[INTF_HEADER_LEN];
1655 adapter->event_cause = event;
1656 /* The first 4bytes will be the event transfer header
1657 len is 2 bytes followed by type which is 2 bytes */
1658 memcpy(&data_len, skb_cmd->data, sizeof(__le16));
1659 evt_len = le16_to_cpu(data_len);
1660
1661 skb_pull(skb_cmd, INTF_HEADER_LEN);
1662 dev_dbg(adapter->dev, "info: Event length: %d\n", evt_len);
1663
1664 if ((evt_len > 0) && (evt_len < MAX_EVENT_SIZE))
1665 memcpy(adapter->event_body, skb_cmd->data +
1666 MWIFIEX_EVENT_HEADER_LEN, evt_len -
1667 MWIFIEX_EVENT_HEADER_LEN);
1668
1669 adapter->event_received = true;
1670 adapter->event_skb = skb_cmd;
1671
1672 /* Do not update the event read pointer here, wait till the
1673 buffer is released. This is just to make things simpler,
1674 we need to find a better method of managing these buffers.
1675 */
1676 }
1677
1678 return 0;
1679 }
1680
1681 /*
1682 * Event processing complete handler
1683 */
1684 static int mwifiex_pcie_event_complete(struct mwifiex_adapter *adapter,
1685 struct sk_buff *skb)
1686 {
1687 struct pcie_service_card *card = adapter->card;
1688 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1689 int ret = 0;
1690 u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1691 u32 wrptr;
1692 dma_addr_t buf_pa;
1693 struct mwifiex_evt_buf_desc *desc;
1694
1695 if (!skb)
1696 return 0;
1697
1698 if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1699 dev_err(adapter->dev, "event_complete: Invalid rdptr 0x%x\n",
1700 rdptr);
1701 return -EINVAL;
1702 }
1703
1704 /* Read the event ring write pointer set by firmware */
1705 if (mwifiex_read_reg(adapter, reg->evt_wrptr, &wrptr)) {
1706 dev_err(adapter->dev,
1707 "event_complete: failed to read reg->evt_wrptr\n");
1708 return -1;
1709 }
1710
1711 if (!card->evt_buf_list[rdptr]) {
1712 skb_push(skb, INTF_HEADER_LEN);
1713 if (mwifiex_map_pci_memory(adapter, skb,
1714 MAX_EVENT_SIZE,
1715 PCI_DMA_FROMDEVICE))
1716 return -1;
1717 MWIFIEX_SKB_PACB(skb, &buf_pa);
1718 card->evt_buf_list[rdptr] = skb;
1719 MWIFIEX_SKB_PACB(skb, &buf_pa);
1720 desc = card->evtbd_ring[rdptr];
1721 desc->paddr = buf_pa;
1722 desc->len = (u16)skb->len;
1723 desc->flags = 0;
1724 skb = NULL;
1725 } else {
1726 dev_dbg(adapter->dev,
1727 "info: ERROR: buf still valid at index %d, <%p, %p>\n",
1728 rdptr, card->evt_buf_list[rdptr], skb);
1729 }
1730
1731 if ((++card->evtbd_rdptr & MWIFIEX_EVTBD_MASK) == MWIFIEX_MAX_EVT_BD) {
1732 card->evtbd_rdptr = ((card->evtbd_rdptr &
1733 reg->evt_rollover_ind) ^
1734 reg->evt_rollover_ind);
1735 }
1736
1737 dev_dbg(adapter->dev, "info: Updated <Rd: 0x%x, Wr: 0x%x>",
1738 card->evtbd_rdptr, wrptr);
1739
1740 /* Write the event ring read pointer in to reg->evt_rdptr */
1741 if (mwifiex_write_reg(adapter, reg->evt_rdptr,
1742 card->evtbd_rdptr)) {
1743 dev_err(adapter->dev,
1744 "event_complete: failed to read reg->evt_rdptr\n");
1745 return -1;
1746 }
1747
1748 dev_dbg(adapter->dev, "info: Check Events Again\n");
1749 ret = mwifiex_pcie_process_event_ready(adapter);
1750
1751 return ret;
1752 }
1753
1754 /*
1755 * This function downloads the firmware to the card.
1756 *
1757 * Firmware is downloaded to the card in blocks. Every block download
1758 * is tested for CRC errors, and retried a number of times before
1759 * returning failure.
1760 */
1761 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter *adapter,
1762 struct mwifiex_fw_image *fw)
1763 {
1764 int ret;
1765 u8 *firmware = fw->fw_buf;
1766 u32 firmware_len = fw->fw_len;
1767 u32 offset = 0;
1768 struct sk_buff *skb;
1769 u32 txlen, tx_blocks = 0, tries, len;
1770 u32 block_retry_cnt = 0;
1771 dma_addr_t buf_pa;
1772 struct pcie_service_card *card = adapter->card;
1773 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1774
1775 if (!firmware || !firmware_len) {
1776 dev_err(adapter->dev,
1777 "No firmware image found! Terminating download\n");
1778 return -1;
1779 }
1780
1781 dev_dbg(adapter->dev, "info: Downloading FW image (%d bytes)\n",
1782 firmware_len);
1783
1784 if (mwifiex_pcie_disable_host_int(adapter)) {
1785 dev_err(adapter->dev,
1786 "%s: Disabling interrupts failed.\n", __func__);
1787 return -1;
1788 }
1789
1790 skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
1791 if (!skb) {
1792 ret = -ENOMEM;
1793 goto done;
1794 }
1795
1796 /* Perform firmware data transfer */
1797 do {
1798 u32 ireg_intr = 0;
1799
1800 /* More data? */
1801 if (offset >= firmware_len)
1802 break;
1803
1804 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
1805 ret = mwifiex_read_reg(adapter, reg->cmd_size,
1806 &len);
1807 if (ret) {
1808 dev_warn(adapter->dev,
1809 "Failed reading len from boot code\n");
1810 goto done;
1811 }
1812 if (len)
1813 break;
1814 usleep_range(10, 20);
1815 }
1816
1817 if (!len) {
1818 break;
1819 } else if (len > MWIFIEX_UPLD_SIZE) {
1820 pr_err("FW download failure @ %d, invalid length %d\n",
1821 offset, len);
1822 ret = -1;
1823 goto done;
1824 }
1825
1826 txlen = len;
1827
1828 if (len & BIT(0)) {
1829 block_retry_cnt++;
1830 if (block_retry_cnt > MAX_WRITE_IOMEM_RETRY) {
1831 pr_err("FW download failure @ %d, over max "
1832 "retry count\n", offset);
1833 ret = -1;
1834 goto done;
1835 }
1836 dev_err(adapter->dev, "FW CRC error indicated by the "
1837 "helper: len = 0x%04X, txlen = %d\n",
1838 len, txlen);
1839 len &= ~BIT(0);
1840 /* Setting this to 0 to resend from same offset */
1841 txlen = 0;
1842 } else {
1843 block_retry_cnt = 0;
1844 /* Set blocksize to transfer - checking for
1845 last block */
1846 if (firmware_len - offset < txlen)
1847 txlen = firmware_len - offset;
1848
1849 dev_dbg(adapter->dev, ".");
1850
1851 tx_blocks = (txlen + card->pcie.blksz_fw_dl - 1) /
1852 card->pcie.blksz_fw_dl;
1853
1854 /* Copy payload to buffer */
1855 memmove(skb->data, &firmware[offset], txlen);
1856 }
1857
1858 skb_put(skb, MWIFIEX_UPLD_SIZE - skb->len);
1859 skb_trim(skb, tx_blocks * card->pcie.blksz_fw_dl);
1860
1861 /* Send the boot command to device */
1862 if (mwifiex_pcie_send_boot_cmd(adapter, skb)) {
1863 dev_err(adapter->dev,
1864 "Failed to send firmware download command\n");
1865 ret = -1;
1866 goto done;
1867 }
1868
1869 MWIFIEX_SKB_PACB(skb, &buf_pa);
1870
1871 /* Wait for the command done interrupt */
1872 do {
1873 if (mwifiex_read_reg(adapter, PCIE_CPU_INT_STATUS,
1874 &ireg_intr)) {
1875 dev_err(adapter->dev, "%s: Failed to read "
1876 "interrupt status during fw dnld.\n",
1877 __func__);
1878 pci_unmap_single(card->dev, buf_pa, skb->len,
1879 PCI_DMA_TODEVICE);
1880 ret = -1;
1881 goto done;
1882 }
1883 } while ((ireg_intr & CPU_INTR_DOOR_BELL) ==
1884 CPU_INTR_DOOR_BELL);
1885
1886 pci_unmap_single(card->dev, buf_pa, skb->len,
1887 PCI_DMA_TODEVICE);
1888
1889 offset += txlen;
1890 } while (true);
1891
1892 dev_dbg(adapter->dev, "info:\nFW download over, size %d bytes\n",
1893 offset);
1894
1895 ret = 0;
1896
1897 done:
1898 dev_kfree_skb_any(skb);
1899 return ret;
1900 }
1901
1902 /*
1903 * This function checks the firmware status in card.
1904 *
1905 * The winner interface is also determined by this function.
1906 */
1907 static int
1908 mwifiex_check_fw_status(struct mwifiex_adapter *adapter, u32 poll_num)
1909 {
1910 int ret = 0;
1911 u32 firmware_stat, winner_status;
1912 struct pcie_service_card *card = adapter->card;
1913 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
1914 u32 tries;
1915
1916 /* Mask spurios interrupts */
1917 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS_MASK,
1918 HOST_INTR_MASK)) {
1919 dev_warn(adapter->dev, "Write register failed\n");
1920 return -1;
1921 }
1922
1923 dev_dbg(adapter->dev, "Setting driver ready signature\n");
1924 if (mwifiex_write_reg(adapter, reg->drv_rdy,
1925 FIRMWARE_READY_PCIE)) {
1926 dev_err(adapter->dev,
1927 "Failed to write driver ready signature\n");
1928 return -1;
1929 }
1930
1931 /* Wait for firmware initialization event */
1932 for (tries = 0; tries < poll_num; tries++) {
1933 if (mwifiex_read_reg(adapter, reg->fw_status,
1934 &firmware_stat))
1935 ret = -1;
1936 else
1937 ret = 0;
1938 if (ret)
1939 continue;
1940 if (firmware_stat == FIRMWARE_READY_PCIE) {
1941 ret = 0;
1942 break;
1943 } else {
1944 msleep(100);
1945 ret = -1;
1946 }
1947 }
1948
1949 if (ret) {
1950 if (mwifiex_read_reg(adapter, reg->fw_status,
1951 &winner_status))
1952 ret = -1;
1953 else if (!winner_status) {
1954 dev_err(adapter->dev, "PCI-E is the winner\n");
1955 adapter->winner = 1;
1956 } else {
1957 dev_err(adapter->dev,
1958 "PCI-E is not the winner <%#x,%d>, exit dnld\n",
1959 ret, adapter->winner);
1960 }
1961 }
1962
1963 return ret;
1964 }
1965
1966 /*
1967 * This function reads the interrupt status from card.
1968 */
1969 static void mwifiex_interrupt_status(struct mwifiex_adapter *adapter)
1970 {
1971 u32 pcie_ireg;
1972 unsigned long flags;
1973
1974 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1975 return;
1976
1977 if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS, &pcie_ireg)) {
1978 dev_warn(adapter->dev, "Read register failed\n");
1979 return;
1980 }
1981
1982 if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
1983
1984 mwifiex_pcie_disable_host_int(adapter);
1985
1986 /* Clear the pending interrupts */
1987 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS,
1988 ~pcie_ireg)) {
1989 dev_warn(adapter->dev, "Write register failed\n");
1990 return;
1991 }
1992 spin_lock_irqsave(&adapter->int_lock, flags);
1993 adapter->int_status |= pcie_ireg;
1994 spin_unlock_irqrestore(&adapter->int_lock, flags);
1995
1996 if (pcie_ireg & HOST_INTR_CMD_DONE) {
1997 if ((adapter->ps_state == PS_STATE_SLEEP_CFM) ||
1998 (adapter->ps_state == PS_STATE_SLEEP)) {
1999 mwifiex_pcie_enable_host_int(adapter);
2000 if (mwifiex_write_reg(adapter,
2001 PCIE_CPU_INT_EVENT,
2002 CPU_INTR_SLEEP_CFM_DONE)
2003 ) {
2004 dev_warn(adapter->dev,
2005 "Write register failed\n");
2006 return;
2007
2008 }
2009 }
2010 } else if (!adapter->pps_uapsd_mode &&
2011 adapter->ps_state == PS_STATE_SLEEP &&
2012 mwifiex_pcie_ok_to_access_hw(adapter)) {
2013 /* Potentially for PCIe we could get other
2014 * interrupts like shared. Don't change power
2015 * state until cookie is set */
2016 adapter->ps_state = PS_STATE_AWAKE;
2017 adapter->pm_wakeup_fw_try = false;
2018 }
2019 }
2020 }
2021
2022 /*
2023 * Interrupt handler for PCIe root port
2024 *
2025 * This function reads the interrupt status from firmware and assigns
2026 * the main process in workqueue which will handle the interrupt.
2027 */
2028 static irqreturn_t mwifiex_pcie_interrupt(int irq, void *context)
2029 {
2030 struct pci_dev *pdev = (struct pci_dev *)context;
2031 struct pcie_service_card *card;
2032 struct mwifiex_adapter *adapter;
2033
2034 if (!pdev) {
2035 pr_debug("info: %s: pdev is NULL\n", (u8 *)pdev);
2036 goto exit;
2037 }
2038
2039 card = pci_get_drvdata(pdev);
2040 if (!card || !card->adapter) {
2041 pr_debug("info: %s: card=%p adapter=%p\n", __func__, card,
2042 card ? card->adapter : NULL);
2043 goto exit;
2044 }
2045 adapter = card->adapter;
2046
2047 if (adapter->surprise_removed)
2048 goto exit;
2049
2050 mwifiex_interrupt_status(adapter);
2051 queue_work(adapter->workqueue, &adapter->main_work);
2052
2053 exit:
2054 return IRQ_HANDLED;
2055 }
2056
2057 /*
2058 * This function checks the current interrupt status.
2059 *
2060 * The following interrupts are checked and handled by this function -
2061 * - Data sent
2062 * - Command sent
2063 * - Command received
2064 * - Packets received
2065 * - Events received
2066 *
2067 * In case of Rx packets received, the packets are uploaded from card to
2068 * host and processed accordingly.
2069 */
2070 static int mwifiex_process_int_status(struct mwifiex_adapter *adapter)
2071 {
2072 int ret;
2073 u32 pcie_ireg;
2074 unsigned long flags;
2075
2076 spin_lock_irqsave(&adapter->int_lock, flags);
2077 /* Clear out unused interrupts */
2078 pcie_ireg = adapter->int_status;
2079 adapter->int_status = 0;
2080 spin_unlock_irqrestore(&adapter->int_lock, flags);
2081
2082 while (pcie_ireg & HOST_INTR_MASK) {
2083 if (pcie_ireg & HOST_INTR_DNLD_DONE) {
2084 pcie_ireg &= ~HOST_INTR_DNLD_DONE;
2085 dev_dbg(adapter->dev, "info: TX DNLD Done\n");
2086 ret = mwifiex_pcie_send_data_complete(adapter);
2087 if (ret)
2088 return ret;
2089 }
2090 if (pcie_ireg & HOST_INTR_UPLD_RDY) {
2091 pcie_ireg &= ~HOST_INTR_UPLD_RDY;
2092 dev_dbg(adapter->dev, "info: Rx DATA\n");
2093 ret = mwifiex_pcie_process_recv_data(adapter);
2094 if (ret)
2095 return ret;
2096 }
2097 if (pcie_ireg & HOST_INTR_EVENT_RDY) {
2098 pcie_ireg &= ~HOST_INTR_EVENT_RDY;
2099 dev_dbg(adapter->dev, "info: Rx EVENT\n");
2100 ret = mwifiex_pcie_process_event_ready(adapter);
2101 if (ret)
2102 return ret;
2103 }
2104
2105 if (pcie_ireg & HOST_INTR_CMD_DONE) {
2106 pcie_ireg &= ~HOST_INTR_CMD_DONE;
2107 if (adapter->cmd_sent) {
2108 dev_dbg(adapter->dev,
2109 "info: CMD sent Interrupt\n");
2110 adapter->cmd_sent = false;
2111 }
2112 /* Handle command response */
2113 ret = mwifiex_pcie_process_cmd_complete(adapter);
2114 if (ret)
2115 return ret;
2116 }
2117
2118 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
2119 if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS,
2120 &pcie_ireg)) {
2121 dev_warn(adapter->dev,
2122 "Read register failed\n");
2123 return -1;
2124 }
2125
2126 if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
2127 if (mwifiex_write_reg(adapter,
2128 PCIE_HOST_INT_STATUS,
2129 ~pcie_ireg)) {
2130 dev_warn(adapter->dev,
2131 "Write register failed\n");
2132 return -1;
2133 }
2134 }
2135
2136 }
2137 }
2138 dev_dbg(adapter->dev, "info: cmd_sent=%d data_sent=%d\n",
2139 adapter->cmd_sent, adapter->data_sent);
2140 if (adapter->ps_state != PS_STATE_SLEEP)
2141 mwifiex_pcie_enable_host_int(adapter);
2142
2143 return 0;
2144 }
2145
2146 /*
2147 * This function downloads data from driver to card.
2148 *
2149 * Both commands and data packets are transferred to the card by this
2150 * function.
2151 *
2152 * This function adds the PCIE specific header to the front of the buffer
2153 * before transferring. The header contains the length of the packet and
2154 * the type. The firmware handles the packets based upon this set type.
2155 */
2156 static int mwifiex_pcie_host_to_card(struct mwifiex_adapter *adapter, u8 type,
2157 struct sk_buff *skb,
2158 struct mwifiex_tx_param *tx_param)
2159 {
2160 if (!skb) {
2161 dev_err(adapter->dev, "Passed NULL skb to %s\n", __func__);
2162 return -1;
2163 }
2164
2165 if (type == MWIFIEX_TYPE_DATA)
2166 return mwifiex_pcie_send_data(adapter, skb, tx_param);
2167 else if (type == MWIFIEX_TYPE_CMD)
2168 return mwifiex_pcie_send_cmd(adapter, skb);
2169
2170 return 0;
2171 }
2172
2173 /*
2174 * This function initializes the PCI-E host memory space, WCB rings, etc.
2175 *
2176 * The following initializations steps are followed -
2177 * - Allocate TXBD ring buffers
2178 * - Allocate RXBD ring buffers
2179 * - Allocate event BD ring buffers
2180 * - Allocate command response ring buffer
2181 * - Allocate sleep cookie buffer
2182 */
2183 static int mwifiex_pcie_init(struct mwifiex_adapter *adapter)
2184 {
2185 struct pcie_service_card *card = adapter->card;
2186 int ret;
2187 struct pci_dev *pdev = card->dev;
2188 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2189
2190 pci_set_drvdata(pdev, card);
2191
2192 ret = pci_enable_device(pdev);
2193 if (ret)
2194 goto err_enable_dev;
2195
2196 pci_set_master(pdev);
2197
2198 dev_dbg(adapter->dev, "try set_consistent_dma_mask(32)\n");
2199 ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2200 if (ret) {
2201 dev_err(adapter->dev, "set_dma_mask(32) failed\n");
2202 goto err_set_dma_mask;
2203 }
2204
2205 ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
2206 if (ret) {
2207 dev_err(adapter->dev, "set_consistent_dma_mask(64) failed\n");
2208 goto err_set_dma_mask;
2209 }
2210
2211 ret = pci_request_region(pdev, 0, DRV_NAME);
2212 if (ret) {
2213 dev_err(adapter->dev, "req_reg(0) error\n");
2214 goto err_req_region0;
2215 }
2216 card->pci_mmap = pci_iomap(pdev, 0, 0);
2217 if (!card->pci_mmap) {
2218 dev_err(adapter->dev, "iomap(0) error\n");
2219 ret = -EIO;
2220 goto err_iomap0;
2221 }
2222 ret = pci_request_region(pdev, 2, DRV_NAME);
2223 if (ret) {
2224 dev_err(adapter->dev, "req_reg(2) error\n");
2225 goto err_req_region2;
2226 }
2227 card->pci_mmap1 = pci_iomap(pdev, 2, 0);
2228 if (!card->pci_mmap1) {
2229 dev_err(adapter->dev, "iomap(2) error\n");
2230 ret = -EIO;
2231 goto err_iomap2;
2232 }
2233
2234 dev_dbg(adapter->dev,
2235 "PCI memory map Virt0: %p PCI memory map Virt2: %p\n",
2236 card->pci_mmap, card->pci_mmap1);
2237
2238 card->cmdrsp_buf = NULL;
2239 ret = mwifiex_pcie_create_txbd_ring(adapter);
2240 if (ret)
2241 goto err_cre_txbd;
2242 ret = mwifiex_pcie_create_rxbd_ring(adapter);
2243 if (ret)
2244 goto err_cre_rxbd;
2245 ret = mwifiex_pcie_create_evtbd_ring(adapter);
2246 if (ret)
2247 goto err_cre_evtbd;
2248 ret = mwifiex_pcie_alloc_cmdrsp_buf(adapter);
2249 if (ret)
2250 goto err_alloc_cmdbuf;
2251 if (reg->sleep_cookie) {
2252 ret = mwifiex_pcie_alloc_sleep_cookie_buf(adapter);
2253 if (ret)
2254 goto err_alloc_cookie;
2255 } else {
2256 card->sleep_cookie_vbase = NULL;
2257 }
2258 return ret;
2259
2260 err_alloc_cookie:
2261 mwifiex_pcie_delete_cmdrsp_buf(adapter);
2262 err_alloc_cmdbuf:
2263 mwifiex_pcie_delete_evtbd_ring(adapter);
2264 err_cre_evtbd:
2265 mwifiex_pcie_delete_rxbd_ring(adapter);
2266 err_cre_rxbd:
2267 mwifiex_pcie_delete_txbd_ring(adapter);
2268 err_cre_txbd:
2269 pci_iounmap(pdev, card->pci_mmap1);
2270 err_iomap2:
2271 pci_release_region(pdev, 2);
2272 err_req_region2:
2273 pci_iounmap(pdev, card->pci_mmap);
2274 err_iomap0:
2275 pci_release_region(pdev, 0);
2276 err_req_region0:
2277 err_set_dma_mask:
2278 pci_disable_device(pdev);
2279 err_enable_dev:
2280 pci_set_drvdata(pdev, NULL);
2281 return ret;
2282 }
2283
2284 /*
2285 * This function cleans up the allocated card buffers.
2286 *
2287 * The following are freed by this function -
2288 * - TXBD ring buffers
2289 * - RXBD ring buffers
2290 * - Event BD ring buffers
2291 * - Command response ring buffer
2292 * - Sleep cookie buffer
2293 */
2294 static void mwifiex_pcie_cleanup(struct mwifiex_adapter *adapter)
2295 {
2296 struct pcie_service_card *card = adapter->card;
2297 struct pci_dev *pdev = card->dev;
2298 const struct mwifiex_pcie_card_reg *reg = card->pcie.reg;
2299
2300 if (user_rmmod) {
2301 dev_dbg(adapter->dev, "Clearing driver ready signature\n");
2302 if (mwifiex_write_reg(adapter, reg->drv_rdy, 0x00000000))
2303 dev_err(adapter->dev,
2304 "Failed to write driver not-ready signature\n");
2305 }
2306
2307 if (pdev) {
2308 pci_iounmap(pdev, card->pci_mmap);
2309 pci_iounmap(pdev, card->pci_mmap1);
2310 pci_disable_device(pdev);
2311 pci_release_region(pdev, 2);
2312 pci_release_region(pdev, 0);
2313 pci_set_drvdata(pdev, NULL);
2314 }
2315 kfree(card);
2316 }
2317
2318 /*
2319 * This function registers the PCIE device.
2320 *
2321 * PCIE IRQ is claimed, block size is set and driver data is initialized.
2322 */
2323 static int mwifiex_register_dev(struct mwifiex_adapter *adapter)
2324 {
2325 int ret;
2326 struct pcie_service_card *card = adapter->card;
2327 struct pci_dev *pdev = card->dev;
2328
2329 /* save adapter pointer in card */
2330 card->adapter = adapter;
2331
2332 ret = request_irq(pdev->irq, mwifiex_pcie_interrupt, IRQF_SHARED,
2333 "MRVL_PCIE", pdev);
2334 if (ret) {
2335 pr_err("request_irq failed: ret=%d\n", ret);
2336 adapter->card = NULL;
2337 return -1;
2338 }
2339
2340 adapter->dev = &pdev->dev;
2341 strcpy(adapter->fw_name, card->pcie.firmware);
2342
2343 return 0;
2344 }
2345
2346 /*
2347 * This function unregisters the PCIE device.
2348 *
2349 * The PCIE IRQ is released, the function is disabled and driver
2350 * data is set to null.
2351 */
2352 static void mwifiex_unregister_dev(struct mwifiex_adapter *adapter)
2353 {
2354 struct pcie_service_card *card = adapter->card;
2355 const struct mwifiex_pcie_card_reg *reg;
2356
2357 if (card) {
2358 dev_dbg(adapter->dev, "%s(): calling free_irq()\n", __func__);
2359 free_irq(card->dev->irq, card->dev);
2360
2361 reg = card->pcie.reg;
2362 if (reg->sleep_cookie)
2363 mwifiex_pcie_delete_sleep_cookie_buf(adapter);
2364
2365 mwifiex_pcie_delete_cmdrsp_buf(adapter);
2366 mwifiex_pcie_delete_evtbd_ring(adapter);
2367 mwifiex_pcie_delete_rxbd_ring(adapter);
2368 mwifiex_pcie_delete_txbd_ring(adapter);
2369 card->cmdrsp_buf = NULL;
2370 }
2371 }
2372
2373 static struct mwifiex_if_ops pcie_ops = {
2374 .init_if = mwifiex_pcie_init,
2375 .cleanup_if = mwifiex_pcie_cleanup,
2376 .check_fw_status = mwifiex_check_fw_status,
2377 .prog_fw = mwifiex_prog_fw_w_helper,
2378 .register_dev = mwifiex_register_dev,
2379 .unregister_dev = mwifiex_unregister_dev,
2380 .enable_int = mwifiex_pcie_enable_host_int,
2381 .process_int_status = mwifiex_process_int_status,
2382 .host_to_card = mwifiex_pcie_host_to_card,
2383 .wakeup = mwifiex_pm_wakeup_card,
2384 .wakeup_complete = mwifiex_pm_wakeup_card_complete,
2385
2386 /* PCIE specific */
2387 .cmdrsp_complete = mwifiex_pcie_cmdrsp_complete,
2388 .event_complete = mwifiex_pcie_event_complete,
2389 .update_mp_end_port = NULL,
2390 .cleanup_mpa_buf = NULL,
2391 .init_fw_port = mwifiex_pcie_init_fw_port,
2392 .clean_pcie_ring = mwifiex_clean_pcie_ring_buf,
2393 };
2394
2395 /*
2396 * This function initializes the PCIE driver module.
2397 *
2398 * This initiates the semaphore and registers the device with
2399 * PCIE bus.
2400 */
2401 static int mwifiex_pcie_init_module(void)
2402 {
2403 int ret;
2404
2405 pr_debug("Marvell PCIe Driver\n");
2406
2407 sema_init(&add_remove_card_sem, 1);
2408
2409 /* Clear the flag in case user removes the card. */
2410 user_rmmod = 0;
2411
2412 ret = pci_register_driver(&mwifiex_pcie);
2413 if (ret)
2414 pr_err("Driver register failed!\n");
2415 else
2416 pr_debug("info: Driver registered successfully!\n");
2417
2418 return ret;
2419 }
2420
2421 /*
2422 * This function cleans up the PCIE driver.
2423 *
2424 * The following major steps are followed for cleanup -
2425 * - Resume the device if its suspended
2426 * - Disconnect the device if connected
2427 * - Shutdown the firmware
2428 * - Unregister the device from PCIE bus.
2429 */
2430 static void mwifiex_pcie_cleanup_module(void)
2431 {
2432 if (!down_interruptible(&add_remove_card_sem))
2433 up(&add_remove_card_sem);
2434
2435 /* Set the flag as user is removing this module. */
2436 user_rmmod = 1;
2437
2438 pci_unregister_driver(&mwifiex_pcie);
2439 }
2440
2441 module_init(mwifiex_pcie_init_module);
2442 module_exit(mwifiex_pcie_cleanup_module);
2443
2444 MODULE_AUTHOR("Marvell International Ltd.");
2445 MODULE_DESCRIPTION("Marvell WiFi-Ex PCI-Express Driver version " PCIE_VERSION);
2446 MODULE_VERSION(PCIE_VERSION);
2447 MODULE_LICENSE("GPL v2");
2448 MODULE_FIRMWARE(PCIE8766_DEFAULT_FW_NAME);
2449 MODULE_FIRMWARE(PCIE8897_DEFAULT_FW_NAME);
Linux with added FPC-III support