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