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 34static u8 user_rmmod; 35 36static struct mwifiex_if_ops pcie_ops; 37 38static struct semaphore add_remove_card_sem; 39static int mwifiex_pcie_enable_host_int(struct mwifiex_adapter *adapter); 40static 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 */ 46static 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 */ 58static 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 */ 80static 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 */ 109static 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 */ 155static 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 */ 193static 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 232static 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 240MODULE_DEVICE_TABLE(pci, mwifiex_ids); 241 242/* PCI Device Driver */ 243static 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 */ 258static 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 */ 270static 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 */ 285static 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 */ 316static 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 */ 329static 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 */ 348static 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 */ 365static 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 return -ENOMEM; 390 } 391 card->txbd_ring_pbase = virt_to_phys(card->txbd_ring_vbase); 392 393 dev_dbg(adapter->dev, "info: txbd_ring - base: %p, pbase: %#x:%x," 394 "len: %x\n", card->txbd_ring_vbase, 395 (u32)card->txbd_ring_pbase, 396 (u32)((u64)card->txbd_ring_pbase >> 32), 397 card->txbd_ring_size); 398 399 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) { 400 card->txbd_ring[i] = (struct mwifiex_pcie_buf_desc *) 401 (card->txbd_ring_vbase + 402 (sizeof(struct mwifiex_pcie_buf_desc) * 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, " 416 "buf_len: %#x\n", skb, skb->data, 417 (u32)*buf_pa, (u32)(((u64)*buf_pa >> 32)), 418 skb->len); 419 420 card->tx_buf_list[i] = skb; 421 card->txbd_ring[i]->paddr = *buf_pa; 422 card->txbd_ring[i]->len = (u16)skb->len; 423 card->txbd_ring[i]->flags = 0; 424 } 425 426 return 0; 427} 428 429static int mwifiex_pcie_delete_txbd_ring(struct mwifiex_adapter *adapter) 430{ 431 struct pcie_service_card *card = adapter->card; 432 int i; 433 434 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) { 435 if (card->tx_buf_list[i]) 436 dev_kfree_skb_any(card->tx_buf_list[i]); 437 card->tx_buf_list[i] = NULL; 438 card->txbd_ring[i]->paddr = 0; 439 card->txbd_ring[i]->len = 0; 440 card->txbd_ring[i]->flags = 0; 441 card->txbd_ring[i] = NULL; 442 } 443 444 kfree(card->txbd_ring_vbase); 445 card->txbd_ring_size = 0; 446 card->txbd_wrptr = 0; 447 card->txbd_rdptr = 0 | MWIFIEX_BD_FLAG_ROLLOVER_IND; 448 card->txbd_ring_vbase = NULL; 449 450 return 0; 451} 452 453/* 454 * This function creates buffer descriptor ring for RX 455 */ 456static int mwifiex_pcie_create_rxbd_ring(struct mwifiex_adapter *adapter) 457{ 458 struct pcie_service_card *card = adapter->card; 459 struct sk_buff *skb; 460 int i; 461 phys_addr_t *buf_pa; 462 463 /* 464 * driver maintaines the read pointer and firmware maintaines the write 465 * pointer. The write pointer starts at 0 (zero) while the read pointer 466 * starts at zero with rollover bit set 467 */ 468 card->rxbd_wrptr = 0; 469 card->rxbd_rdptr |= MWIFIEX_BD_FLAG_ROLLOVER_IND; 470 471 card->rxbd_ring_size = sizeof(struct mwifiex_pcie_buf_desc) * 472 MWIFIEX_MAX_TXRX_BD; 473 dev_dbg(adapter->dev, "info: rxbd_ring: Allocating %d bytes\n", 474 card->rxbd_ring_size); 475 card->rxbd_ring_vbase = kzalloc(card->rxbd_ring_size, GFP_KERNEL); 476 if (!card->rxbd_ring_vbase) { 477 dev_err(adapter->dev, "Unable to allocate buffer for " 478 "rxbd_ring.\n"); 479 return -ENOMEM; 480 } 481 card->rxbd_ring_pbase = virt_to_phys(card->rxbd_ring_vbase); 482 483 dev_dbg(adapter->dev, "info: rxbd_ring - base: %p, pbase: %#x:%x," 484 "len: %#x\n", card->rxbd_ring_vbase, 485 (u32)card->rxbd_ring_pbase, 486 (u32)((u64)card->rxbd_ring_pbase >> 32), 487 card->rxbd_ring_size); 488 489 for (i = 0; i < MWIFIEX_MAX_TXRX_BD; i++) { 490 card->rxbd_ring[i] = (struct mwifiex_pcie_buf_desc *) 491 (card->rxbd_ring_vbase + 492 (sizeof(struct mwifiex_pcie_buf_desc) * 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, "Unable to allocate skb for RX ring.\n"); 498 kfree(card->rxbd_ring_vbase); 499 return -ENOMEM; 500 } 501 buf_pa = mwifiex_update_sk_buff_pa(skb); 502 skb_put(skb, MWIFIEX_RX_DATA_BUF_SIZE); 503 504 dev_dbg(adapter->dev, "info: RX ring: add new skb base: %p, " 505 "buf_base: %p, buf_pbase: %#x:%x, " 506 "buf_len: %#x\n", skb, skb->data, 507 (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 */ 522static 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 */ 549static 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, "Unable to allocate buffer. " 571 "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, "info: CMDRSP/EVT bd_ring - base: %p, " 577 "pbase: %#x:%x, len: %#x\n", card->evtbd_ring_vbase, 578 (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) * i)); 586 587 /* Allocate skb here so that firmware can DMA data from it */ 588 skb = dev_alloc_skb(MAX_EVENT_SIZE); 589 if (!skb) { 590 dev_err(adapter->dev, "Unable to allocate skb for EVENT buf.\n"); 591 kfree(card->evtbd_ring_vbase); 592 return -ENOMEM; 593 } 594 buf_pa = mwifiex_update_sk_buff_pa(skb); 595 skb_put(skb, MAX_EVENT_SIZE); 596 597 dev_dbg(adapter->dev, "info: Evt ring: add new skb. base: %p, " 598 "buf_base: %p, buf_pbase: %#x:%x, " 599 "buf_len: %#x\n", skb, skb->data, 600 (u32)*buf_pa, (u32)((u64)*buf_pa >> 32), 601 skb->len); 602 603 card->evt_buf_list[i] = skb; 604 card->evtbd_ring[i]->paddr = *buf_pa; 605 card->evtbd_ring[i]->len = (u16)skb->len; 606 card->evtbd_ring[i]->flags = 0; 607 } 608 609 return 0; 610} 611 612/* 613 * This function deletes Buffer descriptor ring for Events 614 */ 615static int mwifiex_pcie_delete_evtbd_ring(struct mwifiex_adapter *adapter) 616{ 617 struct pcie_service_card *card = adapter->card; 618 int i; 619 620 for (i = 0; i < MWIFIEX_MAX_EVT_BD; i++) { 621 if (card->evt_buf_list[i]) 622 dev_kfree_skb_any(card->evt_buf_list[i]); 623 card->evt_buf_list[i] = NULL; 624 card->evtbd_ring[i]->paddr = 0; 625 card->evtbd_ring[i]->len = 0; 626 card->evtbd_ring[i]->flags = 0; 627 card->evtbd_ring[i] = NULL; 628 } 629 630 kfree(card->evtbd_ring_vbase); 631 card->evtbd_wrptr = 0; 632 card->evtbd_rdptr = 0 | MWIFIEX_BD_FLAG_ROLLOVER_IND; 633 card->evtbd_ring_size = 0; 634 card->evtbd_ring_vbase = NULL; 635 636 return 0; 637} 638 639/* 640 * This function allocates a buffer for CMDRSP 641 */ 642static int mwifiex_pcie_alloc_cmdrsp_buf(struct mwifiex_adapter *adapter) 643{ 644 struct pcie_service_card *card = adapter->card; 645 struct sk_buff *skb; 646 647 /* Allocate memory for receiving command response data */ 648 skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE); 649 if (!skb) { 650 dev_err(adapter->dev, "Unable to allocate skb for command " 651 "response data.\n"); 652 return -ENOMEM; 653 } 654 mwifiex_update_sk_buff_pa(skb); 655 skb_put(skb, MWIFIEX_UPLD_SIZE); 656 card->cmdrsp_buf = skb; 657 658 skb = NULL; 659 /* Allocate memory for sending command to firmware */ 660 skb = dev_alloc_skb(MWIFIEX_SIZE_OF_CMD_BUFFER); 661 if (!skb) { 662 dev_err(adapter->dev, "Unable to allocate skb for command " 663 "data.\n"); 664 return -ENOMEM; 665 } 666 mwifiex_update_sk_buff_pa(skb); 667 skb_put(skb, MWIFIEX_SIZE_OF_CMD_BUFFER); 668 card->cmd_buf = skb; 669 670 return 0; 671} 672 673/* 674 * This function deletes a buffer for CMDRSP 675 */ 676static int mwifiex_pcie_delete_cmdrsp_buf(struct mwifiex_adapter *adapter) 677{ 678 struct pcie_service_card *card; 679 680 if (!adapter) 681 return 0; 682 683 card = adapter->card; 684 685 if (card && card->cmdrsp_buf) 686 dev_kfree_skb_any(card->cmdrsp_buf); 687 688 if (card && card->cmd_buf) 689 dev_kfree_skb_any(card->cmd_buf); 690 691 return 0; 692} 693 694/* 695 * This function allocates a buffer for sleep cookie 696 */ 697static int mwifiex_pcie_alloc_sleep_cookie_buf(struct mwifiex_adapter *adapter) 698{ 699 struct sk_buff *skb; 700 struct pcie_service_card *card = adapter->card; 701 702 /* Allocate memory for sleep cookie */ 703 skb = dev_alloc_skb(sizeof(u32)); 704 if (!skb) { 705 dev_err(adapter->dev, "Unable to allocate skb for sleep " 706 "cookie!\n"); 707 return -ENOMEM; 708 } 709 mwifiex_update_sk_buff_pa(skb); 710 skb_put(skb, sizeof(u32)); 711 712 /* Init val of Sleep Cookie */ 713 *(u32 *)skb->data = FW_AWAKE_COOKIE; 714 715 dev_dbg(adapter->dev, "alloc_scook: sleep cookie=0x%x\n", 716 *((u32 *)skb->data)); 717 718 /* Save the sleep cookie */ 719 card->sleep_cookie = skb; 720 721 return 0; 722} 723 724/* 725 * This function deletes buffer for sleep cookie 726 */ 727static int mwifiex_pcie_delete_sleep_cookie_buf(struct mwifiex_adapter *adapter) 728{ 729 struct pcie_service_card *card; 730 731 if (!adapter) 732 return 0; 733 734 card = adapter->card; 735 736 if (card && card->sleep_cookie) { 737 dev_kfree_skb_any(card->sleep_cookie); 738 card->sleep_cookie = NULL; 739 } 740 741 return 0; 742} 743 744/* 745 * This function sends data buffer to device 746 */ 747static int 748mwifiex_pcie_send_data(struct mwifiex_adapter *adapter, struct sk_buff *skb) 749{ 750 struct pcie_service_card *card = adapter->card; 751 u32 wrindx, rdptr; 752 phys_addr_t *buf_pa; 753 __le16 *tmp; 754 755 if (!mwifiex_pcie_ok_to_access_hw(adapter)) 756 mwifiex_pm_wakeup_card(adapter); 757 758 /* Read the TX ring read pointer set by firmware */ 759 if (mwifiex_read_reg(adapter, REG_TXBD_RDPTR, &rdptr)) { 760 dev_err(adapter->dev, "SEND DATA: failed to read " 761 "REG_TXBD_RDPTR\n"); 762 return -1; 763 } 764 765 wrindx = card->txbd_wrptr & MWIFIEX_TXBD_MASK; 766 767 dev_dbg(adapter->dev, "info: SEND DATA: <Rd: %#x, Wr: %#x>\n", rdptr, 768 card->txbd_wrptr); 769 if (((card->txbd_wrptr & MWIFIEX_TXBD_MASK) != 770 (rdptr & MWIFIEX_TXBD_MASK)) || 771 ((card->txbd_wrptr & MWIFIEX_BD_FLAG_ROLLOVER_IND) != 772 (rdptr & MWIFIEX_BD_FLAG_ROLLOVER_IND))) { 773 struct sk_buff *skb_data; 774 u8 *payload; 775 776 adapter->data_sent = true; 777 skb_data = card->tx_buf_list[wrindx]; 778 memcpy(skb_data->data, skb->data, skb->len); 779 payload = skb_data->data; 780 tmp = (__le16 *)&payload[0]; 781 *tmp = cpu_to_le16((u16)skb->len); 782 tmp = (__le16 *)&payload[2]; 783 *tmp = cpu_to_le16(MWIFIEX_TYPE_DATA); 784 skb_put(skb_data, MWIFIEX_RX_DATA_BUF_SIZE - skb_data->len); 785 skb_trim(skb_data, skb->len); 786 buf_pa = MWIFIEX_SKB_PACB(skb_data); 787 card->txbd_ring[wrindx]->paddr = *buf_pa; 788 card->txbd_ring[wrindx]->len = (u16)skb_data->len; 789 card->txbd_ring[wrindx]->flags = MWIFIEX_BD_FLAG_FIRST_DESC | 790 MWIFIEX_BD_FLAG_LAST_DESC; 791 792 if ((++card->txbd_wrptr & MWIFIEX_TXBD_MASK) == 793 MWIFIEX_MAX_TXRX_BD) 794 card->txbd_wrptr = ((card->txbd_wrptr & 795 MWIFIEX_BD_FLAG_ROLLOVER_IND) ^ 796 MWIFIEX_BD_FLAG_ROLLOVER_IND); 797 798 /* Write the TX ring write pointer in to REG_TXBD_WRPTR */ 799 if (mwifiex_write_reg(adapter, REG_TXBD_WRPTR, 800 card->txbd_wrptr)) { 801 dev_err(adapter->dev, "SEND DATA: failed to write " 802 "REG_TXBD_WRPTR\n"); 803 return 0; 804 } 805 806 /* Send the TX ready interrupt */ 807 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT, 808 CPU_INTR_DNLD_RDY)) { 809 dev_err(adapter->dev, "SEND DATA: failed to assert " 810 "door-bell interrupt.\n"); 811 return -1; 812 } 813 dev_dbg(adapter->dev, "info: SEND DATA: Updated <Rd: %#x, Wr: " 814 "%#x> and sent packet to firmware " 815 "successfully\n", rdptr, 816 card->txbd_wrptr); 817 } else { 818 dev_dbg(adapter->dev, "info: TX Ring full, can't send anymore " 819 "packets to firmware\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, "SEND DATA: failed to assert " 825 "door-bell interrupt\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 */ 836static 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, "RECV DATA: failed to read " 846 "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, "info: RECV DATA: Rd=%#x, Wr=%#x, " 865 "Len=%d\n", card->rxbd_rdptr, wrptr, rx_len); 866 skb_tmp = dev_alloc_skb(rx_len); 867 if (!skb_tmp) { 868 dev_dbg(adapter->dev, "info: Failed to alloc skb " 869 "for RX\n"); 870 ret = -EBUSY; 871 goto done; 872 } 873 874 skb_put(skb_tmp, rx_len); 875 876 memcpy(skb_tmp->data, skb_data->data + INTF_HEADER_LEN, rx_len); 877 if ((++card->rxbd_rdptr & MWIFIEX_RXBD_MASK) == 878 MWIFIEX_MAX_TXRX_BD) { 879 card->rxbd_rdptr = ((card->rxbd_rdptr & 880 MWIFIEX_BD_FLAG_ROLLOVER_IND) ^ 881 MWIFIEX_BD_FLAG_ROLLOVER_IND); 882 } 883 dev_dbg(adapter->dev, "info: RECV DATA: <Rd: %#x, Wr: %#x>\n", 884 card->rxbd_rdptr, wrptr); 885 886 /* Write the RX ring read pointer in to REG_RXBD_RDPTR */ 887 if (mwifiex_write_reg(adapter, REG_RXBD_RDPTR, 888 card->rxbd_rdptr)) { 889 dev_err(adapter->dev, "RECV DATA: failed to " 890 "write REG_RXBD_RDPTR\n"); 891 ret = -1; 892 goto done; 893 } 894 895 /* Read the RX ring Write pointer set by firmware */ 896 if (mwifiex_read_reg(adapter, REG_RXBD_WRPTR, &wrptr)) { 897 dev_err(adapter->dev, "RECV DATA: failed to read " 898 "REG_TXBD_RDPTR\n"); 899 ret = -1; 900 goto done; 901 } 902 dev_dbg(adapter->dev, "info: RECV DATA: Received packet from " 903 "firmware successfully\n"); 904 mwifiex_handle_rx_packet(adapter, skb_tmp); 905 } 906 907done: 908 if (ret && skb_tmp) 909 dev_kfree_skb_any(skb_tmp); 910 return ret; 911} 912 913/* 914 * This function downloads the boot command to device 915 */ 916static int 917mwifiex_pcie_send_boot_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb) 918{ 919 phys_addr_t *buf_pa = MWIFIEX_SKB_PACB(skb); 920 921 if (!(skb->data && skb->len && *buf_pa)) { 922 dev_err(adapter->dev, "Invalid parameter in %s <%p, %#x:%x, " 923 "%x>\n", __func__, skb->data, skb->len, 924 (u32)*buf_pa, (u32)((u64)*buf_pa >> 32)); 925 return -1; 926 } 927 928 /* Write the lower 32bits of the physical address to scratch 929 * register 0 */ 930 if (mwifiex_write_reg(adapter, PCIE_SCRATCH_0_REG, (u32)*buf_pa)) { 931 dev_err(adapter->dev, "%s: failed to write download command " 932 "to boot code.\n", __func__); 933 return -1; 934 } 935 936 /* Write the upper 32bits of the physical address to scratch 937 * register 1 */ 938 if (mwifiex_write_reg(adapter, PCIE_SCRATCH_1_REG, 939 (u32)((u64)*buf_pa >> 32))) { 940 dev_err(adapter->dev, "%s: failed to write download command " 941 "to boot code.\n", __func__); 942 return -1; 943 } 944 945 /* Write the command length to scratch register 2 */ 946 if (mwifiex_write_reg(adapter, PCIE_SCRATCH_2_REG, skb->len)) { 947 dev_err(adapter->dev, "%s: failed to write command length to " 948 "scratch register 2\n", __func__); 949 return -1; 950 } 951 952 /* Ring the door bell */ 953 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT, 954 CPU_INTR_DOOR_BELL)) { 955 dev_err(adapter->dev, "%s: failed to assert door-bell " 956 "interrupt.\n", __func__); 957 return -1; 958 } 959 960 return 0; 961} 962 963/* 964 * This function downloads commands to the device 965 */ 966static int 967mwifiex_pcie_send_cmd(struct mwifiex_adapter *adapter, struct sk_buff *skb) 968{ 969 struct pcie_service_card *card = adapter->card; 970 int ret = 0; 971 phys_addr_t *cmd_buf_pa; 972 phys_addr_t *cmdrsp_buf_pa; 973 974 if (!(skb->data && skb->len)) { 975 dev_err(adapter->dev, "Invalid parameter in %s <%p, %#x>\n", 976 __func__, skb->data, skb->len); 977 return -1; 978 } 979 980 /* Make sure a command response buffer is available */ 981 if (!card->cmdrsp_buf) { 982 dev_err(adapter->dev, "No response buffer available, send " 983 "command failed\n"); 984 return -EBUSY; 985 } 986 987 /* Make sure a command buffer is available */ 988 if (!card->cmd_buf) { 989 dev_err(adapter->dev, "Command buffer not available\n"); 990 return -EBUSY; 991 } 992 993 adapter->cmd_sent = true; 994 /* Copy the given skb in to DMA accessable shared buffer */ 995 skb_put(card->cmd_buf, MWIFIEX_SIZE_OF_CMD_BUFFER - card->cmd_buf->len); 996 skb_trim(card->cmd_buf, skb->len); 997 memcpy(card->cmd_buf->data, skb->data, skb->len); 998 999 /* To send a command, the driver will: 1000 1. Write the 64bit physical address of the data buffer to 1001 SCRATCH1 + SCRATCH0 1002 2. Ring the door bell (i.e. set the door bell interrupt) 1003 1004 In response to door bell interrupt, the firmware will perform 1005 the DMA of the command packet (first header to obtain the total 1006 length and then rest of the command). 1007 */ 1008 1009 if (card->cmdrsp_buf) { 1010 cmdrsp_buf_pa = MWIFIEX_SKB_PACB(card->cmdrsp_buf); 1011 /* Write the lower 32bits of the cmdrsp buffer physical 1012 address */ 1013 if (mwifiex_write_reg(adapter, REG_CMDRSP_ADDR_LO, 1014 (u32)*cmdrsp_buf_pa)) { 1015 dev_err(adapter->dev, "Failed to write download command to boot code.\n"); 1016 ret = -1; 1017 goto done; 1018 } 1019 /* Write the upper 32bits of the cmdrsp buffer physical 1020 address */ 1021 if (mwifiex_write_reg(adapter, REG_CMDRSP_ADDR_HI, 1022 (u32)((u64)*cmdrsp_buf_pa >> 32))) { 1023 dev_err(adapter->dev, "Failed to write download command" 1024 " to boot code.\n"); 1025 ret = -1; 1026 goto done; 1027 } 1028 } 1029 1030 cmd_buf_pa = MWIFIEX_SKB_PACB(card->cmd_buf); 1031 /* Write the lower 32bits of the physical address to REG_CMD_ADDR_LO */ 1032 if (mwifiex_write_reg(adapter, REG_CMD_ADDR_LO, 1033 (u32)*cmd_buf_pa)) { 1034 dev_err(adapter->dev, "Failed to write download command " 1035 "to boot code.\n"); 1036 ret = -1; 1037 goto done; 1038 } 1039 /* Write the upper 32bits of the physical address to REG_CMD_ADDR_HI */ 1040 if (mwifiex_write_reg(adapter, REG_CMD_ADDR_HI, 1041 (u32)((u64)*cmd_buf_pa >> 32))) { 1042 dev_err(adapter->dev, "Failed to write download command " 1043 "to boot code.\n"); 1044 ret = -1; 1045 goto done; 1046 } 1047 1048 /* Write the command length to REG_CMD_SIZE */ 1049 if (mwifiex_write_reg(adapter, REG_CMD_SIZE, 1050 card->cmd_buf->len)) { 1051 dev_err(adapter->dev, "Failed to write command length to " 1052 "REG_CMD_SIZE\n"); 1053 ret = -1; 1054 goto done; 1055 } 1056 1057 /* Ring the door bell */ 1058 if (mwifiex_write_reg(adapter, PCIE_CPU_INT_EVENT, 1059 CPU_INTR_DOOR_BELL)) { 1060 dev_err(adapter->dev, "Failed to assert door-bell " 1061 "interrupt.\n"); 1062 ret = -1; 1063 goto done; 1064 } 1065 1066done: 1067 if (ret) 1068 adapter->cmd_sent = false; 1069 1070 return 0; 1071} 1072 1073/* 1074 * This function handles command complete interrupt 1075 */ 1076static int mwifiex_pcie_process_cmd_complete(struct mwifiex_adapter *adapter) 1077{ 1078 struct pcie_service_card *card = adapter->card; 1079 int count = 0; 1080 1081 dev_dbg(adapter->dev, "info: Rx CMD Response\n"); 1082 1083 if (!adapter->curr_cmd) { 1084 skb_pull(card->cmdrsp_buf, INTF_HEADER_LEN); 1085 if (adapter->ps_state == PS_STATE_SLEEP_CFM) { 1086 mwifiex_process_sleep_confirm_resp(adapter, 1087 card->cmdrsp_buf->data, 1088 card->cmdrsp_buf->len); 1089 while (mwifiex_pcie_ok_to_access_hw(adapter) && 1090 (count++ < 10)) 1091 udelay(50); 1092 } else { 1093 dev_err(adapter->dev, "There is no command but " 1094 "got cmdrsp\n"); 1095 } 1096 memcpy(adapter->upld_buf, card->cmdrsp_buf->data, 1097 min_t(u32, MWIFIEX_SIZE_OF_CMD_BUFFER, 1098 card->cmdrsp_buf->len)); 1099 skb_push(card->cmdrsp_buf, INTF_HEADER_LEN); 1100 } else if (mwifiex_pcie_ok_to_access_hw(adapter)) { 1101 skb_pull(card->cmdrsp_buf, INTF_HEADER_LEN); 1102 adapter->curr_cmd->resp_skb = card->cmdrsp_buf; 1103 adapter->cmd_resp_received = true; 1104 /* Take the pointer and set it to CMD node and will 1105 return in the response complete callback */ 1106 card->cmdrsp_buf = NULL; 1107 1108 /* Clear the cmd-rsp buffer address in scratch registers. This 1109 will prevent firmware from writing to the same response 1110 buffer again. */ 1111 if (mwifiex_write_reg(adapter, REG_CMDRSP_ADDR_LO, 0)) { 1112 dev_err(adapter->dev, "cmd_done: failed to clear " 1113 "cmd_rsp address.\n"); 1114 return -1; 1115 } 1116 /* Write the upper 32bits of the cmdrsp buffer physical 1117 address */ 1118 if (mwifiex_write_reg(adapter, REG_CMDRSP_ADDR_HI, 0)) { 1119 dev_err(adapter->dev, "cmd_done: failed to clear " 1120 "cmd_rsp address.\n"); 1121 return -1; 1122 } 1123 } 1124 1125 return 0; 1126} 1127 1128/* 1129 * Command Response processing complete handler 1130 */ 1131static int mwifiex_pcie_cmdrsp_complete(struct mwifiex_adapter *adapter, 1132 struct sk_buff *skb) 1133{ 1134 struct pcie_service_card *card = adapter->card; 1135 1136 if (skb) { 1137 card->cmdrsp_buf = skb; 1138 skb_push(card->cmdrsp_buf, INTF_HEADER_LEN); 1139 } 1140 1141 return 0; 1142} 1143 1144/* 1145 * This function handles firmware event ready interrupt 1146 */ 1147static int mwifiex_pcie_process_event_ready(struct mwifiex_adapter *adapter) 1148{ 1149 struct pcie_service_card *card = adapter->card; 1150 u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK; 1151 u32 wrptr, event; 1152 1153 if (adapter->event_received) { 1154 dev_dbg(adapter->dev, "info: Event being processed, "\ 1155 "do not process this interrupt just yet\n"); 1156 return 0; 1157 } 1158 1159 if (rdptr >= MWIFIEX_MAX_EVT_BD) { 1160 dev_dbg(adapter->dev, "info: Invalid read pointer...\n"); 1161 return -1; 1162 } 1163 1164 /* Read the event ring write pointer set by firmware */ 1165 if (mwifiex_read_reg(adapter, REG_EVTBD_WRPTR, &wrptr)) { 1166 dev_err(adapter->dev, "EventReady: failed to read REG_EVTBD_WRPTR\n"); 1167 return -1; 1168 } 1169 1170 dev_dbg(adapter->dev, "info: EventReady: Initial <Rd: 0x%x, Wr: 0x%x>", 1171 card->evtbd_rdptr, wrptr); 1172 if (((wrptr & MWIFIEX_EVTBD_MASK) != 1173 (card->evtbd_rdptr & MWIFIEX_EVTBD_MASK)) || 1174 ((wrptr & MWIFIEX_BD_FLAG_ROLLOVER_IND) == 1175 (card->evtbd_rdptr & MWIFIEX_BD_FLAG_ROLLOVER_IND))) { 1176 struct sk_buff *skb_cmd; 1177 __le16 data_len = 0; 1178 u16 evt_len; 1179 1180 dev_dbg(adapter->dev, "info: Read Index: %d\n", rdptr); 1181 skb_cmd = card->evt_buf_list[rdptr]; 1182 /* Take the pointer and set it to event pointer in adapter 1183 and will return back after event handling callback */ 1184 card->evt_buf_list[rdptr] = NULL; 1185 card->evtbd_ring[rdptr]->paddr = 0; 1186 card->evtbd_ring[rdptr]->len = 0; 1187 card->evtbd_ring[rdptr]->flags = 0; 1188 1189 event = *(u32 *) &skb_cmd->data[INTF_HEADER_LEN]; 1190 adapter->event_cause = event; 1191 /* The first 4bytes will be the event transfer header 1192 len is 2 bytes followed by type which is 2 bytes */ 1193 memcpy(&data_len, skb_cmd->data, sizeof(__le16)); 1194 evt_len = le16_to_cpu(data_len); 1195 1196 skb_pull(skb_cmd, INTF_HEADER_LEN); 1197 dev_dbg(adapter->dev, "info: Event length: %d\n", evt_len); 1198 1199 if ((evt_len > 0) && (evt_len < MAX_EVENT_SIZE)) 1200 memcpy(adapter->event_body, skb_cmd->data + 1201 MWIFIEX_EVENT_HEADER_LEN, evt_len - 1202 MWIFIEX_EVENT_HEADER_LEN); 1203 1204 adapter->event_received = true; 1205 adapter->event_skb = skb_cmd; 1206 1207 /* Do not update the event read pointer here, wait till the 1208 buffer is released. This is just to make things simpler, 1209 we need to find a better method of managing these buffers. 1210 */ 1211 } 1212 1213 return 0; 1214} 1215 1216/* 1217 * Event processing complete handler 1218 */ 1219static int mwifiex_pcie_event_complete(struct mwifiex_adapter *adapter, 1220 struct sk_buff *skb) 1221{ 1222 struct pcie_service_card *card = adapter->card; 1223 int ret = 0; 1224 u32 rdptr = card->evtbd_rdptr & MWIFIEX_EVTBD_MASK; 1225 u32 wrptr; 1226 phys_addr_t *buf_pa; 1227 1228 if (!skb) 1229 return 0; 1230 1231 if (rdptr >= MWIFIEX_MAX_EVT_BD) { 1232 dev_err(adapter->dev, "event_complete: Invalid rdptr 0x%x\n", 1233 rdptr); 1234 return -EINVAL; 1235 } 1236 1237 /* Read the event ring write pointer set by firmware */ 1238 if (mwifiex_read_reg(adapter, REG_EVTBD_WRPTR, &wrptr)) { 1239 dev_err(adapter->dev, "event_complete: failed to read REG_EVTBD_WRPTR\n"); 1240 return -1; 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 return -1; 1270 } 1271 1272 dev_dbg(adapter->dev, "info: Check Events Again\n"); 1273 ret = mwifiex_pcie_process_event_ready(adapter); 1274 1275 return ret; 1276} 1277 1278/* 1279 * This function downloads the firmware to the card. 1280 * 1281 * Firmware is downloaded to the card in blocks. Every block download 1282 * is tested for CRC errors, and retried a number of times before 1283 * returning failure. 1284 */ 1285static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter *adapter, 1286 struct mwifiex_fw_image *fw) 1287{ 1288 int ret; 1289 u8 *firmware = fw->fw_buf; 1290 u32 firmware_len = fw->fw_len; 1291 u32 offset = 0; 1292 struct sk_buff *skb; 1293 u32 txlen, tx_blocks = 0, tries, len; 1294 u32 block_retry_cnt = 0; 1295 1296 if (!adapter) { 1297 pr_err("adapter structure is not valid\n"); 1298 return -1; 1299 } 1300 1301 if (!firmware || !firmware_len) { 1302 dev_err(adapter->dev, "No firmware image found! " 1303 "Terminating download\n"); 1304 return -1; 1305 } 1306 1307 dev_dbg(adapter->dev, "info: Downloading FW image (%d bytes)\n", 1308 firmware_len); 1309 1310 if (mwifiex_pcie_disable_host_int(adapter)) { 1311 dev_err(adapter->dev, "%s: Disabling interrupts" 1312 " failed.\n", __func__); 1313 return -1; 1314 } 1315 1316 skb = dev_alloc_skb(MWIFIEX_UPLD_SIZE); 1317 if (!skb) { 1318 ret = -ENOMEM; 1319 goto done; 1320 } 1321 mwifiex_update_sk_buff_pa(skb); 1322 1323 /* Perform firmware data transfer */ 1324 do { 1325 u32 ireg_intr = 0; 1326 1327 /* More data? */ 1328 if (offset >= firmware_len) 1329 break; 1330 1331 for (tries = 0; tries < MAX_POLL_TRIES; tries++) { 1332 ret = mwifiex_read_reg(adapter, PCIE_SCRATCH_2_REG, 1333 &len); 1334 if (ret) { 1335 dev_warn(adapter->dev, "Failed reading length from boot code\n"); 1336 goto done; 1337 } 1338 if (len) 1339 break; 1340 udelay(10); 1341 } 1342 1343 if (!len) { 1344 break; 1345 } else if (len > MWIFIEX_UPLD_SIZE) { 1346 pr_err("FW download failure @ %d, invalid length %d\n", 1347 offset, len); 1348 ret = -1; 1349 goto done; 1350 } 1351 1352 txlen = len; 1353 1354 if (len & BIT(0)) { 1355 block_retry_cnt++; 1356 if (block_retry_cnt > MAX_WRITE_IOMEM_RETRY) { 1357 pr_err("FW download failure @ %d, over max " 1358 "retry count\n", offset); 1359 ret = -1; 1360 goto done; 1361 } 1362 dev_err(adapter->dev, "FW CRC error indicated by the " 1363 "helper: len = 0x%04X, txlen = " 1364 "%d\n", len, txlen); 1365 len &= ~BIT(0); 1366 /* Setting this to 0 to resend from same offset */ 1367 txlen = 0; 1368 } else { 1369 block_retry_cnt = 0; 1370 /* Set blocksize to transfer - checking for 1371 last block */ 1372 if (firmware_len - offset < txlen) 1373 txlen = firmware_len - offset; 1374 1375 dev_dbg(adapter->dev, "."); 1376 1377 tx_blocks = 1378 (txlen + MWIFIEX_PCIE_BLOCK_SIZE_FW_DNLD - 1) / 1379 MWIFIEX_PCIE_BLOCK_SIZE_FW_DNLD; 1380 1381 /* Copy payload to buffer */ 1382 memmove(skb->data, &firmware[offset], txlen); 1383 } 1384 1385 skb_put(skb, MWIFIEX_UPLD_SIZE - skb->len); 1386 skb_trim(skb, tx_blocks * MWIFIEX_PCIE_BLOCK_SIZE_FW_DNLD); 1387 1388 /* Send the boot command to device */ 1389 if (mwifiex_pcie_send_boot_cmd(adapter, skb)) { 1390 dev_err(adapter->dev, "Failed to send firmware download command\n"); 1391 ret = -1; 1392 goto done; 1393 } 1394 /* Wait for the command done interrupt */ 1395 do { 1396 if (mwifiex_read_reg(adapter, PCIE_CPU_INT_STATUS, 1397 &ireg_intr)) { 1398 dev_err(adapter->dev, "%s: Failed to read " 1399 "interrupt status during " 1400 "fw dnld.\n", __func__); 1401 ret = -1; 1402 goto done; 1403 } 1404 } while ((ireg_intr & CPU_INTR_DOOR_BELL) == 1405 CPU_INTR_DOOR_BELL); 1406 offset += txlen; 1407 } while (true); 1408 1409 dev_dbg(adapter->dev, "info:\nFW download over, size %d bytes\n", 1410 offset); 1411 1412 ret = 0; 1413 1414done: 1415 dev_kfree_skb_any(skb); 1416 return ret; 1417} 1418 1419/* 1420 * This function checks the firmware status in card. 1421 * 1422 * The winner interface is also determined by this function. 1423 */ 1424static int 1425mwifiex_check_fw_status(struct mwifiex_adapter *adapter, u32 poll_num) 1426{ 1427 int ret = 0; 1428 u32 firmware_stat, winner_status; 1429 u32 tries; 1430 1431 /* Mask spurios interrupts */ 1432 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS_MASK, 1433 HOST_INTR_MASK)) { 1434 dev_warn(adapter->dev, "Write register failed\n"); 1435 return -1; 1436 } 1437 1438 dev_dbg(adapter->dev, "Setting driver ready signature\n"); 1439 if (mwifiex_write_reg(adapter, REG_DRV_READY, FIRMWARE_READY_PCIE)) { 1440 dev_err(adapter->dev, "Failed to write driver ready signature\n"); 1441 return -1; 1442 } 1443 1444 /* Wait for firmware initialization event */ 1445 for (tries = 0; tries < poll_num; tries++) { 1446 if (mwifiex_read_reg(adapter, PCIE_SCRATCH_3_REG, 1447 &firmware_stat)) 1448 ret = -1; 1449 else 1450 ret = 0; 1451 if (ret) 1452 continue; 1453 if (firmware_stat == FIRMWARE_READY_PCIE) { 1454 ret = 0; 1455 break; 1456 } else { 1457 mdelay(100); 1458 ret = -1; 1459 } 1460 } 1461 1462 if (ret) { 1463 if (mwifiex_read_reg(adapter, PCIE_SCRATCH_3_REG, 1464 &winner_status)) 1465 ret = -1; 1466 else if (!winner_status) { 1467 dev_err(adapter->dev, "PCI-E is the winner\n"); 1468 adapter->winner = 1; 1469 ret = -1; 1470 } else { 1471 dev_err(adapter->dev, "PCI-E is not the winner <%#x, %d>, exit download\n", 1472 ret, adapter->winner); 1473 ret = 0; 1474 } 1475 } 1476 1477 return ret; 1478} 1479 1480/* 1481 * This function reads the interrupt status from card. 1482 */ 1483static void mwifiex_interrupt_status(struct mwifiex_adapter *adapter) 1484{ 1485 u32 pcie_ireg; 1486 unsigned long flags; 1487 1488 if (!mwifiex_pcie_ok_to_access_hw(adapter)) 1489 return; 1490 1491 if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS, &pcie_ireg)) { 1492 dev_warn(adapter->dev, "Read register failed\n"); 1493 return; 1494 } 1495 1496 if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) { 1497 1498 mwifiex_pcie_disable_host_int(adapter); 1499 1500 /* Clear the pending interrupts */ 1501 if (mwifiex_write_reg(adapter, PCIE_HOST_INT_STATUS, 1502 ~pcie_ireg)) { 1503 dev_warn(adapter->dev, "Write register failed\n"); 1504 return; 1505 } 1506 spin_lock_irqsave(&adapter->int_lock, flags); 1507 adapter->int_status |= pcie_ireg; 1508 spin_unlock_irqrestore(&adapter->int_lock, flags); 1509 1510 if (pcie_ireg & HOST_INTR_CMD_DONE) { 1511 if ((adapter->ps_state == PS_STATE_SLEEP_CFM) || 1512 (adapter->ps_state == PS_STATE_SLEEP)) { 1513 mwifiex_pcie_enable_host_int(adapter); 1514 if (mwifiex_write_reg(adapter, 1515 PCIE_CPU_INT_EVENT, 1516 CPU_INTR_SLEEP_CFM_DONE)) { 1517 dev_warn(adapter->dev, "Write register" 1518 " failed\n"); 1519 return; 1520 1521 } 1522 } 1523 } else if (!adapter->pps_uapsd_mode && 1524 adapter->ps_state == PS_STATE_SLEEP) { 1525 /* Potentially for PCIe we could get other 1526 * interrupts like shared. Don't change power 1527 * state until cookie is set */ 1528 if (mwifiex_pcie_ok_to_access_hw(adapter)) 1529 adapter->ps_state = PS_STATE_AWAKE; 1530 } 1531 } 1532} 1533 1534/* 1535 * Interrupt handler for PCIe root port 1536 * 1537 * This function reads the interrupt status from firmware and assigns 1538 * the main process in workqueue which will handle the interrupt. 1539 */ 1540static irqreturn_t mwifiex_pcie_interrupt(int irq, void *context) 1541{ 1542 struct pci_dev *pdev = (struct pci_dev *)context; 1543 struct pcie_service_card *card; 1544 struct mwifiex_adapter *adapter; 1545 1546 if (!pdev) { 1547 pr_debug("info: %s: pdev is NULL\n", (u8 *)pdev); 1548 goto exit; 1549 } 1550 1551 card = (struct pcie_service_card *) pci_get_drvdata(pdev); 1552 if (!card || !card->adapter) { 1553 pr_debug("info: %s: card=%p adapter=%p\n", __func__, card, 1554 card ? card->adapter : NULL); 1555 goto exit; 1556 } 1557 adapter = card->adapter; 1558 1559 if (adapter->surprise_removed) 1560 goto exit; 1561 1562 mwifiex_interrupt_status(adapter); 1563 queue_work(adapter->workqueue, &adapter->main_work); 1564 1565exit: 1566 return IRQ_HANDLED; 1567} 1568 1569/* 1570 * This function checks the current interrupt status. 1571 * 1572 * The following interrupts are checked and handled by this function - 1573 * - Data sent 1574 * - Command sent 1575 * - Command received 1576 * - Packets received 1577 * - Events received 1578 * 1579 * In case of Rx packets received, the packets are uploaded from card to 1580 * host and processed accordingly. 1581 */ 1582static int mwifiex_process_int_status(struct mwifiex_adapter *adapter) 1583{ 1584 int ret; 1585 u32 pcie_ireg = 0; 1586 unsigned long flags; 1587 1588 spin_lock_irqsave(&adapter->int_lock, flags); 1589 /* Clear out unused interrupts */ 1590 adapter->int_status &= HOST_INTR_MASK; 1591 spin_unlock_irqrestore(&adapter->int_lock, flags); 1592 1593 while (adapter->int_status & HOST_INTR_MASK) { 1594 if (adapter->int_status & HOST_INTR_DNLD_DONE) { 1595 adapter->int_status &= ~HOST_INTR_DNLD_DONE; 1596 if (adapter->data_sent) { 1597 dev_dbg(adapter->dev, "info: DATA sent Interrupt\n"); 1598 adapter->data_sent = false; 1599 } 1600 } 1601 if (adapter->int_status & HOST_INTR_UPLD_RDY) { 1602 adapter->int_status &= ~HOST_INTR_UPLD_RDY; 1603 dev_dbg(adapter->dev, "info: Rx DATA\n"); 1604 ret = mwifiex_pcie_process_recv_data(adapter); 1605 if (ret) 1606 return ret; 1607 } 1608 if (adapter->int_status & HOST_INTR_EVENT_RDY) { 1609 adapter->int_status &= ~HOST_INTR_EVENT_RDY; 1610 dev_dbg(adapter->dev, "info: Rx EVENT\n"); 1611 ret = mwifiex_pcie_process_event_ready(adapter); 1612 if (ret) 1613 return ret; 1614 } 1615 1616 if (adapter->int_status & HOST_INTR_CMD_DONE) { 1617 adapter->int_status &= ~HOST_INTR_CMD_DONE; 1618 if (adapter->cmd_sent) { 1619 dev_dbg(adapter->dev, "info: CMD sent Interrupt\n"); 1620 adapter->cmd_sent = false; 1621 } 1622 /* Handle command response */ 1623 ret = mwifiex_pcie_process_cmd_complete(adapter); 1624 if (ret) 1625 return ret; 1626 } 1627 1628 if (mwifiex_pcie_ok_to_access_hw(adapter)) { 1629 if (mwifiex_read_reg(adapter, PCIE_HOST_INT_STATUS, 1630 &pcie_ireg)) { 1631 dev_warn(adapter->dev, "Read register failed\n"); 1632 return -1; 1633 } 1634 1635 if ((pcie_ireg != 0xFFFFFFFF) && (pcie_ireg)) { 1636 if (mwifiex_write_reg(adapter, 1637 PCIE_HOST_INT_STATUS, ~pcie_ireg)) { 1638 dev_warn(adapter->dev, "Write register" 1639 " failed\n"); 1640 return -1; 1641 } 1642 adapter->int_status |= pcie_ireg; 1643 adapter->int_status &= HOST_INTR_MASK; 1644 } 1645 1646 } 1647 } 1648 dev_dbg(adapter->dev, "info: cmd_sent=%d data_sent=%d\n", 1649 adapter->cmd_sent, adapter->data_sent); 1650 mwifiex_pcie_enable_host_int(adapter); 1651 1652 return 0; 1653} 1654 1655/* 1656 * This function downloads data from driver to card. 1657 * 1658 * Both commands and data packets are transferred to the card by this 1659 * function. 1660 * 1661 * This function adds the PCIE specific header to the front of the buffer 1662 * before transferring. The header contains the length of the packet and 1663 * the type. The firmware handles the packets based upon this set type. 1664 */ 1665static int mwifiex_pcie_host_to_card(struct mwifiex_adapter *adapter, u8 type, 1666 struct sk_buff *skb, 1667 struct mwifiex_tx_param *tx_param) 1668{ 1669 if (!skb) { 1670 dev_err(adapter->dev, "Passed NULL skb to %s\n", __func__); 1671 return -1; 1672 } 1673 1674 if (type == MWIFIEX_TYPE_DATA) 1675 return mwifiex_pcie_send_data(adapter, skb); 1676 else if (type == MWIFIEX_TYPE_CMD) 1677 return mwifiex_pcie_send_cmd(adapter, skb); 1678 1679 return 0; 1680} 1681 1682/* 1683 * This function initializes the PCI-E host memory space, WCB rings, etc. 1684 * 1685 * The following initializations steps are followed - 1686 * - Allocate TXBD ring buffers 1687 * - Allocate RXBD ring buffers 1688 * - Allocate event BD ring buffers 1689 * - Allocate command response ring buffer 1690 * - Allocate sleep cookie buffer 1691 */ 1692static int mwifiex_pcie_init(struct mwifiex_adapter *adapter) 1693{ 1694 struct pcie_service_card *card = adapter->card; 1695 int ret; 1696 struct pci_dev *pdev = card->dev; 1697 1698 pci_set_drvdata(pdev, card); 1699 1700 ret = pci_enable_device(pdev); 1701 if (ret) 1702 goto err_enable_dev; 1703 1704 pci_set_master(pdev); 1705 1706 dev_dbg(adapter->dev, "try set_consistent_dma_mask(32)\n"); 1707 ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32)); 1708 if (ret) { 1709 dev_err(adapter->dev, "set_dma_mask(32) failed\n"); 1710 goto err_set_dma_mask; 1711 } 1712 1713 ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)); 1714 if (ret) { 1715 dev_err(adapter->dev, "set_consistent_dma_mask(64) failed\n"); 1716 goto err_set_dma_mask; 1717 } 1718 1719 ret = pci_request_region(pdev, 0, DRV_NAME); 1720 if (ret) { 1721 dev_err(adapter->dev, "req_reg(0) error\n"); 1722 goto err_req_region0; 1723 } 1724 card->pci_mmap = pci_iomap(pdev, 0, 0); 1725 if (!card->pci_mmap) { 1726 dev_err(adapter->dev, "iomap(0) error\n"); 1727 goto err_iomap0; 1728 } 1729 ret = pci_request_region(pdev, 2, DRV_NAME); 1730 if (ret) { 1731 dev_err(adapter->dev, "req_reg(2) error\n"); 1732 goto err_req_region2; 1733 } 1734 card->pci_mmap1 = pci_iomap(pdev, 2, 0); 1735 if (!card->pci_mmap1) { 1736 dev_err(adapter->dev, "iomap(2) error\n"); 1737 goto err_iomap2; 1738 } 1739 1740 dev_dbg(adapter->dev, "PCI memory map Virt0: %p PCI memory map Virt2: " 1741 "%p\n", card->pci_mmap, card->pci_mmap1); 1742 1743 card->cmdrsp_buf = NULL; 1744 ret = mwifiex_pcie_create_txbd_ring(adapter); 1745 if (ret) 1746 goto err_cre_txbd; 1747 ret = mwifiex_pcie_create_rxbd_ring(adapter); 1748 if (ret) 1749 goto err_cre_rxbd; 1750 ret = mwifiex_pcie_create_evtbd_ring(adapter); 1751 if (ret) 1752 goto err_cre_evtbd; 1753 ret = mwifiex_pcie_alloc_cmdrsp_buf(adapter); 1754 if (ret) 1755 goto err_alloc_cmdbuf; 1756 ret = mwifiex_pcie_alloc_sleep_cookie_buf(adapter); 1757 if (ret) 1758 goto err_alloc_cookie; 1759 1760 return ret; 1761 1762err_alloc_cookie: 1763 mwifiex_pcie_delete_cmdrsp_buf(adapter); 1764err_alloc_cmdbuf: 1765 mwifiex_pcie_delete_evtbd_ring(adapter); 1766err_cre_evtbd: 1767 mwifiex_pcie_delete_rxbd_ring(adapter); 1768err_cre_rxbd: 1769 mwifiex_pcie_delete_txbd_ring(adapter); 1770err_cre_txbd: 1771 pci_iounmap(pdev, card->pci_mmap1); 1772err_iomap2: 1773 pci_release_region(pdev, 2); 1774err_req_region2: 1775 pci_iounmap(pdev, card->pci_mmap); 1776err_iomap0: 1777 pci_release_region(pdev, 0); 1778err_req_region0: 1779err_set_dma_mask: 1780 pci_disable_device(pdev); 1781err_enable_dev: 1782 pci_set_drvdata(pdev, NULL); 1783 return ret; 1784} 1785 1786/* 1787 * This function cleans up the allocated card buffers. 1788 * 1789 * The following are freed by this function - 1790 * - TXBD ring buffers 1791 * - RXBD ring buffers 1792 * - Event BD ring buffers 1793 * - Command response ring buffer 1794 * - Sleep cookie buffer 1795 */ 1796static void mwifiex_pcie_cleanup(struct mwifiex_adapter *adapter) 1797{ 1798 struct pcie_service_card *card = adapter->card; 1799 struct pci_dev *pdev = card->dev; 1800 1801 mwifiex_pcie_delete_sleep_cookie_buf(adapter); 1802 mwifiex_pcie_delete_cmdrsp_buf(adapter); 1803 mwifiex_pcie_delete_evtbd_ring(adapter); 1804 mwifiex_pcie_delete_rxbd_ring(adapter); 1805 mwifiex_pcie_delete_txbd_ring(adapter); 1806 card->cmdrsp_buf = NULL; 1807 1808 dev_dbg(adapter->dev, "Clearing driver ready signature\n"); 1809 if (user_rmmod) { 1810 if (mwifiex_write_reg(adapter, REG_DRV_READY, 0x00000000)) 1811 dev_err(adapter->dev, "Failed to write driver not-ready signature\n"); 1812 } 1813 1814 if (pdev) { 1815 pci_iounmap(pdev, card->pci_mmap); 1816 pci_iounmap(pdev, card->pci_mmap1); 1817 1818 pci_release_regions(pdev); 1819 pci_disable_device(pdev); 1820 pci_set_drvdata(pdev, NULL); 1821 } 1822} 1823 1824/* 1825 * This function registers the PCIE device. 1826 * 1827 * PCIE IRQ is claimed, block size is set and driver data is initialized. 1828 */ 1829static int mwifiex_register_dev(struct mwifiex_adapter *adapter) 1830{ 1831 int ret; 1832 struct pcie_service_card *card = adapter->card; 1833 struct pci_dev *pdev = card->dev; 1834 1835 /* save adapter pointer in card */ 1836 card->adapter = adapter; 1837 1838 ret = request_irq(pdev->irq, mwifiex_pcie_interrupt, IRQF_SHARED, 1839 "MRVL_PCIE", pdev); 1840 if (ret) { 1841 pr_err("request_irq failed: ret=%d\n", ret); 1842 adapter->card = NULL; 1843 return -1; 1844 } 1845 1846 adapter->dev = &pdev->dev; 1847 strcpy(adapter->fw_name, PCIE8766_DEFAULT_FW_NAME); 1848 1849 return 0; 1850} 1851 1852/* 1853 * This function unregisters the PCIE device. 1854 * 1855 * The PCIE IRQ is released, the function is disabled and driver 1856 * data is set to null. 1857 */ 1858static void mwifiex_unregister_dev(struct mwifiex_adapter *adapter) 1859{ 1860 struct pcie_service_card *card = adapter->card; 1861 1862 if (card) { 1863 dev_dbg(adapter->dev, "%s(): calling free_irq()\n", __func__); 1864 free_irq(card->dev->irq, card->dev); 1865 } 1866} 1867 1868static struct mwifiex_if_ops pcie_ops = { 1869 .init_if = mwifiex_pcie_init, 1870 .cleanup_if = mwifiex_pcie_cleanup, 1871 .check_fw_status = mwifiex_check_fw_status, 1872 .prog_fw = mwifiex_prog_fw_w_helper, 1873 .register_dev = mwifiex_register_dev, 1874 .unregister_dev = mwifiex_unregister_dev, 1875 .enable_int = mwifiex_pcie_enable_host_int, 1876 .process_int_status = mwifiex_process_int_status, 1877 .host_to_card = mwifiex_pcie_host_to_card, 1878 .wakeup = mwifiex_pm_wakeup_card, 1879 .wakeup_complete = mwifiex_pm_wakeup_card_complete, 1880 1881 /* PCIE specific */ 1882 .cmdrsp_complete = mwifiex_pcie_cmdrsp_complete, 1883 .event_complete = mwifiex_pcie_event_complete, 1884 .update_mp_end_port = NULL, 1885 .cleanup_mpa_buf = NULL, 1886}; 1887 1888/* 1889 * This function initializes the PCIE driver module. 1890 * 1891 * This initiates the semaphore and registers the device with 1892 * PCIE bus. 1893 */ 1894static int mwifiex_pcie_init_module(void) 1895{ 1896 int ret; 1897 1898 pr_debug("Marvell 8766 PCIe Driver\n"); 1899 1900 sema_init(&add_remove_card_sem, 1); 1901 1902 /* Clear the flag in case user removes the card. */ 1903 user_rmmod = 0; 1904 1905 ret = pci_register_driver(&mwifiex_pcie); 1906 if (ret) 1907 pr_err("Driver register failed!\n"); 1908 else 1909 pr_debug("info: Driver registered successfully!\n"); 1910 1911 return ret; 1912} 1913 1914/* 1915 * This function cleans up the PCIE driver. 1916 * 1917 * The following major steps are followed for cleanup - 1918 * - Resume the device if its suspended 1919 * - Disconnect the device if connected 1920 * - Shutdown the firmware 1921 * - Unregister the device from PCIE bus. 1922 */ 1923static void mwifiex_pcie_cleanup_module(void) 1924{ 1925 if (!down_interruptible(&add_remove_card_sem)) 1926 up(&add_remove_card_sem); 1927 1928 /* Set the flag as user is removing this module. */ 1929 user_rmmod = 1; 1930 1931 pci_unregister_driver(&mwifiex_pcie); 1932} 1933 1934module_init(mwifiex_pcie_init_module); 1935module_exit(mwifiex_pcie_cleanup_module); 1936 1937MODULE_AUTHOR("Marvell International Ltd."); 1938MODULE_DESCRIPTION("Marvell WiFi-Ex PCI-Express Driver version " PCIE_VERSION); 1939MODULE_VERSION(PCIE_VERSION); 1940MODULE_LICENSE("GPL v2"); 1941MODULE_FIRMWARE("mrvl/pcie8766_uapsta.bin"); 1942