drivers/net/wireless/marvell/mwifiex/sdio.c

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