projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
mwifiex: fix checkpatch --strict warnings/errors Part 4
[deliverable/linux.git] / drivers / net / wireless / mwifiex / pcie.c
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 struct mwifiex_private *priv;
114 int i;
115
116 card = pci_get_drvdata(pdev);
117 if (!card)
118 return;
119
120 adapter = card->adapter;
121 if (!adapter || !adapter->priv_num)
122 return;
123
124 if (user_rmmod) {
125 #ifdef CONFIG_PM
126 if (adapter->is_suspended)
127 mwifiex_pcie_resume(pdev);
128 #endif
129
130 for (i = 0; i < adapter->priv_num; i++)
131 if ((GET_BSS_ROLE(adapter->priv[i]) ==
132 MWIFIEX_BSS_ROLE_STA) &&
133 adapter->priv[i]->media_connected)
134 mwifiex_deauthenticate(adapter->priv[i], NULL);
135
136 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
137
138 mwifiex_disable_auto_ds(priv);
139
140 mwifiex_init_shutdown_fw(priv, 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 usleep_range(10, 20);
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 alloc buffer for txbd ring\n");
389 return -ENOMEM;
390 }
391 card->txbd_ring_pbase = virt_to_phys(card->txbd_ring_vbase);
392
393 dev_dbg(adapter->dev,
394 "info: txbd_ring - base: %p, pbase: %#x:%x, len: %x\n",
395 card->txbd_ring_vbase, (u32)card->txbd_ring_pbase,
396 (u32)((u64)card->txbd_ring_pbase >> 32), card->txbd_ring_size);
397
398 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
399 card->txbd_ring[i] = (struct mwifiex_pcie_buf_desc *)
400 (card->txbd_ring_vbase +
401 (sizeof(struct mwifiex_pcie_buf_desc)
402 * i));
403
404 /* Allocate buffer here so that firmware can DMA data from it */
405 skb = dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE);
406 if (!skb) {
407 dev_err(adapter->dev, "Unable to allocate skb for TX ring.\n");
408 kfree(card->txbd_ring_vbase);
409 return -ENOMEM;
410 }
411 buf_pa = mwifiex_update_sk_buff_pa(skb);
412
413 skb_put(skb, MWIFIEX_RX_DATA_BUF_SIZE);
414 dev_dbg(adapter->dev, "info: TX ring: add new skb base: %p, "
415 "buf_base: %p, buf_pbase: %#x:%x, buf_len: %#x\n",
416 skb, skb->data, (u32)*buf_pa,
417 (u32)(((u64)*buf_pa >> 32)), skb->len);
418
419 card->tx_buf_list[i] = skb;
420 card->txbd_ring[i]->paddr = *buf_pa;
421 card->txbd_ring[i]->len = (u16)skb->len;
422 card->txbd_ring[i]->flags = 0;
423 }
424
425 return 0;
426 }
427
428 static int mwifiex_pcie_delete_txbd_ring(struct mwifiex_adapter *adapter)
429 {
430 struct pcie_service_card *card = adapter->card;
431 int i;
432
433 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
434 if (card->tx_buf_list[i])
435 dev_kfree_skb_any(card->tx_buf_list[i]);
436 card->tx_buf_list[i] = NULL;
437 card->txbd_ring[i]->paddr = 0;
438 card->txbd_ring[i]->len = 0;
439 card->txbd_ring[i]->flags = 0;
440 card->txbd_ring[i] = NULL;
441 }
442
443 kfree(card->txbd_ring_vbase);
444 card->txbd_ring_size = 0;
445 card->txbd_wrptr = 0;
446 card->txbd_rdptr = 0 | MWIFIEX_BD_FLAG_ROLLOVER_IND;
447 card->txbd_ring_vbase = NULL;
448
449 return 0;
450 }
451
452 /*
453 * This function creates buffer descriptor ring for RX
454 */
455 static int mwifiex_pcie_create_rxbd_ring(struct mwifiex_adapter *adapter)
456 {
457 struct pcie_service_card *card = adapter->card;
458 struct sk_buff *skb;
459 int i;
460 phys_addr_t *buf_pa;
461
462 /*
463 * driver maintaines the read pointer and firmware maintaines the write
464 * pointer. The write pointer starts at 0 (zero) while the read pointer
465 * starts at zero with rollover bit set
466 */
467 card->rxbd_wrptr = 0;
468 card->rxbd_rdptr |= MWIFIEX_BD_FLAG_ROLLOVER_IND;
469
470 card->rxbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
471 MWIFIEX_MAX_TXRX_BD;
472 dev_dbg(adapter->dev, "info: rxbd_ring: Allocating %d bytes\n",
473 card->rxbd_ring_size);
474 card->rxbd_ring_vbase = kzalloc(card->rxbd_ring_size, GFP_KERNEL);
475 if (!card->rxbd_ring_vbase) {
476 dev_err(adapter->dev, "Unable to allocate buffer for "
477 "rxbd_ring.\n");
478 return -ENOMEM;
479 }
480 card->rxbd_ring_pbase = virt_to_phys(card->rxbd_ring_vbase);
481
482 dev_dbg(adapter->dev,
483 "info: rxbd_ring - base: %p, pbase: %#x:%x, len: %#x\n",
484 card->rxbd_ring_vbase, (u32)card->rxbd_ring_pbase,
485 (u32)((u64)card->rxbd_ring_pbase >> 32),
486 card->rxbd_ring_size);
487
488 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
489 card->rxbd_ring[i] = (struct mwifiex_pcie_buf_desc *)
490 (card->rxbd_ring_vbase +
491 (sizeof(struct mwifiex_pcie_buf_desc)
492 * i));
493
494 /* Allocate skb here so that firmware can DMA data from it */
495 skb = dev_alloc_skb(MWIFIEX_RX_DATA_BUF_SIZE);
496 if (!skb) {
497 dev_err(adapter->dev,
498 "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, buf_len: %#x\n",
507 skb, skb->data, (u32)*buf_pa, (u32)((u64)*buf_pa >> 32),
508 skb->len);
509
510 card->rx_buf_list[i] = skb;
511 card->rxbd_ring[i]->paddr = *buf_pa;
512 card->rxbd_ring[i]->len = (u16)skb->len;
513 card->rxbd_ring[i]->flags = 0;
514 }
515
516 return 0;
517 }
518
519 /*
520 * This function deletes Buffer descriptor ring for RX
521 */
522 static int mwifiex_pcie_delete_rxbd_ring(struct mwifiex_adapter *adapter)
523 {
524 struct pcie_service_card *card = adapter->card;
525 int i;
526
527 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) {
528 if (card->rx_buf_list[i])
529 dev_kfree_skb_any(card->rx_buf_list[i]);
530 card->rx_buf_list[i] = NULL;
531 card->rxbd_ring[i]->paddr = 0;
532 card->rxbd_ring[i]->len = 0;
533 card->rxbd_ring[i]->flags = 0;
534 card->rxbd_ring[i] = NULL;
535 }
536
537 kfree(card->rxbd_ring_vbase);
538 card->rxbd_ring_size = 0;
539 card->rxbd_wrptr = 0;
540 card->rxbd_rdptr = 0 | MWIFIEX_BD_FLAG_ROLLOVER_IND;
541 card->rxbd_ring_vbase = NULL;
542
543 return 0;
544 }
545
546 /*
547 * This function creates buffer descriptor ring for Events
548 */
549 static int mwifiex_pcie_create_evtbd_ring(struct mwifiex_adapter *adapter)
550 {
551 struct pcie_service_card *card = adapter->card;
552 struct sk_buff *skb;
553 int i;
554 phys_addr_t *buf_pa;
555
556 /*
557 * driver maintaines the read pointer and firmware maintaines the write
558 * pointer. The write pointer starts at 0 (zero) while the read pointer
559 * starts at zero with rollover bit set
560 */
561 card->evtbd_wrptr = 0;
562 card->evtbd_rdptr |= MWIFIEX_BD_FLAG_ROLLOVER_IND;
563
564 card->evtbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) *
565 MWIFIEX_MAX_EVT_BD;
566 dev_dbg(adapter->dev, "info: evtbd_ring: Allocating %d bytes\n",
567 card->evtbd_ring_size);
568 card->evtbd_ring_vbase = kzalloc(card->evtbd_ring_size, GFP_KERNEL);
569 if (!card->evtbd_ring_vbase) {
570 dev_err(adapter->dev,
571 "Unable to allocate buffer. Terminating download\n");
572 return -ENOMEM;
573 }
574 card->evtbd_ring_pbase = virt_to_phys(card->evtbd_ring_vbase);
575
576 dev_dbg(adapter->dev,
577 "info: CMDRSP/EVT bd_ring - base: %p pbase: %#x:%x len: %#x\n",
578 card->evtbd_ring_vbase, (u32)card->evtbd_ring_pbase,
579 (u32)((u64)card->evtbd_ring_pbase >> 32),
580 card->evtbd_ring_size);
581
582 for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) {
583 card->evtbd_ring[i] = (struct mwifiex_pcie_buf_desc *)
584 (card->evtbd_ring_vbase +
585 (sizeof(struct mwifiex_pcie_buf_desc)
586 * 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,
592 "Unable to allocate skb for EVENT buf.\n");
593 kfree(card->evtbd_ring_vbase);
594 return -ENOMEM;
595 }
596 buf_pa = mwifiex_update_sk_buff_pa(skb);
597 skb_put(skb, MAX_EVENT_SIZE);
598
599 dev_dbg(adapter->dev, "info: Evt ring: add new skb. base: %p, "
600 "buf_base: %p, buf_pbase: %#x:%x, buf_len: %#x\n",
601 skb, skb->data, (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,
652 "Unable to allocate skb for command 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,
664 "Unable to allocate skb for command 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,
707 "Unable to allocate skb for sleep 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,
762 "SEND DATA: failed to read 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,
803 "SEND DATA: failed to write 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,
811 "SEND DATA: failed to assert door-bell intr\n");
812 return -1;
813 }
814 dev_dbg(adapter->dev, "info: SEND DATA: Updated <Rd: %#x, Wr: "
815 "%#x> and sent packet to firmware successfully\n",
816 rdptr, card->txbd_wrptr);
817 } else {
818 dev_dbg(adapter->dev,
819 "info: TX Ring full, can't send packets to fw\n");
820 adapter->data_sent = true;
821 /* Send the TX ready interrupt */
822 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
823 CPU_INTR_DNLD_RDY))
824 dev_err(adapter->dev,
825 "SEND DATA: failed to assert door-bell intr\n");
826 return -EBUSY;
827 }
828
829 return 0;
830 }
831
832 /*
833 * This function handles received buffer ring and
834 * dispatches packets to upper
835 */
836 static int mwifiex_pcie_process_recv_data(struct mwifiex_adapter *adapter)
837 {
838 struct pcie_service_card *card = adapter->card;
839 u32 wrptr, rd_index;
840 int ret = 0;
841 struct sk_buff *skb_tmp = NULL;
842
843 /* Read the RX ring Write pointer set by firmware */
844 if (mwifiex_read_reg(adapter, REG_RXBD_WRPTR, &wrptr)) {
845 dev_err(adapter->dev,
846 "RECV DATA: failed to read REG_TXBD_RDPTR\n");
847 ret = -1;
848 goto done;
849 }
850
851 while (((wrptr & MWIFIEX_RXBD_MASK) !=
852 (card->rxbd_rdptr & MWIFIEX_RXBD_MASK)) ||
853 ((wrptr & MWIFIEX_BD_FLAG_ROLLOVER_IND) ==
854 (card->rxbd_rdptr & MWIFIEX_BD_FLAG_ROLLOVER_IND))) {
855 struct sk_buff *skb_data;
856 u16 rx_len;
857
858 rd_index = card->rxbd_rdptr & MWIFIEX_RXBD_MASK;
859 skb_data = card->rx_buf_list[rd_index];
860
861 /* Get data length from interface header -
862 first byte is len, second byte is type */
863 rx_len = *((u16 *)skb_data->data);
864 dev_dbg(adapter->dev,
865 "info: RECV DATA: Rd=%#x, Wr=%#x, Len=%d\n",
866 card->rxbd_rdptr, wrptr, rx_len);
867 skb_tmp = dev_alloc_skb(rx_len);
868 if (!skb_tmp) {
869 dev_dbg(adapter->dev,
870 "info: Failed to alloc skb 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,
891 "RECV DATA: failed to 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,
899 "RECV DATA: failed to read REG_TXBD_RDPTR\n");
900 ret = -1;
901 goto done;
902 }
903 dev_dbg(adapter->dev,
904 "info: RECV DATA: Rcvd packet from fw 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,
924 "Invalid parameter in %s <%p, %#x:%x, %x>\n",
925 __func__, skb->data, skb->len,
926 (u32)*buf_pa, (u32)((u64)*buf_pa >> 32));
927 return -1;
928 }
929
930 /* Write the lower 32bits of the physical address to scratch
931 * register 0 */
932 if (mwifiex_write_reg(adapter, PCIE_SCRATCH_0_REG, (u32)*buf_pa)) {
933 dev_err(adapter->dev,
934 "%s: failed to write download command to boot code.\n",
935 __func__);
936 return -1;
937 }
938
939 /* Write the upper 32bits of the physical address to scratch
940 * register 1 */
941 if (mwifiex_write_reg(adapter, PCIE_SCRATCH_1_REG,
942 (u32)((u64)*buf_pa >> 32))) {
943 dev_err(adapter->dev,
944 "%s: failed to write download command to boot code.\n",
945 __func__);
946 return -1;
947 }
948
949 /* Write the command length to scratch register 2 */
950 if (mwifiex_write_reg(adapter, PCIE_SCRATCH_2_REG, skb->len)) {
951 dev_err(adapter->dev,
952 "%s: failed to write command len to scratch reg 2\n",
953 __func__);
954 return -1;
955 }
956
957 /* Ring the door bell */
958 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
959 CPU_INTR_DOOR_BELL)) {
960 dev_err(adapter->dev,
961 "%s: failed to assert door-bell intr\n", __func__);
962 return -1;
963 }
964
965 return 0;
966 }
967
968 /*
969 * This function downloads commands to the device
970 */
971 static int
972 mwifiex_pcie_send_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb)
973 {
974 struct pcie_service_card *card = adapter->card;
975 int ret = 0;
976 phys_addr_t *cmd_buf_pa;
977 phys_addr_t *cmdrsp_buf_pa;
978
979 if (!(skb->data && skb->len)) {
980 dev_err(adapter->dev, "Invalid parameter in %s <%p, %#x>\n",
981 __func__, skb->data, skb->len);
982 return -1;
983 }
984
985 /* Make sure a command response buffer is available */
986 if (!card->cmdrsp_buf) {
987 dev_err(adapter->dev,
988 "No response buffer available, send command failed\n");
989 return -EBUSY;
990 }
991
992 /* Make sure a command buffer is available */
993 if (!card->cmd_buf) {
994 dev_err(adapter->dev, "Command buffer not available\n");
995 return -EBUSY;
996 }
997
998 adapter->cmd_sent = true;
999 /* Copy the given skb in to DMA accessable shared buffer */
1000 skb_put(card->cmd_buf, MWIFIEX_SIZE_OF_CMD_BUFFER - card->cmd_buf->len);
1001 skb_trim(card->cmd_buf, skb->len);
1002 memcpy(card->cmd_buf->data, skb->data, skb->len);
1003
1004 /* To send a command, the driver will:
1005 1. Write the 64bit physical address of the data buffer to
1006 SCRATCH1 + SCRATCH0
1007 2. Ring the door bell (i.e. set the door bell interrupt)
1008
1009 In response to door bell interrupt, the firmware will perform
1010 the DMA of the command packet (first header to obtain the total
1011 length and then rest of the command).
1012 */
1013
1014 if (card->cmdrsp_buf) {
1015 cmdrsp_buf_pa = MWIFIEX_SKB_PACB(card->cmdrsp_buf);
1016 /* Write the lower 32bits of the cmdrsp buffer physical
1017 address */
1018 if (mwifiex_write_reg(adapter, REG_CMDRSP_ADDR_LO,
1019 (u32)*cmdrsp_buf_pa)) {
1020 dev_err(adapter->dev,
1021 "Failed to write download cmd to boot code.\n");
1022 ret = -1;
1023 goto done;
1024 }
1025 /* Write the upper 32bits of the cmdrsp buffer physical
1026 address */
1027 if (mwifiex_write_reg(adapter, REG_CMDRSP_ADDR_HI,
1028 (u32)((u64)*cmdrsp_buf_pa >> 32))) {
1029 dev_err(adapter->dev,
1030 "Failed to write download cmd to boot code.\n");
1031 ret = -1;
1032 goto done;
1033 }
1034 }
1035
1036 cmd_buf_pa = MWIFIEX_SKB_PACB(card->cmd_buf);
1037 /* Write the lower 32bits of the physical address to REG_CMD_ADDR_LO */
1038 if (mwifiex_write_reg(adapter, REG_CMD_ADDR_LO, (u32)*cmd_buf_pa)) {
1039 dev_err(adapter->dev,
1040 "Failed to write download cmd to boot code.\n");
1041 ret = -1;
1042 goto done;
1043 }
1044 /* Write the upper 32bits of the physical address to REG_CMD_ADDR_HI */
1045 if (mwifiex_write_reg(adapter, REG_CMD_ADDR_HI,
1046 (u32)((u64)*cmd_buf_pa >> 32))) {
1047 dev_err(adapter->dev,
1048 "Failed to write download cmd to boot code.\n");
1049 ret = -1;
1050 goto done;
1051 }
1052
1053 /* Write the command length to REG_CMD_SIZE */
1054 if (mwifiex_write_reg(adapter, REG_CMD_SIZE, card->cmd_buf->len)) {
1055 dev_err(adapter->dev,
1056 "Failed to write cmd len to REG_CMD_SIZE\n");
1057 ret = -1;
1058 goto done;
1059 }
1060
1061 /* Ring the door bell */
1062 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT,
1063 CPU_INTR_DOOR_BELL)) {
1064 dev_err(adapter->dev,
1065 "Failed to assert door-bell intr\n");
1066 ret = -1;
1067 goto done;
1068 }
1069
1070 done:
1071 if (ret)
1072 adapter->cmd_sent = false;
1073
1074 return 0;
1075 }
1076
1077 /*
1078 * This function handles command complete interrupt
1079 */
1080 static int mwifiex_pcie_process_cmd_complete(struct mwifiex_adapter *adapter)
1081 {
1082 struct pcie_service_card *card = adapter->card;
1083 struct sk_buff *skb = card->cmdrsp_buf;
1084 int count = 0;
1085
1086 dev_dbg(adapter->dev, "info: Rx CMD Response\n");
1087
1088 if (!adapter->curr_cmd) {
1089 skb_pull(skb, INTF_HEADER_LEN);
1090 if (adapter->ps_state == PS_STATE_SLEEP_CFM) {
1091 mwifiex_process_sleep_confirm_resp(adapter, skb->data,
1092 skb->len);
1093 while (mwifiex_pcie_ok_to_access_hw(adapter) &&
1094 (count++ < 10))
1095 usleep_range(50, 60);
1096 } else {
1097 dev_err(adapter->dev,
1098 "There is no command but got cmdrsp\n");
1099 }
1100 memcpy(adapter->upld_buf, skb->data,
1101 min_t(u32, MWIFIEX_SIZE_OF_CMD_BUFFER, skb->len));
1102 skb_push(skb, INTF_HEADER_LEN);
1103 } else if (mwifiex_pcie_ok_to_access_hw(adapter)) {
1104 skb_pull(skb, INTF_HEADER_LEN);
1105 adapter->curr_cmd->resp_skb = skb;
1106 adapter->cmd_resp_received = true;
1107 /* Take the pointer and set it to CMD node and will
1108 return in the response complete callback */
1109 card->cmdrsp_buf = NULL;
1110
1111 /* Clear the cmd-rsp buffer address in scratch registers. This
1112 will prevent firmware from writing to the same response
1113 buffer again. */
1114 if (mwifiex_write_reg(adapter, REG_CMDRSP_ADDR_LO, 0)) {
1115 dev_err(adapter->dev,
1116 "cmd_done: failed to clear cmd_rsp_addr_lo\n");
1117 return -1;
1118 }
1119 /* Write the upper 32bits of the cmdrsp buffer physical
1120 address */
1121 if (mwifiex_write_reg(adapter, REG_CMDRSP_ADDR_HI, 0)) {
1122 dev_err(adapter->dev,
1123 "cmd_done: failed to clear cmd_rsp_addr_hi\n");
1124 return -1;
1125 }
1126 }
1127
1128 return 0;
1129 }
1130
1131 /*
1132 * Command Response processing complete handler
1133 */
1134 static int mwifiex_pcie_cmdrsp_complete(struct mwifiex_adapter *adapter,
1135 struct sk_buff *skb)
1136 {
1137 struct pcie_service_card *card = adapter->card;
1138
1139 if (skb) {
1140 card->cmdrsp_buf = skb;
1141 skb_push(card->cmdrsp_buf, INTF_HEADER_LEN);
1142 }
1143
1144 return 0;
1145 }
1146
1147 /*
1148 * This function handles firmware event ready interrupt
1149 */
1150 static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter *adapter)
1151 {
1152 struct pcie_service_card *card = adapter->card;
1153 u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1154 u32 wrptr, event;
1155
1156 if (adapter->event_received) {
1157 dev_dbg(adapter->dev, "info: Event being processed, "
1158 "do not process this interrupt just yet\n");
1159 return 0;
1160 }
1161
1162 if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1163 dev_dbg(adapter->dev, "info: Invalid read pointer...\n");
1164 return -1;
1165 }
1166
1167 /* Read the event ring write pointer set by firmware */
1168 if (mwifiex_read_reg(adapter, REG_EVTBD_WRPTR, &wrptr)) {
1169 dev_err(adapter->dev,
1170 "EventReady: failed to read REG_EVTBD_WRPTR\n");
1171 return -1;
1172 }
1173
1174 dev_dbg(adapter->dev, "info: EventReady: Initial <Rd: 0x%x, Wr: 0x%x>",
1175 card->evtbd_rdptr, wrptr);
1176 if (((wrptr & MWIFIEX_EVTBD_MASK) != (card->evtbd_rdptr
1177 & MWIFIEX_EVTBD_MASK)) ||
1178 ((wrptr & MWIFIEX_BD_FLAG_ROLLOVER_IND) ==
1179 (card->evtbd_rdptr & MWIFIEX_BD_FLAG_ROLLOVER_IND))) {
1180 struct sk_buff *skb_cmd;
1181 __le16 data_len = 0;
1182 u16 evt_len;
1183
1184 dev_dbg(adapter->dev, "info: Read Index: %d\n", rdptr);
1185 skb_cmd = card->evt_buf_list[rdptr];
1186 /* Take the pointer and set it to event pointer in adapter
1187 and will return back after event handling callback */
1188 card->evt_buf_list[rdptr] = NULL;
1189 card->evtbd_ring[rdptr]->paddr = 0;
1190 card->evtbd_ring[rdptr]->len = 0;
1191 card->evtbd_ring[rdptr]->flags = 0;
1192
1193 event = *(u32 *) &skb_cmd->data[INTF_HEADER_LEN];
1194 adapter->event_cause = event;
1195 /* The first 4bytes will be the event transfer header
1196 len is 2 bytes followed by type which is 2 bytes */
1197 memcpy(&data_len, skb_cmd->data, sizeof(__le16));
1198 evt_len = le16_to_cpu(data_len);
1199
1200 skb_pull(skb_cmd, INTF_HEADER_LEN);
1201 dev_dbg(adapter->dev, "info: Event length: %d\n", evt_len);
1202
1203 if ((evt_len > 0) && (evt_len < MAX_EVENT_SIZE))
1204 memcpy(adapter->event_body, skb_cmd->data +
1205 MWIFIEX_EVENT_HEADER_LEN, evt_len -
1206 MWIFIEX_EVENT_HEADER_LEN);
1207
1208 adapter->event_received = true;
1209 adapter->event_skb = skb_cmd;
1210
1211 /* Do not update the event read pointer here, wait till the
1212 buffer is released. This is just to make things simpler,
1213 we need to find a better method of managing these buffers.
1214 */
1215 }
1216
1217 return 0;
1218 }
1219
1220 /*
1221 * Event processing complete handler
1222 */
1223 static int mwifiex_pcie_event_complete(struct mwifiex_adapter *adapter,
1224 struct sk_buff *skb)
1225 {
1226 struct pcie_service_card *card = adapter->card;
1227 int ret = 0;
1228 u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK;
1229 u32 wrptr;
1230 phys_addr_t *buf_pa;
1231
1232 if (!skb)
1233 return 0;
1234
1235 if (rdptr >= MWIFIEX_MAX_EVT_BD) {
1236 dev_err(adapter->dev, "event_complete: Invalid rdptr 0x%x\n",
1237 rdptr);
1238 return -EINVAL;
1239 }
1240
1241 /* Read the event ring write pointer set by firmware */
1242 if (mwifiex_read_reg(adapter, REG_EVTBD_WRPTR, &wrptr)) {
1243 dev_err(adapter->dev,
1244 "event_complete: failed to read REG_EVTBD_WRPTR\n");
1245 return -1;
1246 }
1247
1248 if (!card->evt_buf_list[rdptr]) {
1249 skb_push(skb, INTF_HEADER_LEN);
1250 card->evt_buf_list[rdptr] = skb;
1251 buf_pa = MWIFIEX_SKB_PACB(skb);
1252 card->evtbd_ring[rdptr]->paddr = *buf_pa;
1253 card->evtbd_ring[rdptr]->len = (u16)skb->len;
1254 card->evtbd_ring[rdptr]->flags = 0;
1255 skb = NULL;
1256 } else {
1257 dev_dbg(adapter->dev,
1258 "info: ERROR: buf still valid at index %d, <%p, %p>\n",
1259 rdptr, card->evt_buf_list[rdptr], skb);
1260 }
1261
1262 if ((++card->evtbd_rdptr & MWIFIEX_EVTBD_MASK) == MWIFIEX_MAX_EVT_BD) {
1263 card->evtbd_rdptr = ((card->evtbd_rdptr &
1264 MWIFIEX_BD_FLAG_ROLLOVER_IND) ^
1265 MWIFIEX_BD_FLAG_ROLLOVER_IND);
1266 }
1267
1268 dev_dbg(adapter->dev, "info: Updated <Rd: 0x%x, Wr: 0x%x>",
1269 card->evtbd_rdptr, wrptr);
1270
1271 /* Write the event ring read pointer in to REG_EVTBD_RDPTR */
1272 if (mwifiex_write_reg(adapter, REG_EVTBD_RDPTR, card->evtbd_rdptr)) {
1273 dev_err(adapter->dev,
1274 "event_complete: failed to read REG_EVTBD_RDPTR\n");
1275 return -1;
1276 }
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,
1309 "No firmware image found! 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,
1318 "%s: Disabling interrupts 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,
1342 "Failed reading len from boot code\n");
1343 goto done;
1344 }
1345 if (len)
1346 break;
1347 usleep_range(10, 20);
1348 }
1349
1350 if (!len) {
1351 break;
1352 } else if (len > MWIFIEX_UPLD_SIZE) {
1353 pr_err("FW download failure @ %d, invalid length %d\n",
1354 offset, len);
1355 ret = -1;
1356 goto done;
1357 }
1358
1359 txlen = len;
1360
1361 if (len & BIT(0)) {
1362 block_retry_cnt++;
1363 if (block_retry_cnt > MAX_WRITE_IOMEM_RETRY) {
1364 pr_err("FW download failure @ %d, over max "
1365 "retry count\n", offset);
1366 ret = -1;
1367 goto done;
1368 }
1369 dev_err(adapter->dev, "FW CRC error indicated by the "
1370 "helper: len = 0x%04X, txlen = %d\n",
1371 len, txlen);
1372 len &= ~BIT(0);
1373 /* Setting this to 0 to resend from same offset */
1374 txlen = 0;
1375 } else {
1376 block_retry_cnt = 0;
1377 /* Set blocksize to transfer - checking for
1378 last block */
1379 if (firmware_len - offset < txlen)
1380 txlen = firmware_len - offset;
1381
1382 dev_dbg(adapter->dev, ".");
1383
1384 tx_blocks = (txlen +
1385 MWIFIEX_PCIE_BLOCK_SIZE_FW_DNLD - 1) /
1386 MWIFIEX_PCIE_BLOCK_SIZE_FW_DNLD;
1387
1388 /* Copy payload to buffer */
1389 memmove(skb->data, &firmware[offset], txlen);
1390 }
1391
1392 skb_put(skb, MWIFIEX_UPLD_SIZE - skb->len);
1393 skb_trim(skb, tx_blocks * MWIFIEX_PCIE_BLOCK_SIZE_FW_DNLD);
1394
1395 /* Send the boot command to device */
1396 if (mwifiex_pcie_send_boot_cmd(adapter, skb)) {
1397 dev_err(adapter->dev,
1398 "Failed to send firmware download command\n");
1399 ret = -1;
1400 goto done;
1401 }
1402 /* Wait for the command done interrupt */
1403 do {
1404 if (mwifiex_read_reg(adapter, PCIE_CPU_INT_STATUS,
1405 &ireg_intr)) {
1406 dev_err(adapter->dev, "%s: Failed to read "
1407 "interrupt status during fw dnld.\n",
1408 __func__);
1409 ret = -1;
1410 goto done;
1411 }
1412 } while ((ireg_intr & CPU_INTR_DOOR_BELL) ==
1413 CPU_INTR_DOOR_BELL);
1414 offset += txlen;
1415 } while (true);
1416
1417 dev_dbg(adapter->dev, "info:\nFW download over, size %d bytes\n",
1418 offset);
1419
1420 ret = 0;
1421
1422 done:
1423 dev_kfree_skb_any(skb);
1424 return ret;
1425 }
1426
1427 /*
1428 * This function checks the firmware status in card.
1429 *
1430 * The winner interface is also determined by this function.
1431 */
1432 static int
1433 mwifiex_check_fw_status(struct mwifiex_adapter *adapter, u32 poll_num)
1434 {
1435 int ret = 0;
1436 u32 firmware_stat, winner_status;
1437 u32 tries;
1438
1439 /* Mask spurios interrupts */
1440 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS_MASK,
1441 HOST_INTR_MASK)) {
1442 dev_warn(adapter->dev, "Write register failed\n");
1443 return -1;
1444 }
1445
1446 dev_dbg(adapter->dev, "Setting driver ready signature\n");
1447 if (mwifiex_write_reg(adapter, REG_DRV_READY, FIRMWARE_READY_PCIE)) {
1448 dev_err(adapter->dev,
1449 "Failed to write driver ready signature\n");
1450 return -1;
1451 }
1452
1453 /* Wait for firmware initialization event */
1454 for (tries = 0; tries < poll_num; tries++) {
1455 if (mwifiex_read_reg(adapter, PCIE_SCRATCH_3_REG,
1456 &firmware_stat))
1457 ret = -1;
1458 else
1459 ret = 0;
1460 if (ret)
1461 continue;
1462 if (firmware_stat == FIRMWARE_READY_PCIE) {
1463 ret = 0;
1464 break;
1465 } else {
1466 mdelay(100);
1467 ret = -1;
1468 }
1469 }
1470
1471 if (ret) {
1472 if (mwifiex_read_reg(adapter, PCIE_SCRATCH_3_REG,
1473 &winner_status))
1474 ret = -1;
1475 else if (!winner_status) {
1476 dev_err(adapter->dev, "PCI-E is the winner\n");
1477 adapter->winner = 1;
1478 ret = -1;
1479 } else {
1480 dev_err(adapter->dev,
1481 "PCI-E is not the winner <%#x,%d>, exit dnld\n",
1482 ret, adapter->winner);
1483 ret = 0;
1484 }
1485 }
1486
1487 return ret;
1488 }
1489
1490 /*
1491 * This function reads the interrupt status from card.
1492 */
1493 static void mwifiex_interrupt_status(struct mwifiex_adapter *adapter)
1494 {
1495 u32 pcie_ireg;
1496 unsigned long flags;
1497
1498 if (!mwifiex_pcie_ok_to_access_hw(adapter))
1499 return;
1500
1501 if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS, &pcie_ireg)) {
1502 dev_warn(adapter->dev, "Read register failed\n");
1503 return;
1504 }
1505
1506 if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
1507
1508 mwifiex_pcie_disable_host_int(adapter);
1509
1510 /* Clear the pending interrupts */
1511 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS,
1512 ~pcie_ireg)) {
1513 dev_warn(adapter->dev, "Write register failed\n");
1514 return;
1515 }
1516 spin_lock_irqsave(&adapter->int_lock, flags);
1517 adapter->int_status |= pcie_ireg;
1518 spin_unlock_irqrestore(&adapter->int_lock, flags);
1519
1520 if (pcie_ireg & HOST_INTR_CMD_DONE) {
1521 if ((adapter->ps_state == PS_STATE_SLEEP_CFM) ||
1522 (adapter->ps_state == PS_STATE_SLEEP)) {
1523 mwifiex_pcie_enable_host_int(adapter);
1524 if (mwifiex_write_reg(adapter,
1525 PCIE_CPU_INT_EVENT,
1526 CPU_INTR_SLEEP_CFM_DONE)
1527 ) {
1528 dev_warn(adapter->dev,
1529 "Write register failed\n");
1530 return;
1531
1532 }
1533 }
1534 } else if (!adapter->pps_uapsd_mode &&
1535 adapter->ps_state == PS_STATE_SLEEP) {
1536 /* Potentially for PCIe we could get other
1537 * interrupts like shared. Don't change power
1538 * state until cookie is set */
1539 if (mwifiex_pcie_ok_to_access_hw(adapter))
1540 adapter->ps_state = PS_STATE_AWAKE;
1541 }
1542 }
1543 }
1544
1545 /*
1546 * Interrupt handler for PCIe root port
1547 *
1548 * This function reads the interrupt status from firmware and assigns
1549 * the main process in workqueue which will handle the interrupt.
1550 */
1551 static irqreturn_t mwifiex_pcie_interrupt(int irq, void *context)
1552 {
1553 struct pci_dev *pdev = (struct pci_dev *)context;
1554 struct pcie_service_card *card;
1555 struct mwifiex_adapter *adapter;
1556
1557 if (!pdev) {
1558 pr_debug("info: %s: pdev is NULL\n", (u8 *)pdev);
1559 goto exit;
1560 }
1561
1562 card = (struct pcie_service_card *) pci_get_drvdata(pdev);
1563 if (!card || !card->adapter) {
1564 pr_debug("info: %s: card=%p adapter=%p\n", __func__, card,
1565 card ? card->adapter : NULL);
1566 goto exit;
1567 }
1568 adapter = card->adapter;
1569
1570 if (adapter->surprise_removed)
1571 goto exit;
1572
1573 mwifiex_interrupt_status(adapter);
1574 queue_work(adapter->workqueue, &adapter->main_work);
1575
1576 exit:
1577 return IRQ_HANDLED;
1578 }
1579
1580 /*
1581 * This function checks the current interrupt status.
1582 *
1583 * The following interrupts are checked and handled by this function -
1584 * - Data sent
1585 * - Command sent
1586 * - Command received
1587 * - Packets received
1588 * - Events received
1589 *
1590 * In case of Rx packets received, the packets are uploaded from card to
1591 * host and processed accordingly.
1592 */
1593 static int mwifiex_process_int_status(struct mwifiex_adapter *adapter)
1594 {
1595 int ret;
1596 u32 pcie_ireg = 0;
1597 unsigned long flags;
1598
1599 spin_lock_irqsave(&adapter->int_lock, flags);
1600 /* Clear out unused interrupts */
1601 adapter->int_status &= HOST_INTR_MASK;
1602 spin_unlock_irqrestore(&adapter->int_lock, flags);
1603
1604 while (adapter->int_status & HOST_INTR_MASK) {
1605 if (adapter->int_status & HOST_INTR_DNLD_DONE) {
1606 adapter->int_status &= ~HOST_INTR_DNLD_DONE;
1607 if (adapter->data_sent) {
1608 dev_dbg(adapter->dev, "info: DATA sent intr\n");
1609 adapter->data_sent = false;
1610 }
1611 }
1612 if (adapter->int_status & HOST_INTR_UPLD_RDY) {
1613 adapter->int_status &= ~HOST_INTR_UPLD_RDY;
1614 dev_dbg(adapter->dev, "info: Rx DATA\n");
1615 ret = mwifiex_pcie_process_recv_data(adapter);
1616 if (ret)
1617 return ret;
1618 }
1619 if (adapter->int_status & HOST_INTR_EVENT_RDY) {
1620 adapter->int_status &= ~HOST_INTR_EVENT_RDY;
1621 dev_dbg(adapter->dev, "info: Rx EVENT\n");
1622 ret = mwifiex_pcie_process_event_ready(adapter);
1623 if (ret)
1624 return ret;
1625 }
1626
1627 if (adapter->int_status & HOST_INTR_CMD_DONE) {
1628 adapter->int_status &= ~HOST_INTR_CMD_DONE;
1629 if (adapter->cmd_sent) {
1630 dev_dbg(adapter->dev,
1631 "info: CMD sent Interrupt\n");
1632 adapter->cmd_sent = false;
1633 }
1634 /* Handle command response */
1635 ret = mwifiex_pcie_process_cmd_complete(adapter);
1636 if (ret)
1637 return ret;
1638 }
1639
1640 if (mwifiex_pcie_ok_to_access_hw(adapter)) {
1641 if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS,
1642 &pcie_ireg)) {
1643 dev_warn(adapter->dev,
1644 "Read register failed\n");
1645 return -1;
1646 }
1647
1648 if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) {
1649 if (mwifiex_write_reg(adapter,
1650 PCIE_HOST_INT_STATUS,
1651 ~pcie_ireg)) {
1652 dev_warn(adapter->dev,
1653 "Write register failed\n");
1654 return -1;
1655 }
1656 adapter->int_status |= pcie_ireg;
1657 adapter->int_status &= HOST_INTR_MASK;
1658 }
1659
1660 }
1661 }
1662 dev_dbg(adapter->dev, "info: cmd_sent=%d data_sent=%d\n",
1663 adapter->cmd_sent, adapter->data_sent);
1664 mwifiex_pcie_enable_host_int(adapter);
1665
1666 return 0;
1667 }
1668
1669 /*
1670 * This function downloads data from driver to card.
1671 *
1672 * Both commands and data packets are transferred to the card by this
1673 * function.
1674 *
1675 * This function adds the PCIE specific header to the front of the buffer
1676 * before transferring. The header contains the length of the packet and
1677 * the type. The firmware handles the packets based upon this set type.
1678 */
1679 static int mwifiex_pcie_host_to_card(struct mwifiex_adapter *adapter, u8 type,
1680 struct sk_buff *skb,
1681 struct mwifiex_tx_param *tx_param)
1682 {
1683 if (!skb) {
1684 dev_err(adapter->dev, "Passed NULL skb to %s\n", __func__);
1685 return -1;
1686 }
1687
1688 if (type == MWIFIEX_TYPE_DATA)
1689 return mwifiex_pcie_send_data(adapter, skb);
1690 else if (type == MWIFIEX_TYPE_CMD)
1691 return mwifiex_pcie_send_cmd(adapter, skb);
1692
1693 return 0;
1694 }
1695
1696 /*
1697 * This function initializes the PCI-E host memory space, WCB rings, etc.
1698 *
1699 * The following initializations steps are followed -
1700 * - Allocate TXBD ring buffers
1701 * - Allocate RXBD ring buffers
1702 * - Allocate event BD ring buffers
1703 * - Allocate command response ring buffer
1704 * - Allocate sleep cookie buffer
1705 */
1706 static int mwifiex_pcie_init(struct mwifiex_adapter *adapter)
1707 {
1708 struct pcie_service_card *card = adapter->card;
1709 int ret;
1710 struct pci_dev *pdev = card->dev;
1711
1712 pci_set_drvdata(pdev, card);
1713
1714 ret = pci_enable_device(pdev);
1715 if (ret)
1716 goto err_enable_dev;
1717
1718 pci_set_master(pdev);
1719
1720 dev_dbg(adapter->dev, "try set_consistent_dma_mask(32)\n");
1721 ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
1722 if (ret) {
1723 dev_err(adapter->dev, "set_dma_mask(32) failed\n");
1724 goto err_set_dma_mask;
1725 }
1726
1727 ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
1728 if (ret) {
1729 dev_err(adapter->dev, "set_consistent_dma_mask(64) failed\n");
1730 goto err_set_dma_mask;
1731 }
1732
1733 ret = pci_request_region(pdev, 0, DRV_NAME);
1734 if (ret) {
1735 dev_err(adapter->dev, "req_reg(0) error\n");
1736 goto err_req_region0;
1737 }
1738 card->pci_mmap = pci_iomap(pdev, 0, 0);
1739 if (!card->pci_mmap) {
1740 dev_err(adapter->dev, "iomap(0) error\n");
1741 goto err_iomap0;
1742 }
1743 ret = pci_request_region(pdev, 2, DRV_NAME);
1744 if (ret) {
1745 dev_err(adapter->dev, "req_reg(2) error\n");
1746 goto err_req_region2;
1747 }
1748 card->pci_mmap1 = pci_iomap(pdev, 2, 0);
1749 if (!card->pci_mmap1) {
1750 dev_err(adapter->dev, "iomap(2) error\n");
1751 goto err_iomap2;
1752 }
1753
1754 dev_dbg(adapter->dev,
1755 "PCI memory map Virt0: %p PCI memory map Virt2: %p\n",
1756 card->pci_mmap, card->pci_mmap1);
1757
1758 card->cmdrsp_buf = NULL;
1759 ret = mwifiex_pcie_create_txbd_ring(adapter);
1760 if (ret)
1761 goto err_cre_txbd;
1762 ret = mwifiex_pcie_create_rxbd_ring(adapter);
1763 if (ret)
1764 goto err_cre_rxbd;
1765 ret = mwifiex_pcie_create_evtbd_ring(adapter);
1766 if (ret)
1767 goto err_cre_evtbd;
1768 ret = mwifiex_pcie_alloc_cmdrsp_buf(adapter);
1769 if (ret)
1770 goto err_alloc_cmdbuf;
1771 ret = mwifiex_pcie_alloc_sleep_cookie_buf(adapter);
1772 if (ret)
1773 goto err_alloc_cookie;
1774
1775 return ret;
1776
1777 err_alloc_cookie:
1778 mwifiex_pcie_delete_cmdrsp_buf(adapter);
1779 err_alloc_cmdbuf:
1780 mwifiex_pcie_delete_evtbd_ring(adapter);
1781 err_cre_evtbd:
1782 mwifiex_pcie_delete_rxbd_ring(adapter);
1783 err_cre_rxbd:
1784 mwifiex_pcie_delete_txbd_ring(adapter);
1785 err_cre_txbd:
1786 pci_iounmap(pdev, card->pci_mmap1);
1787 err_iomap2:
1788 pci_release_region(pdev, 2);
1789 err_req_region2:
1790 pci_iounmap(pdev, card->pci_mmap);
1791 err_iomap0:
1792 pci_release_region(pdev, 0);
1793 err_req_region0:
1794 err_set_dma_mask:
1795 pci_disable_device(pdev);
1796 err_enable_dev:
1797 pci_set_drvdata(pdev, NULL);
1798 return ret;
1799 }
1800
1801 /*
1802 * This function cleans up the allocated card buffers.
1803 *
1804 * The following are freed by this function -
1805 * - TXBD ring buffers
1806 * - RXBD ring buffers
1807 * - Event BD ring buffers
1808 * - Command response ring buffer
1809 * - Sleep cookie buffer
1810 */
1811 static void mwifiex_pcie_cleanup(struct mwifiex_adapter *adapter)
1812 {
1813 struct pcie_service_card *card = adapter->card;
1814 struct pci_dev *pdev = card->dev;
1815
1816 mwifiex_pcie_delete_sleep_cookie_buf(adapter);
1817 mwifiex_pcie_delete_cmdrsp_buf(adapter);
1818 mwifiex_pcie_delete_evtbd_ring(adapter);
1819 mwifiex_pcie_delete_rxbd_ring(adapter);
1820 mwifiex_pcie_delete_txbd_ring(adapter);
1821 card->cmdrsp_buf = NULL;
1822
1823 dev_dbg(adapter->dev, "Clearing driver ready signature\n");
1824 if (user_rmmod) {
1825 if (mwifiex_write_reg(adapter, REG_DRV_READY, 0x00000000))
1826 dev_err(adapter->dev,
1827 "Failed to write driver not-ready signature\n");
1828 }
1829
1830 if (pdev) {
1831 pci_iounmap(pdev, card->pci_mmap);
1832 pci_iounmap(pdev, card->pci_mmap1);
1833
1834 pci_release_regions(pdev);
1835 pci_disable_device(pdev);
1836 pci_set_drvdata(pdev, NULL);
1837 }
1838 }
1839
1840 /*
1841 * This function registers the PCIE device.
1842 *
1843 * PCIE IRQ is claimed, block size is set and driver data is initialized.
1844 */
1845 static int mwifiex_register_dev(struct mwifiex_adapter *adapter)
1846 {
1847 int ret;
1848 struct pcie_service_card *card = adapter->card;
1849 struct pci_dev *pdev = card->dev;
1850
1851 /* save adapter pointer in card */
1852 card->adapter = adapter;
1853
1854 ret = request_irq(pdev->irq, mwifiex_pcie_interrupt, IRQF_SHARED,
1855 "MRVL_PCIE", pdev);
1856 if (ret) {
1857 pr_err("request_irq failed: ret=%d\n", ret);
1858 adapter->card = NULL;
1859 return -1;
1860 }
1861
1862 adapter->dev = &pdev->dev;
1863 strcpy(adapter->fw_name, PCIE8766_DEFAULT_FW_NAME);
1864
1865 return 0;
1866 }
1867
1868 /*
1869 * This function unregisters the PCIE device.
1870 *
1871 * The PCIE IRQ is released, the function is disabled and driver
1872 * data is set to null.
1873 */
1874 static void mwifiex_unregister_dev(struct mwifiex_adapter *adapter)
1875 {
1876 struct pcie_service_card *card = adapter->card;
1877
1878 if (card) {
1879 dev_dbg(adapter->dev, "%s(): calling free_irq()\n", __func__);
1880 free_irq(card->dev->irq, card->dev);
1881 }
1882 }
1883
1884 static struct mwifiex_if_ops pcie_ops = {
1885 .init_if = mwifiex_pcie_init,
1886 .cleanup_if = mwifiex_pcie_cleanup,
1887 .check_fw_status = mwifiex_check_fw_status,
1888 .prog_fw = mwifiex_prog_fw_w_helper,
1889 .register_dev = mwifiex_register_dev,
1890 .unregister_dev = mwifiex_unregister_dev,
1891 .enable_int = mwifiex_pcie_enable_host_int,
1892 .process_int_status = mwifiex_process_int_status,
1893 .host_to_card = mwifiex_pcie_host_to_card,
1894 .wakeup = mwifiex_pm_wakeup_card,
1895 .wakeup_complete = mwifiex_pm_wakeup_card_complete,
1896
1897 /* PCIE specific */
1898 .cmdrsp_complete = mwifiex_pcie_cmdrsp_complete,
1899 .event_complete = mwifiex_pcie_event_complete,
1900 .update_mp_end_port = NULL,
1901 .cleanup_mpa_buf = NULL,
1902 };
1903
1904 /*
1905 * This function initializes the PCIE driver module.
1906 *
1907 * This initiates the semaphore and registers the device with
1908 * PCIE bus.
1909 */
1910 static int mwifiex_pcie_init_module(void)
1911 {
1912 int ret;
1913
1914 pr_debug("Marvell 8766 PCIe Driver\n");
1915
1916 sema_init(&add_remove_card_sem, 1);
1917
1918 /* Clear the flag in case user removes the card. */
1919 user_rmmod = 0;
1920
1921 ret = pci_register_driver(&mwifiex_pcie);
1922 if (ret)
1923 pr_err("Driver register failed!\n");
1924 else
1925 pr_debug("info: Driver registered successfully!\n");
1926
1927 return ret;
1928 }
1929
1930 /*
1931 * This function cleans up the PCIE driver.
1932 *
1933 * The following major steps are followed for cleanup -
1934 * - Resume the device if its suspended
1935 * - Disconnect the device if connected
1936 * - Shutdown the firmware
1937 * - Unregister the device from PCIE bus.
1938 */
1939 static void mwifiex_pcie_cleanup_module(void)
1940 {
1941 if (!down_interruptible(&add_remove_card_sem))
1942 up(&add_remove_card_sem);
1943
1944 /* Set the flag as user is removing this module. */
1945 user_rmmod = 1;
1946
1947 pci_unregister_driver(&mwifiex_pcie);
1948 }
1949
1950 module_init(mwifiex_pcie_init_module);
1951 module_exit(mwifiex_pcie_cleanup_module);
1952
1953 MODULE_AUTHOR("Marvell International Ltd.");
1954 MODULE_DESCRIPTION("Marvell WiFi-Ex PCI-Express Driver version " PCIE_VERSION);
1955 MODULE_VERSION(PCIE_VERSION);
1956 MODULE_LICENSE("GPL v2");
1957 MODULE_FIRMWARE("mrvl/pcie8766_uapsta.bin");
Linux kernel - Deliverables
This page took 0.120708 seconds and 5 git commands to generate.