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