drivers/net/wireless/marvell/libertas/if_sdio.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  linux/drivers/net/wireless/libertas/if_sdio.c
   4  *
   5  *  Copyright 2007-2008 Pierre Ossman
   6  *
   7  * Inspired by if_cs.c, Copyright 2007 Holger Schurig
   8  *
   9  * This hardware has more or less no CMD53 support, so all registers
  10  * must be accessed using sdio_readb()/sdio_writeb().
  11  *
  12  * Transfers must be in one transaction or the firmware goes bonkers.
  13  * This means that the transfer must either be small enough to do a
  14  * byte based transfer or it must be padded to a multiple of the
  15  * current block size.
  16  *
  17  * As SDIO is still new to the kernel, it is unfortunately common with
  18  * bugs in the host controllers related to that. One such bug is that
  19  * controllers cannot do transfers that aren't a multiple of 4 bytes.
  20  * If you don't have time to fix the host controller driver, you can
  21  * work around the problem by modifying if_sdio_host_to_card() and
  22  * if_sdio_card_to_host() to pad the data.
  23  */
  24
  25 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  26
  27 #include <linux/kernel.h>
  28 #include <linux/module.h>
  29 #include <linux/slab.h>
  30 #include <linux/firmware.h>
  31 #include <linux/netdevice.h>
  32 #include <linux/delay.h>
  33 #include <linux/mmc/card.h>
  34 #include <linux/mmc/sdio_func.h>
  35 #include <linux/mmc/sdio_ids.h>
  36 #include <linux/mmc/sdio.h>
  37 #include <linux/mmc/host.h>
  38 #include <linux/pm_runtime.h>
  39
  40 #include "host.h"
  41 #include "decl.h"
  42 #include "defs.h"
  43 #include "dev.h"
  44 #include "cmd.h"
  45 #include "if_sdio.h"
  46
  47 static void if_sdio_interrupt(struct sdio_func *func);
  48
  49 /* The if_sdio_remove() callback function is called when
  50  * user removes this module from kernel space or ejects
  51  * the card from the slot. The driver handles these 2 cases
  52  * differently for SD8688 combo chip.
  53  * If the user is removing the module, the FUNC_SHUTDOWN
  54  * command for SD8688 is sent to the firmware.
  55  * If the card is removed, there is no need to send this command.
  56  *
  57  * The variable 'user_rmmod' is used to distinguish these two
  58  * scenarios. This flag is initialized as FALSE in case the card
  59  * is removed, and will be set to TRUE for module removal when
  60  * module_exit function is called.
  61  */
  62 static u8 user_rmmod;
  63
  64 static const struct sdio_device_id if_sdio_ids[] = {
  65         { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL,
  66                         SDIO_DEVICE_ID_MARVELL_LIBERTAS) },
  67         { SDIO_DEVICE(SDIO_VENDOR_ID_MARVELL,
  68                         SDIO_DEVICE_ID_MARVELL_8688WLAN) },
  69         { /* end: all zeroes */                         },
  70 };
  71
  72 MODULE_DEVICE_TABLE(sdio, if_sdio_ids);
  73
  74 #define MODEL_8385      0x04
  75 #define MODEL_8686      0x0b
  76 #define MODEL_8688      0x10
  77
  78 static const struct lbs_fw_table fw_table[] = {
  79         { MODEL_8385, "/*(DEBLOBBED)*/", "/*(DEBLOBBED)*/" },
  80         { MODEL_8385, "/*(DEBLOBBED)*/", "/*(DEBLOBBED)*/" },
  81         { MODEL_8686, "/*(DEBLOBBED)*/", "/*(DEBLOBBED)*/" },
  82         { MODEL_8686, "/*(DEBLOBBED)*/", "/*(DEBLOBBED)*/" },
  83         { MODEL_8686, "/*(DEBLOBBED)*/", "/*(DEBLOBBED)*/" },
  84         { MODEL_8688, "/*(DEBLOBBED)*/", "/*(DEBLOBBED)*/" },
  85         { MODEL_8688, "/*(DEBLOBBED)*/", "/*(DEBLOBBED)*/" },
  86         { 0, NULL, NULL }
  87 };
  88 /*(DEBLOBBED)*/
  89
  90 struct if_sdio_packet {
  91         struct if_sdio_packet   *next;
  92         u16                     nb;
  93         u8                      buffer[0] __attribute__((aligned(4)));
  94 };
  95
  96 struct if_sdio_card {
  97         struct sdio_func        *func;
  98         struct lbs_private      *priv;
  99
 100         int                     model;
 101         unsigned long           ioport;
 102         unsigned int            scratch_reg;
 103         bool                    started;
 104         wait_queue_head_t       pwron_waitq;
 105
 106         u8                      buffer[65536] __attribute__((aligned(4)));
 107
 108         spinlock_t              lock;
 109         struct if_sdio_packet   *packets;
 110
 111         struct workqueue_struct *workqueue;
 112         struct work_struct      packet_worker;
 113
 114         u8                      rx_unit;
 115 };
 116
 117 static void if_sdio_finish_power_on(struct if_sdio_card *card);
 118 static int if_sdio_power_off(struct if_sdio_card *card);
 119
 120 /********************************************************************/
 121 /* I/O                                                              */
 122 /********************************************************************/
 123
 124 /*
 125  *  For SD8385/SD8686, this function reads firmware status after
 126  *  the image is downloaded, or reads RX packet length when
 127  *  interrupt (with IF_SDIO_H_INT_UPLD bit set) is received.
 128  *  For SD8688, this function reads firmware status only.
 129  */
 130 static u16 if_sdio_read_scratch(struct if_sdio_card *card, int *err)
 131 {
 132         int ret;
 133         u16 scratch;
 134
 135         scratch = sdio_readb(card->func, card->scratch_reg, &ret);
 136         if (!ret)
 137                 scratch |= sdio_readb(card->func, card->scratch_reg + 1,
 138                                         &ret) << 8;
 139
 140         if (err)
 141                 *err = ret;
 142
 143         if (ret)
 144                 return 0xffff;
 145
 146         return scratch;
 147 }
 148
 149 static u8 if_sdio_read_rx_unit(struct if_sdio_card *card)
 150 {
 151         int ret;
 152         u8 rx_unit;
 153
 154         rx_unit = sdio_readb(card->func, IF_SDIO_RX_UNIT, &ret);
 155
 156         if (ret)
 157                 rx_unit = 0;
 158
 159         return rx_unit;
 160 }
 161
 162 static u16 if_sdio_read_rx_len(struct if_sdio_card *card, int *err)
 163 {
 164         int ret;
 165         u16 rx_len;
 166
 167         switch (card->model) {
 168         case MODEL_8385:
 169         case MODEL_8686:
 170                 rx_len = if_sdio_read_scratch(card, &ret);
 171                 break;
 172         case MODEL_8688:
 173         default: /* for newer chipsets */
 174                 rx_len = sdio_readb(card->func, IF_SDIO_RX_LEN, &ret);
 175                 if (!ret)
 176                         rx_len <<= card->rx_unit;
 177                 else
 178                         rx_len = 0xffff;        /* invalid length */
 179
 180                 break;
 181         }
 182
 183         if (err)
 184                 *err = ret;
 185
 186         return rx_len;
 187 }
 188
 189 static int if_sdio_handle_cmd(struct if_sdio_card *card,
 190                 u8 *buffer, unsigned size)
 191 {
 192         struct lbs_private *priv = card->priv;
 193         int ret;
 194         unsigned long flags;
 195         u8 i;
 196
 197         if (size > LBS_CMD_BUFFER_SIZE) {
 198                 lbs_deb_sdio("response packet too large (%d bytes)\n",
 199                         (int)size);
 200                 ret = -E2BIG;
 201                 goto out;
 202         }
 203
 204         spin_lock_irqsave(&priv->driver_lock, flags);
 205
 206         i = (priv->resp_idx == 0) ? 1 : 0;
 207         BUG_ON(priv->resp_len[i]);
 208         priv->resp_len[i] = size;
 209         memcpy(priv->resp_buf[i], buffer, size);
 210         lbs_notify_command_response(priv, i);
 211
 212         spin_unlock_irqrestore(&priv->driver_lock, flags);
 213
 214         ret = 0;
 215
 216 out:
 217         return ret;
 218 }
 219
 220 static int if_sdio_handle_data(struct if_sdio_card *card,
 221                 u8 *buffer, unsigned size)
 222 {
 223         int ret;
 224         struct sk_buff *skb;
 225
 226         if (size > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE) {
 227                 lbs_deb_sdio("response packet too large (%d bytes)\n",
 228                         (int)size);
 229                 ret = -E2BIG;
 230                 goto out;
 231         }
 232
 233         skb = dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + NET_IP_ALIGN);
 234         if (!skb) {
 235                 ret = -ENOMEM;
 236                 goto out;
 237         }
 238
 239         skb_reserve(skb, NET_IP_ALIGN);
 240
 241         skb_put_data(skb, buffer, size);
 242
 243         lbs_process_rxed_packet(card->priv, skb);
 244
 245         ret = 0;
 246
 247 out:
 248         return ret;
 249 }
 250
 251 static int if_sdio_handle_event(struct if_sdio_card *card,
 252                 u8 *buffer, unsigned size)
 253 {
 254         int ret;
 255         u32 event;
 256
 257         if (card->model == MODEL_8385) {
 258                 event = sdio_readb(card->func, IF_SDIO_EVENT, &ret);
 259                 if (ret)
 260                         goto out;
 261
 262                 /* right shift 3 bits to get the event id */
 263                 event >>= 3;
 264         } else {
 265                 if (size < 4) {
 266                         lbs_deb_sdio("event packet too small (%d bytes)\n",
 267                                 (int)size);
 268                         ret = -EINVAL;
 269                         goto out;
 270                 }
 271                 event = buffer[3] << 24;
 272                 event |= buffer[2] << 16;
 273                 event |= buffer[1] << 8;
 274                 event |= buffer[0] << 0;
 275         }
 276
 277         lbs_queue_event(card->priv, event & 0xFF);
 278         ret = 0;
 279
 280 out:
 281         return ret;
 282 }
 283
 284 static int if_sdio_wait_status(struct if_sdio_card *card, const u8 condition)
 285 {
 286         u8 status;
 287         unsigned long timeout;
 288         int ret = 0;
 289
 290         timeout = jiffies + HZ;
 291         while (1) {
 292                 status = sdio_readb(card->func, IF_SDIO_STATUS, &ret);
 293                 if (ret)
 294                         return ret;
 295                 if ((status & condition) == condition)
 296                         break;
 297                 if (time_after(jiffies, timeout))
 298                         return -ETIMEDOUT;
 299                 mdelay(1);
 300         }
 301         return ret;
 302 }
 303
 304 static int if_sdio_card_to_host(struct if_sdio_card *card)
 305 {
 306         int ret;
 307         u16 size, type, chunk;
 308
 309         size = if_sdio_read_rx_len(card, &ret);
 310         if (ret)
 311                 goto out;
 312
 313         if (size < 4) {
 314                 lbs_deb_sdio("invalid packet size (%d bytes) from firmware\n",
 315                         (int)size);
 316                 ret = -EINVAL;
 317                 goto out;
 318         }
 319
 320         ret = if_sdio_wait_status(card, IF_SDIO_IO_RDY);
 321         if (ret)
 322                 goto out;
 323
 324         /*
 325          * The transfer must be in one transaction or the firmware
 326          * goes suicidal. There's no way to guarantee that for all
 327          * controllers, but we can at least try.
 328          */
 329         chunk = sdio_align_size(card->func, size);
 330
 331         ret = sdio_readsb(card->func, card->buffer, card->ioport, chunk);
 332         if (ret)
 333                 goto out;
 334
 335         chunk = card->buffer[0] | (card->buffer[1] << 8);
 336         type = card->buffer[2] | (card->buffer[3] << 8);
 337
 338         lbs_deb_sdio("packet of type %d and size %d bytes\n",
 339                 (int)type, (int)chunk);
 340
 341         if (chunk > size) {
 342                 lbs_deb_sdio("packet fragment (%d > %d)\n",
 343                         (int)chunk, (int)size);
 344                 ret = -EINVAL;
 345                 goto out;
 346         }
 347
 348         if (chunk < size) {
 349                 lbs_deb_sdio("packet fragment (%d < %d)\n",
 350                         (int)chunk, (int)size);
 351         }
 352
 353         switch (type) {
 354         case MVMS_CMD:
 355                 ret = if_sdio_handle_cmd(card, card->buffer + 4, chunk - 4);
 356                 if (ret)
 357                         goto out;
 358                 break;
 359         case MVMS_DAT:
 360                 ret = if_sdio_handle_data(card, card->buffer + 4, chunk - 4);
 361                 if (ret)
 362                         goto out;
 363                 break;
 364         case MVMS_EVENT:
 365                 ret = if_sdio_handle_event(card, card->buffer + 4, chunk - 4);
 366                 if (ret)
 367                         goto out;
 368                 break;
 369         default:
 370                 lbs_deb_sdio("invalid type (%d) from firmware\n",
 371                                 (int)type);
 372                 ret = -EINVAL;
 373                 goto out;
 374         }
 375
 376 out:
 377         if (ret)
 378                 pr_err("problem fetching packet from firmware\n");
 379
 380         return ret;
 381 }
 382
 383 static void if_sdio_host_to_card_worker(struct work_struct *work)
 384 {
 385         struct if_sdio_card *card;
 386         struct if_sdio_packet *packet;
 387         int ret;
 388         unsigned long flags;
 389
 390         card = container_of(work, struct if_sdio_card, packet_worker);
 391
 392         while (1) {
 393                 spin_lock_irqsave(&card->lock, flags);
 394                 packet = card->packets;
 395                 if (packet)
 396                         card->packets = packet->next;
 397                 spin_unlock_irqrestore(&card->lock, flags);
 398
 399                 if (!packet)
 400                         break;
 401
 402                 sdio_claim_host(card->func);
 403
 404                 ret = if_sdio_wait_status(card, IF_SDIO_IO_RDY);
 405                 if (ret == 0) {
 406                         ret = sdio_writesb(card->func, card->ioport,
 407                                            packet->buffer, packet->nb);
 408                 }
 409
 410                 if (ret)
 411                         pr_err("error %d sending packet to firmware\n", ret);
 412
 413                 sdio_release_host(card->func);
 414
 415                 kfree(packet);
 416         }
 417 }
 418
 419 /********************************************************************/
 420 /* Firmware                                                         */
 421 /********************************************************************/
 422
 423 #define FW_DL_READY_STATUS (IF_SDIO_IO_RDY | IF_SDIO_DL_RDY)
 424
 425 static int if_sdio_prog_helper(struct if_sdio_card *card,
 426                                 const struct firmware *fw)
 427 {
 428         int ret;
 429         unsigned long timeout;
 430         u8 *chunk_buffer;
 431         u32 chunk_size;
 432         const u8 *firmware;
 433         size_t size;
 434
 435         chunk_buffer = kzalloc(64, GFP_KERNEL);
 436         if (!chunk_buffer) {
 437                 ret = -ENOMEM;
 438                 goto out;
 439         }
 440
 441         sdio_claim_host(card->func);
 442
 443         ret = sdio_set_block_size(card->func, 32);
 444         if (ret)
 445                 goto release;
 446
 447         firmware = fw->data;
 448         size = fw->size;
 449
 450         while (size) {
 451                 ret = if_sdio_wait_status(card, FW_DL_READY_STATUS);
 452                 if (ret)
 453                         goto release;
 454
 455                 /* On some platforms (like Davinci) the chip needs more time
 456                  * between helper blocks.
 457                  */
 458                 mdelay(2);
 459
 460                 chunk_size = min_t(size_t, size, 60);
 461
 462                 *((__le32*)chunk_buffer) = cpu_to_le32(chunk_size);
 463                 memcpy(chunk_buffer + 4, firmware, chunk_size);
 464 /*
 465                 lbs_deb_sdio("sending %d bytes chunk\n", chunk_size);
 466 */
 467                 ret = sdio_writesb(card->func, card->ioport,
 468                                 chunk_buffer, 64);
 469                 if (ret)
 470                         goto release;
 471
 472                 firmware += chunk_size;
 473                 size -= chunk_size;
 474         }
 475
 476         /* an empty block marks the end of the transfer */
 477         memset(chunk_buffer, 0, 4);
 478         ret = sdio_writesb(card->func, card->ioport, chunk_buffer, 64);
 479         if (ret)
 480                 goto release;
 481
 482         lbs_deb_sdio("waiting for helper to boot...\n");
 483
 484         /* wait for the helper to boot by looking at the size register */
 485         timeout = jiffies + HZ;
 486         while (1) {
 487                 u16 req_size;
 488
 489                 req_size = sdio_readb(card->func, IF_SDIO_RD_BASE, &ret);
 490                 if (ret)
 491                         goto release;
 492
 493                 req_size |= sdio_readb(card->func, IF_SDIO_RD_BASE + 1, &ret) << 8;
 494                 if (ret)
 495                         goto release;
 496
 497                 if (req_size != 0)
 498                         break;
 499
 500                 if (time_after(jiffies, timeout)) {
 501                         ret = -ETIMEDOUT;
 502                         goto release;
 503                 }
 504
 505                 msleep(10);
 506         }
 507
 508         ret = 0;
 509
 510 release:
 511         sdio_release_host(card->func);
 512         kfree(chunk_buffer);
 513
 514 out:
 515         if (ret)
 516                 pr_err("failed to load helper firmware\n");
 517
 518         return ret;
 519 }
 520
 521 static int if_sdio_prog_real(struct if_sdio_card *card,
 522                                 const struct firmware *fw)
 523 {
 524         int ret;
 525         unsigned long timeout;
 526         u8 *chunk_buffer;
 527         u32 chunk_size;
 528         const u8 *firmware;
 529         size_t size, req_size;
 530
 531         chunk_buffer = kzalloc(512, GFP_KERNEL);
 532         if (!chunk_buffer) {
 533                 ret = -ENOMEM;
 534                 goto out;
 535         }
 536
 537         sdio_claim_host(card->func);
 538
 539         ret = sdio_set_block_size(card->func, 32);
 540         if (ret)
 541                 goto release;
 542
 543         firmware = fw->data;
 544         size = fw->size;
 545
 546         while (size) {
 547                 timeout = jiffies + HZ;
 548                 while (1) {
 549                         ret = if_sdio_wait_status(card, FW_DL_READY_STATUS);
 550                         if (ret)
 551                                 goto release;
 552
 553                         req_size = sdio_readb(card->func, IF_SDIO_RD_BASE,
 554                                         &ret);
 555                         if (ret)
 556                                 goto release;
 557
 558                         req_size |= sdio_readb(card->func, IF_SDIO_RD_BASE + 1,
 559                                         &ret) << 8;
 560                         if (ret)
 561                                 goto release;
 562
 563                         /*
 564                          * For SD8688 wait until the length is not 0, 1 or 2
 565                          * before downloading the first FW block,
 566                          * since BOOT code writes the register to indicate the
 567                          * helper/FW download winner,
 568                          * the value could be 1 or 2 (Func1 or Func2).
 569                          */
 570                         if ((size != fw->size) || (req_size > 2))
 571                                 break;
 572                         if (time_after(jiffies, timeout)) {
 573                                 ret = -ETIMEDOUT;
 574                                 goto release;
 575                         }
 576                         mdelay(1);
 577                 }
 578
 579 /*
 580                 lbs_deb_sdio("firmware wants %d bytes\n", (int)req_size);
 581 */
 582                 if (req_size == 0) {
 583                         lbs_deb_sdio("firmware helper gave up early\n");
 584                         ret = -EIO;
 585                         goto release;
 586                 }
 587
 588                 if (req_size & 0x01) {
 589                         lbs_deb_sdio("firmware helper signalled error\n");
 590                         ret = -EIO;
 591                         goto release;
 592                 }
 593
 594                 if (req_size > size)
 595                         req_size = size;
 596
 597                 while (req_size) {
 598                         chunk_size = min_t(size_t, req_size, 512);
 599
 600                         memcpy(chunk_buffer, firmware, chunk_size);
 601 /*
 602                         lbs_deb_sdio("sending %d bytes (%d bytes) chunk\n",
 603                                 chunk_size, (chunk_size + 31) / 32 * 32);
 604 */
 605                         ret = sdio_writesb(card->func, card->ioport,
 606                                 chunk_buffer, roundup(chunk_size, 32));
 607                         if (ret)
 608                                 goto release;
 609
 610                         firmware += chunk_size;
 611                         size -= chunk_size;
 612                         req_size -= chunk_size;
 613                 }
 614         }
 615
 616         ret = 0;
 617
 618         lbs_deb_sdio("waiting for firmware to boot...\n");
 619
 620         /* wait for the firmware to boot */
 621         timeout = jiffies + HZ;
 622         while (1) {
 623                 u16 scratch;
 624
 625                 scratch = if_sdio_read_scratch(card, &ret);
 626                 if (ret)
 627                         goto release;
 628
 629                 if (scratch == IF_SDIO_FIRMWARE_OK)
 630                         break;
 631
 632                 if (time_after(jiffies, timeout)) {
 633                         ret = -ETIMEDOUT;
 634                         goto release;
 635                 }
 636
 637                 msleep(10);
 638         }
 639
 640         ret = 0;
 641
 642 release:
 643         sdio_release_host(card->func);
 644         kfree(chunk_buffer);
 645
 646 out:
 647         if (ret)
 648                 pr_err("failed to load firmware\n");
 649
 650         return ret;
 651 }
 652
 653 static void if_sdio_do_prog_firmware(struct lbs_private *priv, int ret,
 654                                      const struct firmware *helper,
 655                                      const struct firmware *mainfw)
 656 {
 657         struct if_sdio_card *card = priv->card;
 658
 659         if (ret) {
 660                 pr_err("failed to find firmware (%d)\n", ret);
 661                 return;
 662         }
 663
 664         ret = if_sdio_prog_helper(card, helper);
 665         if (ret)
 666                 return;
 667
 668         lbs_deb_sdio("Helper firmware loaded\n");
 669
 670         ret = if_sdio_prog_real(card, mainfw);
 671         if (ret)
 672                 return;
 673
 674         lbs_deb_sdio("Firmware loaded\n");
 675         if_sdio_finish_power_on(card);
 676 }
 677
 678 static int if_sdio_prog_firmware(struct if_sdio_card *card)
 679 {
 680         int ret;
 681         u16 scratch;
 682
 683         /*
 684          * Disable interrupts
 685          */
 686         sdio_claim_host(card->func);
 687         sdio_writeb(card->func, 0x00, IF_SDIO_H_INT_MASK, &ret);
 688         sdio_release_host(card->func);
 689
 690         sdio_claim_host(card->func);
 691         scratch = if_sdio_read_scratch(card, &ret);
 692         sdio_release_host(card->func);
 693
 694         lbs_deb_sdio("firmware status = %#x\n", scratch);
 695         lbs_deb_sdio("scratch ret = %d\n", ret);
 696
 697         if (ret)
 698                 goto out;
 699
 700
 701         /*
 702          * The manual clearly describes that FEDC is the right code to use
 703          * to detect firmware presence, but for SD8686 it is not that simple.
 704          * Scratch is also used to store the RX packet length, so we lose
 705          * the FEDC value early on. So we use a non-zero check in order
 706          * to validate firmware presence.
 707          * Additionally, the SD8686 in the Gumstix always has the high scratch
 708          * bit set, even when the firmware is not loaded. So we have to
 709          * exclude that from the test.
 710          */
 711         if (scratch == IF_SDIO_FIRMWARE_OK) {
 712                 lbs_deb_sdio("firmware already loaded\n");
 713                 if_sdio_finish_power_on(card);
 714                 return 0;
 715         } else if ((card->model == MODEL_8686) && (scratch & 0x7fff)) {
 716                 lbs_deb_sdio("firmware may be running\n");
 717                 if_sdio_finish_power_on(card);
 718                 return 0;
 719         }
 720
 721         ret = lbs_get_firmware_async(card->priv, &card->func->dev, card->model,
 722                                      fw_table, if_sdio_do_prog_firmware);
 723
 724 out:
 725         return ret;
 726 }
 727
 728 /********************************************************************/
 729 /* Power management                                                 */
 730 /********************************************************************/
 731
 732 /* Finish power on sequence (after firmware is loaded) */
 733 static void if_sdio_finish_power_on(struct if_sdio_card *card)
 734 {
 735         struct sdio_func *func = card->func;
 736         struct lbs_private *priv = card->priv;
 737         int ret;
 738
 739         sdio_claim_host(func);
 740         sdio_set_block_size(card->func, IF_SDIO_BLOCK_SIZE);
 741
 742         /*
 743          * Get rx_unit if the chip is SD8688 or newer.
 744          * SD8385 & SD8686 do not have rx_unit.
 745          */
 746         if ((card->model != MODEL_8385)
 747                         && (card->model != MODEL_8686))
 748                 card->rx_unit = if_sdio_read_rx_unit(card);
 749         else
 750                 card->rx_unit = 0;
 751
 752         /*
 753          * Set up the interrupt handler late.
 754          *
 755          * If we set it up earlier, the (buggy) hardware generates a spurious
 756          * interrupt, even before the interrupt has been enabled, with
 757          * CCCR_INTx = 0.
 758          *
 759          * We register the interrupt handler late so that we can handle any
 760          * spurious interrupts, and also to avoid generation of that known
 761          * spurious interrupt in the first place.
 762          */
 763         ret = sdio_claim_irq(func, if_sdio_interrupt);
 764         if (ret)
 765                 goto release;
 766
 767         /*
 768          * Enable interrupts now that everything is set up
 769          */
 770         sdio_writeb(func, 0x0f, IF_SDIO_H_INT_MASK, &ret);
 771         if (ret)
 772                 goto release_irq;
 773
 774         sdio_release_host(func);
 775
 776         /* Set fw_ready before queuing any commands so that
 777          * lbs_thread won't block from sending them to firmware.
 778          */
 779         priv->fw_ready = 1;
 780
 781         /*
 782          * FUNC_INIT is required for SD8688 WLAN/BT multiple functions
 783          */
 784         if (card->model == MODEL_8688) {
 785                 struct cmd_header cmd;
 786
 787                 memset(&cmd, 0, sizeof(cmd));
 788
 789                 lbs_deb_sdio("send function INIT command\n");
 790                 if (__lbs_cmd(priv, CMD_FUNC_INIT, &cmd, sizeof(cmd),
 791                                 lbs_cmd_copyback, (unsigned long) &cmd))
 792                         netdev_alert(priv->dev, "CMD_FUNC_INIT cmd failed\n");
 793         }
 794
 795         wake_up(&card->pwron_waitq);
 796
 797         if (!card->started) {
 798                 ret = lbs_start_card(priv);
 799                 if_sdio_power_off(card);
 800                 if (ret == 0) {
 801                         card->started = true;
 802                         /* Tell PM core that we don't need the card to be
 803                          * powered now */
 804                         pm_runtime_put(&func->dev);
 805                 }
 806         }
 807
 808         return;
 809
 810 release_irq:
 811         sdio_release_irq(func);
 812 release:
 813         sdio_release_host(func);
 814 }
 815
 816 static int if_sdio_power_on(struct if_sdio_card *card)
 817 {
 818         struct sdio_func *func = card->func;
 819         struct mmc_host *host = func->card->host;
 820         int ret;
 821
 822         sdio_claim_host(func);
 823
 824         ret = sdio_enable_func(func);
 825         if (ret)
 826                 goto release;
 827
 828         /* For 1-bit transfers to the 8686 model, we need to enable the
 829          * interrupt flag in the CCCR register. Set the MMC_QUIRK_LENIENT_FN0
 830          * bit to allow access to non-vendor registers. */
 831         if ((card->model == MODEL_8686) &&
 832             (host->caps & MMC_CAP_SDIO_IRQ) &&
 833             (host->ios.bus_width == MMC_BUS_WIDTH_1)) {
 834                 u8 reg;
 835
 836                 func->card->quirks |= MMC_QUIRK_LENIENT_FN0;
 837                 reg = sdio_f0_readb(func, SDIO_CCCR_IF, &ret);
 838                 if (ret)
 839                         goto disable;
 840
 841                 reg |= SDIO_BUS_ECSI;
 842                 sdio_f0_writeb(func, reg, SDIO_CCCR_IF, &ret);
 843                 if (ret)
 844                         goto disable;
 845         }
 846
 847         card->ioport = sdio_readb(func, IF_SDIO_IOPORT, &ret);
 848         if (ret)
 849                 goto disable;
 850
 851         card->ioport |= sdio_readb(func, IF_SDIO_IOPORT + 1, &ret) << 8;
 852         if (ret)
 853                 goto disable;
 854
 855         card->ioport |= sdio_readb(func, IF_SDIO_IOPORT + 2, &ret) << 16;
 856         if (ret)
 857                 goto disable;
 858
 859         sdio_release_host(func);
 860         ret = if_sdio_prog_firmware(card);
 861         if (ret) {
 862                 sdio_claim_host(func);
 863                 goto disable;
 864         }
 865
 866         return 0;
 867
 868 disable:
 869         sdio_disable_func(func);
 870 release:
 871         sdio_release_host(func);
 872         return ret;
 873 }
 874
 875 static int if_sdio_power_off(struct if_sdio_card *card)
 876 {
 877         struct sdio_func *func = card->func;
 878         struct lbs_private *priv = card->priv;
 879
 880         priv->fw_ready = 0;
 881
 882         sdio_claim_host(func);
 883         sdio_release_irq(func);
 884         sdio_disable_func(func);
 885         sdio_release_host(func);
 886         return 0;
 887 }
 888
 889
 890 /*******************************************************************/
 891 /* Libertas callbacks                                              */
 892 /*******************************************************************/
 893
 894 static int if_sdio_host_to_card(struct lbs_private *priv,
 895                 u8 type, u8 *buf, u16 nb)
 896 {
 897         int ret;
 898         struct if_sdio_card *card;
 899         struct if_sdio_packet *packet, *cur;
 900         u16 size;
 901         unsigned long flags;
 902
 903         card = priv->card;
 904
 905         if (nb > (65536 - sizeof(struct if_sdio_packet) - 4)) {
 906                 ret = -EINVAL;
 907                 goto out;
 908         }
 909
 910         /*
 911          * The transfer must be in one transaction or the firmware
 912          * goes suicidal. There's no way to guarantee that for all
 913          * controllers, but we can at least try.
 914          */
 915         size = sdio_align_size(card->func, nb + 4);
 916
 917         packet = kzalloc(sizeof(struct if_sdio_packet) + size,
 918                         GFP_ATOMIC);
 919         if (!packet) {
 920                 ret = -ENOMEM;
 921                 goto out;
 922         }
 923
 924         packet->next = NULL;
 925         packet->nb = size;
 926
 927         /*
 928          * SDIO specific header.
 929          */
 930         packet->buffer[0] = (nb + 4) & 0xff;
 931         packet->buffer[1] = ((nb + 4) >> 8) & 0xff;
 932         packet->buffer[2] = type;
 933         packet->buffer[3] = 0;
 934
 935         memcpy(packet->buffer + 4, buf, nb);
 936
 937         spin_lock_irqsave(&card->lock, flags);
 938
 939         if (!card->packets)
 940                 card->packets = packet;
 941         else {
 942                 cur = card->packets;
 943                 while (cur->next)
 944                         cur = cur->next;
 945                 cur->next = packet;
 946         }
 947
 948         switch (type) {
 949         case MVMS_CMD:
 950                 priv->dnld_sent = DNLD_CMD_SENT;
 951                 break;
 952         case MVMS_DAT:
 953                 priv->dnld_sent = DNLD_DATA_SENT;
 954                 break;
 955         default:
 956                 lbs_deb_sdio("unknown packet type %d\n", (int)type);
 957         }
 958
 959         spin_unlock_irqrestore(&card->lock, flags);
 960
 961         queue_work(card->workqueue, &card->packet_worker);
 962
 963         ret = 0;
 964
 965 out:
 966         return ret;
 967 }
 968
 969 static int if_sdio_enter_deep_sleep(struct lbs_private *priv)
 970 {
 971         int ret = -1;
 972         struct cmd_header cmd;
 973
 974         memset(&cmd, 0, sizeof(cmd));
 975
 976         lbs_deb_sdio("send DEEP_SLEEP command\n");
 977         ret = __lbs_cmd(priv, CMD_802_11_DEEP_SLEEP, &cmd, sizeof(cmd),
 978                         lbs_cmd_copyback, (unsigned long) &cmd);
 979         if (ret)
 980                 netdev_err(priv->dev, "DEEP_SLEEP cmd failed\n");
 981
 982         mdelay(200);
 983         return ret;
 984 }
 985
 986 static int if_sdio_exit_deep_sleep(struct lbs_private *priv)
 987 {
 988         struct if_sdio_card *card = priv->card;
 989         int ret = -1;
 990
 991         sdio_claim_host(card->func);
 992
 993         sdio_writeb(card->func, HOST_POWER_UP, CONFIGURATION_REG, &ret);
 994         if (ret)
 995                 netdev_err(priv->dev, "sdio_writeb failed!\n");
 996
 997         sdio_release_host(card->func);
 998
 999         return ret;
1000 }
1001
1002 static int if_sdio_reset_deep_sleep_wakeup(struct lbs_private *priv)
1003 {
1004         struct if_sdio_card *card = priv->card;
1005         int ret = -1;
1006
1007         sdio_claim_host(card->func);
1008
1009         sdio_writeb(card->func, 0, CONFIGURATION_REG, &ret);
1010         if (ret)
1011                 netdev_err(priv->dev, "sdio_writeb failed!\n");
1012
1013         sdio_release_host(card->func);
1014
1015         return ret;
1016
1017 }
1018
1019 static struct mmc_host *reset_host;
1020
1021 static void if_sdio_reset_card_worker(struct work_struct *work)
1022 {
1023         /*
1024          * The actual reset operation must be run outside of lbs_thread. This
1025          * is because mmc_remove_host() will cause the device to be instantly
1026          * destroyed, and the libertas driver then needs to end lbs_thread,
1027          * leading to a deadlock.
1028          *
1029          * We run it in a workqueue totally independent from the if_sdio_card
1030          * instance for that reason.
1031          */
1032
1033         pr_info("Resetting card...");
1034         mmc_remove_host(reset_host);
1035         mmc_add_host(reset_host);
1036 }
1037 static DECLARE_WORK(card_reset_work, if_sdio_reset_card_worker);
1038
1039 static void if_sdio_reset_card(struct lbs_private *priv)
1040 {
1041         struct if_sdio_card *card = priv->card;
1042
1043         if (work_pending(&card_reset_work))
1044                 return;
1045
1046         reset_host = card->func->card->host;
1047         schedule_work(&card_reset_work);
1048 }
1049
1050 static int if_sdio_power_save(struct lbs_private *priv)
1051 {
1052         struct if_sdio_card *card = priv->card;
1053         int ret;
1054
1055         flush_workqueue(card->workqueue);
1056
1057         ret = if_sdio_power_off(card);
1058
1059         /* Let runtime PM know the card is powered off */
1060         pm_runtime_put_sync(&card->func->dev);
1061
1062         return ret;
1063 }
1064
1065 static int if_sdio_power_restore(struct lbs_private *priv)
1066 {
1067         struct if_sdio_card *card = priv->card;
1068         int r;
1069
1070         /* Make sure the card will not be powered off by runtime PM */
1071         pm_runtime_get_sync(&card->func->dev);
1072
1073         r = if_sdio_power_on(card);
1074         if (r)
1075                 return r;
1076
1077         wait_event(card->pwron_waitq, priv->fw_ready);
1078         return 0;
1079 }
1080
1081
1082 /*******************************************************************/
1083 /* SDIO callbacks                                                  */
1084 /*******************************************************************/
1085
1086 static void if_sdio_interrupt(struct sdio_func *func)
1087 {
1088         int ret;
1089         struct if_sdio_card *card;
1090         u8 cause;
1091
1092         card = sdio_get_drvdata(func);
1093
1094         cause = sdio_readb(card->func, IF_SDIO_H_INT_STATUS, &ret);
1095         if (ret || !cause)
1096                 return;
1097
1098         lbs_deb_sdio("interrupt: 0x%X\n", (unsigned)cause);
1099
1100         sdio_writeb(card->func, ~cause, IF_SDIO_H_INT_STATUS, &ret);
1101         if (ret)
1102                 return;
1103
1104         /*
1105          * Ignore the define name, this really means the card has
1106          * successfully received the command.
1107          */
1108         card->priv->is_activity_detected = 1;
1109         if (cause & IF_SDIO_H_INT_DNLD)
1110                 lbs_host_to_card_done(card->priv);
1111
1112
1113         if (cause & IF_SDIO_H_INT_UPLD) {
1114                 ret = if_sdio_card_to_host(card);
1115                 if (ret)
1116                         return;
1117         }
1118 }
1119
1120 static int if_sdio_probe(struct sdio_func *func,
1121                 const struct sdio_device_id *id)
1122 {
1123         struct if_sdio_card *card;
1124         struct lbs_private *priv;
1125         int ret, i;
1126         unsigned int model;
1127         struct if_sdio_packet *packet;
1128
1129         for (i = 0;i < func->card->num_info;i++) {
1130                 if (sscanf(func->card->info[i],
1131                                 "802.11 SDIO ID: %x", &model) == 1)
1132                         break;
1133                 if (sscanf(func->card->info[i],
1134                                 "ID: %x", &model) == 1)
1135                         break;
1136                 if (!strcmp(func->card->info[i], "IBIS Wireless SDIO Card")) {
1137                         model = MODEL_8385;
1138                         break;
1139                 }
1140         }
1141
1142         if (i == func->card->num_info) {
1143                 pr_err("unable to identify card model\n");
1144                 return -ENODEV;
1145         }
1146
1147         card = kzalloc(sizeof(struct if_sdio_card), GFP_KERNEL);
1148         if (!card)
1149                 return -ENOMEM;
1150
1151         card->func = func;
1152         card->model = model;
1153
1154         switch (card->model) {
1155         case MODEL_8385:
1156                 card->scratch_reg = IF_SDIO_SCRATCH_OLD;
1157                 break;
1158         case MODEL_8686:
1159                 card->scratch_reg = IF_SDIO_SCRATCH;
1160                 break;
1161         case MODEL_8688:
1162         default: /* for newer chipsets */
1163                 card->scratch_reg = IF_SDIO_FW_STATUS;
1164                 break;
1165         }
1166
1167         spin_lock_init(&card->lock);
1168         card->workqueue = alloc_workqueue("libertas_sdio", WQ_MEM_RECLAIM, 0);
1169         INIT_WORK(&card->packet_worker, if_sdio_host_to_card_worker);
1170         init_waitqueue_head(&card->pwron_waitq);
1171
1172         /* Check if we support this card */
1173         for (i = 0; i < ARRAY_SIZE(fw_table); i++) {
1174                 if (card->model == fw_table[i].model)
1175                         break;
1176         }
1177         if (i == ARRAY_SIZE(fw_table)) {
1178                 pr_err("unknown card model 0x%x\n", card->model);
1179                 ret = -ENODEV;
1180                 goto free;
1181         }
1182
1183         sdio_set_drvdata(func, card);
1184
1185         lbs_deb_sdio("class = 0x%X, vendor = 0x%X, "
1186                         "device = 0x%X, model = 0x%X, ioport = 0x%X\n",
1187                         func->class, func->vendor, func->device,
1188                         model, (unsigned)card->ioport);
1189
1190
1191         priv = lbs_add_card(card, &func->dev);
1192         if (IS_ERR(priv)) {
1193                 ret = PTR_ERR(priv);
1194                 goto free;
1195         }
1196
1197         card->priv = priv;
1198
1199         priv->card = card;
1200         priv->hw_host_to_card = if_sdio_host_to_card;
1201         priv->enter_deep_sleep = if_sdio_enter_deep_sleep;
1202         priv->exit_deep_sleep = if_sdio_exit_deep_sleep;
1203         priv->reset_deep_sleep_wakeup = if_sdio_reset_deep_sleep_wakeup;
1204         priv->reset_card = if_sdio_reset_card;
1205         priv->power_save = if_sdio_power_save;
1206         priv->power_restore = if_sdio_power_restore;
1207         priv->is_polling = !(func->card->host->caps & MMC_CAP_SDIO_IRQ);
1208         ret = if_sdio_power_on(card);
1209         if (ret)
1210                 goto err_activate_card;
1211
1212 out:
1213         return ret;
1214
1215 err_activate_card:
1216         flush_workqueue(card->workqueue);
1217         lbs_remove_card(priv);
1218 free:
1219         destroy_workqueue(card->workqueue);
1220         while (card->packets) {
1221                 packet = card->packets;
1222                 card->packets = card->packets->next;
1223                 kfree(packet);
1224         }
1225
1226         kfree(card);
1227
1228         goto out;
1229 }
1230
1231 static void if_sdio_remove(struct sdio_func *func)
1232 {
1233         struct if_sdio_card *card;
1234         struct if_sdio_packet *packet;
1235
1236         card = sdio_get_drvdata(func);
1237
1238         /* Undo decrement done above in if_sdio_probe */
1239         pm_runtime_get_noresume(&func->dev);
1240
1241         if (user_rmmod && (card->model == MODEL_8688)) {
1242                 /*
1243                  * FUNC_SHUTDOWN is required for SD8688 WLAN/BT
1244                  * multiple functions
1245                  */
1246                 struct cmd_header cmd;
1247
1248                 memset(&cmd, 0, sizeof(cmd));
1249
1250                 lbs_deb_sdio("send function SHUTDOWN command\n");
1251                 if (__lbs_cmd(card->priv, CMD_FUNC_SHUTDOWN,
1252                                 &cmd, sizeof(cmd), lbs_cmd_copyback,
1253                                 (unsigned long) &cmd))
1254                         pr_alert("CMD_FUNC_SHUTDOWN cmd failed\n");
1255         }
1256
1257
1258         lbs_deb_sdio("call remove card\n");
1259         lbs_stop_card(card->priv);
1260         lbs_remove_card(card->priv);
1261
1262         destroy_workqueue(card->workqueue);
1263
1264         while (card->packets) {
1265                 packet = card->packets;
1266                 card->packets = card->packets->next;
1267                 kfree(packet);
1268         }
1269
1270         kfree(card);
1271 }
1272
1273 static int if_sdio_suspend(struct device *dev)
1274 {
1275         struct sdio_func *func = dev_to_sdio_func(dev);
1276         struct if_sdio_card *card = sdio_get_drvdata(func);
1277         struct lbs_private *priv = card->priv;
1278         int ret;
1279
1280         mmc_pm_flag_t flags = sdio_get_host_pm_caps(func);
1281         priv->power_up_on_resume = false;
1282
1283         /* If we're powered off anyway, just let the mmc layer remove the
1284          * card. */
1285         if (!lbs_iface_active(priv)) {
1286                 if (priv->fw_ready) {
1287                         priv->power_up_on_resume = true;
1288                         if_sdio_power_off(card);
1289                 }
1290
1291                 return 0;
1292         }
1293
1294         dev_info(dev, "%s: suspend: PM flags = 0x%x\n",
1295                  sdio_func_id(func), flags);
1296
1297         /* If we aren't being asked to wake on anything, we should bail out
1298          * and let the SD stack power down the card.
1299          */
1300         if (priv->wol_criteria == EHS_REMOVE_WAKEUP) {
1301                 dev_info(dev, "Suspend without wake params -- powering down card\n");
1302                 if (priv->fw_ready) {
1303                         ret = lbs_suspend(priv);
1304                         if (ret)
1305                                 return ret;
1306
1307                         priv->power_up_on_resume = true;
1308                         if_sdio_power_off(card);
1309                 }
1310
1311                 return 0;
1312         }
1313
1314         if (!(flags & MMC_PM_KEEP_POWER)) {
1315                 dev_err(dev, "%s: cannot remain alive while host is suspended\n",
1316                         sdio_func_id(func));
1317                 return -ENOSYS;
1318         }
1319
1320         ret = sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
1321         if (ret)
1322                 return ret;
1323
1324         ret = lbs_suspend(priv);
1325         if (ret)
1326                 return ret;
1327
1328         return sdio_set_host_pm_flags(func, MMC_PM_WAKE_SDIO_IRQ);
1329 }
1330
1331 static int if_sdio_resume(struct device *dev)
1332 {
1333         struct sdio_func *func = dev_to_sdio_func(dev);
1334         struct if_sdio_card *card = sdio_get_drvdata(func);
1335         int ret;
1336
1337         dev_info(dev, "%s: resume: we're back\n", sdio_func_id(func));
1338
1339         if (card->priv->power_up_on_resume) {
1340                 if_sdio_power_on(card);
1341                 wait_event(card->pwron_waitq, card->priv->fw_ready);
1342         }
1343
1344         ret = lbs_resume(card->priv);
1345
1346         return ret;
1347 }
1348
1349 static const struct dev_pm_ops if_sdio_pm_ops = {
1350         .suspend        = if_sdio_suspend,
1351         .resume         = if_sdio_resume,
1352 };
1353
1354 static struct sdio_driver if_sdio_driver = {
1355         .name           = "libertas_sdio",
1356         .id_table       = if_sdio_ids,
1357         .probe          = if_sdio_probe,
1358         .remove         = if_sdio_remove,
1359         .drv = {
1360                 .pm = &if_sdio_pm_ops,
1361         },
1362 };
1363
1364 /*******************************************************************/
1365 /* Module functions                                                */
1366 /*******************************************************************/
1367
1368 static int __init if_sdio_init_module(void)
1369 {
1370         int ret = 0;
1371
1372         printk(KERN_INFO "libertas_sdio: Libertas SDIO driver\n");
1373         printk(KERN_INFO "libertas_sdio: Copyright Pierre Ossman\n");
1374
1375         ret = sdio_register_driver(&if_sdio_driver);
1376
1377         /* Clear the flag in case user removes the card. */
1378         user_rmmod = 0;
1379
1380         return ret;
1381 }
1382
1383 static void __exit if_sdio_exit_module(void)
1384 {
1385         /* Set the flag as user is removing this module. */
1386         user_rmmod = 1;
1387
1388         cancel_work_sync(&card_reset_work);
1389
1390         sdio_unregister_driver(&if_sdio_driver);
1391 }
1392
1393 module_init(if_sdio_init_module);
1394 module_exit(if_sdio_exit_module);
1395
1396 MODULE_DESCRIPTION("Libertas SDIO WLAN Driver");
1397 MODULE_AUTHOR("Pierre Ossman");
1398 MODULE_LICENSE("GPL");