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