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