?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[linux-btrfs-devel.git] / drivers / net / wireless / mwifiex / pcie.c
blobd34acf082d3ae03fdc0b35b58f19a924415915a0
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 /*
43 * This function is called after skb allocation to update
44 * "skb->cb" with physical address of data pointer.
45 */
46 static phys_addr_t *mwifiex_update_sk_buff_pa(struct sk_buff *skb)
47 {
48 phys_addr_t *buf_pa = MWIFIEX_SKB_PACB(skb);
49
50 *buf_pa = (phys_addr_t)virt_to_phys(skb->data);
51
52 return buf_pa;
53 }
54
55 /*
56 * This function reads sleep cookie and checks if FW is ready
57 */
58 static bool mwifiex_pcie_ok_to_access_hw(struct mwifiex_adapter *adapter)
59 {
60 u32 *cookie_addr;
61 struct pcie_service_card *card = adapter->card;
62
63 if (card->sleep_cookie) {
64 cookie_addr = (u32 *)card->sleep_cookie->data;
65 dev_dbg(adapter->dev, "info: ACCESS_HW: sleep cookie=0x%x\n",
66 *cookie_addr);
67 if (*cookie_addr == FW_AWAKE_COOKIE)
68 return true;
69 }
70
71 return false;
72 }
73
74 /*
75 * This function probes an mwifiex device and registers it. It allocates
76 * the card structure, enables PCIE function number and initiates the
77 * device registration and initialization procedure by adding a logical
78 * interface.
79 */
80 static int mwifiex_pcie_probe(struct pci_dev *pdev,
81 const struct pci_device_id *ent)
82 {
83 struct pcie_service_card *card;
84
85 pr_debug("info: vendor=0x%4.04X device=0x%4.04X rev=%d\n",
86 pdev->vendor, pdev->device, pdev->revision);
87
88 card = kzalloc(sizeof(struct pcie_service_card), GFP_KERNEL);
89 if (!card) {
90 pr_err("%s: failed to alloc memory\n", __func__);
91 return -ENOMEM;
92 }
93
94 card->dev = pdev;
95
96 if (mwifiex_add_card(card, &add_remove_card_sem, &pcie_ops,
97 MWIFIEX_PCIE)) {
98 pr_err("%s failed\n", __func__);
99 kfree(card);
100 return -1;
101 }
102
103 return 0;
104 }
105
106 /*
107 * This function removes the interface and frees up the card structure.
108 */
109 static void mwifiex_pcie_remove(struct pci_dev *pdev)
110 {
111 struct pcie_service_card *card;
112 struct mwifiex_adapter *adapter;
113 int i;
114
115 card = pci_get_drvdata(pdev);
116 if (!card)
117 return;
118
119 adapter = card->adapter;
120 if (!adapter || !adapter->priv_num)
121 return;
122
123 if (user_rmmod) {
124 #ifdef CONFIG_PM
125 if (adapter->is_suspended)
126 mwifiex_pcie_resume(pdev);
127 #endif
128
129 for (i = 0; i < adapter->priv_num; i++)
130 if ((GET_BSS_ROLE(adapter->priv[i]) ==
131 MWIFIEX_BSS_ROLE_STA) &&
132 adapter->priv[i]->media_connected)
133 mwifiex_deauthenticate(adapter->priv[i], NULL);
134
135 mwifiex_disable_auto_ds(mwifiex_get_priv(adapter,
136 MWIFIEX_BSS_ROLE_ANY));
137
138 mwifiex_init_shutdown_fw(mwifiex_get_priv(adapter,
139 MWIFIEX_BSS_ROLE_ANY),
140 MWIFIEX_FUNC_SHUTDOWN);
141 }
142
143 mwifiex_remove_card(card->adapter, &add_remove_card_sem);
144 kfree(card);
145 }
146
147 /*
148 * Kernel needs to suspend all functions separately. Therefore all
149 * registered functions must have drivers with suspend and resume
150 * methods. Failing that the kernel simply removes the whole card.
151 *
152 * If already not suspended, this function allocates and sends a host
153 * sleep activate request to the firmware and turns off the traffic.
154 */
155 static int mwifiex_pcie_suspend(struct pci_dev *pdev, pm_message_t state)
156 {
157 struct mwifiex_adapter *adapter;
158 struct pcie_service_card *card;
159 int hs_actived, i;
160
161 if (pdev) {
162 card = (struct pcie_service_card *) pci_get_drvdata(pdev);
163 if (!card || card->adapter) {
164 pr_err("Card or adapter structure is not valid\n");
165 return 0;
166 }
167 } else {
168 pr_err("PCIE device is not specified\n");
169 return 0;
170 }
171
172 adapter = card->adapter;
173
174 hs_actived = mwifiex_enable_hs(adapter);
175
176 /* Indicate device suspended */
177 adapter->is_suspended = true;
178
179 for (i = 0; i < adapter->priv_num; i++)
180 netif_carrier_off(adapter->priv[i]->netdev);
181
182 return 0;
183 }
184
185 /*
186 * Kernel needs to suspend all functions separately. Therefore all
187 * registered functions must have drivers with suspend and resume
188 * methods. Failing that the kernel simply removes the whole card.
189 *
190 * If already not resumed, this function turns on the traffic and
191 * sends a host sleep cancel request to the firmware.
192 */
193 static int mwifiex_pcie_resume(struct pci_dev *pdev)
194 {
195 struct mwifiex_adapter *adapter;
196 struct pcie_service_card *card;
197 int i;
198
199 if (pdev) {
200 card = (struct pcie_service_card *) pci_get_drvdata(pdev);
201 if (!card || !card->adapter) {
202 pr_err("Card or adapter structure is not valid\n");
203 return 0;
204 }
205 } else {
206 pr_err("PCIE device is not specified\n");
207 return 0;
208 }
209
210 adapter = card->adapter;
211
212 if (!adapter->is_suspended) {
213 dev_warn(adapter->dev, "Device already resumed\n");
214 return 0;
215 }
216
217 adapter->is_suspended = false;
218
219 for (i = 0; i < adapter->priv_num; i++)
220 if (adapter->priv[i]->media_connected)
221 netif_carrier_on(adapter->priv[i]->netdev);
222
223 mwifiex_cancel_hs(mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA),
224 MWIFIEX_ASYNC_CMD);
225
226 return 0;
227 }
228
229 #define PCIE_VENDOR_ID_MARVELL (0x11ab)
230 #define PCIE_DEVICE_ID_MARVELL_88W8766P (0x2b30)
231
232 static DEFINE_PCI_DEVICE_TABLE(mwifiex_ids) = {
233 {
234 PCIE_VENDOR_ID_MARVELL, PCIE_DEVICE_ID_MARVELL_88W8766P,
235 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
236 },
237 {},
238 };
239
240 MODULE_DEVICE_TABLE(pci, mwifiex_ids);
241
242 /* PCI Device Driver */
243 static struct pci_driver __refdata mwifiex_pcie = {
244 .name = "mwifiex_pcie",
245 .id_table = mwifiex_ids,
246 .probe = mwifiex_pcie_probe,
247 .remove = mwifiex_pcie_remove,
248 #ifdef CONFIG_PM
249 /* Power Management Hooks */
250 .suspend = mwifiex_pcie_suspend,
251 .resume = mwifiex_pcie_resume,
252 #endif
253 };
254
255 /*
256 * This function writes data into PCIE card register.
257 */
258 static int mwifiex_write_reg(struct mwifiex_adapter *adapter, int reg, u32 data)
259 {
260 struct pcie_service_card *card = adapter->card;
261
262 iowrite32(data, card->pci_mmap1 + reg);
263
264 return 0;
265 }
266
267 /*
268 * This function reads data from PCIE card register.
269 */
270 static int mwifiex_read_reg(struct mwifiex_adapter *adapter, int reg, u32 *data)
271 {
272 struct pcie_service_card *card = adapter->card;
273
274 *data = ioread32(card->pci_mmap1 + reg);
275
276 return 0;
277 }
278
279 /*
280 * This function wakes up the card.
281 *
282 * A host power up command is written to the card configuration
283 * register to wake up the card.
284 */
285 static int mwifiex_pm_wakeup_card(struct mwifiex_adapter *adapter)
286 {
287 int i = 0;
288
289 while (mwifiex_pcie_ok_to_access_hw(adapter)) {
290 i++;
291 udelay(10);
292 /* 50ms max wait */
293 if (i == 50000)
294 break;
295 }
296
297 dev_dbg(adapter->dev, "event: Wakeup device...\n");
298
299 /* Enable interrupts or any chip access will wakeup device */
300 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK, HOST_INTR_MASK)) {
301 dev_warn(adapter->dev, "Enable host interrupt failed\n");
302 return -1;
303 }
304
305 dev_dbg(adapter->dev, "PCIE wakeup: Setting PS_STATE_AWAKE\n");
306 adapter->ps_state = PS_STATE_AWAKE;
307
308 return 0;
309 }
310
311 /*
312 * This function is called after the card has woken up.
313 *
314 * The card configuration register is reset.
315 */
316 static int mwifiex_pm_wakeup_card_complete(struct mwifiex_adapter *adapter)
317 {
318 dev_dbg(adapter->dev, "cmd: Wakeup device completed\n");
319
320 return 0;
321 }
322
323 /*
324 * This function disables the host interrupt.
325 *
326 * The host interrupt mask is read, the disable bit is reset and
327 * written back to the card host interrupt mask register.
328 */
329 static int mwifiex_pcie_disable_host_int(struct mwifiex_adapter *adapter)
330 {
331 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
332 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK,
333 0x00000000)) {
334 dev_warn(adapter->dev, "Disable host interrupt failed\n");
335 return -1;
336 }
337 }
338
339 return 0;
340 }
341
342 /*
343 * This function enables the host interrupt.
344 *
345 * The host interrupt enable mask is written to the card
346 * host interrupt mask register.
347 */
348 static int mwifiex_pcie_enable_host_int(struct mwifiex_adapter *adapter)
349 {
350 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
351 /* Simply write the mask to the register */
352 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_MASK,
353 HOST_INTR_MASK)) {
354 dev_warn(adapter->dev, "Enable host interrupt failed\n");
355 return -1;
356 }
357 }
358
359 return 0;
360 }
361
362 /*
363 * This function creates buffer descriptor ring for TX
364 */
365 static int mwifiex_pcie_create_txbd_ring(struct mwifiex_adapter *adapter)
366 {
367 struct pcie_service_card *card = adapter->card;
368 struct sk_buff *skb;
369 int i;
370 phys_addr_t *buf_pa;
371
372 /*
373 * driver maintaines the write pointer and firmware maintaines the read
374 * pointer. The write pointer starts at 0 (zero) while the read pointer
375 * starts at zero with rollover bit set
376 */
377 card->txbd_wrptr = 0;
378 card->txbd_rdptr |= MWIFIEX_BD_FLAG_ROLLOVER_IND;
379
380 /* allocate shared memory for the BD ring and divide the same in to
381 several descriptors */
382 card->txbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
383 MWIFIEX_MAX_TXRX_BD;
384 dev_dbg(adapter->dev, "info: txbd_ring: Allocating %d bytes\n",
385 card->txbd_ring_size);
386 card->txbd_ring_vbase = kzalloc(card->txbd_ring_size, GFP_KERNEL);
387 if (!card->txbd_ring_vbase) {
388 dev_err(adapter->dev, "Unable to allocate buffer for txbd ring.\n");
389 kfree(card->txbd_ring_vbase);
390 return -1;
391 }
392 card->txbd_ring_pbase = virt_to_phys(card->txbd_ring_vbase);
393
394 dev_dbg(adapter->dev, "info: txbd_ring - base: %p, pbase: %#x:%x,"
395 "len: %x\n", card->txbd_ring_vbase,
396 (u32)card->txbd_ring_pbase,
397 (u32)((u64)card->txbd_ring_pbase >> 32),
398 card->txbd_ring_size);
399
400 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
401 card->txbd_ring[i] = (struct mwifiex_pcie_buf_desc *)
402 (card->txbd_ring_vbase +
403 (sizeof(struct mwifiex_pcie_buf_desc) * i));
404
405 /* Allocate buffer here so that firmware can DMA data from it */
406 skb = dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE);
407 if (!skb) {
408 dev_err(adapter->dev, "Unable to allocate skb for TX ring.\n");
409 kfree(card->txbd_ring_vbase);
410 return -ENOMEM;
411 }
412 buf_pa = mwifiex_update_sk_buff_pa(skb);
413
414 skb_put(skb, MWIFIEX_RX_DATA_BUF_SIZE);
415 dev_dbg(adapter->dev, "info: TX ring: add new skb base: %p, "
416 "buf_base: %p, buf_pbase: %#x:%x, "
417 "buf_len: %#x\n", skb, skb->data,
418 (u32)*buf_pa, (u32)(((u64)*buf_pa >> 32)),
419 skb->len);
420
421 card->tx_buf_list[i] = skb;
422 card->txbd_ring[i]->paddr = *buf_pa;
423 card->txbd_ring[i]->len = (u16)skb->len;
424 card->txbd_ring[i]->flags = 0;
425 }
426
427 return 0;
428 }
429
430 static int mwifiex_pcie_delete_txbd_ring(struct mwifiex_adapter *adapter)
431 {
432 struct pcie_service_card *card = adapter->card;
433 int i;
434
435 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
436 if (card->tx_buf_list[i])
437 dev_kfree_skb_any(card->tx_buf_list[i]);
438 card->tx_buf_list[i] = NULL;
439 card->txbd_ring[i]->paddr = 0;
440 card->txbd_ring[i]->len = 0;
441 card->txbd_ring[i]->flags = 0;
442 card->txbd_ring[i] = NULL;
443 }
444
445 kfree(card->txbd_ring_vbase);
446 card->txbd_ring_size = 0;
447 card->txbd_wrptr = 0;
448 card->txbd_rdptr = 0 | MWIFIEX_BD_FLAG_ROLLOVER_IND;
449 card->txbd_ring_vbase = NULL;
450
451 return 0;
452 }
453
454 /*
455 * This function creates buffer descriptor ring for RX
456 */
457 static int mwifiex_pcie_create_rxbd_ring(struct mwifiex_adapter *adapter)
458 {
459 struct pcie_service_card *card = adapter->card;
460 struct sk_buff *skb;
461 int i;
462 phys_addr_t *buf_pa;
463
464 /*
465 * driver maintaines the read pointer and firmware maintaines the write
466 * pointer. The write pointer starts at 0 (zero) while the read pointer
467 * starts at zero with rollover bit set
468 */
469 card->rxbd_wrptr = 0;
470 card->rxbd_rdptr |= MWIFIEX_BD_FLAG_ROLLOVER_IND;
471
472 card->rxbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
473 MWIFIEX_MAX_TXRX_BD;
474 dev_dbg(adapter->dev, "info: rxbd_ring: Allocating %d bytes\n",
475 card->rxbd_ring_size);
476 card->rxbd_ring_vbase = kzalloc(card->rxbd_ring_size, GFP_KERNEL);
477 if (!card->rxbd_ring_vbase) {
478 dev_err(adapter->dev, "Unable to allocate buffer for "
479 "rxbd_ring.\n");
480 return -1;
481 }
482 card->rxbd_ring_pbase = virt_to_phys(card->rxbd_ring_vbase);
483
484 dev_dbg(adapter->dev, "info: rxbd_ring - base: %p, pbase: %#x:%x,"
485 "len: %#x\n", card->rxbd_ring_vbase,
486 (u32)card->rxbd_ring_pbase,
487 (u32)((u64)card->rxbd_ring_pbase >> 32),
488 card->rxbd_ring_size);
489
490 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
491 card->rxbd_ring[i] = (struct mwifiex_pcie_buf_desc *)
492 (card->rxbd_ring_vbase +
493 (sizeof(struct mwifiex_pcie_buf_desc) * i));
494
495 /* Allocate skb here so that firmware can DMA data from it */
496 skb = dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE);
497 if (!skb) {
498 dev_err(adapter->dev, "Unable to allocate skb for RX ring.\n");
499 kfree(card->rxbd_ring_vbase);
500 return -ENOMEM;
501 }
502 buf_pa = mwifiex_update_sk_buff_pa(skb);
503 skb_put(skb, MWIFIEX_RX_DATA_BUF_SIZE);
504
505 dev_dbg(adapter->dev, "info: RX ring: add new skb base: %p, "
506 "buf_base: %p, buf_pbase: %#x:%x, "
507 "buf_len: %#x\n", skb, skb->data,
508 (u32)*buf_pa, (u32)((u64)*buf_pa >> 32),
509 skb->len);
510
511 card->rx_buf_list[i] = skb;
512 card->rxbd_ring[i]->paddr = *buf_pa;
513 card->rxbd_ring[i]->len = (u16)skb->len;
514 card->rxbd_ring[i]->flags = 0;
515 }
516
517 return 0;
518 }
519
520 /*
521 * This function deletes Buffer descriptor ring for RX
522 */
523 static int mwifiex_pcie_delete_rxbd_ring(struct mwifiex_adapter *adapter)
524 {
525 struct pcie_service_card *card = adapter->card;
526 int i;
527
528 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
529 if (card->rx_buf_list[i])
530 dev_kfree_skb_any(card->rx_buf_list[i]);
531 card->rx_buf_list[i] = NULL;
532 card->rxbd_ring[i]->paddr = 0;
533 card->rxbd_ring[i]->len = 0;
534 card->rxbd_ring[i]->flags = 0;
535 card->rxbd_ring[i] = NULL;
536 }
537
538 kfree(card->rxbd_ring_vbase);
539 card->rxbd_ring_size = 0;
540 card->rxbd_wrptr = 0;
541 card->rxbd_rdptr = 0 | MWIFIEX_BD_FLAG_ROLLOVER_IND;
542 card->rxbd_ring_vbase = NULL;
543
544 return 0;
545 }
546
547 /*
548 * This function creates buffer descriptor ring for Events
549 */
550 static int mwifiex_pcie_create_evtbd_ring(struct mwifiex_adapter *adapter)
551 {
552 struct pcie_service_card *card = adapter->card;
553 struct sk_buff *skb;
554 int i;
555 phys_addr_t *buf_pa;
556
557 /*
558 * driver maintaines the read pointer and firmware maintaines the write
559 * pointer. The write pointer starts at 0 (zero) while the read pointer
560 * starts at zero with rollover bit set
561 */
562 card->evtbd_wrptr = 0;
563 card->evtbd_rdptr |= MWIFIEX_BD_FLAG_ROLLOVER_IND;
564
565 card->evtbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
566 MWIFIEX_MAX_EVT_BD;
567 dev_dbg(adapter->dev, "info: evtbd_ring: Allocating %d bytes\n",
568 card->evtbd_ring_size);
569 card->evtbd_ring_vbase = kzalloc(card->evtbd_ring_size, GFP_KERNEL);
570 if (!card->evtbd_ring_vbase) {
571 dev_err(adapter->dev, "Unable to allocate buffer. "
572 "Terminating download\n");
573 return -1;
574 }
575 card->evtbd_ring_pbase = virt_to_phys(card->evtbd_ring_vbase);
576
577 dev_dbg(adapter->dev, "info: CMDRSP/EVT bd_ring - base: %p, "
578 "pbase: %#x:%x, len: %#x\n", card->evtbd_ring_vbase,
579 (u32)card->evtbd_ring_pbase,
580 (u32)((u64)card->evtbd_ring_pbase >> 32),
581 card->evtbd_ring_size);
582
583 for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) {
584 card->evtbd_ring[i] = (struct mwifiex_pcie_buf_desc *)
585 (card->evtbd_ring_vbase +
586 (sizeof(struct mwifiex_pcie_buf_desc) * i));
587
588 /* Allocate skb here so that firmware can DMA data from it */
589 skb = dev_alloc_skb(MAX_EVENT_SIZE);
590 if (!skb) {
591 dev_err(adapter->dev, "Unable to allocate skb for EVENT buf.\n");
592 kfree(card->evtbd_ring_vbase);
593 return -ENOMEM;
594 }
595 buf_pa = mwifiex_update_sk_buff_pa(skb);
596 skb_put(skb, MAX_EVENT_SIZE);
597
598 dev_dbg(adapter->dev, "info: Evt ring: add new skb. base: %p, "
599 "buf_base: %p, buf_pbase: %#x:%x, "
600 "buf_len: %#x\n", skb, skb->data,
601 (u32)*buf_pa, (u32)((u64)*buf_pa >> 32),
602 skb->len);
603
604 card->evt_buf_list[i] = skb;
605 card->evtbd_ring[i]->paddr = *buf_pa;
606 card->evtbd_ring[i]->len = (u16)skb->len;
607 card->evtbd_ring[i]->flags = 0;
608 }
609
610 return 0;
611 }
612
613 /*
614 * This function deletes Buffer descriptor ring for Events
615 */
616 static int mwifiex_pcie_delete_evtbd_ring(struct mwifiex_adapter *adapter)
617 {
618 struct pcie_service_card *card = adapter->card;
619 int i;
620
621 for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) {
622 if (card->evt_buf_list[i])
623 dev_kfree_skb_any(card->evt_buf_list[i]);
624 card->evt_buf_list[i] = NULL;
625 card->evtbd_ring[i]->paddr = 0;
626 card->evtbd_ring[i]->len = 0;
627 card->evtbd_ring[i]->flags = 0;
628 card->evtbd_ring[i] = NULL;
629 }
630
631 kfree(card->evtbd_ring_vbase);
632 card->evtbd_wrptr = 0;
633 card->evtbd_rdptr = 0 | MWIFIEX_BD_FLAG_ROLLOVER_IND;
634 card->evtbd_ring_size = 0;
635 card->evtbd_ring_vbase = NULL;
636
637 return 0;
638 }
639
640 /*
641 * This function allocates a buffer for CMDRSP
642 */
643 static int mwifiex_pcie_alloc_cmdrsp_buf(struct mwifiex_adapter *adapter)
644 {
645 struct pcie_service_card *card = adapter->card;
646 struct sk_buff *skb;
647
648 /* Allocate memory for receiving command response data */
649 skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
650 if (!skb) {
651 dev_err(adapter->dev, "Unable to allocate skb for command "
652 "response data.\n");
653 return -ENOMEM;
654 }
655 mwifiex_update_sk_buff_pa(skb);
656 skb_put(skb, MWIFIEX_UPLD_SIZE);
657 card->cmdrsp_buf = skb;
658
659 skb = NULL;
660 /* Allocate memory for sending command to firmware */
661 skb = dev_alloc_skb(MWIFIEX_SIZE_OF_CMD_BUFFER);
662 if (!skb) {
663 dev_err(adapter->dev, "Unable to allocate skb for command "
664 "data.\n");
665 return -ENOMEM;
666 }
667 mwifiex_update_sk_buff_pa(skb);
668 skb_put(skb, MWIFIEX_SIZE_OF_CMD_BUFFER);
669 card->cmd_buf = skb;
670
671 return 0;
672 }
673
674 /*
675 * This function deletes a buffer for CMDRSP
676 */
677 static int mwifiex_pcie_delete_cmdrsp_buf(struct mwifiex_adapter *adapter)
678 {
679 struct pcie_service_card *card;
680
681 if (!adapter)
682 return 0;
683
684 card = adapter->card;
685
686 if (card && card->cmdrsp_buf)
687 dev_kfree_skb_any(card->cmdrsp_buf);
688
689 if (card && card->cmd_buf)
690 dev_kfree_skb_any(card->cmd_buf);
691
692 return 0;
693 }
694
695 /*
696 * This function allocates a buffer for sleep cookie
697 */
698 static int mwifiex_pcie_alloc_sleep_cookie_buf(struct mwifiex_adapter *adapter)
699 {
700 struct sk_buff *skb;
701 struct pcie_service_card *card = adapter->card;
702
703 /* Allocate memory for sleep cookie */
704 skb = dev_alloc_skb(sizeof(u32));
705 if (!skb) {
706 dev_err(adapter->dev, "Unable to allocate skb for sleep "
707 "cookie!\n");
708 return -ENOMEM;
709 }
710 mwifiex_update_sk_buff_pa(skb);
711 skb_put(skb, sizeof(u32));
712
713 /* Init val of Sleep Cookie */
714 *(u32 *)skb->data = FW_AWAKE_COOKIE;
715
716 dev_dbg(adapter->dev, "alloc_scook: sleep cookie=0x%x\n",
717 *((u32 *)skb->data));
718
719 /* Save the sleep cookie */
720 card->sleep_cookie = skb;
721
722 return 0;
723 }
724
725 /*
726 * This function deletes buffer for sleep cookie
727 */
728 static int mwifiex_pcie_delete_sleep_cookie_buf(struct mwifiex_adapter *adapter)
729 {
730 struct pcie_service_card *card;
731
732 if (!adapter)
733 return 0;
734
735 card = adapter->card;
736
737 if (card && card->sleep_cookie) {
738 dev_kfree_skb_any(card->sleep_cookie);
739 card->sleep_cookie = NULL;
740 }
741
742 return 0;
743 }
744
745 /*
746 * This function sends data buffer to device
747 */
748 static int
749 mwifiex_pcie_send_data(struct mwifiex_adapter *adapter, struct sk_buff *skb)
750 {
751 struct pcie_service_card *card = adapter->card;
752 u32 wrindx, rdptr;
753 phys_addr_t *buf_pa;
754 __le16 *tmp;
755
756 if (!mwifiex_pcie_ok_to_access_hw(adapter))
757 mwifiex_pm_wakeup_card(adapter);
758
759 /* Read the TX ring read pointer set by firmware */
760 if (mwifiex_read_reg(adapter, REG_TXBD_RDPTR, &rdptr)) {
761 dev_err(adapter->dev, "SEND DATA: failed to read "
762 "REG_TXBD_RDPTR\n");
763 return -1;
764 }
765
766 wrindx = card->txbd_wrptr & MWIFIEX_TXBD_MASK;
767
768 dev_dbg(adapter->dev, "info: SEND DATA: <Rd: %#x, Wr: %#x>\n", rdptr,
769 card->txbd_wrptr);
770 if (((card->txbd_wrptr & MWIFIEX_TXBD_MASK) !=
771 (rdptr & MWIFIEX_TXBD_MASK)) ||
772 ((card->txbd_wrptr & MWIFIEX_BD_FLAG_ROLLOVER_IND) !=
773 (rdptr & MWIFIEX_BD_FLAG_ROLLOVER_IND))) {
774 struct sk_buff *skb_data;
775 u8 *payload;
776
777 adapter->data_sent = true;
778 skb_data = card->tx_buf_list[wrindx];
779 memcpy(skb_data->data, skb->data, skb->len);
780 payload = skb_data->data;
781 tmp = (__le16 *)&payload[0];
782 *tmp = cpu_to_le16((u16)skb->len);
783 tmp = (__le16 *)&payload[2];
784 *tmp = cpu_to_le16(MWIFIEX_TYPE_DATA);
785 skb_put(skb_data, MWIFIEX_RX_DATA_BUF_SIZE - skb_data->len);
786 skb_trim(skb_data, skb->len);
787 buf_pa = MWIFIEX_SKB_PACB(skb_data);
788 card->txbd_ring[wrindx]->paddr = *buf_pa;
789 card->txbd_ring[wrindx]->len = (u16)skb_data->len;
790 card->txbd_ring[wrindx]->flags = MWIFIEX_BD_FLAG_FIRST_DESC |
791 MWIFIEX_BD_FLAG_LAST_DESC;
792
793 if ((++card->txbd_wrptr & MWIFIEX_TXBD_MASK) ==
794 MWIFIEX_MAX_TXRX_BD)
795 card->txbd_wrptr = ((card->txbd_wrptr &
796 MWIFIEX_BD_FLAG_ROLLOVER_IND) ^
797 MWIFIEX_BD_FLAG_ROLLOVER_IND);
798
799 /* Write the TX ring write pointer in to REG_TXBD_WRPTR */
800 if (mwifiex_write_reg(adapter, REG_TXBD_WRPTR,
801 card->txbd_wrptr)) {
802 dev_err(adapter->dev, "SEND DATA: failed to write "
803 "REG_TXBD_WRPTR\n");
804 return 0;
805 }
806
807 /* Send the TX ready interrupt */
808 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
809 CPU_INTR_DNLD_RDY)) {
810 dev_err(adapter->dev, "SEND DATA: failed to assert "
811 "door-bell interrupt.\n");
812 return -1;
813 }
814 dev_dbg(adapter->dev, "info: SEND DATA: Updated <Rd: %#x, Wr: "
815 "%#x> and sent packet to firmware "
816 "successfully\n", rdptr,
817 card->txbd_wrptr);
818 } else {
819 dev_dbg(adapter->dev, "info: TX Ring full, can't send anymore "
820 "packets to firmware\n");
821 adapter->data_sent = true;
822 /* Send the TX ready interrupt */
823 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
824 CPU_INTR_DNLD_RDY))
825 dev_err(adapter->dev, "SEND DATA: failed to assert "
826 "door-bell interrupt\n");
827 return -EBUSY;
828 }
829
830 return 0;
831 }
832
833 /*
834 * This function handles received buffer ring and
835 * dispatches packets to upper
836 */
837 static int mwifiex_pcie_process_recv_data(struct mwifiex_adapter *adapter)
838 {
839 struct pcie_service_card *card = adapter->card;
840 u32 wrptr, rd_index;
841 int ret = 0;
842 struct sk_buff *skb_tmp = NULL;
843
844 /* Read the RX ring Write pointer set by firmware */
845 if (mwifiex_read_reg(adapter, REG_RXBD_WRPTR, &wrptr)) {
846 dev_err(adapter->dev, "RECV DATA: failed to read "
847 "REG_TXBD_RDPTR\n");
848 ret = -1;
849 goto done;
850 }
851
852 while (((wrptr & MWIFIEX_RXBD_MASK) !=
853 (card->rxbd_rdptr & MWIFIEX_RXBD_MASK)) ||
854 ((wrptr & MWIFIEX_BD_FLAG_ROLLOVER_IND) ==
855 (card->rxbd_rdptr & MWIFIEX_BD_FLAG_ROLLOVER_IND))) {
856 struct sk_buff *skb_data;
857 u16 rx_len;
858
859 rd_index = card->rxbd_rdptr & MWIFIEX_RXBD_MASK;
860 skb_data = card->rx_buf_list[rd_index];
861
862 /* Get data length from interface header -
863 first byte is len, second byte is type */
864 rx_len = *((u16 *)skb_data->data);
865 dev_dbg(adapter->dev, "info: RECV DATA: Rd=%#x, Wr=%#x, "
866 "Len=%d\n", card->rxbd_rdptr, wrptr, rx_len);
867 skb_tmp = dev_alloc_skb(rx_len);
868 if (!skb_tmp) {
869 dev_dbg(adapter->dev, "info: Failed to alloc skb "
870 "for RX\n");
871 ret = -EBUSY;
872 goto done;
873 }
874
875 skb_put(skb_tmp, rx_len);
876
877 memcpy(skb_tmp->data, skb_data->data + INTF_HEADER_LEN, rx_len);
878 if ((++card->rxbd_rdptr & MWIFIEX_RXBD_MASK) ==
879 MWIFIEX_MAX_TXRX_BD) {
880 card->rxbd_rdptr = ((card->rxbd_rdptr &
881 MWIFIEX_BD_FLAG_ROLLOVER_IND) ^
882 MWIFIEX_BD_FLAG_ROLLOVER_IND);
883 }
884 dev_dbg(adapter->dev, "info: RECV DATA: <Rd: %#x, Wr: %#x>\n",
885 card->rxbd_rdptr, wrptr);
886
887 /* Write the RX ring read pointer in to REG_RXBD_RDPTR */
888 if (mwifiex_write_reg(adapter, REG_RXBD_RDPTR,
889 card->rxbd_rdptr)) {
890 dev_err(adapter->dev, "RECV DATA: failed to "
891 "write REG_RXBD_RDPTR\n");
892 ret = -1;
893 goto done;
894 }
895
896 /* Read the RX ring Write pointer set by firmware */
897 if (mwifiex_read_reg(adapter, REG_RXBD_WRPTR, &wrptr)) {
898 dev_err(adapter->dev, "RECV DATA: failed to read "
899 "REG_TXBD_RDPTR\n");
900 ret = -1;
901 goto done;
902 }
903 dev_dbg(adapter->dev, "info: RECV DATA: Received packet from "
904 "firmware successfully\n");
905 mwifiex_handle_rx_packet(adapter, skb_tmp);
906 }
907
908 done:
909 if (ret && skb_tmp)
910 dev_kfree_skb_any(skb_tmp);
911 return ret;
912 }
913
914 /*
915 * This function downloads the boot command to device
916 */
917 static int
918 mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
919 {
920 phys_addr_t *buf_pa = MWIFIEX_SKB_PACB(skb);
921
922 if (!(skb->data && skb->len && *buf_pa)) {
923 dev_err(adapter->dev, "Invalid parameter in %s <%p, %#x:%x, "
924 "%x>\n", __func__, skb->data, skb->len,
925 (u32)*buf_pa, (u32)((u64)*buf_pa >> 32));
926 return -1;
927 }
928
929 /* Write the lower 32bits of the physical address to scratch
930 * register 0 */
931 if (mwifiex_write_reg(adapter, PCIE_SCRATCH_0_REG, (u32)*buf_pa)) {
932 dev_err(adapter->dev, "%s: failed to write download command "
933 "to boot code.\n", __func__);
934 return -1;
935 }
936
937 /* Write the upper 32bits of the physical address to scratch
938 * register 1 */
939 if (mwifiex_write_reg(adapter, PCIE_SCRATCH_1_REG,
940 (u32)((u64)*buf_pa >> 32))) {
941 dev_err(adapter->dev, "%s: failed to write download command "
942 "to boot code.\n", __func__);
943 return -1;
944 }
945
946 /* Write the command length to scratch register 2 */
947 if (mwifiex_write_reg(adapter, PCIE_SCRATCH_2_REG, skb->len)) {
948 dev_err(adapter->dev, "%s: failed to write command length to "
949 "scratch register 2\n", __func__);
950 return -1;
951 }
952
953 /* Ring the door bell */
954 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
955 CPU_INTR_DOOR_BELL)) {
956 dev_err(adapter->dev, "%s: failed to assert door-bell "
957 "interrupt.\n", __func__);
958 return -1;
959 }
960
961 return 0;
962 }
963
964 /*
965 * This function downloads commands to the device
966 */
967 static int
968 mwifiex_pcie_send_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
969 {
970 struct pcie_service_card *card = adapter->card;
971 int ret = 0;
972 phys_addr_t *cmd_buf_pa;
973 phys_addr_t *cmdrsp_buf_pa;
974
975 if (!(skb->data && skb->len)) {
976 dev_err(adapter->dev, "Invalid parameter in %s <%p, %#x>\n",
977 __func__, skb->data, skb->len);
978 return -1;
979 }
980
981 /* Make sure a command response buffer is available */
982 if (!card->cmdrsp_buf) {
983 dev_err(adapter->dev, "No response buffer available, send "
984 "command failed\n");
985 return -EBUSY;
986 }
987
988 /* Make sure a command buffer is available */
989 if (!card->cmd_buf) {
990 dev_err(adapter->dev, "Command buffer not available\n");
991 return -EBUSY;
992 }
993
994 adapter->cmd_sent = true;
995 /* Copy the given skb in to DMA accessable shared buffer */
996 skb_put(card->cmd_buf, MWIFIEX_SIZE_OF_CMD_BUFFER - card->cmd_buf->len);
997 skb_trim(card->cmd_buf, skb->len);
998 memcpy(card->cmd_buf->data, skb->data, skb->len);
999
1000 /* To send a command, the driver will:
1001 1. Write the 64bit physical address of the data buffer to
1002 SCRATCH1 + SCRATCH0
1003 2. Ring the door bell (i.e. set the door bell interrupt)
1004
1005 In response to door bell interrupt, the firmware will perform
1006 the DMA of the command packet (first header to obtain the total
1007 length and then rest of the command).
1008 */
1009
1010 if (card->cmdrsp_buf) {
1011 cmdrsp_buf_pa = MWIFIEX_SKB_PACB(card->cmdrsp_buf);
1012 /* Write the lower 32bits of the cmdrsp buffer physical
1013 address */
1014 if (mwifiex_write_reg(adapter, REG_CMDRSP_ADDR_LO,
1015 (u32)*cmdrsp_buf_pa)) {
1016 dev_err(adapter->dev, "Failed to write download command to boot code.\n");
1017 ret = -1;
1018 goto done;
1019 }
1020 /* Write the upper 32bits of the cmdrsp buffer physical
1021 address */
1022 if (mwifiex_write_reg(adapter, REG_CMDRSP_ADDR_HI,
1023 (u32)((u64)*cmdrsp_buf_pa >> 32))) {
1024 dev_err(adapter->dev, "Failed to write download command"
1025 " to boot code.\n");
1026 ret = -1;
1027 goto done;
1028 }
1029 }
1030
1031 cmd_buf_pa = MWIFIEX_SKB_PACB(card->cmd_buf);
1032 /* Write the lower 32bits of the physical address to REG_CMD_ADDR_LO */
1033 if (mwifiex_write_reg(adapter, REG_CMD_ADDR_LO,
1034 (u32)*cmd_buf_pa)) {
1035 dev_err(adapter->dev, "Failed to write download command "
1036 "to boot code.\n");
1037 ret = -1;
1038 goto done;
1039 }
1040 /* Write the upper 32bits of the physical address to REG_CMD_ADDR_HI */
1041 if (mwifiex_write_reg(adapter, REG_CMD_ADDR_HI,
1042 (u32)((u64)*cmd_buf_pa >> 32))) {
1043 dev_err(adapter->dev, "Failed to write download command "
1044 "to boot code.\n");
1045 ret = -1;
1046 goto done;
1047 }
1048
1049 /* Write the command length to REG_CMD_SIZE */
1050 if (mwifiex_write_reg(adapter, REG_CMD_SIZE,
1051 card->cmd_buf->len)) {
1052 dev_err(adapter->dev, "Failed to write command length to "
1053 "REG_CMD_SIZE\n");
1054 ret = -1;
1055 goto done;
1056 }
1057
1058 /* Ring the door bell */
1059 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1060 CPU_INTR_DOOR_BELL)) {
1061 dev_err(adapter->dev, "Failed to assert door-bell "
1062 "interrupt.\n");
1063 ret = -1;
1064 goto done;
1065 }
1066
1067 done:
1068 if (ret)
1069 adapter->cmd_sent = false;
1070
1071 return 0;
1072 }
1073
1074 /*
1075 * This function handles command complete interrupt
1076 */
1077 static int mwifiex_pcie_process_cmd_complete(struct mwifiex_adapter *adapter)
1078 {
1079 struct pcie_service_card *card = adapter->card;
1080 int count = 0;
1081
1082 dev_dbg(adapter->dev, "info: Rx CMD Response\n");
1083
1084 if (!adapter->curr_cmd) {
1085 skb_pull(card->cmdrsp_buf, INTF_HEADER_LEN);
1086 if (adapter->ps_state == PS_STATE_SLEEP_CFM) {
1087 mwifiex_process_sleep_confirm_resp(adapter,
1088 card->cmdrsp_buf->data,
1089 card->cmdrsp_buf->len);
1090 while (mwifiex_pcie_ok_to_access_hw(adapter) &&
1091 (count++ < 10))
1092 udelay(50);
1093 } else {
1094 dev_err(adapter->dev, "There is no command but "
1095 "got cmdrsp\n");
1096 }
1097 memcpy(adapter->upld_buf, card->cmdrsp_buf->data,
1098 min_t(u32, MWIFIEX_SIZE_OF_CMD_BUFFER,
1099 card->cmdrsp_buf->len));
1100 skb_push(card->cmdrsp_buf, INTF_HEADER_LEN);
1101 } else if (mwifiex_pcie_ok_to_access_hw(adapter)) {
1102 skb_pull(card->cmdrsp_buf, INTF_HEADER_LEN);
1103 adapter->curr_cmd->resp_skb = card->cmdrsp_buf;
1104 adapter->cmd_resp_received = true;
1105 /* Take the pointer and set it to CMD node and will
1106 return in the response complete callback */
1107 card->cmdrsp_buf = NULL;
1108
1109 /* Clear the cmd-rsp buffer address in scratch registers. This
1110 will prevent firmware from writing to the same response
1111 buffer again. */
1112 if (mwifiex_write_reg(adapter, REG_CMDRSP_ADDR_LO, 0)) {
1113 dev_err(adapter->dev, "cmd_done: failed to clear "
1114 "cmd_rsp address.\n");
1115 return -1;
1116 }
1117 /* Write the upper 32bits of the cmdrsp buffer physical
1118 address */
1119 if (mwifiex_write_reg(adapter, REG_CMDRSP_ADDR_HI, 0)) {
1120 dev_err(adapter->dev, "cmd_done: failed to clear "
1121 "cmd_rsp address.\n");
1122 return -1;
1123 }
1124 }
1125
1126 return 0;
1127 }
1128
1129 /*
1130 * Command Response processing complete handler
1131 */
1132 static int mwifiex_pcie_cmdrsp_complete(struct mwifiex_adapter *adapter,
1133 struct sk_buff *skb)
1134 {
1135 struct pcie_service_card *card = adapter->card;
1136
1137 if (skb) {
1138 card->cmdrsp_buf = skb;
1139 skb_push(card->cmdrsp_buf, INTF_HEADER_LEN);
1140 }
1141
1142 return 0;
1143 }
1144
1145 /*
1146 * This function handles firmware event ready interrupt
1147 */
1148 static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter *adapter)
1149 {
1150 struct pcie_service_card *card = adapter->card;
1151 u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1152 u32 wrptr, event;
1153
1154 if (adapter->event_received) {
1155 dev_dbg(adapter->dev, "info: Event being processed, "\
1156 "do not process this interrupt just yet\n");
1157 return 0;
1158 }
1159
1160 if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1161 dev_dbg(adapter->dev, "info: Invalid read pointer...\n");
1162 return -1;
1163 }
1164
1165 /* Read the event ring write pointer set by firmware */
1166 if (mwifiex_read_reg(adapter, REG_EVTBD_WRPTR, &wrptr)) {
1167 dev_err(adapter->dev, "EventReady: failed to read REG_EVTBD_WRPTR\n");
1168 return -1;
1169 }
1170
1171 dev_dbg(adapter->dev, "info: EventReady: Initial <Rd: 0x%x, Wr: 0x%x>",
1172 card->evtbd_rdptr, wrptr);
1173 if (((wrptr & MWIFIEX_EVTBD_MASK) !=
1174 (card->evtbd_rdptr & MWIFIEX_EVTBD_MASK)) ||
1175 ((wrptr & MWIFIEX_BD_FLAG_ROLLOVER_IND) ==
1176 (card->evtbd_rdptr & MWIFIEX_BD_FLAG_ROLLOVER_IND))) {
1177 struct sk_buff *skb_cmd;
1178 __le16 data_len = 0;
1179 u16 evt_len;
1180
1181 dev_dbg(adapter->dev, "info: Read Index: %d\n", rdptr);
1182 skb_cmd = card->evt_buf_list[rdptr];
1183 /* Take the pointer and set it to event pointer in adapter
1184 and will return back after event handling callback */
1185 card->evt_buf_list[rdptr] = NULL;
1186 card->evtbd_ring[rdptr]->paddr = 0;
1187 card->evtbd_ring[rdptr]->len = 0;
1188 card->evtbd_ring[rdptr]->flags = 0;
1189
1190 event = *(u32 *) &skb_cmd->data[INTF_HEADER_LEN];
1191 adapter->event_cause = event;
1192 /* The first 4bytes will be the event transfer header
1193 len is 2 bytes followed by type which is 2 bytes */
1194 memcpy(&data_len, skb_cmd->data, sizeof(__le16));
1195 evt_len = le16_to_cpu(data_len);
1196
1197 skb_pull(skb_cmd, INTF_HEADER_LEN);
1198 dev_dbg(adapter->dev, "info: Event length: %d\n", evt_len);
1199
1200 if ((evt_len > 0) && (evt_len < MAX_EVENT_SIZE))
1201 memcpy(adapter->event_body, skb_cmd->data +
1202 MWIFIEX_EVENT_HEADER_LEN, evt_len -
1203 MWIFIEX_EVENT_HEADER_LEN);
1204
1205 adapter->event_received = true;
1206 adapter->event_skb = skb_cmd;
1207
1208 /* Do not update the event read pointer here, wait till the
1209 buffer is released. This is just to make things simpler,
1210 we need to find a better method of managing these buffers.
1211 */
1212 }
1213
1214 return 0;
1215 }
1216
1217 /*
1218 * Event processing complete handler
1219 */
1220 static int mwifiex_pcie_event_complete(struct mwifiex_adapter *adapter,
1221 struct sk_buff *skb)
1222 {
1223 struct pcie_service_card *card = adapter->card;
1224 int ret = 0;
1225 u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1226 u32 wrptr;
1227 phys_addr_t *buf_pa;
1228
1229 if (!skb)
1230 return 0;
1231
1232 if (rdptr >= MWIFIEX_MAX_EVT_BD)
1233 dev_err(adapter->dev, "event_complete: Invalid rdptr 0x%x\n",
1234 rdptr);
1235
1236 /* Read the event ring write pointer set by firmware */
1237 if (mwifiex_read_reg(adapter, REG_EVTBD_WRPTR, &wrptr)) {
1238 dev_err(adapter->dev, "event_complete: failed to read REG_EVTBD_WRPTR\n");
1239 ret = -1;
1240 goto done;
1241 }
1242
1243 if (!card->evt_buf_list[rdptr]) {
1244 skb_push(skb, INTF_HEADER_LEN);
1245 card->evt_buf_list[rdptr] = skb;
1246 buf_pa = MWIFIEX_SKB_PACB(skb);
1247 card->evtbd_ring[rdptr]->paddr = *buf_pa;
1248 card->evtbd_ring[rdptr]->len = (u16)skb->len;
1249 card->evtbd_ring[rdptr]->flags = 0;
1250 skb = NULL;
1251 } else {
1252 dev_dbg(adapter->dev, "info: ERROR: Buffer is still valid at "
1253 "index %d, <%p, %p>\n", rdptr,
1254 card->evt_buf_list[rdptr], skb);
1255 }
1256
1257 if ((++card->evtbd_rdptr & MWIFIEX_EVTBD_MASK) == MWIFIEX_MAX_EVT_BD) {
1258 card->evtbd_rdptr = ((card->evtbd_rdptr &
1259 MWIFIEX_BD_FLAG_ROLLOVER_IND) ^
1260 MWIFIEX_BD_FLAG_ROLLOVER_IND);
1261 }
1262
1263 dev_dbg(adapter->dev, "info: Updated <Rd: 0x%x, Wr: 0x%x>",
1264 card->evtbd_rdptr, wrptr);
1265
1266 /* Write the event ring read pointer in to REG_EVTBD_RDPTR */
1267 if (mwifiex_write_reg(adapter, REG_EVTBD_RDPTR, card->evtbd_rdptr)) {
1268 dev_err(adapter->dev, "event_complete: failed to read REG_EVTBD_RDPTR\n");
1269 ret = -1;
1270 goto done;
1271 }
1272
1273 done:
1274 /* Free the buffer for failure case */
1275 if (ret && skb)
1276 dev_kfree_skb_any(skb);
1277
1278 dev_dbg(adapter->dev, "info: Check Events Again\n");
1279 ret = mwifiex_pcie_process_event_ready(adapter);
1280
1281 return ret;
1282 }
1283
1284 /*
1285 * This function downloads the firmware to the card.
1286 *
1287 * Firmware is downloaded to the card in blocks. Every block download
1288 * is tested for CRC errors, and retried a number of times before
1289 * returning failure.
1290 */
1291 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter *adapter,
1292 struct mwifiex_fw_image *fw)
1293 {
1294 int ret;
1295 u8 *firmware = fw->fw_buf;
1296 u32 firmware_len = fw->fw_len;
1297 u32 offset = 0;
1298 struct sk_buff *skb;
1299 u32 txlen, tx_blocks = 0, tries, len;
1300 u32 block_retry_cnt = 0;
1301
1302 if (!adapter) {
1303 pr_err("adapter structure is not valid\n");
1304 return -1;
1305 }
1306
1307 if (!firmware || !firmware_len) {
1308 dev_err(adapter->dev, "No firmware image found! "
1309 "Terminating download\n");
1310 return -1;
1311 }
1312
1313 dev_dbg(adapter->dev, "info: Downloading FW image (%d bytes)\n",
1314 firmware_len);
1315
1316 if (mwifiex_pcie_disable_host_int(adapter)) {
1317 dev_err(adapter->dev, "%s: Disabling interrupts"
1318 " failed.\n", __func__);
1319 return -1;
1320 }
1321
1322 skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE);
1323 if (!skb) {
1324 ret = -ENOMEM;
1325 goto done;
1326 }
1327 mwifiex_update_sk_buff_pa(skb);
1328
1329 /* Perform firmware data transfer */
1330 do {
1331 u32 ireg_intr = 0;
1332
1333 /* More data? */
1334 if (offset >= firmware_len)
1335 break;
1336
1337 for (tries = 0; tries < MAX_POLL_TRIES; tries++) {
1338 ret = mwifiex_read_reg(adapter, PCIE_SCRATCH_2_REG,
1339 &len);
1340 if (ret) {
1341 dev_warn(adapter->dev, "Failed reading length from boot code\n");
1342 goto done;
1343 }
1344 if (len)
1345 break;
1346 udelay(10);
1347 }
1348
1349 if (!len) {
1350 break;
1351 } else if (len > MWIFIEX_UPLD_SIZE) {
1352 pr_err("FW download failure @ %d, invalid length %d\n",
1353 offset, len);
1354 ret = -1;
1355 goto done;
1356 }
1357
1358 txlen = len;
1359
1360 if (len & BIT(0)) {
1361 block_retry_cnt++;
1362 if (block_retry_cnt > MAX_WRITE_IOMEM_RETRY) {
1363 pr_err("FW download failure @ %d, over max "
1364 "retry count\n", offset);
1365 ret = -1;
1366 goto done;
1367 }
1368 dev_err(adapter->dev, "FW CRC error indicated by the "
1369 "helper: len = 0x%04X, txlen = "
1370 "%d\n", len, txlen);
1371 len &= ~BIT(0);
1372 /* Setting this to 0 to resend from same offset */
1373 txlen = 0;
1374 } else {
1375 block_retry_cnt = 0;
1376 /* Set blocksize to transfer - checking for
1377 last block */
1378 if (firmware_len - offset < txlen)
1379 txlen = firmware_len - offset;
1380
1381 dev_dbg(adapter->dev, ".");
1382
1383 tx_blocks =
1384 (txlen + MWIFIEX_PCIE_BLOCK_SIZE_FW_DNLD - 1) /
1385 MWIFIEX_PCIE_BLOCK_SIZE_FW_DNLD;
1386
1387 /* Copy payload to buffer */
1388 memmove(skb->data, &firmware[offset], txlen);
1389 }
1390
1391 skb_put(skb, MWIFIEX_UPLD_SIZE - skb->len);
1392 skb_trim(skb, tx_blocks * MWIFIEX_PCIE_BLOCK_SIZE_FW_DNLD);
1393
1394 /* Send the boot command to device */
1395 if (mwifiex_pcie_send_boot_cmd(adapter, skb)) {
1396 dev_err(adapter->dev, "Failed to send firmware download command\n");
1397 ret = -1;
1398 goto done;
1399 }
1400 /* Wait for the command done interrupt */
1401 do {
1402 if (mwifiex_read_reg(adapter, PCIE_CPU_INT_STATUS,
1403 &ireg_intr)) {
1404 dev_err(adapter->dev, "%s: Failed to read "
1405 "interrupt status during "
1406 "fw dnld.\n", __func__);
1407 ret = -1;
1408 goto done;
1409 }
1410 } while ((ireg_intr & CPU_INTR_DOOR_BELL) ==
1411 CPU_INTR_DOOR_BELL);
1412 offset += txlen;
1413 } while (true);
1414
1415 dev_dbg(adapter->dev, "info:\nFW download over, size %d bytes\n",
1416 offset);
1417
1418 ret = 0;
1419
1420 done:
1421 dev_kfree_skb_any(skb);
1422 return ret;
1423 }
1424
1425 /*
1426 * This function checks the firmware status in card.
1427 *
1428 * The winner interface is also determined by this function.
1429 */
1430 static int
1431 mwifiex_check_fw_status(struct mwifiex_adapter *adapter, u32 poll_num)
1432 {
1433 int ret = 0;
1434 u32 firmware_stat, winner_status;
1435 u32 tries;
1436
1437 /* Mask spurios interrupts */
1438 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS_MASK,
1439 HOST_INTR_MASK)) {
1440 dev_warn(adapter->dev, "Write register failed\n");
1441 return -1;
1442 }
1443
1444 dev_dbg(adapter->dev, "Setting driver ready signature\n");
1445 if (mwifiex_write_reg(adapter, REG_DRV_READY, FIRMWARE_READY_PCIE)) {
1446 dev_err(adapter->dev, "Failed to write driver ready signature\n");
1447 return -1;
1448 }
1449
1450 /* Wait for firmware initialization event */
1451 for (tries = 0; tries < poll_num; tries++) {
1452 if (mwifiex_read_reg(adapter, PCIE_SCRATCH_3_REG,
1453 &firmware_stat))
1454 ret = -1;
1455 else
1456 ret = 0;
1457 if (ret)
1458 continue;
1459 if (firmware_stat == FIRMWARE_READY_PCIE) {
1460 ret = 0;
1461 break;
1462 } else {
1463 mdelay(100);
1464 ret = -1;
1465 }
1466 }
1467
1468 if (ret) {
1469 if (mwifiex_read_reg(adapter, PCIE_SCRATCH_3_REG,
1470 &winner_status))
1471 ret = -1;
1472 else if (!winner_status) {
1473 dev_err(adapter->dev, "PCI-E is the winner\n");
1474 adapter->winner = 1;
1475 ret = -1;
1476 } else {
1477 dev_err(adapter->dev, "PCI-E is not the winner <%#x, %d>, exit download\n",
1478 ret, adapter->winner);
1479 ret = 0;
1480 }
1481 }
1482
1483 return ret;
1484 }
1485
1486 /*
1487 * This function reads the interrupt status from card.
1488 */
1489 static void mwifiex_interrupt_status(struct mwifiex_adapter *adapter)
1490 {
1491 u32 pcie_ireg;
1492 unsigned long flags;
1493
1494 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1495 return;
1496
1497 if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS, &pcie_ireg)) {
1498 dev_warn(adapter->dev, "Read register failed\n");
1499 return;
1500 }
1501
1502 if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
1503
1504 mwifiex_pcie_disable_host_int(adapter);
1505
1506 /* Clear the pending interrupts */
1507 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS,
1508 ~pcie_ireg)) {
1509 dev_warn(adapter->dev, "Write register failed\n");
1510 return;
1511 }
1512 spin_lock_irqsave(&adapter->int_lock, flags);
1513 adapter->int_status |= pcie_ireg;
1514 spin_unlock_irqrestore(&adapter->int_lock, flags);
1515
1516 if (pcie_ireg & HOST_INTR_CMD_DONE) {
1517 if ((adapter->ps_state == PS_STATE_SLEEP_CFM) ||
1518 (adapter->ps_state == PS_STATE_SLEEP)) {
1519 mwifiex_pcie_enable_host_int(adapter);
1520 if (mwifiex_write_reg(adapter,
1521 PCIE_CPU_INT_EVENT,
1522 CPU_INTR_SLEEP_CFM_DONE)) {
1523 dev_warn(adapter->dev, "Write register"
1524 " failed\n");
1525 return;
1526
1527 }
1528 }
1529 } else if (!adapter->pps_uapsd_mode &&
1530 adapter->ps_state == PS_STATE_SLEEP) {
1531 /* Potentially for PCIe we could get other
1532 * interrupts like shared. Don't change power
1533 * state until cookie is set */
1534 if (mwifiex_pcie_ok_to_access_hw(adapter))
1535 adapter->ps_state = PS_STATE_AWAKE;
1536 }
1537 }
1538 }
1539
1540 /*
1541 * Interrupt handler for PCIe root port
1542 *
1543 * This function reads the interrupt status from firmware and assigns
1544 * the main process in workqueue which will handle the interrupt.
1545 */
1546 static irqreturn_t mwifiex_pcie_interrupt(int irq, void *context)
1547 {
1548 struct pci_dev *pdev = (struct pci_dev *)context;
1549 struct pcie_service_card *card;
1550 struct mwifiex_adapter *adapter;
1551
1552 if (!pdev) {
1553 pr_debug("info: %s: pdev is NULL\n", (u8 *)pdev);
1554 goto exit;
1555 }
1556
1557 card = (struct pcie_service_card *) pci_get_drvdata(pdev);
1558 if (!card || !card->adapter) {
1559 pr_debug("info: %s: card=%p adapter=%p\n", __func__, card,
1560 card ? card->adapter : NULL);
1561 goto exit;
1562 }
1563 adapter = card->adapter;
1564
1565 if (adapter->surprise_removed)
1566 goto exit;
1567
1568 mwifiex_interrupt_status(adapter);
1569 queue_work(adapter->workqueue, &adapter->main_work);
1570
1571 exit:
1572 return IRQ_HANDLED;
1573 }
1574
1575 /*
1576 * This function checks the current interrupt status.
1577 *
1578 * The following interrupts are checked and handled by this function -
1579 * - Data sent
1580 * - Command sent
1581 * - Command received
1582 * - Packets received
1583 * - Events received
1584 *
1585 * In case of Rx packets received, the packets are uploaded from card to
1586 * host and processed accordingly.
1587 */
1588 static int mwifiex_process_int_status(struct mwifiex_adapter *adapter)
1589 {
1590 int ret;
1591 u32 pcie_ireg = 0;
1592 unsigned long flags;
1593
1594 spin_lock_irqsave(&adapter->int_lock, flags);
1595 /* Clear out unused interrupts */
1596 adapter->int_status &= HOST_INTR_MASK;
1597 spin_unlock_irqrestore(&adapter->int_lock, flags);
1598
1599 while (adapter->int_status & HOST_INTR_MASK) {
1600 if (adapter->int_status & HOST_INTR_DNLD_DONE) {
1601 adapter->int_status &= ~HOST_INTR_DNLD_DONE;
1602 if (adapter->data_sent) {
1603 dev_dbg(adapter->dev, "info: DATA sent Interrupt\n");
1604 adapter->data_sent = false;
1605 }
1606 }
1607 if (adapter->int_status & HOST_INTR_UPLD_RDY) {
1608 adapter->int_status &= ~HOST_INTR_UPLD_RDY;
1609 dev_dbg(adapter->dev, "info: Rx DATA\n");
1610 ret = mwifiex_pcie_process_recv_data(adapter);
1611 if (ret)
1612 return ret;
1613 }
1614 if (adapter->int_status & HOST_INTR_EVENT_RDY) {
1615 adapter->int_status &= ~HOST_INTR_EVENT_RDY;
1616 dev_dbg(adapter->dev, "info: Rx EVENT\n");
1617 ret = mwifiex_pcie_process_event_ready(adapter);
1618 if (ret)
1619 return ret;
1620 }
1621
1622 if (adapter->int_status & HOST_INTR_CMD_DONE) {
1623 adapter->int_status &= ~HOST_INTR_CMD_DONE;
1624 if (adapter->cmd_sent) {
1625 dev_dbg(adapter->dev, "info: CMD sent Interrupt\n");
1626 adapter->cmd_sent = false;
1627 }
1628 /* Handle command response */
1629 ret = mwifiex_pcie_process_cmd_complete(adapter);
1630 if (ret)
1631 return ret;
1632 }
1633
1634 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
1635 if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS,
1636 &pcie_ireg)) {
1637 dev_warn(adapter->dev, "Read register failed\n");
1638 return -1;
1639 }
1640
1641 if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
1642 if (mwifiex_write_reg(adapter,
1643 PCIE_HOST_INT_STATUS, ~pcie_ireg)) {
1644 dev_warn(adapter->dev, "Write register"
1645 " failed\n");
1646 return -1;
1647 }
1648 adapter->int_status |= pcie_ireg;
1649 adapter->int_status &= HOST_INTR_MASK;
1650 }
1651
1652 }
1653 }
1654 dev_dbg(adapter->dev, "info: cmd_sent=%d data_sent=%d\n",
1655 adapter->cmd_sent, adapter->data_sent);
1656 mwifiex_pcie_enable_host_int(adapter);
1657
1658 return 0;
1659 }
1660
1661 /*
1662 * This function downloads data from driver to card.
1663 *
1664 * Both commands and data packets are transferred to the card by this
1665 * function.
1666 *
1667 * This function adds the PCIE specific header to the front of the buffer
1668 * before transferring. The header contains the length of the packet and
1669 * the type. The firmware handles the packets based upon this set type.
1670 */
1671 static int mwifiex_pcie_host_to_card(struct mwifiex_adapter *adapter, u8 type,
1672 struct sk_buff *skb,
1673 struct mwifiex_tx_param *tx_param)
1674 {
1675 if (!adapter || !skb) {
1676 dev_err(adapter->dev, "Invalid parameter in %s <%p, %p>\n",
1677 __func__, adapter, skb);
1678 return -1;
1679 }
1680
1681 if (type == MWIFIEX_TYPE_DATA)
1682 return mwifiex_pcie_send_data(adapter, skb);
1683 else if (type == MWIFIEX_TYPE_CMD)
1684 return mwifiex_pcie_send_cmd(adapter, skb);
1685
1686 return 0;
1687 }
1688
1689 /*
1690 * This function initializes the PCI-E host memory space, WCB rings, etc.
1691 *
1692 * The following initializations steps are followed -
1693 * - Allocate TXBD ring buffers
1694 * - Allocate RXBD ring buffers
1695 * - Allocate event BD ring buffers
1696 * - Allocate command response ring buffer
1697 * - Allocate sleep cookie buffer
1698 */
1699 static int mwifiex_pcie_init(struct mwifiex_adapter *adapter)
1700 {
1701 struct pcie_service_card *card = adapter->card;
1702 int ret;
1703 struct pci_dev *pdev = card->dev;
1704
1705 pci_set_drvdata(pdev, card);
1706
1707 ret = pci_enable_device(pdev);
1708 if (ret)
1709 goto err_enable_dev;
1710
1711 pci_set_master(pdev);
1712
1713 dev_dbg(adapter->dev, "try set_consistent_dma_mask(32)\n");
1714 ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
1715 if (ret) {
1716 dev_err(adapter->dev, "set_dma_mask(32) failed\n");
1717 goto err_set_dma_mask;
1718 }
1719
1720 ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
1721 if (ret) {
1722 dev_err(adapter->dev, "set_consistent_dma_mask(64) failed\n");
1723 goto err_set_dma_mask;
1724 }
1725
1726 ret = pci_request_region(pdev, 0, DRV_NAME);
1727 if (ret) {
1728 dev_err(adapter->dev, "req_reg(0) error\n");
1729 goto err_req_region0;
1730 }
1731 card->pci_mmap = pci_iomap(pdev, 0, 0);
1732 if (!card->pci_mmap) {
1733 dev_err(adapter->dev, "iomap(0) error\n");
1734 goto err_iomap0;
1735 }
1736 ret = pci_request_region(pdev, 2, DRV_NAME);
1737 if (ret) {
1738 dev_err(adapter->dev, "req_reg(2) error\n");
1739 goto err_req_region2;
1740 }
1741 card->pci_mmap1 = pci_iomap(pdev, 2, 0);
1742 if (!card->pci_mmap1) {
1743 dev_err(adapter->dev, "iomap(2) error\n");
1744 goto err_iomap2;
1745 }
1746
1747 dev_dbg(adapter->dev, "PCI memory map Virt0: %p PCI memory map Virt2: "
1748 "%p\n", card->pci_mmap, card->pci_mmap1);
1749
1750 card->cmdrsp_buf = NULL;
1751 ret = mwifiex_pcie_create_txbd_ring(adapter);
1752 if (ret)
1753 goto err_cre_txbd;
1754 ret = mwifiex_pcie_create_rxbd_ring(adapter);
1755 if (ret)
1756 goto err_cre_rxbd;
1757 ret = mwifiex_pcie_create_evtbd_ring(adapter);
1758 if (ret)
1759 goto err_cre_evtbd;
1760 ret = mwifiex_pcie_alloc_cmdrsp_buf(adapter);
1761 if (ret)
1762 goto err_alloc_cmdbuf;
1763 ret = mwifiex_pcie_alloc_sleep_cookie_buf(adapter);
1764 if (ret)
1765 goto err_alloc_cookie;
1766
1767 return ret;
1768
1769 err_alloc_cookie:
1770 mwifiex_pcie_delete_cmdrsp_buf(adapter);
1771 err_alloc_cmdbuf:
1772 mwifiex_pcie_delete_evtbd_ring(adapter);
1773 err_cre_evtbd:
1774 mwifiex_pcie_delete_rxbd_ring(adapter);
1775 err_cre_rxbd:
1776 mwifiex_pcie_delete_txbd_ring(adapter);
1777 err_cre_txbd:
1778 pci_iounmap(pdev, card->pci_mmap1);
1779 err_iomap2:
1780 pci_release_region(pdev, 2);
1781 err_req_region2:
1782 pci_iounmap(pdev, card->pci_mmap);
1783 err_iomap0:
1784 pci_release_region(pdev, 0);
1785 err_req_region0:
1786 err_set_dma_mask:
1787 pci_disable_device(pdev);
1788 err_enable_dev:
1789 pci_set_drvdata(pdev, NULL);
1790 return ret;
1791 }
1792
1793 /*
1794 * This function cleans up the allocated card buffers.
1795 *
1796 * The following are freed by this function -
1797 * - TXBD ring buffers
1798 * - RXBD ring buffers
1799 * - Event BD ring buffers
1800 * - Command response ring buffer
1801 * - Sleep cookie buffer
1802 */
1803 static void mwifiex_pcie_cleanup(struct mwifiex_adapter *adapter)
1804 {
1805 struct pcie_service_card *card = adapter->card;
1806 struct pci_dev *pdev = card->dev;
1807
1808 mwifiex_pcie_delete_sleep_cookie_buf(adapter);
1809 mwifiex_pcie_delete_cmdrsp_buf(adapter);
1810 mwifiex_pcie_delete_evtbd_ring(adapter);
1811 mwifiex_pcie_delete_rxbd_ring(adapter);
1812 mwifiex_pcie_delete_txbd_ring(adapter);
1813 card->cmdrsp_buf = NULL;
1814
1815 dev_dbg(adapter->dev, "Clearing driver ready signature\n");
1816 if (user_rmmod) {
1817 if (mwifiex_write_reg(adapter, REG_DRV_READY, 0x00000000))
1818 dev_err(adapter->dev, "Failed to write driver not-ready signature\n");
1819 }
1820
1821 if (pdev) {
1822 pci_iounmap(pdev, card->pci_mmap);
1823 pci_iounmap(pdev, card->pci_mmap1);
1824
1825 pci_release_regions(pdev);
1826 pci_disable_device(pdev);
1827 pci_set_drvdata(pdev, NULL);
1828 }
1829 }
1830
1831 /*
1832 * This function registers the PCIE device.
1833 *
1834 * PCIE IRQ is claimed, block size is set and driver data is initialized.
1835 */
1836 static int mwifiex_register_dev(struct mwifiex_adapter *adapter)
1837 {
1838 int ret;
1839 struct pcie_service_card *card = adapter->card;
1840 struct pci_dev *pdev = card->dev;
1841
1842 /* save adapter pointer in card */
1843 card->adapter = adapter;
1844
1845 ret = request_irq(pdev->irq, mwifiex_pcie_interrupt, IRQF_SHARED,
1846 "MRVL_PCIE", pdev);
1847 if (ret) {
1848 pr_err("request_irq failed: ret=%d\n", ret);
1849 adapter->card = NULL;
1850 return -1;
1851 }
1852
1853 adapter->dev = &pdev->dev;
1854 strcpy(adapter->fw_name, PCIE8766_DEFAULT_FW_NAME);
1855
1856 return 0;
1857 }
1858
1859 /*
1860 * This function unregisters the PCIE device.
1861 *
1862 * The PCIE IRQ is released, the function is disabled and driver
1863 * data is set to null.
1864 */
1865 static void mwifiex_unregister_dev(struct mwifiex_adapter *adapter)
1866 {
1867 struct pcie_service_card *card = adapter->card;
1868
1869 if (card) {
1870 dev_dbg(adapter->dev, "%s(): calling free_irq()\n", __func__);
1871 free_irq(card->dev->irq, card->dev);
1872 }
1873 }
1874
1875 static struct mwifiex_if_ops pcie_ops = {
1876 .init_if = mwifiex_pcie_init,
1877 .cleanup_if = mwifiex_pcie_cleanup,
1878 .check_fw_status = mwifiex_check_fw_status,
1879 .prog_fw = mwifiex_prog_fw_w_helper,
1880 .register_dev = mwifiex_register_dev,
1881 .unregister_dev = mwifiex_unregister_dev,
1882 .enable_int = mwifiex_pcie_enable_host_int,
1883 .process_int_status = mwifiex_process_int_status,
1884 .host_to_card = mwifiex_pcie_host_to_card,
1885 .wakeup = mwifiex_pm_wakeup_card,
1886 .wakeup_complete = mwifiex_pm_wakeup_card_complete,
1887
1888 /* PCIE specific */
1889 .cmdrsp_complete = mwifiex_pcie_cmdrsp_complete,
1890 .event_complete = mwifiex_pcie_event_complete,
1891 .update_mp_end_port = NULL,
1892 .cleanup_mpa_buf = NULL,
1893 };
1894
1895 /*
1896 * This function initializes the PCIE driver module.
1897 *
1898 * This initiates the semaphore and registers the device with
1899 * PCIE bus.
1900 */
1901 static int mwifiex_pcie_init_module(void)
1902 {
1903 int ret;
1904
1905 pr_debug("Marvell 8766 PCIe Driver\n");
1906
1907 sema_init(&add_remove_card_sem, 1);
1908
1909 /* Clear the flag in case user removes the card. */
1910 user_rmmod = 0;
1911
1912 ret = pci_register_driver(&mwifiex_pcie);
1913 if (ret)
1914 pr_err("Driver register failed!\n");
1915 else
1916 pr_debug("info: Driver registered successfully!\n");
1917
1918 return ret;
1919 }
1920
1921 /*
1922 * This function cleans up the PCIE driver.
1923 *
1924 * The following major steps are followed for cleanup -
1925 * - Resume the device if its suspended
1926 * - Disconnect the device if connected
1927 * - Shutdown the firmware
1928 * - Unregister the device from PCIE bus.
1929 */
1930 static void mwifiex_pcie_cleanup_module(void)
1931 {
1932 if (!down_interruptible(&add_remove_card_sem))
1933 up(&add_remove_card_sem);
1934
1935 /* Set the flag as user is removing this module. */
1936 user_rmmod = 1;
1937
1938 pci_unregister_driver(&mwifiex_pcie);
1939 }
1940
1941 module_init(mwifiex_pcie_init_module);
1942 module_exit(mwifiex_pcie_cleanup_module);
1943
1944 MODULE_AUTHOR("Marvell International Ltd.");
1945 MODULE_DESCRIPTION("Marvell WiFi-Ex PCI-Express Driver version " PCIE_VERSION);
1946 MODULE_VERSION(PCIE_VERSION);
1947 MODULE_LICENSE("GPL v2");
1948 MODULE_FIRMWARE("mrvl/pcie8766_uapsta.bin");
Linux Btrfs Development