1 /* 2 * Marvell Wireless LAN device driver: SDIO specific handling 3 * 4 * Copyright (C) 2011-2014, Marvell International Ltd. 5 * 6 * This software file (the "File") is distributed by Marvell International 7 * Ltd. under the terms of the GNU General Public License Version 2, June 1991 8 * (the "License"). You may use, redistribute and/or modify this File in 9 * accordance with the terms and conditions of the License, a copy of which 10 * is available by writing to the Free Software Foundation, Inc., 11 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the 12 * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. 13 * 14 * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE 15 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE 16 * ARE EXPRESSLY DISCLAIMED. The License provides additional details about 17 * this warranty disclaimer. 18 */ 19 20 #include <linux/firmware.h> 21 22 #include "decl.h" 23 #include "ioctl.h" 24 #include "util.h" 25 #include "fw.h" 26 #include "main.h" 27 #include "wmm.h" 28 #include "11n.h" 29 #include "sdio.h" 30 31 32 #define SDIO_VERSION "1.0" 33 34 /* The mwifiex_sdio_remove() callback function is called when 35 * user removes this module from kernel space or ejects 36 * the card from the slot. The driver handles these 2 cases 37 * differently. 38 * If the user is removing the module, the few commands (FUNC_SHUTDOWN, 39 * HS_CANCEL etc.) are sent to the firmware. 40 * If the card is removed, there is no need to send these command. 41 * 42 * The variable 'user_rmmod' is used to distinguish these two 43 * scenarios. This flag is initialized as FALSE in case the card 44 * is removed, and will be set to TRUE for module removal when 45 * module_exit function is called. 46 */ 47 static u8 user_rmmod; 48 49 static struct mwifiex_if_ops sdio_ops; 50 static unsigned long iface_work_flags; 51 52 static struct memory_type_mapping generic_mem_type_map[] = { 53 {"DUMP", NULL, 0, 0xDD}, 54 }; 55 56 static struct memory_type_mapping mem_type_mapping_tbl[] = { 57 {"ITCM", NULL, 0, 0xF0}, 58 {"DTCM", NULL, 0, 0xF1}, 59 {"SQRAM", NULL, 0, 0xF2}, 60 {"APU", NULL, 0, 0xF3}, 61 {"CIU", NULL, 0, 0xF4}, 62 {"ICU", NULL, 0, 0xF5}, 63 {"MAC", NULL, 0, 0xF6}, 64 {"EXT7", NULL, 0, 0xF7}, 65 {"EXT8", NULL, 0, 0xF8}, 66 {"EXT9", NULL, 0, 0xF9}, 67 {"EXT10", NULL, 0, 0xFA}, 68 {"EXT11", NULL, 0, 0xFB}, 69 {"EXT12", NULL, 0, 0xFC}, 70 {"EXT13", NULL, 0, 0xFD}, 71 {"EXTLAST", NULL, 0, 0xFE}, 72 }; 73 74 static const struct of_device_id mwifiex_sdio_of_match_table[] = { 75 { .compatible = "marvell,sd8897" }, 76 { .compatible = "marvell,sd8997" }, 77 { } 78 }; 79 80 /* This function parse device tree node using mmc subnode devicetree API. 81 * The device node is saved in card->plt_of_node. 82 * if the device tree node exist and include interrupts attributes, this 83 * function will also request platform specific wakeup interrupt. 84 */ 85 static int mwifiex_sdio_probe_of(struct device *dev) 86 { 87 if (!of_match_node(mwifiex_sdio_of_match_table, dev->of_node)) { 88 dev_err(dev, "required compatible string missing\n"); 89 return -EINVAL; 90 } 91 92 return 0; 93 } 94 95 /* 96 * SDIO probe. 97 * 98 * This function probes an mwifiex device and registers it. It allocates 99 * the card structure, enables SDIO function number and initiates the 100 * device registration and initialization procedure by adding a logical 101 * interface. 102 */ 103 static int 104 mwifiex_sdio_probe(struct sdio_func *func, const struct sdio_device_id *id) 105 { 106 int ret; 107 struct sdio_mmc_card *card = NULL; 108 109 pr_debug("info: vendor=0x%4.04X device=0x%4.04X class=%d function=%d\n", 110 func->vendor, func->device, func->class, func->num); 111 112 card = devm_kzalloc(&func->dev, sizeof(*card), GFP_KERNEL); 113 if (!card) 114 return -ENOMEM; 115 116 init_completion(&card->fw_done); 117 118 card->func = func; 119 card->device_id = id; 120 121 func->card->quirks |= MMC_QUIRK_BLKSZ_FOR_BYTE_MODE; 122 123 if (id->driver_data) { 124 struct mwifiex_sdio_device *data = (void *)id->driver_data; 125 126 card->firmware = data->firmware; 127 card->reg = data->reg; 128 card->max_ports = data->max_ports; 129 card->mp_agg_pkt_limit = data->mp_agg_pkt_limit; 130 card->supports_sdio_new_mode = data->supports_sdio_new_mode; 131 card->has_control_mask = data->has_control_mask; 132 card->tx_buf_size = data->tx_buf_size; 133 card->mp_tx_agg_buf_size = data->mp_tx_agg_buf_size; 134 card->mp_rx_agg_buf_size = data->mp_rx_agg_buf_size; 135 card->can_dump_fw = data->can_dump_fw; 136 card->fw_dump_enh = data->fw_dump_enh; 137 card->can_auto_tdls = data->can_auto_tdls; 138 card->can_ext_scan = data->can_ext_scan; 139 } 140 141 sdio_claim_host(func); 142 ret = sdio_enable_func(func); 143 sdio_release_host(func); 144 145 if (ret) { 146 dev_err(&func->dev, "failed to enable function\n"); 147 return ret; 148 } 149 150 /* device tree node parsing and platform specific configuration*/ 151 if (func->dev.of_node) { 152 ret = mwifiex_sdio_probe_of(&func->dev); 153 if (ret) 154 goto err_disable; 155 } 156 157 ret = mwifiex_add_card(card, &card->fw_done, &sdio_ops, 158 MWIFIEX_SDIO, &func->dev); 159 if (ret) { 160 dev_err(&func->dev, "add card failed\n"); 161 goto err_disable; 162 } 163 164 return 0; 165 166 err_disable: 167 sdio_claim_host(func); 168 sdio_disable_func(func); 169 sdio_release_host(func); 170 171 return ret; 172 } 173 174 /* 175 * SDIO resume. 176 * 177 * Kernel needs to suspend all functions separately. Therefore all 178 * registered functions must have drivers with suspend and resume 179 * methods. Failing that the kernel simply removes the whole card. 180 * 181 * If already not resumed, this function turns on the traffic and 182 * sends a host sleep cancel request to the firmware. 183 */ 184 static int mwifiex_sdio_resume(struct device *dev) 185 { 186 struct sdio_func *func = dev_to_sdio_func(dev); 187 struct sdio_mmc_card *card; 188 struct mwifiex_adapter *adapter; 189 190 card = sdio_get_drvdata(func); 191 if (!card || !card->adapter) { 192 dev_err(dev, "resume: invalid card or adapter\n"); 193 return 0; 194 } 195 196 adapter = card->adapter; 197 198 if (!adapter->is_suspended) { 199 mwifiex_dbg(adapter, WARN, 200 "device already resumed\n"); 201 return 0; 202 } 203 204 adapter->is_suspended = false; 205 206 /* Disable Host Sleep */ 207 mwifiex_cancel_hs(mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA), 208 MWIFIEX_SYNC_CMD); 209 210 mwifiex_disable_wake(adapter); 211 212 return 0; 213 } 214 215 /* 216 * SDIO remove. 217 * 218 * This function removes the interface and frees up the card structure. 219 */ 220 static void 221 mwifiex_sdio_remove(struct sdio_func *func) 222 { 223 struct sdio_mmc_card *card; 224 struct mwifiex_adapter *adapter; 225 struct mwifiex_private *priv; 226 227 card = sdio_get_drvdata(func); 228 if (!card) 229 return; 230 231 wait_for_completion(&card->fw_done); 232 233 adapter = card->adapter; 234 if (!adapter || !adapter->priv_num) 235 return; 236 237 mwifiex_dbg(adapter, INFO, "info: SDIO func num=%d\n", func->num); 238 239 if (user_rmmod && !adapter->mfg_mode) { 240 mwifiex_deauthenticate_all(adapter); 241 242 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY); 243 mwifiex_disable_auto_ds(priv); 244 mwifiex_init_shutdown_fw(priv, MWIFIEX_FUNC_SHUTDOWN); 245 } 246 247 mwifiex_remove_card(adapter); 248 } 249 250 /* 251 * SDIO suspend. 252 * 253 * Kernel needs to suspend all functions separately. Therefore all 254 * registered functions must have drivers with suspend and resume 255 * methods. Failing that the kernel simply removes the whole card. 256 * 257 * If already not suspended, this function allocates and sends a host 258 * sleep activate request to the firmware and turns off the traffic. 259 */ 260 static int mwifiex_sdio_suspend(struct device *dev) 261 { 262 struct sdio_func *func = dev_to_sdio_func(dev); 263 struct sdio_mmc_card *card; 264 struct mwifiex_adapter *adapter; 265 mmc_pm_flag_t pm_flag = 0; 266 int ret = 0; 267 268 pm_flag = sdio_get_host_pm_caps(func); 269 pr_debug("cmd: %s: suspend: PM flag = 0x%x\n", 270 sdio_func_id(func), pm_flag); 271 if (!(pm_flag & MMC_PM_KEEP_POWER)) { 272 dev_err(dev, "%s: cannot remain alive while host is" 273 " suspended\n", sdio_func_id(func)); 274 return -ENOSYS; 275 } 276 277 card = sdio_get_drvdata(func); 278 if (!card) { 279 dev_err(dev, "suspend: invalid card\n"); 280 return 0; 281 } 282 283 /* Might still be loading firmware */ 284 wait_for_completion(&card->fw_done); 285 286 adapter = card->adapter; 287 if (!adapter) { 288 dev_err(dev, "adapter is not valid\n"); 289 return 0; 290 } 291 292 mwifiex_enable_wake(adapter); 293 294 /* Enable the Host Sleep */ 295 if (!mwifiex_enable_hs(adapter)) { 296 mwifiex_dbg(adapter, ERROR, 297 "cmd: failed to suspend\n"); 298 adapter->hs_enabling = false; 299 mwifiex_disable_wake(adapter); 300 return -EFAULT; 301 } 302 303 mwifiex_dbg(adapter, INFO, 304 "cmd: suspend with MMC_PM_KEEP_POWER\n"); 305 ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER); 306 307 /* Indicate device suspended */ 308 adapter->is_suspended = true; 309 adapter->hs_enabling = false; 310 311 return ret; 312 } 313 314 /* Device ID for SD8786 */ 315 #define SDIO_DEVICE_ID_MARVELL_8786 (0x9116) 316 /* Device ID for SD8787 */ 317 #define SDIO_DEVICE_ID_MARVELL_8787 (0x9119) 318 /* Device ID for SD8797 */ 319 #define SDIO_DEVICE_ID_MARVELL_8797 (0x9129) 320 /* Device ID for SD8897 */ 321 #define SDIO_DEVICE_ID_MARVELL_8897 (0x912d) 322 /* Device ID for SD8887 */ 323 #define SDIO_DEVICE_ID_MARVELL_8887 (0x9135) 324 /* Device ID for SD8801 */ 325 #define SDIO_DEVICE_ID_MARVELL_8801 (0x9139) 326 /* Device ID for SD8997 */ 327 #define SDIO_DEVICE_ID_MARVELL_8997 (0x9141) 328 329 330 /* WLAN IDs */ 331 static const struct sdio_device_id mwifiex_ids[] = { 332 {SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8786), 333 .driver_data = (unsigned long) &mwifiex_sdio_sd8786}, 334 {SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8787), 335 .driver_data = (unsigned long) &mwifiex_sdio_sd8787}, 336 {SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8797), 337 .driver_data = (unsigned long) &mwifiex_sdio_sd8797}, 338 {SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8897), 339 .driver_data = (unsigned long) &mwifiex_sdio_sd8897}, 340 {SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8887), 341 .driver_data = (unsigned long)&mwifiex_sdio_sd8887}, 342 {SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8801), 343 .driver_data = (unsigned long)&mwifiex_sdio_sd8801}, 344 {SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL, SDIO_DEVICE_ID_MARVELL_8997), 345 .driver_data = (unsigned long)&mwifiex_sdio_sd8997}, 346 {}, 347 }; 348 349 MODULE_DEVICE_TABLE(sdio, mwifiex_ids); 350 351 static const struct dev_pm_ops mwifiex_sdio_pm_ops = { 352 .suspend = mwifiex_sdio_suspend, 353 .resume = mwifiex_sdio_resume, 354 }; 355 356 static struct sdio_driver mwifiex_sdio = { 357 .name = "mwifiex_sdio", 358 .id_table = mwifiex_ids, 359 .probe = mwifiex_sdio_probe, 360 .remove = mwifiex_sdio_remove, 361 .drv = { 362 .owner = THIS_MODULE, 363 .pm = &mwifiex_sdio_pm_ops, 364 } 365 }; 366 367 /* Write data into SDIO card register. Caller claims SDIO device. */ 368 static int 369 mwifiex_write_reg_locked(struct sdio_func *func, u32 reg, u8 data) 370 { 371 int ret = -1; 372 sdio_writeb(func, data, reg, &ret); 373 return ret; 374 } 375 376 /* 377 * This function writes data into SDIO card register. 378 */ 379 static int 380 mwifiex_write_reg(struct mwifiex_adapter *adapter, u32 reg, u8 data) 381 { 382 struct sdio_mmc_card *card = adapter->card; 383 int ret; 384 385 sdio_claim_host(card->func); 386 ret = mwifiex_write_reg_locked(card->func, reg, data); 387 sdio_release_host(card->func); 388 389 return ret; 390 } 391 392 /* 393 * This function reads data from SDIO card register. 394 */ 395 static int 396 mwifiex_read_reg(struct mwifiex_adapter *adapter, u32 reg, u8 *data) 397 { 398 struct sdio_mmc_card *card = adapter->card; 399 int ret = -1; 400 u8 val; 401 402 sdio_claim_host(card->func); 403 val = sdio_readb(card->func, reg, &ret); 404 sdio_release_host(card->func); 405 406 *data = val; 407 408 return ret; 409 } 410 411 /* 412 * This function writes multiple data into SDIO card memory. 413 * 414 * This does not work in suspended mode. 415 */ 416 static int 417 mwifiex_write_data_sync(struct mwifiex_adapter *adapter, 418 u8 *buffer, u32 pkt_len, u32 port) 419 { 420 struct sdio_mmc_card *card = adapter->card; 421 int ret; 422 u8 blk_mode = 423 (port & MWIFIEX_SDIO_BYTE_MODE_MASK) ? BYTE_MODE : BLOCK_MODE; 424 u32 blk_size = (blk_mode == BLOCK_MODE) ? MWIFIEX_SDIO_BLOCK_SIZE : 1; 425 u32 blk_cnt = 426 (blk_mode == 427 BLOCK_MODE) ? (pkt_len / 428 MWIFIEX_SDIO_BLOCK_SIZE) : pkt_len; 429 u32 ioport = (port & MWIFIEX_SDIO_IO_PORT_MASK); 430 431 if (adapter->is_suspended) { 432 mwifiex_dbg(adapter, ERROR, 433 "%s: not allowed while suspended\n", __func__); 434 return -1; 435 } 436 437 sdio_claim_host(card->func); 438 439 ret = sdio_writesb(card->func, ioport, buffer, blk_cnt * blk_size); 440 441 sdio_release_host(card->func); 442 443 return ret; 444 } 445 446 /* 447 * This function reads multiple data from SDIO card memory. 448 */ 449 static int mwifiex_read_data_sync(struct mwifiex_adapter *adapter, u8 *buffer, 450 u32 len, u32 port, u8 claim) 451 { 452 struct sdio_mmc_card *card = adapter->card; 453 int ret; 454 u8 blk_mode = (port & MWIFIEX_SDIO_BYTE_MODE_MASK) ? BYTE_MODE 455 : BLOCK_MODE; 456 u32 blk_size = (blk_mode == BLOCK_MODE) ? MWIFIEX_SDIO_BLOCK_SIZE : 1; 457 u32 blk_cnt = (blk_mode == BLOCK_MODE) ? (len / MWIFIEX_SDIO_BLOCK_SIZE) 458 : len; 459 u32 ioport = (port & MWIFIEX_SDIO_IO_PORT_MASK); 460 461 if (claim) 462 sdio_claim_host(card->func); 463 464 ret = sdio_readsb(card->func, buffer, ioport, blk_cnt * blk_size); 465 466 if (claim) 467 sdio_release_host(card->func); 468 469 return ret; 470 } 471 472 /* 473 * This function wakes up the card. 474 * 475 * A host power up command is written to the card configuration 476 * register to wake up the card. 477 */ 478 static int mwifiex_pm_wakeup_card(struct mwifiex_adapter *adapter) 479 { 480 mwifiex_dbg(adapter, EVENT, 481 "event: wakeup device...\n"); 482 483 return mwifiex_write_reg(adapter, CONFIGURATION_REG, HOST_POWER_UP); 484 } 485 486 /* 487 * This function is called after the card has woken up. 488 * 489 * The card configuration register is reset. 490 */ 491 static int mwifiex_pm_wakeup_card_complete(struct mwifiex_adapter *adapter) 492 { 493 mwifiex_dbg(adapter, EVENT, 494 "cmd: wakeup device completed\n"); 495 496 return mwifiex_write_reg(adapter, CONFIGURATION_REG, 0); 497 } 498 499 static int mwifiex_sdio_dnld_fw(struct mwifiex_adapter *adapter, 500 struct mwifiex_fw_image *fw) 501 { 502 struct sdio_mmc_card *card = adapter->card; 503 int ret; 504 505 sdio_claim_host(card->func); 506 ret = mwifiex_dnld_fw(adapter, fw); 507 sdio_release_host(card->func); 508 509 return ret; 510 } 511 512 /* 513 * This function is used to initialize IO ports for the 514 * chipsets supporting SDIO new mode eg SD8897. 515 */ 516 static int mwifiex_init_sdio_new_mode(struct mwifiex_adapter *adapter) 517 { 518 u8 reg; 519 struct sdio_mmc_card *card = adapter->card; 520 521 adapter->ioport = MEM_PORT; 522 523 /* enable sdio new mode */ 524 if (mwifiex_read_reg(adapter, card->reg->card_cfg_2_1_reg, ®)) 525 return -1; 526 if (mwifiex_write_reg(adapter, card->reg->card_cfg_2_1_reg, 527 reg | CMD53_NEW_MODE)) 528 return -1; 529 530 /* Configure cmd port and enable reading rx length from the register */ 531 if (mwifiex_read_reg(adapter, card->reg->cmd_cfg_0, ®)) 532 return -1; 533 if (mwifiex_write_reg(adapter, card->reg->cmd_cfg_0, 534 reg | CMD_PORT_RD_LEN_EN)) 535 return -1; 536 537 /* Enable Dnld/Upld ready auto reset for cmd port after cmd53 is 538 * completed 539 */ 540 if (mwifiex_read_reg(adapter, card->reg->cmd_cfg_1, ®)) 541 return -1; 542 if (mwifiex_write_reg(adapter, card->reg->cmd_cfg_1, 543 reg | CMD_PORT_AUTO_EN)) 544 return -1; 545 546 return 0; 547 } 548 549 /* This function initializes the IO ports. 550 * 551 * The following operations are performed - 552 * - Read the IO ports (0, 1 and 2) 553 * - Set host interrupt Reset-To-Read to clear 554 * - Set auto re-enable interrupt 555 */ 556 static int mwifiex_init_sdio_ioport(struct mwifiex_adapter *adapter) 557 { 558 u8 reg; 559 struct sdio_mmc_card *card = adapter->card; 560 561 adapter->ioport = 0; 562 563 if (card->supports_sdio_new_mode) { 564 if (mwifiex_init_sdio_new_mode(adapter)) 565 return -1; 566 goto cont; 567 } 568 569 /* Read the IO port */ 570 if (!mwifiex_read_reg(adapter, card->reg->io_port_0_reg, ®)) 571 adapter->ioport |= (reg & 0xff); 572 else 573 return -1; 574 575 if (!mwifiex_read_reg(adapter, card->reg->io_port_1_reg, ®)) 576 adapter->ioport |= ((reg & 0xff) << 8); 577 else 578 return -1; 579 580 if (!mwifiex_read_reg(adapter, card->reg->io_port_2_reg, ®)) 581 adapter->ioport |= ((reg & 0xff) << 16); 582 else 583 return -1; 584 cont: 585 mwifiex_dbg(adapter, INFO, 586 "info: SDIO FUNC1 IO port: %#x\n", adapter->ioport); 587 588 /* Set Host interrupt reset to read to clear */ 589 if (!mwifiex_read_reg(adapter, card->reg->host_int_rsr_reg, ®)) 590 mwifiex_write_reg(adapter, card->reg->host_int_rsr_reg, 591 reg | card->reg->sdio_int_mask); 592 else 593 return -1; 594 595 /* Dnld/Upld ready set to auto reset */ 596 if (!mwifiex_read_reg(adapter, card->reg->card_misc_cfg_reg, ®)) 597 mwifiex_write_reg(adapter, card->reg->card_misc_cfg_reg, 598 reg | AUTO_RE_ENABLE_INT); 599 else 600 return -1; 601 602 return 0; 603 } 604 605 /* 606 * This function sends data to the card. 607 */ 608 static int mwifiex_write_data_to_card(struct mwifiex_adapter *adapter, 609 u8 *payload, u32 pkt_len, u32 port) 610 { 611 u32 i = 0; 612 int ret; 613 614 do { 615 ret = mwifiex_write_data_sync(adapter, payload, pkt_len, port); 616 if (ret) { 617 i++; 618 mwifiex_dbg(adapter, ERROR, 619 "host_to_card, write iomem\t" 620 "(%d) failed: %d\n", i, ret); 621 if (mwifiex_write_reg(adapter, CONFIGURATION_REG, 0x04)) 622 mwifiex_dbg(adapter, ERROR, 623 "write CFG reg failed\n"); 624 625 ret = -1; 626 if (i > MAX_WRITE_IOMEM_RETRY) 627 return ret; 628 } 629 } while (ret == -1); 630 631 return ret; 632 } 633 634 /* 635 * This function gets the read port. 636 * 637 * If control port bit is set in MP read bitmap, the control port 638 * is returned, otherwise the current read port is returned and 639 * the value is increased (provided it does not reach the maximum 640 * limit, in which case it is reset to 1) 641 */ 642 static int mwifiex_get_rd_port(struct mwifiex_adapter *adapter, u8 *port) 643 { 644 struct sdio_mmc_card *card = adapter->card; 645 const struct mwifiex_sdio_card_reg *reg = card->reg; 646 u32 rd_bitmap = card->mp_rd_bitmap; 647 648 mwifiex_dbg(adapter, DATA, 649 "data: mp_rd_bitmap=0x%08x\n", rd_bitmap); 650 651 if (card->supports_sdio_new_mode) { 652 if (!(rd_bitmap & reg->data_port_mask)) 653 return -1; 654 } else { 655 if (!(rd_bitmap & (CTRL_PORT_MASK | reg->data_port_mask))) 656 return -1; 657 } 658 659 if ((card->has_control_mask) && 660 (card->mp_rd_bitmap & CTRL_PORT_MASK)) { 661 card->mp_rd_bitmap &= (u32) (~CTRL_PORT_MASK); 662 *port = CTRL_PORT; 663 mwifiex_dbg(adapter, DATA, 664 "data: port=%d mp_rd_bitmap=0x%08x\n", 665 *port, card->mp_rd_bitmap); 666 return 0; 667 } 668 669 if (!(card->mp_rd_bitmap & (1 << card->curr_rd_port))) 670 return -1; 671 672 /* We are now handling the SDIO data ports */ 673 card->mp_rd_bitmap &= (u32)(~(1 << card->curr_rd_port)); 674 *port = card->curr_rd_port; 675 676 if (++card->curr_rd_port == card->max_ports) 677 card->curr_rd_port = reg->start_rd_port; 678 679 mwifiex_dbg(adapter, DATA, 680 "data: port=%d mp_rd_bitmap=0x%08x -> 0x%08x\n", 681 *port, rd_bitmap, card->mp_rd_bitmap); 682 683 return 0; 684 } 685 686 /* 687 * This function gets the write port for data. 688 * 689 * The current write port is returned if available and the value is 690 * increased (provided it does not reach the maximum limit, in which 691 * case it is reset to 1) 692 */ 693 static int mwifiex_get_wr_port_data(struct mwifiex_adapter *adapter, u32 *port) 694 { 695 struct sdio_mmc_card *card = adapter->card; 696 const struct mwifiex_sdio_card_reg *reg = card->reg; 697 u32 wr_bitmap = card->mp_wr_bitmap; 698 699 mwifiex_dbg(adapter, DATA, 700 "data: mp_wr_bitmap=0x%08x\n", wr_bitmap); 701 702 if (!(wr_bitmap & card->mp_data_port_mask)) { 703 adapter->data_sent = true; 704 return -EBUSY; 705 } 706 707 if (card->mp_wr_bitmap & (1 << card->curr_wr_port)) { 708 card->mp_wr_bitmap &= (u32) (~(1 << card->curr_wr_port)); 709 *port = card->curr_wr_port; 710 if (++card->curr_wr_port == card->mp_end_port) 711 card->curr_wr_port = reg->start_wr_port; 712 } else { 713 adapter->data_sent = true; 714 return -EBUSY; 715 } 716 717 if ((card->has_control_mask) && (*port == CTRL_PORT)) { 718 mwifiex_dbg(adapter, ERROR, 719 "invalid data port=%d cur port=%d mp_wr_bitmap=0x%08x -> 0x%08x\n", 720 *port, card->curr_wr_port, wr_bitmap, 721 card->mp_wr_bitmap); 722 return -1; 723 } 724 725 mwifiex_dbg(adapter, DATA, 726 "data: port=%d mp_wr_bitmap=0x%08x -> 0x%08x\n", 727 *port, wr_bitmap, card->mp_wr_bitmap); 728 729 return 0; 730 } 731 732 /* 733 * This function polls the card status. 734 */ 735 static int 736 mwifiex_sdio_poll_card_status(struct mwifiex_adapter *adapter, u8 bits) 737 { 738 struct sdio_mmc_card *card = adapter->card; 739 u32 tries; 740 u8 cs; 741 742 for (tries = 0; tries < MAX_POLL_TRIES; tries++) { 743 if (mwifiex_read_reg(adapter, card->reg->poll_reg, &cs)) 744 break; 745 else if ((cs & bits) == bits) 746 return 0; 747 748 usleep_range(10, 20); 749 } 750 751 mwifiex_dbg(adapter, ERROR, 752 "poll card status failed, tries = %d\n", tries); 753 754 return -1; 755 } 756 757 /* 758 * This function reads the firmware status. 759 */ 760 static int 761 mwifiex_sdio_read_fw_status(struct mwifiex_adapter *adapter, u16 *dat) 762 { 763 struct sdio_mmc_card *card = adapter->card; 764 const struct mwifiex_sdio_card_reg *reg = card->reg; 765 u8 fws0, fws1; 766 767 if (mwifiex_read_reg(adapter, reg->status_reg_0, &fws0)) 768 return -1; 769 770 if (mwifiex_read_reg(adapter, reg->status_reg_1, &fws1)) 771 return -1; 772 773 *dat = (u16) ((fws1 << 8) | fws0); 774 775 return 0; 776 } 777 778 /* 779 * This function disables the host interrupt. 780 * 781 * The host interrupt mask is read, the disable bit is reset and 782 * written back to the card host interrupt mask register. 783 */ 784 static void mwifiex_sdio_disable_host_int(struct mwifiex_adapter *adapter) 785 { 786 struct sdio_mmc_card *card = adapter->card; 787 struct sdio_func *func = card->func; 788 789 sdio_claim_host(func); 790 mwifiex_write_reg_locked(func, card->reg->host_int_mask_reg, 0); 791 sdio_release_irq(func); 792 sdio_release_host(func); 793 } 794 795 /* 796 * This function reads the interrupt status from card. 797 */ 798 static void mwifiex_interrupt_status(struct mwifiex_adapter *adapter) 799 { 800 struct sdio_mmc_card *card = adapter->card; 801 u8 sdio_ireg; 802 unsigned long flags; 803 804 if (mwifiex_read_data_sync(adapter, card->mp_regs, 805 card->reg->max_mp_regs, 806 REG_PORT | MWIFIEX_SDIO_BYTE_MODE_MASK, 0)) { 807 mwifiex_dbg(adapter, ERROR, "read mp_regs failed\n"); 808 return; 809 } 810 811 sdio_ireg = card->mp_regs[card->reg->host_int_status_reg]; 812 if (sdio_ireg) { 813 /* 814 * DN_LD_HOST_INT_STATUS and/or UP_LD_HOST_INT_STATUS 815 * For SDIO new mode CMD port interrupts 816 * DN_LD_CMD_PORT_HOST_INT_STATUS and/or 817 * UP_LD_CMD_PORT_HOST_INT_STATUS 818 * Clear the interrupt status register 819 */ 820 mwifiex_dbg(adapter, INTR, 821 "int: sdio_ireg = %#x\n", sdio_ireg); 822 spin_lock_irqsave(&adapter->int_lock, flags); 823 adapter->int_status |= sdio_ireg; 824 spin_unlock_irqrestore(&adapter->int_lock, flags); 825 } 826 } 827 828 /* 829 * SDIO interrupt handler. 830 * 831 * This function reads the interrupt status from firmware and handles 832 * the interrupt in current thread (ksdioirqd) right away. 833 */ 834 static void 835 mwifiex_sdio_interrupt(struct sdio_func *func) 836 { 837 struct mwifiex_adapter *adapter; 838 struct sdio_mmc_card *card; 839 840 card = sdio_get_drvdata(func); 841 if (!card || !card->adapter) { 842 pr_err("int: func=%p card=%p adapter=%p\n", 843 func, card, card ? card->adapter : NULL); 844 return; 845 } 846 adapter = card->adapter; 847 848 if (!adapter->pps_uapsd_mode && adapter->ps_state == PS_STATE_SLEEP) 849 adapter->ps_state = PS_STATE_AWAKE; 850 851 mwifiex_interrupt_status(adapter); 852 mwifiex_main_process(adapter); 853 } 854 855 /* 856 * This function enables the host interrupt. 857 * 858 * The host interrupt enable mask is written to the card 859 * host interrupt mask register. 860 */ 861 static int mwifiex_sdio_enable_host_int(struct mwifiex_adapter *adapter) 862 { 863 struct sdio_mmc_card *card = adapter->card; 864 struct sdio_func *func = card->func; 865 int ret; 866 867 sdio_claim_host(func); 868 869 /* Request the SDIO IRQ */ 870 ret = sdio_claim_irq(func, mwifiex_sdio_interrupt); 871 if (ret) { 872 mwifiex_dbg(adapter, ERROR, 873 "claim irq failed: ret=%d\n", ret); 874 goto out; 875 } 876 877 /* Simply write the mask to the register */ 878 ret = mwifiex_write_reg_locked(func, card->reg->host_int_mask_reg, 879 card->reg->host_int_enable); 880 if (ret) { 881 mwifiex_dbg(adapter, ERROR, 882 "enable host interrupt failed\n"); 883 sdio_release_irq(func); 884 } 885 886 out: 887 sdio_release_host(func); 888 return ret; 889 } 890 891 /* 892 * This function sends a data buffer to the card. 893 */ 894 static int mwifiex_sdio_card_to_host(struct mwifiex_adapter *adapter, 895 u32 *type, u8 *buffer, 896 u32 npayload, u32 ioport) 897 { 898 int ret; 899 u32 nb; 900 901 if (!buffer) { 902 mwifiex_dbg(adapter, ERROR, 903 "%s: buffer is NULL\n", __func__); 904 return -1; 905 } 906 907 ret = mwifiex_read_data_sync(adapter, buffer, npayload, ioport, 1); 908 909 if (ret) { 910 mwifiex_dbg(adapter, ERROR, 911 "%s: read iomem failed: %d\n", __func__, 912 ret); 913 return -1; 914 } 915 916 nb = le16_to_cpu(*(__le16 *) (buffer)); 917 if (nb > npayload) { 918 mwifiex_dbg(adapter, ERROR, 919 "%s: invalid packet, nb=%d npayload=%d\n", 920 __func__, nb, npayload); 921 return -1; 922 } 923 924 *type = le16_to_cpu(*(__le16 *) (buffer + 2)); 925 926 return ret; 927 } 928 929 /* 930 * This function downloads the firmware to the card. 931 * 932 * Firmware is downloaded to the card in blocks. Every block download 933 * is tested for CRC errors, and retried a number of times before 934 * returning failure. 935 */ 936 static int mwifiex_prog_fw_w_helper(struct mwifiex_adapter *adapter, 937 struct mwifiex_fw_image *fw) 938 { 939 struct sdio_mmc_card *card = adapter->card; 940 const struct mwifiex_sdio_card_reg *reg = card->reg; 941 int ret; 942 u8 *firmware = fw->fw_buf; 943 u32 firmware_len = fw->fw_len; 944 u32 offset = 0; 945 u8 base0, base1; 946 u8 *fwbuf; 947 u16 len = 0; 948 u32 txlen, tx_blocks = 0, tries; 949 u32 i = 0; 950 951 if (!firmware_len) { 952 mwifiex_dbg(adapter, ERROR, 953 "firmware image not found! Terminating download\n"); 954 return -1; 955 } 956 957 mwifiex_dbg(adapter, INFO, 958 "info: downloading FW image (%d bytes)\n", 959 firmware_len); 960 961 /* Assume that the allocated buffer is 8-byte aligned */ 962 fwbuf = kzalloc(MWIFIEX_UPLD_SIZE, GFP_KERNEL); 963 if (!fwbuf) 964 return -ENOMEM; 965 966 sdio_claim_host(card->func); 967 968 /* Perform firmware data transfer */ 969 do { 970 /* The host polls for the DN_LD_CARD_RDY and CARD_IO_READY 971 bits */ 972 ret = mwifiex_sdio_poll_card_status(adapter, CARD_IO_READY | 973 DN_LD_CARD_RDY); 974 if (ret) { 975 mwifiex_dbg(adapter, ERROR, 976 "FW download with helper:\t" 977 "poll status timeout @ %d\n", offset); 978 goto done; 979 } 980 981 /* More data? */ 982 if (offset >= firmware_len) 983 break; 984 985 for (tries = 0; tries < MAX_POLL_TRIES; tries++) { 986 ret = mwifiex_read_reg(adapter, reg->base_0_reg, 987 &base0); 988 if (ret) { 989 mwifiex_dbg(adapter, ERROR, 990 "dev BASE0 register read failed:\t" 991 "base0=%#04X(%d). Terminating dnld\n", 992 base0, base0); 993 goto done; 994 } 995 ret = mwifiex_read_reg(adapter, reg->base_1_reg, 996 &base1); 997 if (ret) { 998 mwifiex_dbg(adapter, ERROR, 999 "dev BASE1 register read failed:\t" 1000 "base1=%#04X(%d). Terminating dnld\n", 1001 base1, base1); 1002 goto done; 1003 } 1004 len = (u16) (((base1 & 0xff) << 8) | (base0 & 0xff)); 1005 1006 if (len) 1007 break; 1008 1009 usleep_range(10, 20); 1010 } 1011 1012 if (!len) { 1013 break; 1014 } else if (len > MWIFIEX_UPLD_SIZE) { 1015 mwifiex_dbg(adapter, ERROR, 1016 "FW dnld failed @ %d, invalid length %d\n", 1017 offset, len); 1018 ret = -1; 1019 goto done; 1020 } 1021 1022 txlen = len; 1023 1024 if (len & BIT(0)) { 1025 i++; 1026 if (i > MAX_WRITE_IOMEM_RETRY) { 1027 mwifiex_dbg(adapter, ERROR, 1028 "FW dnld failed @ %d, over max retry\n", 1029 offset); 1030 ret = -1; 1031 goto done; 1032 } 1033 mwifiex_dbg(adapter, ERROR, 1034 "CRC indicated by the helper:\t" 1035 "len = 0x%04X, txlen = %d\n", len, txlen); 1036 len &= ~BIT(0); 1037 /* Setting this to 0 to resend from same offset */ 1038 txlen = 0; 1039 } else { 1040 i = 0; 1041 1042 /* Set blocksize to transfer - checking for last 1043 block */ 1044 if (firmware_len - offset < txlen) 1045 txlen = firmware_len - offset; 1046 1047 tx_blocks = (txlen + MWIFIEX_SDIO_BLOCK_SIZE - 1) 1048 / MWIFIEX_SDIO_BLOCK_SIZE; 1049 1050 /* Copy payload to buffer */ 1051 memmove(fwbuf, &firmware[offset], txlen); 1052 } 1053 1054 ret = mwifiex_write_data_sync(adapter, fwbuf, tx_blocks * 1055 MWIFIEX_SDIO_BLOCK_SIZE, 1056 adapter->ioport); 1057 if (ret) { 1058 mwifiex_dbg(adapter, ERROR, 1059 "FW download, write iomem (%d) failed @ %d\n", 1060 i, offset); 1061 if (mwifiex_write_reg(adapter, CONFIGURATION_REG, 0x04)) 1062 mwifiex_dbg(adapter, ERROR, 1063 "write CFG reg failed\n"); 1064 1065 ret = -1; 1066 goto done; 1067 } 1068 1069 offset += txlen; 1070 } while (true); 1071 1072 mwifiex_dbg(adapter, MSG, 1073 "info: FW download over, size %d bytes\n", offset); 1074 1075 ret = 0; 1076 done: 1077 sdio_release_host(card->func); 1078 kfree(fwbuf); 1079 return ret; 1080 } 1081 1082 /* 1083 * This function checks the firmware status in card. 1084 */ 1085 static int mwifiex_check_fw_status(struct mwifiex_adapter *adapter, 1086 u32 poll_num) 1087 { 1088 int ret = 0; 1089 u16 firmware_stat; 1090 u32 tries; 1091 1092 for (tries = 0; tries < poll_num; tries++) { 1093 ret = mwifiex_sdio_read_fw_status(adapter, &firmware_stat); 1094 if (ret) 1095 continue; 1096 if (firmware_stat == FIRMWARE_READY_SDIO) { 1097 ret = 0; 1098 break; 1099 } else { 1100 msleep(100); 1101 ret = -1; 1102 } 1103 } 1104 1105 return ret; 1106 } 1107 1108 /* This function checks if WLAN is the winner. 1109 */ 1110 static int mwifiex_check_winner_status(struct mwifiex_adapter *adapter) 1111 { 1112 int ret = 0; 1113 u8 winner = 0; 1114 struct sdio_mmc_card *card = adapter->card; 1115 1116 if (mwifiex_read_reg(adapter, card->reg->status_reg_0, &winner)) 1117 return -1; 1118 1119 if (winner) 1120 adapter->winner = 0; 1121 else 1122 adapter->winner = 1; 1123 1124 return ret; 1125 } 1126 1127 /* 1128 * This function decode sdio aggreation pkt. 1129 * 1130 * Based on the the data block size and pkt_len, 1131 * skb data will be decoded to few packets. 1132 */ 1133 static void mwifiex_deaggr_sdio_pkt(struct mwifiex_adapter *adapter, 1134 struct sk_buff *skb) 1135 { 1136 u32 total_pkt_len, pkt_len; 1137 struct sk_buff *skb_deaggr; 1138 u16 blk_size; 1139 u8 blk_num; 1140 u8 *data; 1141 1142 data = skb->data; 1143 total_pkt_len = skb->len; 1144 1145 while (total_pkt_len >= (SDIO_HEADER_OFFSET + INTF_HEADER_LEN)) { 1146 if (total_pkt_len < adapter->sdio_rx_block_size) 1147 break; 1148 blk_num = *(data + BLOCK_NUMBER_OFFSET); 1149 blk_size = adapter->sdio_rx_block_size * blk_num; 1150 if (blk_size > total_pkt_len) { 1151 mwifiex_dbg(adapter, ERROR, 1152 "%s: error in blk_size,\t" 1153 "blk_num=%d, blk_size=%d, total_pkt_len=%d\n", 1154 __func__, blk_num, blk_size, total_pkt_len); 1155 break; 1156 } 1157 pkt_len = le16_to_cpu(*(__le16 *)(data + SDIO_HEADER_OFFSET)); 1158 if ((pkt_len + SDIO_HEADER_OFFSET) > blk_size) { 1159 mwifiex_dbg(adapter, ERROR, 1160 "%s: error in pkt_len,\t" 1161 "pkt_len=%d, blk_size=%d\n", 1162 __func__, pkt_len, blk_size); 1163 break; 1164 } 1165 1166 skb_deaggr = mwifiex_alloc_dma_align_buf(pkt_len, GFP_KERNEL); 1167 if (!skb_deaggr) 1168 break; 1169 skb_put(skb_deaggr, pkt_len); 1170 memcpy(skb_deaggr->data, data + SDIO_HEADER_OFFSET, pkt_len); 1171 skb_pull(skb_deaggr, INTF_HEADER_LEN); 1172 1173 mwifiex_handle_rx_packet(adapter, skb_deaggr); 1174 data += blk_size; 1175 total_pkt_len -= blk_size; 1176 } 1177 } 1178 1179 /* 1180 * This function decodes a received packet. 1181 * 1182 * Based on the type, the packet is treated as either a data, or 1183 * a command response, or an event, and the correct handler 1184 * function is invoked. 1185 */ 1186 static int mwifiex_decode_rx_packet(struct mwifiex_adapter *adapter, 1187 struct sk_buff *skb, u32 upld_typ) 1188 { 1189 u8 *cmd_buf; 1190 __le16 *curr_ptr = (__le16 *)skb->data; 1191 u16 pkt_len = le16_to_cpu(*curr_ptr); 1192 struct mwifiex_rxinfo *rx_info; 1193 1194 if (upld_typ != MWIFIEX_TYPE_AGGR_DATA) { 1195 skb_trim(skb, pkt_len); 1196 skb_pull(skb, INTF_HEADER_LEN); 1197 } 1198 1199 switch (upld_typ) { 1200 case MWIFIEX_TYPE_AGGR_DATA: 1201 mwifiex_dbg(adapter, INFO, 1202 "info: --- Rx: Aggr Data packet ---\n"); 1203 rx_info = MWIFIEX_SKB_RXCB(skb); 1204 rx_info->buf_type = MWIFIEX_TYPE_AGGR_DATA; 1205 if (adapter->rx_work_enabled) { 1206 skb_queue_tail(&adapter->rx_data_q, skb); 1207 atomic_inc(&adapter->rx_pending); 1208 adapter->data_received = true; 1209 } else { 1210 mwifiex_deaggr_sdio_pkt(adapter, skb); 1211 dev_kfree_skb_any(skb); 1212 } 1213 break; 1214 1215 case MWIFIEX_TYPE_DATA: 1216 mwifiex_dbg(adapter, DATA, 1217 "info: --- Rx: Data packet ---\n"); 1218 if (adapter->rx_work_enabled) { 1219 skb_queue_tail(&adapter->rx_data_q, skb); 1220 adapter->data_received = true; 1221 atomic_inc(&adapter->rx_pending); 1222 } else { 1223 mwifiex_handle_rx_packet(adapter, skb); 1224 } 1225 break; 1226 1227 case MWIFIEX_TYPE_CMD: 1228 mwifiex_dbg(adapter, CMD, 1229 "info: --- Rx: Cmd Response ---\n"); 1230 /* take care of curr_cmd = NULL case */ 1231 if (!adapter->curr_cmd) { 1232 cmd_buf = adapter->upld_buf; 1233 1234 if (adapter->ps_state == PS_STATE_SLEEP_CFM) 1235 mwifiex_process_sleep_confirm_resp(adapter, 1236 skb->data, 1237 skb->len); 1238 1239 memcpy(cmd_buf, skb->data, 1240 min_t(u32, MWIFIEX_SIZE_OF_CMD_BUFFER, 1241 skb->len)); 1242 1243 dev_kfree_skb_any(skb); 1244 } else { 1245 adapter->cmd_resp_received = true; 1246 adapter->curr_cmd->resp_skb = skb; 1247 } 1248 break; 1249 1250 case MWIFIEX_TYPE_EVENT: 1251 mwifiex_dbg(adapter, EVENT, 1252 "info: --- Rx: Event ---\n"); 1253 adapter->event_cause = le32_to_cpu(*(__le32 *) skb->data); 1254 1255 if ((skb->len > 0) && (skb->len < MAX_EVENT_SIZE)) 1256 memcpy(adapter->event_body, 1257 skb->data + MWIFIEX_EVENT_HEADER_LEN, 1258 skb->len); 1259 1260 /* event cause has been saved to adapter->event_cause */ 1261 adapter->event_received = true; 1262 adapter->event_skb = skb; 1263 1264 break; 1265 1266 default: 1267 mwifiex_dbg(adapter, ERROR, 1268 "unknown upload type %#x\n", upld_typ); 1269 dev_kfree_skb_any(skb); 1270 break; 1271 } 1272 1273 return 0; 1274 } 1275 1276 /* 1277 * This function transfers received packets from card to driver, performing 1278 * aggregation if required. 1279 * 1280 * For data received on control port, or if aggregation is disabled, the 1281 * received buffers are uploaded as separate packets. However, if aggregation 1282 * is enabled and required, the buffers are copied onto an aggregation buffer, 1283 * provided there is space left, processed and finally uploaded. 1284 */ 1285 static int mwifiex_sdio_card_to_host_mp_aggr(struct mwifiex_adapter *adapter, 1286 u16 rx_len, u8 port) 1287 { 1288 struct sdio_mmc_card *card = adapter->card; 1289 s32 f_do_rx_aggr = 0; 1290 s32 f_do_rx_cur = 0; 1291 s32 f_aggr_cur = 0; 1292 s32 f_post_aggr_cur = 0; 1293 struct sk_buff *skb_deaggr; 1294 struct sk_buff *skb = NULL; 1295 u32 pkt_len, pkt_type, mport, pind; 1296 u8 *curr_ptr; 1297 1298 if ((card->has_control_mask) && (port == CTRL_PORT)) { 1299 /* Read the command Resp without aggr */ 1300 mwifiex_dbg(adapter, CMD, 1301 "info: %s: no aggregation for cmd\t" 1302 "response\n", __func__); 1303 1304 f_do_rx_cur = 1; 1305 goto rx_curr_single; 1306 } 1307 1308 if (!card->mpa_rx.enabled) { 1309 mwifiex_dbg(adapter, WARN, 1310 "info: %s: rx aggregation disabled\n", 1311 __func__); 1312 1313 f_do_rx_cur = 1; 1314 goto rx_curr_single; 1315 } 1316 1317 if ((!card->has_control_mask && (card->mp_rd_bitmap & 1318 card->reg->data_port_mask)) || 1319 (card->has_control_mask && (card->mp_rd_bitmap & 1320 (~((u32) CTRL_PORT_MASK))))) { 1321 /* Some more data RX pending */ 1322 mwifiex_dbg(adapter, INFO, 1323 "info: %s: not last packet\n", __func__); 1324 1325 if (MP_RX_AGGR_IN_PROGRESS(card)) { 1326 if (MP_RX_AGGR_BUF_HAS_ROOM(card, rx_len)) { 1327 f_aggr_cur = 1; 1328 } else { 1329 /* No room in Aggr buf, do rx aggr now */ 1330 f_do_rx_aggr = 1; 1331 f_post_aggr_cur = 1; 1332 } 1333 } else { 1334 /* Rx aggr not in progress */ 1335 f_aggr_cur = 1; 1336 } 1337 1338 } else { 1339 /* No more data RX pending */ 1340 mwifiex_dbg(adapter, INFO, 1341 "info: %s: last packet\n", __func__); 1342 1343 if (MP_RX_AGGR_IN_PROGRESS(card)) { 1344 f_do_rx_aggr = 1; 1345 if (MP_RX_AGGR_BUF_HAS_ROOM(card, rx_len)) 1346 f_aggr_cur = 1; 1347 else 1348 /* No room in Aggr buf, do rx aggr now */ 1349 f_do_rx_cur = 1; 1350 } else { 1351 f_do_rx_cur = 1; 1352 } 1353 } 1354 1355 if (f_aggr_cur) { 1356 mwifiex_dbg(adapter, INFO, 1357 "info: current packet aggregation\n"); 1358 /* Curr pkt can be aggregated */ 1359 mp_rx_aggr_setup(card, rx_len, port); 1360 1361 if (MP_RX_AGGR_PKT_LIMIT_REACHED(card) || 1362 mp_rx_aggr_port_limit_reached(card)) { 1363 mwifiex_dbg(adapter, INFO, 1364 "info: %s: aggregated packet\t" 1365 "limit reached\n", __func__); 1366 /* No more pkts allowed in Aggr buf, rx it */ 1367 f_do_rx_aggr = 1; 1368 } 1369 } 1370 1371 if (f_do_rx_aggr) { 1372 /* do aggr RX now */ 1373 mwifiex_dbg(adapter, DATA, 1374 "info: do_rx_aggr: num of packets: %d\n", 1375 card->mpa_rx.pkt_cnt); 1376 1377 if (card->supports_sdio_new_mode) { 1378 int i; 1379 u32 port_count; 1380 1381 for (i = 0, port_count = 0; i < card->max_ports; i++) 1382 if (card->mpa_rx.ports & BIT(i)) 1383 port_count++; 1384 1385 /* Reading data from "start_port + 0" to "start_port + 1386 * port_count -1", so decrease the count by 1 1387 */ 1388 port_count--; 1389 mport = (adapter->ioport | SDIO_MPA_ADDR_BASE | 1390 (port_count << 8)) + card->mpa_rx.start_port; 1391 } else { 1392 mport = (adapter->ioport | SDIO_MPA_ADDR_BASE | 1393 (card->mpa_rx.ports << 4)) + 1394 card->mpa_rx.start_port; 1395 } 1396 1397 if (card->mpa_rx.pkt_cnt == 1) 1398 mport = adapter->ioport + port; 1399 1400 if (mwifiex_read_data_sync(adapter, card->mpa_rx.buf, 1401 card->mpa_rx.buf_len, mport, 1)) 1402 goto error; 1403 1404 curr_ptr = card->mpa_rx.buf; 1405 1406 for (pind = 0; pind < card->mpa_rx.pkt_cnt; pind++) { 1407 u32 *len_arr = card->mpa_rx.len_arr; 1408 1409 /* get curr PKT len & type */ 1410 pkt_len = le16_to_cpu(*(__le16 *) &curr_ptr[0]); 1411 pkt_type = le16_to_cpu(*(__le16 *) &curr_ptr[2]); 1412 1413 /* copy pkt to deaggr buf */ 1414 skb_deaggr = mwifiex_alloc_dma_align_buf(len_arr[pind], 1415 GFP_KERNEL); 1416 if (!skb_deaggr) { 1417 mwifiex_dbg(adapter, ERROR, "skb allocation failure\t" 1418 "drop pkt len=%d type=%d\n", 1419 pkt_len, pkt_type); 1420 curr_ptr += len_arr[pind]; 1421 continue; 1422 } 1423 1424 skb_put(skb_deaggr, len_arr[pind]); 1425 1426 if ((pkt_type == MWIFIEX_TYPE_DATA || 1427 (pkt_type == MWIFIEX_TYPE_AGGR_DATA && 1428 adapter->sdio_rx_aggr_enable)) && 1429 (pkt_len <= len_arr[pind])) { 1430 1431 memcpy(skb_deaggr->data, curr_ptr, pkt_len); 1432 1433 skb_trim(skb_deaggr, pkt_len); 1434 1435 /* Process de-aggr packet */ 1436 mwifiex_decode_rx_packet(adapter, skb_deaggr, 1437 pkt_type); 1438 } else { 1439 mwifiex_dbg(adapter, ERROR, 1440 "drop wrong aggr pkt:\t" 1441 "sdio_single_port_rx_aggr=%d\t" 1442 "type=%d len=%d max_len=%d\n", 1443 adapter->sdio_rx_aggr_enable, 1444 pkt_type, pkt_len, len_arr[pind]); 1445 dev_kfree_skb_any(skb_deaggr); 1446 } 1447 curr_ptr += len_arr[pind]; 1448 } 1449 MP_RX_AGGR_BUF_RESET(card); 1450 } 1451 1452 rx_curr_single: 1453 if (f_do_rx_cur) { 1454 mwifiex_dbg(adapter, INFO, "info: RX: port: %d, rx_len: %d\n", 1455 port, rx_len); 1456 1457 skb = mwifiex_alloc_dma_align_buf(rx_len, GFP_KERNEL); 1458 if (!skb) { 1459 mwifiex_dbg(adapter, ERROR, 1460 "single skb allocated fail,\t" 1461 "drop pkt port=%d len=%d\n", port, rx_len); 1462 if (mwifiex_sdio_card_to_host(adapter, &pkt_type, 1463 card->mpa_rx.buf, rx_len, 1464 adapter->ioport + port)) 1465 goto error; 1466 return 0; 1467 } 1468 1469 skb_put(skb, rx_len); 1470 1471 if (mwifiex_sdio_card_to_host(adapter, &pkt_type, 1472 skb->data, skb->len, 1473 adapter->ioport + port)) 1474 goto error; 1475 if (!adapter->sdio_rx_aggr_enable && 1476 pkt_type == MWIFIEX_TYPE_AGGR_DATA) { 1477 mwifiex_dbg(adapter, ERROR, "drop wrong pkt type %d\t" 1478 "current SDIO RX Aggr not enabled\n", 1479 pkt_type); 1480 dev_kfree_skb_any(skb); 1481 return 0; 1482 } 1483 1484 mwifiex_decode_rx_packet(adapter, skb, pkt_type); 1485 } 1486 if (f_post_aggr_cur) { 1487 mwifiex_dbg(adapter, INFO, 1488 "info: current packet aggregation\n"); 1489 /* Curr pkt can be aggregated */ 1490 mp_rx_aggr_setup(card, rx_len, port); 1491 } 1492 1493 return 0; 1494 error: 1495 if (MP_RX_AGGR_IN_PROGRESS(card)) 1496 MP_RX_AGGR_BUF_RESET(card); 1497 1498 if (f_do_rx_cur && skb) 1499 /* Single transfer pending. Free curr buff also */ 1500 dev_kfree_skb_any(skb); 1501 1502 return -1; 1503 } 1504 1505 /* 1506 * This function checks the current interrupt status. 1507 * 1508 * The following interrupts are checked and handled by this function - 1509 * - Data sent 1510 * - Command sent 1511 * - Packets received 1512 * 1513 * Since the firmware does not generate download ready interrupt if the 1514 * port updated is command port only, command sent interrupt checking 1515 * should be done manually, and for every SDIO interrupt. 1516 * 1517 * In case of Rx packets received, the packets are uploaded from card to 1518 * host and processed accordingly. 1519 */ 1520 static int mwifiex_process_int_status(struct mwifiex_adapter *adapter) 1521 { 1522 struct sdio_mmc_card *card = adapter->card; 1523 const struct mwifiex_sdio_card_reg *reg = card->reg; 1524 int ret = 0; 1525 u8 sdio_ireg; 1526 struct sk_buff *skb; 1527 u8 port = CTRL_PORT; 1528 u32 len_reg_l, len_reg_u; 1529 u32 rx_blocks; 1530 u16 rx_len; 1531 unsigned long flags; 1532 u32 bitmap; 1533 u8 cr; 1534 1535 spin_lock_irqsave(&adapter->int_lock, flags); 1536 sdio_ireg = adapter->int_status; 1537 adapter->int_status = 0; 1538 spin_unlock_irqrestore(&adapter->int_lock, flags); 1539 1540 if (!sdio_ireg) 1541 return ret; 1542 1543 /* Following interrupt is only for SDIO new mode */ 1544 if (sdio_ireg & DN_LD_CMD_PORT_HOST_INT_STATUS && adapter->cmd_sent) 1545 adapter->cmd_sent = false; 1546 1547 /* Following interrupt is only for SDIO new mode */ 1548 if (sdio_ireg & UP_LD_CMD_PORT_HOST_INT_STATUS) { 1549 u32 pkt_type; 1550 1551 /* read the len of control packet */ 1552 rx_len = card->mp_regs[reg->cmd_rd_len_1] << 8; 1553 rx_len |= (u16)card->mp_regs[reg->cmd_rd_len_0]; 1554 rx_blocks = DIV_ROUND_UP(rx_len, MWIFIEX_SDIO_BLOCK_SIZE); 1555 if (rx_len <= INTF_HEADER_LEN || 1556 (rx_blocks * MWIFIEX_SDIO_BLOCK_SIZE) > 1557 MWIFIEX_RX_DATA_BUF_SIZE) 1558 return -1; 1559 rx_len = (u16) (rx_blocks * MWIFIEX_SDIO_BLOCK_SIZE); 1560 mwifiex_dbg(adapter, INFO, "info: rx_len = %d\n", rx_len); 1561 1562 skb = mwifiex_alloc_dma_align_buf(rx_len, GFP_KERNEL); 1563 if (!skb) 1564 return -1; 1565 1566 skb_put(skb, rx_len); 1567 1568 if (mwifiex_sdio_card_to_host(adapter, &pkt_type, skb->data, 1569 skb->len, adapter->ioport | 1570 CMD_PORT_SLCT)) { 1571 mwifiex_dbg(adapter, ERROR, 1572 "%s: failed to card_to_host", __func__); 1573 dev_kfree_skb_any(skb); 1574 goto term_cmd; 1575 } 1576 1577 if ((pkt_type != MWIFIEX_TYPE_CMD) && 1578 (pkt_type != MWIFIEX_TYPE_EVENT)) 1579 mwifiex_dbg(adapter, ERROR, 1580 "%s:Received wrong packet on cmd port", 1581 __func__); 1582 1583 mwifiex_decode_rx_packet(adapter, skb, pkt_type); 1584 } 1585 1586 if (sdio_ireg & DN_LD_HOST_INT_STATUS) { 1587 bitmap = (u32) card->mp_regs[reg->wr_bitmap_l]; 1588 bitmap |= ((u32) card->mp_regs[reg->wr_bitmap_u]) << 8; 1589 if (card->supports_sdio_new_mode) { 1590 bitmap |= 1591 ((u32) card->mp_regs[reg->wr_bitmap_1l]) << 16; 1592 bitmap |= 1593 ((u32) card->mp_regs[reg->wr_bitmap_1u]) << 24; 1594 } 1595 card->mp_wr_bitmap = bitmap; 1596 1597 mwifiex_dbg(adapter, INTR, 1598 "int: DNLD: wr_bitmap=0x%x\n", 1599 card->mp_wr_bitmap); 1600 if (adapter->data_sent && 1601 (card->mp_wr_bitmap & card->mp_data_port_mask)) { 1602 mwifiex_dbg(adapter, INTR, 1603 "info: <--- Tx DONE Interrupt --->\n"); 1604 adapter->data_sent = false; 1605 } 1606 } 1607 1608 /* As firmware will not generate download ready interrupt if the port 1609 updated is command port only, cmd_sent should be done for any SDIO 1610 interrupt. */ 1611 if (card->has_control_mask && adapter->cmd_sent) { 1612 /* Check if firmware has attach buffer at command port and 1613 update just that in wr_bit_map. */ 1614 card->mp_wr_bitmap |= 1615 (u32) card->mp_regs[reg->wr_bitmap_l] & CTRL_PORT_MASK; 1616 if (card->mp_wr_bitmap & CTRL_PORT_MASK) 1617 adapter->cmd_sent = false; 1618 } 1619 1620 mwifiex_dbg(adapter, INTR, "info: cmd_sent=%d data_sent=%d\n", 1621 adapter->cmd_sent, adapter->data_sent); 1622 if (sdio_ireg & UP_LD_HOST_INT_STATUS) { 1623 bitmap = (u32) card->mp_regs[reg->rd_bitmap_l]; 1624 bitmap |= ((u32) card->mp_regs[reg->rd_bitmap_u]) << 8; 1625 if (card->supports_sdio_new_mode) { 1626 bitmap |= 1627 ((u32) card->mp_regs[reg->rd_bitmap_1l]) << 16; 1628 bitmap |= 1629 ((u32) card->mp_regs[reg->rd_bitmap_1u]) << 24; 1630 } 1631 card->mp_rd_bitmap = bitmap; 1632 mwifiex_dbg(adapter, INTR, 1633 "int: UPLD: rd_bitmap=0x%x\n", 1634 card->mp_rd_bitmap); 1635 1636 while (true) { 1637 ret = mwifiex_get_rd_port(adapter, &port); 1638 if (ret) { 1639 mwifiex_dbg(adapter, INFO, 1640 "info: no more rd_port available\n"); 1641 break; 1642 } 1643 len_reg_l = reg->rd_len_p0_l + (port << 1); 1644 len_reg_u = reg->rd_len_p0_u + (port << 1); 1645 rx_len = ((u16) card->mp_regs[len_reg_u]) << 8; 1646 rx_len |= (u16) card->mp_regs[len_reg_l]; 1647 mwifiex_dbg(adapter, INFO, 1648 "info: RX: port=%d rx_len=%u\n", 1649 port, rx_len); 1650 rx_blocks = 1651 (rx_len + MWIFIEX_SDIO_BLOCK_SIZE - 1652 1) / MWIFIEX_SDIO_BLOCK_SIZE; 1653 if (rx_len <= INTF_HEADER_LEN || 1654 (card->mpa_rx.enabled && 1655 ((rx_blocks * MWIFIEX_SDIO_BLOCK_SIZE) > 1656 card->mpa_rx.buf_size))) { 1657 mwifiex_dbg(adapter, ERROR, 1658 "invalid rx_len=%d\n", 1659 rx_len); 1660 return -1; 1661 } 1662 1663 rx_len = (u16) (rx_blocks * MWIFIEX_SDIO_BLOCK_SIZE); 1664 mwifiex_dbg(adapter, INFO, "info: rx_len = %d\n", 1665 rx_len); 1666 1667 if (mwifiex_sdio_card_to_host_mp_aggr(adapter, rx_len, 1668 port)) { 1669 mwifiex_dbg(adapter, ERROR, 1670 "card_to_host_mpa failed: int status=%#x\n", 1671 sdio_ireg); 1672 goto term_cmd; 1673 } 1674 } 1675 } 1676 1677 return 0; 1678 1679 term_cmd: 1680 /* terminate cmd */ 1681 if (mwifiex_read_reg(adapter, CONFIGURATION_REG, &cr)) 1682 mwifiex_dbg(adapter, ERROR, "read CFG reg failed\n"); 1683 else 1684 mwifiex_dbg(adapter, INFO, 1685 "info: CFG reg val = %d\n", cr); 1686 1687 if (mwifiex_write_reg(adapter, CONFIGURATION_REG, (cr | 0x04))) 1688 mwifiex_dbg(adapter, ERROR, 1689 "write CFG reg failed\n"); 1690 else 1691 mwifiex_dbg(adapter, INFO, "info: write success\n"); 1692 1693 if (mwifiex_read_reg(adapter, CONFIGURATION_REG, &cr)) 1694 mwifiex_dbg(adapter, ERROR, 1695 "read CFG reg failed\n"); 1696 else 1697 mwifiex_dbg(adapter, INFO, 1698 "info: CFG reg val =%x\n", cr); 1699 1700 return -1; 1701 } 1702 1703 /* 1704 * This function aggregates transmission buffers in driver and downloads 1705 * the aggregated packet to card. 1706 * 1707 * The individual packets are aggregated by copying into an aggregation 1708 * buffer and then downloaded to the card. Previous unsent packets in the 1709 * aggregation buffer are pre-copied first before new packets are added. 1710 * Aggregation is done till there is space left in the aggregation buffer, 1711 * or till new packets are available. 1712 * 1713 * The function will only download the packet to the card when aggregation 1714 * stops, otherwise it will just aggregate the packet in aggregation buffer 1715 * and return. 1716 */ 1717 static int mwifiex_host_to_card_mp_aggr(struct mwifiex_adapter *adapter, 1718 u8 *payload, u32 pkt_len, u32 port, 1719 u32 next_pkt_len) 1720 { 1721 struct sdio_mmc_card *card = adapter->card; 1722 int ret = 0; 1723 s32 f_send_aggr_buf = 0; 1724 s32 f_send_cur_buf = 0; 1725 s32 f_precopy_cur_buf = 0; 1726 s32 f_postcopy_cur_buf = 0; 1727 u32 mport; 1728 int index; 1729 1730 if (!card->mpa_tx.enabled || 1731 (card->has_control_mask && (port == CTRL_PORT)) || 1732 (card->supports_sdio_new_mode && (port == CMD_PORT_SLCT))) { 1733 mwifiex_dbg(adapter, WARN, 1734 "info: %s: tx aggregation disabled\n", 1735 __func__); 1736 1737 f_send_cur_buf = 1; 1738 goto tx_curr_single; 1739 } 1740 1741 if (next_pkt_len) { 1742 /* More pkt in TX queue */ 1743 mwifiex_dbg(adapter, INFO, 1744 "info: %s: more packets in queue.\n", 1745 __func__); 1746 1747 if (MP_TX_AGGR_IN_PROGRESS(card)) { 1748 if (MP_TX_AGGR_BUF_HAS_ROOM(card, pkt_len)) { 1749 f_precopy_cur_buf = 1; 1750 1751 if (!(card->mp_wr_bitmap & 1752 (1 << card->curr_wr_port)) || 1753 !MP_TX_AGGR_BUF_HAS_ROOM( 1754 card, pkt_len + next_pkt_len)) 1755 f_send_aggr_buf = 1; 1756 } else { 1757 /* No room in Aggr buf, send it */ 1758 f_send_aggr_buf = 1; 1759 1760 if (!(card->mp_wr_bitmap & 1761 (1 << card->curr_wr_port))) 1762 f_send_cur_buf = 1; 1763 else 1764 f_postcopy_cur_buf = 1; 1765 } 1766 } else { 1767 if (MP_TX_AGGR_BUF_HAS_ROOM(card, pkt_len) && 1768 (card->mp_wr_bitmap & (1 << card->curr_wr_port))) 1769 f_precopy_cur_buf = 1; 1770 else 1771 f_send_cur_buf = 1; 1772 } 1773 } else { 1774 /* Last pkt in TX queue */ 1775 mwifiex_dbg(adapter, INFO, 1776 "info: %s: Last packet in Tx Queue.\n", 1777 __func__); 1778 1779 if (MP_TX_AGGR_IN_PROGRESS(card)) { 1780 /* some packs in Aggr buf already */ 1781 f_send_aggr_buf = 1; 1782 1783 if (MP_TX_AGGR_BUF_HAS_ROOM(card, pkt_len)) 1784 f_precopy_cur_buf = 1; 1785 else 1786 /* No room in Aggr buf, send it */ 1787 f_send_cur_buf = 1; 1788 } else { 1789 f_send_cur_buf = 1; 1790 } 1791 } 1792 1793 if (f_precopy_cur_buf) { 1794 mwifiex_dbg(adapter, DATA, 1795 "data: %s: precopy current buffer\n", 1796 __func__); 1797 MP_TX_AGGR_BUF_PUT(card, payload, pkt_len, port); 1798 1799 if (MP_TX_AGGR_PKT_LIMIT_REACHED(card) || 1800 mp_tx_aggr_port_limit_reached(card)) 1801 /* No more pkts allowed in Aggr buf, send it */ 1802 f_send_aggr_buf = 1; 1803 } 1804 1805 if (f_send_aggr_buf) { 1806 mwifiex_dbg(adapter, DATA, 1807 "data: %s: send aggr buffer: %d %d\n", 1808 __func__, card->mpa_tx.start_port, 1809 card->mpa_tx.ports); 1810 if (card->supports_sdio_new_mode) { 1811 u32 port_count; 1812 int i; 1813 1814 for (i = 0, port_count = 0; i < card->max_ports; i++) 1815 if (card->mpa_tx.ports & BIT(i)) 1816 port_count++; 1817 1818 /* Writing data from "start_port + 0" to "start_port + 1819 * port_count -1", so decrease the count by 1 1820 */ 1821 port_count--; 1822 mport = (adapter->ioport | SDIO_MPA_ADDR_BASE | 1823 (port_count << 8)) + card->mpa_tx.start_port; 1824 } else { 1825 mport = (adapter->ioport | SDIO_MPA_ADDR_BASE | 1826 (card->mpa_tx.ports << 4)) + 1827 card->mpa_tx.start_port; 1828 } 1829 1830 if (card->mpa_tx.pkt_cnt == 1) 1831 mport = adapter->ioport + port; 1832 1833 ret = mwifiex_write_data_to_card(adapter, card->mpa_tx.buf, 1834 card->mpa_tx.buf_len, mport); 1835 1836 /* Save the last multi port tx aggreagation info to debug log */ 1837 index = adapter->dbg.last_sdio_mp_index; 1838 index = (index + 1) % MWIFIEX_DBG_SDIO_MP_NUM; 1839 adapter->dbg.last_sdio_mp_index = index; 1840 adapter->dbg.last_mp_wr_ports[index] = mport; 1841 adapter->dbg.last_mp_wr_bitmap[index] = card->mp_wr_bitmap; 1842 adapter->dbg.last_mp_wr_len[index] = card->mpa_tx.buf_len; 1843 adapter->dbg.last_mp_curr_wr_port[index] = card->curr_wr_port; 1844 1845 MP_TX_AGGR_BUF_RESET(card); 1846 } 1847 1848 tx_curr_single: 1849 if (f_send_cur_buf) { 1850 mwifiex_dbg(adapter, DATA, 1851 "data: %s: send current buffer %d\n", 1852 __func__, port); 1853 ret = mwifiex_write_data_to_card(adapter, payload, pkt_len, 1854 adapter->ioport + port); 1855 } 1856 1857 if (f_postcopy_cur_buf) { 1858 mwifiex_dbg(adapter, DATA, 1859 "data: %s: postcopy current buffer\n", 1860 __func__); 1861 MP_TX_AGGR_BUF_PUT(card, payload, pkt_len, port); 1862 } 1863 1864 return ret; 1865 } 1866 1867 /* 1868 * This function downloads data from driver to card. 1869 * 1870 * Both commands and data packets are transferred to the card by this 1871 * function. 1872 * 1873 * This function adds the SDIO specific header to the front of the buffer 1874 * before transferring. The header contains the length of the packet and 1875 * the type. The firmware handles the packets based upon this set type. 1876 */ 1877 static int mwifiex_sdio_host_to_card(struct mwifiex_adapter *adapter, 1878 u8 type, struct sk_buff *skb, 1879 struct mwifiex_tx_param *tx_param) 1880 { 1881 struct sdio_mmc_card *card = adapter->card; 1882 int ret; 1883 u32 buf_block_len; 1884 u32 blk_size; 1885 u32 port = CTRL_PORT; 1886 u8 *payload = (u8 *)skb->data; 1887 u32 pkt_len = skb->len; 1888 1889 /* Allocate buffer and copy payload */ 1890 blk_size = MWIFIEX_SDIO_BLOCK_SIZE; 1891 buf_block_len = (pkt_len + blk_size - 1) / blk_size; 1892 *(__le16 *)&payload[0] = cpu_to_le16((u16)pkt_len); 1893 *(__le16 *)&payload[2] = cpu_to_le16(type); 1894 1895 /* 1896 * This is SDIO specific header 1897 * u16 length, 1898 * u16 type (MWIFIEX_TYPE_DATA = 0, MWIFIEX_TYPE_CMD = 1, 1899 * MWIFIEX_TYPE_EVENT = 3) 1900 */ 1901 if (type == MWIFIEX_TYPE_DATA) { 1902 ret = mwifiex_get_wr_port_data(adapter, &port); 1903 if (ret) { 1904 mwifiex_dbg(adapter, ERROR, 1905 "%s: no wr_port available\n", 1906 __func__); 1907 return ret; 1908 } 1909 } else { 1910 adapter->cmd_sent = true; 1911 /* Type must be MWIFIEX_TYPE_CMD */ 1912 1913 if (pkt_len <= INTF_HEADER_LEN || 1914 pkt_len > MWIFIEX_UPLD_SIZE) 1915 mwifiex_dbg(adapter, ERROR, 1916 "%s: payload=%p, nb=%d\n", 1917 __func__, payload, pkt_len); 1918 1919 if (card->supports_sdio_new_mode) 1920 port = CMD_PORT_SLCT; 1921 } 1922 1923 /* Transfer data to card */ 1924 pkt_len = buf_block_len * blk_size; 1925 1926 if (tx_param) 1927 ret = mwifiex_host_to_card_mp_aggr(adapter, payload, pkt_len, 1928 port, tx_param->next_pkt_len 1929 ); 1930 else 1931 ret = mwifiex_host_to_card_mp_aggr(adapter, payload, pkt_len, 1932 port, 0); 1933 1934 if (ret) { 1935 if (type == MWIFIEX_TYPE_CMD) 1936 adapter->cmd_sent = false; 1937 if (type == MWIFIEX_TYPE_DATA) { 1938 adapter->data_sent = false; 1939 /* restore curr_wr_port in error cases */ 1940 card->curr_wr_port = port; 1941 card->mp_wr_bitmap |= (u32)(1 << card->curr_wr_port); 1942 } 1943 } else { 1944 if (type == MWIFIEX_TYPE_DATA) { 1945 if (!(card->mp_wr_bitmap & (1 << card->curr_wr_port))) 1946 adapter->data_sent = true; 1947 else 1948 adapter->data_sent = false; 1949 } 1950 } 1951 1952 return ret; 1953 } 1954 1955 /* 1956 * This function allocates the MPA Tx and Rx buffers. 1957 */ 1958 static int mwifiex_alloc_sdio_mpa_buffers(struct mwifiex_adapter *adapter, 1959 u32 mpa_tx_buf_size, u32 mpa_rx_buf_size) 1960 { 1961 struct sdio_mmc_card *card = adapter->card; 1962 u32 rx_buf_size; 1963 int ret = 0; 1964 1965 card->mpa_tx.buf = kzalloc(mpa_tx_buf_size, GFP_KERNEL); 1966 if (!card->mpa_tx.buf) { 1967 ret = -1; 1968 goto error; 1969 } 1970 1971 card->mpa_tx.buf_size = mpa_tx_buf_size; 1972 1973 rx_buf_size = max_t(u32, mpa_rx_buf_size, 1974 (u32)SDIO_MAX_AGGR_BUF_SIZE); 1975 card->mpa_rx.buf = kzalloc(rx_buf_size, GFP_KERNEL); 1976 if (!card->mpa_rx.buf) { 1977 ret = -1; 1978 goto error; 1979 } 1980 1981 card->mpa_rx.buf_size = rx_buf_size; 1982 1983 error: 1984 if (ret) { 1985 kfree(card->mpa_tx.buf); 1986 kfree(card->mpa_rx.buf); 1987 card->mpa_tx.buf_size = 0; 1988 card->mpa_rx.buf_size = 0; 1989 } 1990 1991 return ret; 1992 } 1993 1994 /* 1995 * This function unregisters the SDIO device. 1996 * 1997 * The SDIO IRQ is released, the function is disabled and driver 1998 * data is set to null. 1999 */ 2000 static void 2001 mwifiex_unregister_dev(struct mwifiex_adapter *adapter) 2002 { 2003 struct sdio_mmc_card *card = adapter->card; 2004 2005 if (adapter->card) { 2006 card->adapter = NULL; 2007 sdio_claim_host(card->func); 2008 sdio_disable_func(card->func); 2009 sdio_release_host(card->func); 2010 } 2011 } 2012 2013 /* 2014 * This function registers the SDIO device. 2015 * 2016 * SDIO IRQ is claimed, block size is set and driver data is initialized. 2017 */ 2018 static int mwifiex_register_dev(struct mwifiex_adapter *adapter) 2019 { 2020 int ret; 2021 struct sdio_mmc_card *card = adapter->card; 2022 struct sdio_func *func = card->func; 2023 2024 /* save adapter pointer in card */ 2025 card->adapter = adapter; 2026 adapter->tx_buf_size = card->tx_buf_size; 2027 2028 sdio_claim_host(func); 2029 2030 /* Set block size */ 2031 ret = sdio_set_block_size(card->func, MWIFIEX_SDIO_BLOCK_SIZE); 2032 sdio_release_host(func); 2033 if (ret) { 2034 mwifiex_dbg(adapter, ERROR, 2035 "cannot set SDIO block size\n"); 2036 return ret; 2037 } 2038 2039 strcpy(adapter->fw_name, card->firmware); 2040 if (card->fw_dump_enh) { 2041 adapter->mem_type_mapping_tbl = generic_mem_type_map; 2042 adapter->num_mem_types = 1; 2043 } else { 2044 adapter->mem_type_mapping_tbl = mem_type_mapping_tbl; 2045 adapter->num_mem_types = ARRAY_SIZE(mem_type_mapping_tbl); 2046 } 2047 2048 return 0; 2049 } 2050 2051 /* 2052 * This function initializes the SDIO driver. 2053 * 2054 * The following initializations steps are followed - 2055 * - Read the Host interrupt status register to acknowledge 2056 * the first interrupt got from bootloader 2057 * - Disable host interrupt mask register 2058 * - Get SDIO port 2059 * - Initialize SDIO variables in card 2060 * - Allocate MP registers 2061 * - Allocate MPA Tx and Rx buffers 2062 */ 2063 static int mwifiex_init_sdio(struct mwifiex_adapter *adapter) 2064 { 2065 struct sdio_mmc_card *card = adapter->card; 2066 const struct mwifiex_sdio_card_reg *reg = card->reg; 2067 int ret; 2068 u8 sdio_ireg; 2069 2070 sdio_set_drvdata(card->func, card); 2071 2072 /* 2073 * Read the host_int_status_reg for ACK the first interrupt got 2074 * from the bootloader. If we don't do this we get a interrupt 2075 * as soon as we register the irq. 2076 */ 2077 mwifiex_read_reg(adapter, card->reg->host_int_status_reg, &sdio_ireg); 2078 2079 /* Get SDIO ioport */ 2080 mwifiex_init_sdio_ioport(adapter); 2081 2082 /* Initialize SDIO variables in card */ 2083 card->mp_rd_bitmap = 0; 2084 card->mp_wr_bitmap = 0; 2085 card->curr_rd_port = reg->start_rd_port; 2086 card->curr_wr_port = reg->start_wr_port; 2087 2088 card->mp_data_port_mask = reg->data_port_mask; 2089 2090 card->mpa_tx.buf_len = 0; 2091 card->mpa_tx.pkt_cnt = 0; 2092 card->mpa_tx.start_port = 0; 2093 2094 card->mpa_tx.enabled = 1; 2095 card->mpa_tx.pkt_aggr_limit = card->mp_agg_pkt_limit; 2096 2097 card->mpa_rx.buf_len = 0; 2098 card->mpa_rx.pkt_cnt = 0; 2099 card->mpa_rx.start_port = 0; 2100 2101 card->mpa_rx.enabled = 1; 2102 card->mpa_rx.pkt_aggr_limit = card->mp_agg_pkt_limit; 2103 2104 /* Allocate buffers for SDIO MP-A */ 2105 card->mp_regs = kzalloc(reg->max_mp_regs, GFP_KERNEL); 2106 if (!card->mp_regs) 2107 return -ENOMEM; 2108 2109 /* Allocate skb pointer buffers */ 2110 card->mpa_rx.skb_arr = kzalloc((sizeof(void *)) * 2111 card->mp_agg_pkt_limit, GFP_KERNEL); 2112 if (!card->mpa_rx.skb_arr) { 2113 kfree(card->mp_regs); 2114 return -ENOMEM; 2115 } 2116 2117 card->mpa_rx.len_arr = kzalloc(sizeof(*card->mpa_rx.len_arr) * 2118 card->mp_agg_pkt_limit, GFP_KERNEL); 2119 if (!card->mpa_rx.len_arr) { 2120 kfree(card->mp_regs); 2121 kfree(card->mpa_rx.skb_arr); 2122 return -ENOMEM; 2123 } 2124 2125 ret = mwifiex_alloc_sdio_mpa_buffers(adapter, 2126 card->mp_tx_agg_buf_size, 2127 card->mp_rx_agg_buf_size); 2128 2129 /* Allocate 32k MPA Tx/Rx buffers if 64k memory allocation fails */ 2130 if (ret && (card->mp_tx_agg_buf_size == MWIFIEX_MP_AGGR_BUF_SIZE_MAX || 2131 card->mp_rx_agg_buf_size == MWIFIEX_MP_AGGR_BUF_SIZE_MAX)) { 2132 /* Disable rx single port aggregation */ 2133 adapter->host_disable_sdio_rx_aggr = true; 2134 2135 ret = mwifiex_alloc_sdio_mpa_buffers 2136 (adapter, MWIFIEX_MP_AGGR_BUF_SIZE_32K, 2137 MWIFIEX_MP_AGGR_BUF_SIZE_32K); 2138 if (ret) { 2139 /* Disable multi port aggregation */ 2140 card->mpa_tx.enabled = 0; 2141 card->mpa_rx.enabled = 0; 2142 } 2143 } 2144 2145 adapter->auto_tdls = card->can_auto_tdls; 2146 adapter->ext_scan = card->can_ext_scan; 2147 return 0; 2148 } 2149 2150 /* 2151 * This function resets the MPA Tx and Rx buffers. 2152 */ 2153 static void mwifiex_cleanup_mpa_buf(struct mwifiex_adapter *adapter) 2154 { 2155 struct sdio_mmc_card *card = adapter->card; 2156 2157 MP_TX_AGGR_BUF_RESET(card); 2158 MP_RX_AGGR_BUF_RESET(card); 2159 } 2160 2161 /* 2162 * This function cleans up the allocated card buffers. 2163 * 2164 * The following are freed by this function - 2165 * - MP registers 2166 * - MPA Tx buffer 2167 * - MPA Rx buffer 2168 */ 2169 static void mwifiex_cleanup_sdio(struct mwifiex_adapter *adapter) 2170 { 2171 struct sdio_mmc_card *card = adapter->card; 2172 2173 kfree(card->mp_regs); 2174 kfree(card->mpa_rx.skb_arr); 2175 kfree(card->mpa_rx.len_arr); 2176 kfree(card->mpa_tx.buf); 2177 kfree(card->mpa_rx.buf); 2178 } 2179 2180 /* 2181 * This function updates the MP end port in card. 2182 */ 2183 static void 2184 mwifiex_update_mp_end_port(struct mwifiex_adapter *adapter, u16 port) 2185 { 2186 struct sdio_mmc_card *card = adapter->card; 2187 const struct mwifiex_sdio_card_reg *reg = card->reg; 2188 int i; 2189 2190 card->mp_end_port = port; 2191 2192 card->mp_data_port_mask = reg->data_port_mask; 2193 2194 if (reg->start_wr_port) { 2195 for (i = 1; i <= card->max_ports - card->mp_end_port; i++) 2196 card->mp_data_port_mask &= 2197 ~(1 << (card->max_ports - i)); 2198 } 2199 2200 card->curr_wr_port = reg->start_wr_port; 2201 2202 mwifiex_dbg(adapter, CMD, 2203 "cmd: mp_end_port %d, data port mask 0x%x\n", 2204 port, card->mp_data_port_mask); 2205 } 2206 2207 static void mwifiex_recreate_adapter(struct sdio_mmc_card *card) 2208 { 2209 struct sdio_func *func = card->func; 2210 const struct sdio_device_id *device_id = card->device_id; 2211 2212 /* TODO mmc_hw_reset does not require destroying and re-probing the 2213 * whole adapter. Hence there was no need to for this rube-goldberg 2214 * design to reload the fw from an external workqueue. If we don't 2215 * destroy the adapter we could reload the fw from 2216 * mwifiex_main_work_queue directly. 2217 * The real difficulty with fw reset is to restore all the user 2218 * settings applied through ioctl. By destroying and recreating the 2219 * adapter, we take the easy way out, since we rely on user space to 2220 * restore them. We assume that user space will treat the new 2221 * incarnation of the adapter(interfaces) as if they had been just 2222 * discovered and initializes them from scratch. 2223 */ 2224 2225 mwifiex_sdio_remove(func); 2226 2227 /* 2228 * Normally, we would let the driver core take care of releasing these. 2229 * But we're not letting the driver core handle this one. See above 2230 * TODO. 2231 */ 2232 sdio_set_drvdata(func, NULL); 2233 devm_kfree(&func->dev, card); 2234 2235 /* power cycle the adapter */ 2236 sdio_claim_host(func); 2237 mmc_hw_reset(func->card->host); 2238 sdio_release_host(func); 2239 2240 mwifiex_sdio_probe(func, device_id); 2241 } 2242 2243 static struct mwifiex_adapter *save_adapter; 2244 static void mwifiex_sdio_card_reset_work(struct mwifiex_adapter *adapter) 2245 { 2246 struct sdio_mmc_card *card = adapter->card; 2247 2248 /* TODO card pointer is unprotected. If the adapter is removed 2249 * physically, sdio core might trigger mwifiex_sdio_remove, before this 2250 * workqueue is run, which will destroy the adapter struct. When this 2251 * workqueue eventually exceutes it will dereference an invalid adapter 2252 * pointer 2253 */ 2254 mwifiex_recreate_adapter(card); 2255 } 2256 2257 /* This function read/write firmware */ 2258 static enum 2259 rdwr_status mwifiex_sdio_rdwr_firmware(struct mwifiex_adapter *adapter, 2260 u8 doneflag) 2261 { 2262 struct sdio_mmc_card *card = adapter->card; 2263 int ret, tries; 2264 u8 ctrl_data = 0; 2265 2266 sdio_writeb(card->func, card->reg->fw_dump_host_ready, 2267 card->reg->fw_dump_ctrl, &ret); 2268 if (ret) { 2269 mwifiex_dbg(adapter, ERROR, "SDIO Write ERR\n"); 2270 return RDWR_STATUS_FAILURE; 2271 } 2272 for (tries = 0; tries < MAX_POLL_TRIES; tries++) { 2273 ctrl_data = sdio_readb(card->func, card->reg->fw_dump_ctrl, 2274 &ret); 2275 if (ret) { 2276 mwifiex_dbg(adapter, ERROR, "SDIO read err\n"); 2277 return RDWR_STATUS_FAILURE; 2278 } 2279 if (ctrl_data == FW_DUMP_DONE) 2280 break; 2281 if (doneflag && ctrl_data == doneflag) 2282 return RDWR_STATUS_DONE; 2283 if (ctrl_data != card->reg->fw_dump_host_ready) { 2284 mwifiex_dbg(adapter, WARN, 2285 "The ctrl reg was changed, re-try again\n"); 2286 sdio_writeb(card->func, card->reg->fw_dump_host_ready, 2287 card->reg->fw_dump_ctrl, &ret); 2288 if (ret) { 2289 mwifiex_dbg(adapter, ERROR, "SDIO write err\n"); 2290 return RDWR_STATUS_FAILURE; 2291 } 2292 } 2293 usleep_range(100, 200); 2294 } 2295 if (ctrl_data == card->reg->fw_dump_host_ready) { 2296 mwifiex_dbg(adapter, ERROR, 2297 "Fail to pull ctrl_data\n"); 2298 return RDWR_STATUS_FAILURE; 2299 } 2300 2301 return RDWR_STATUS_SUCCESS; 2302 } 2303 2304 /* This function dump firmware memory to file */ 2305 static void mwifiex_sdio_fw_dump(struct mwifiex_adapter *adapter) 2306 { 2307 struct sdio_mmc_card *card = adapter->card; 2308 int ret = 0; 2309 unsigned int reg, reg_start, reg_end; 2310 u8 *dbg_ptr, *end_ptr, dump_num, idx, i, read_reg, doneflag = 0; 2311 enum rdwr_status stat; 2312 u32 memory_size; 2313 2314 if (!card->can_dump_fw) 2315 return; 2316 2317 for (idx = 0; idx < ARRAY_SIZE(mem_type_mapping_tbl); idx++) { 2318 struct memory_type_mapping *entry = &mem_type_mapping_tbl[idx]; 2319 2320 if (entry->mem_ptr) { 2321 vfree(entry->mem_ptr); 2322 entry->mem_ptr = NULL; 2323 } 2324 entry->mem_size = 0; 2325 } 2326 2327 mwifiex_pm_wakeup_card(adapter); 2328 sdio_claim_host(card->func); 2329 2330 mwifiex_dbg(adapter, MSG, "== mwifiex firmware dump start ==\n"); 2331 2332 stat = mwifiex_sdio_rdwr_firmware(adapter, doneflag); 2333 if (stat == RDWR_STATUS_FAILURE) 2334 goto done; 2335 2336 reg = card->reg->fw_dump_start; 2337 /* Read the number of the memories which will dump */ 2338 dump_num = sdio_readb(card->func, reg, &ret); 2339 if (ret) { 2340 mwifiex_dbg(adapter, ERROR, "SDIO read memory length err\n"); 2341 goto done; 2342 } 2343 2344 /* Read the length of every memory which will dump */ 2345 for (idx = 0; idx < dump_num; idx++) { 2346 struct memory_type_mapping *entry = &mem_type_mapping_tbl[idx]; 2347 2348 stat = mwifiex_sdio_rdwr_firmware(adapter, doneflag); 2349 if (stat == RDWR_STATUS_FAILURE) 2350 goto done; 2351 2352 memory_size = 0; 2353 reg = card->reg->fw_dump_start; 2354 for (i = 0; i < 4; i++) { 2355 read_reg = sdio_readb(card->func, reg, &ret); 2356 if (ret) { 2357 mwifiex_dbg(adapter, ERROR, "SDIO read err\n"); 2358 goto done; 2359 } 2360 memory_size |= (read_reg << i*8); 2361 reg++; 2362 } 2363 2364 if (memory_size == 0) { 2365 mwifiex_dbg(adapter, DUMP, "Firmware dump Finished!\n"); 2366 ret = mwifiex_write_reg(adapter, 2367 card->reg->fw_dump_ctrl, 2368 FW_DUMP_READ_DONE); 2369 if (ret) { 2370 mwifiex_dbg(adapter, ERROR, "SDIO write err\n"); 2371 return; 2372 } 2373 break; 2374 } 2375 2376 mwifiex_dbg(adapter, DUMP, 2377 "%s_SIZE=0x%x\n", entry->mem_name, memory_size); 2378 entry->mem_ptr = vmalloc(memory_size + 1); 2379 entry->mem_size = memory_size; 2380 if (!entry->mem_ptr) { 2381 mwifiex_dbg(adapter, ERROR, "Vmalloc %s failed\n", 2382 entry->mem_name); 2383 goto done; 2384 } 2385 dbg_ptr = entry->mem_ptr; 2386 end_ptr = dbg_ptr + memory_size; 2387 2388 doneflag = entry->done_flag; 2389 mwifiex_dbg(adapter, DUMP, 2390 "Start %s output, please wait...\n", 2391 entry->mem_name); 2392 2393 do { 2394 stat = mwifiex_sdio_rdwr_firmware(adapter, doneflag); 2395 if (stat == RDWR_STATUS_FAILURE) 2396 goto done; 2397 2398 reg_start = card->reg->fw_dump_start; 2399 reg_end = card->reg->fw_dump_end; 2400 for (reg = reg_start; reg <= reg_end; reg++) { 2401 *dbg_ptr = sdio_readb(card->func, reg, &ret); 2402 if (ret) { 2403 mwifiex_dbg(adapter, ERROR, 2404 "SDIO read err\n"); 2405 goto done; 2406 } 2407 if (dbg_ptr < end_ptr) 2408 dbg_ptr++; 2409 else 2410 mwifiex_dbg(adapter, ERROR, 2411 "Allocated buf not enough\n"); 2412 } 2413 2414 if (stat != RDWR_STATUS_DONE) 2415 continue; 2416 2417 mwifiex_dbg(adapter, DUMP, "%s done: size=0x%tx\n", 2418 entry->mem_name, dbg_ptr - entry->mem_ptr); 2419 break; 2420 } while (1); 2421 } 2422 mwifiex_dbg(adapter, MSG, "== mwifiex firmware dump end ==\n"); 2423 2424 done: 2425 sdio_release_host(card->func); 2426 } 2427 2428 static void mwifiex_sdio_generic_fw_dump(struct mwifiex_adapter *adapter) 2429 { 2430 struct sdio_mmc_card *card = adapter->card; 2431 struct memory_type_mapping *entry = &generic_mem_type_map[0]; 2432 unsigned int reg, reg_start, reg_end; 2433 u8 start_flag = 0, done_flag = 0; 2434 u8 *dbg_ptr, *end_ptr; 2435 enum rdwr_status stat; 2436 int ret = -1, tries; 2437 2438 if (!card->fw_dump_enh) 2439 return; 2440 2441 if (entry->mem_ptr) { 2442 vfree(entry->mem_ptr); 2443 entry->mem_ptr = NULL; 2444 } 2445 entry->mem_size = 0; 2446 2447 mwifiex_pm_wakeup_card(adapter); 2448 sdio_claim_host(card->func); 2449 2450 mwifiex_dbg(adapter, MSG, "== mwifiex firmware dump start ==\n"); 2451 2452 stat = mwifiex_sdio_rdwr_firmware(adapter, done_flag); 2453 if (stat == RDWR_STATUS_FAILURE) 2454 goto done; 2455 2456 reg_start = card->reg->fw_dump_start; 2457 reg_end = card->reg->fw_dump_end; 2458 for (reg = reg_start; reg <= reg_end; reg++) { 2459 for (tries = 0; tries < MAX_POLL_TRIES; tries++) { 2460 start_flag = sdio_readb(card->func, reg, &ret); 2461 if (ret) { 2462 mwifiex_dbg(adapter, ERROR, 2463 "SDIO read err\n"); 2464 goto done; 2465 } 2466 if (start_flag == 0) 2467 break; 2468 if (tries == MAX_POLL_TRIES) { 2469 mwifiex_dbg(adapter, ERROR, 2470 "FW not ready to dump\n"); 2471 ret = -1; 2472 goto done; 2473 } 2474 } 2475 usleep_range(100, 200); 2476 } 2477 2478 entry->mem_ptr = vmalloc(0xf0000 + 1); 2479 if (!entry->mem_ptr) { 2480 ret = -1; 2481 goto done; 2482 } 2483 dbg_ptr = entry->mem_ptr; 2484 entry->mem_size = 0xf0000; 2485 end_ptr = dbg_ptr + entry->mem_size; 2486 2487 done_flag = entry->done_flag; 2488 mwifiex_dbg(adapter, DUMP, 2489 "Start %s output, please wait...\n", entry->mem_name); 2490 2491 while (true) { 2492 stat = mwifiex_sdio_rdwr_firmware(adapter, done_flag); 2493 if (stat == RDWR_STATUS_FAILURE) 2494 goto done; 2495 for (reg = reg_start; reg <= reg_end; reg++) { 2496 *dbg_ptr = sdio_readb(card->func, reg, &ret); 2497 if (ret) { 2498 mwifiex_dbg(adapter, ERROR, 2499 "SDIO read err\n"); 2500 goto done; 2501 } 2502 dbg_ptr++; 2503 if (dbg_ptr >= end_ptr) { 2504 u8 *tmp_ptr; 2505 2506 tmp_ptr = vmalloc(entry->mem_size + 0x4000 + 1); 2507 if (!tmp_ptr) 2508 goto done; 2509 2510 memcpy(tmp_ptr, entry->mem_ptr, 2511 entry->mem_size); 2512 vfree(entry->mem_ptr); 2513 entry->mem_ptr = tmp_ptr; 2514 tmp_ptr = NULL; 2515 dbg_ptr = entry->mem_ptr + entry->mem_size; 2516 entry->mem_size += 0x4000; 2517 end_ptr = entry->mem_ptr + entry->mem_size; 2518 } 2519 } 2520 if (stat == RDWR_STATUS_DONE) { 2521 entry->mem_size = dbg_ptr - entry->mem_ptr; 2522 mwifiex_dbg(adapter, DUMP, "dump %s done size=0x%x\n", 2523 entry->mem_name, entry->mem_size); 2524 ret = 0; 2525 break; 2526 } 2527 } 2528 mwifiex_dbg(adapter, MSG, "== mwifiex firmware dump end ==\n"); 2529 2530 done: 2531 if (ret) { 2532 mwifiex_dbg(adapter, ERROR, "firmware dump failed\n"); 2533 if (entry->mem_ptr) { 2534 vfree(entry->mem_ptr); 2535 entry->mem_ptr = NULL; 2536 } 2537 entry->mem_size = 0; 2538 } 2539 sdio_release_host(card->func); 2540 } 2541 2542 static void mwifiex_sdio_device_dump_work(struct mwifiex_adapter *adapter) 2543 { 2544 struct sdio_mmc_card *card = adapter->card; 2545 2546 mwifiex_drv_info_dump(adapter); 2547 if (card->fw_dump_enh) 2548 mwifiex_sdio_generic_fw_dump(adapter); 2549 else 2550 mwifiex_sdio_fw_dump(adapter); 2551 mwifiex_upload_device_dump(adapter); 2552 } 2553 2554 static void mwifiex_sdio_work(struct work_struct *work) 2555 { 2556 if (test_and_clear_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP, 2557 &iface_work_flags)) 2558 mwifiex_sdio_device_dump_work(save_adapter); 2559 if (test_and_clear_bit(MWIFIEX_IFACE_WORK_CARD_RESET, 2560 &iface_work_flags)) 2561 mwifiex_sdio_card_reset_work(save_adapter); 2562 } 2563 2564 static DECLARE_WORK(sdio_work, mwifiex_sdio_work); 2565 /* This function resets the card */ 2566 static void mwifiex_sdio_card_reset(struct mwifiex_adapter *adapter) 2567 { 2568 save_adapter = adapter; 2569 if (test_bit(MWIFIEX_IFACE_WORK_CARD_RESET, &iface_work_flags)) 2570 return; 2571 2572 set_bit(MWIFIEX_IFACE_WORK_CARD_RESET, &iface_work_flags); 2573 2574 schedule_work(&sdio_work); 2575 } 2576 2577 /* This function dumps FW information */ 2578 static void mwifiex_sdio_device_dump(struct mwifiex_adapter *adapter) 2579 { 2580 save_adapter = adapter; 2581 if (test_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP, &iface_work_flags)) 2582 return; 2583 2584 set_bit(MWIFIEX_IFACE_WORK_DEVICE_DUMP, &iface_work_flags); 2585 schedule_work(&sdio_work); 2586 } 2587 2588 /* Function to dump SDIO function registers and SDIO scratch registers in case 2589 * of FW crash 2590 */ 2591 static int 2592 mwifiex_sdio_reg_dump(struct mwifiex_adapter *adapter, char *drv_buf) 2593 { 2594 char *p = drv_buf; 2595 struct sdio_mmc_card *cardp = adapter->card; 2596 int ret = 0; 2597 u8 count, func, data, index = 0, size = 0; 2598 u8 reg, reg_start, reg_end; 2599 char buf[256], *ptr; 2600 2601 if (!p) 2602 return 0; 2603 2604 mwifiex_dbg(adapter, MSG, "SDIO register dump start\n"); 2605 2606 mwifiex_pm_wakeup_card(adapter); 2607 2608 sdio_claim_host(cardp->func); 2609 2610 for (count = 0; count < 5; count++) { 2611 memset(buf, 0, sizeof(buf)); 2612 ptr = buf; 2613 2614 switch (count) { 2615 case 0: 2616 /* Read the registers of SDIO function0 */ 2617 func = count; 2618 reg_start = 0; 2619 reg_end = 9; 2620 break; 2621 case 1: 2622 /* Read the registers of SDIO function1 */ 2623 func = count; 2624 reg_start = cardp->reg->func1_dump_reg_start; 2625 reg_end = cardp->reg->func1_dump_reg_end; 2626 break; 2627 case 2: 2628 index = 0; 2629 func = 1; 2630 reg_start = cardp->reg->func1_spec_reg_table[index++]; 2631 size = cardp->reg->func1_spec_reg_num; 2632 reg_end = cardp->reg->func1_spec_reg_table[size-1]; 2633 break; 2634 default: 2635 /* Read the scratch registers of SDIO function1 */ 2636 if (count == 4) 2637 mdelay(100); 2638 func = 1; 2639 reg_start = cardp->reg->func1_scratch_reg; 2640 reg_end = reg_start + MWIFIEX_SDIO_SCRATCH_SIZE; 2641 } 2642 2643 if (count != 2) 2644 ptr += sprintf(ptr, "SDIO Func%d (%#x-%#x): ", 2645 func, reg_start, reg_end); 2646 else 2647 ptr += sprintf(ptr, "SDIO Func%d: ", func); 2648 2649 for (reg = reg_start; reg <= reg_end;) { 2650 if (func == 0) 2651 data = sdio_f0_readb(cardp->func, reg, &ret); 2652 else 2653 data = sdio_readb(cardp->func, reg, &ret); 2654 2655 if (count == 2) 2656 ptr += sprintf(ptr, "(%#x) ", reg); 2657 if (!ret) { 2658 ptr += sprintf(ptr, "%02x ", data); 2659 } else { 2660 ptr += sprintf(ptr, "ERR"); 2661 break; 2662 } 2663 2664 if (count == 2 && reg < reg_end) 2665 reg = cardp->reg->func1_spec_reg_table[index++]; 2666 else 2667 reg++; 2668 } 2669 2670 mwifiex_dbg(adapter, MSG, "%s\n", buf); 2671 p += sprintf(p, "%s\n", buf); 2672 } 2673 2674 sdio_release_host(cardp->func); 2675 2676 mwifiex_dbg(adapter, MSG, "SDIO register dump end\n"); 2677 2678 return p - drv_buf; 2679 } 2680 2681 static struct mwifiex_if_ops sdio_ops = { 2682 .init_if = mwifiex_init_sdio, 2683 .cleanup_if = mwifiex_cleanup_sdio, 2684 .check_fw_status = mwifiex_check_fw_status, 2685 .check_winner_status = mwifiex_check_winner_status, 2686 .prog_fw = mwifiex_prog_fw_w_helper, 2687 .register_dev = mwifiex_register_dev, 2688 .unregister_dev = mwifiex_unregister_dev, 2689 .enable_int = mwifiex_sdio_enable_host_int, 2690 .disable_int = mwifiex_sdio_disable_host_int, 2691 .process_int_status = mwifiex_process_int_status, 2692 .host_to_card = mwifiex_sdio_host_to_card, 2693 .wakeup = mwifiex_pm_wakeup_card, 2694 .wakeup_complete = mwifiex_pm_wakeup_card_complete, 2695 2696 /* SDIO specific */ 2697 .update_mp_end_port = mwifiex_update_mp_end_port, 2698 .cleanup_mpa_buf = mwifiex_cleanup_mpa_buf, 2699 .cmdrsp_complete = mwifiex_sdio_cmdrsp_complete, 2700 .event_complete = mwifiex_sdio_event_complete, 2701 .dnld_fw = mwifiex_sdio_dnld_fw, 2702 .card_reset = mwifiex_sdio_card_reset, 2703 .reg_dump = mwifiex_sdio_reg_dump, 2704 .device_dump = mwifiex_sdio_device_dump, 2705 .deaggr_pkt = mwifiex_deaggr_sdio_pkt, 2706 }; 2707 2708 /* 2709 * This function initializes the SDIO driver. 2710 * 2711 * This registers the device with SDIO bus. 2712 */ 2713 static int 2714 mwifiex_sdio_init_module(void) 2715 { 2716 /* Clear the flag in case user removes the card. */ 2717 user_rmmod = 0; 2718 2719 return sdio_register_driver(&mwifiex_sdio); 2720 } 2721 2722 /* 2723 * This function cleans up the SDIO driver. 2724 * 2725 * The following major steps are followed for cleanup - 2726 * - Resume the device if its suspended 2727 * - Disconnect the device if connected 2728 * - Shutdown the firmware 2729 * - Unregister the device from SDIO bus. 2730 */ 2731 static void 2732 mwifiex_sdio_cleanup_module(void) 2733 { 2734 /* Set the flag as user is removing this module. */ 2735 user_rmmod = 1; 2736 cancel_work_sync(&sdio_work); 2737 2738 sdio_unregister_driver(&mwifiex_sdio); 2739 } 2740 2741 module_init(mwifiex_sdio_init_module); 2742 module_exit(mwifiex_sdio_cleanup_module); 2743 2744 MODULE_AUTHOR("Marvell International Ltd."); 2745 MODULE_DESCRIPTION("Marvell WiFi-Ex SDIO Driver version " SDIO_VERSION); 2746 MODULE_VERSION(SDIO_VERSION); 2747 MODULE_LICENSE("GPL v2"); 2748 MODULE_FIRMWARE(SD8786_DEFAULT_FW_NAME); 2749 MODULE_FIRMWARE(SD8787_DEFAULT_FW_NAME); 2750 MODULE_FIRMWARE(SD8797_DEFAULT_FW_NAME); 2751 MODULE_FIRMWARE(SD8897_DEFAULT_FW_NAME); 2752 MODULE_FIRMWARE(SD8887_DEFAULT_FW_NAME); 2753 MODULE_FIRMWARE(SD8997_DEFAULT_FW_NAME); 2754