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