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