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