drivers/mmc/core/sdio.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  linux/drivers/mmc/sdio.c
   4  *
   5  *  Copyright 2006-2007 Pierre Ossman
   6  */
   7
   8 #include <linux/err.h>
   9 #include <linux/pm_runtime.h>
  10 #include <linux/sysfs.h>
  11
  12 #include <linux/mmc/host.h>
  13 #include <linux/mmc/card.h>
  14 #include <linux/mmc/mmc.h>
  15 #include <linux/mmc/sdio.h>
  16 #include <linux/mmc/sdio_func.h>
  17 #include <linux/mmc/sdio_ids.h>
  18
  19 #include "core.h"
  20 #include "card.h"
  21 #include "host.h"
  22 #include "bus.h"
  23 #include "quirks.h"
  24 #include "sd.h"
  25 #include "sdio_bus.h"
  26 #include "mmc_ops.h"
  27 #include "sd_ops.h"
  28 #include "sdio_ops.h"
  29 #include "sdio_cis.h"
  30
  31 MMC_DEV_ATTR(vendor, "0x%04x\n", card->cis.vendor);
  32 MMC_DEV_ATTR(device, "0x%04x\n", card->cis.device);
  33 MMC_DEV_ATTR(revision, "%u.%u\n", card->major_rev, card->minor_rev);
  34 MMC_DEV_ATTR(ocr, "0x%08x\n", card->ocr);
  35 MMC_DEV_ATTR(rca, "0x%04x\n", card->rca);
  36
  37 #define sdio_info_attr(num)                                                                     \
  38 static ssize_t info##num##_show(struct device *dev, struct device_attribute *attr, char *buf)   \
  39 {                                                                                               \
  40         struct mmc_card *card = mmc_dev_to_card(dev);                                           \
  41                                                                                                 \
  42         if (num > card->num_info)                                                               \
  43                 return -ENODATA;                                                                \
  44         if (!card->info[num - 1][0])                                                            \
  45                 return 0;                                                                       \
  46         return sysfs_emit(buf, "%s\n", card->info[num - 1]);                                    \
  47 }                                                                                               \
  48 static DEVICE_ATTR_RO(info##num)
  49
  50 sdio_info_attr(1);
  51 sdio_info_attr(2);
  52 sdio_info_attr(3);
  53 sdio_info_attr(4);
  54
  55 static struct attribute *sdio_std_attrs[] = {
  56         &dev_attr_vendor.attr,
  57         &dev_attr_device.attr,
  58         &dev_attr_revision.attr,
  59         &dev_attr_info1.attr,
  60         &dev_attr_info2.attr,
  61         &dev_attr_info3.attr,
  62         &dev_attr_info4.attr,
  63         &dev_attr_ocr.attr,
  64         &dev_attr_rca.attr,
  65         NULL,
  66 };
  67 ATTRIBUTE_GROUPS(sdio_std);
  68
  69 static struct device_type sdio_type = {
  70         .groups = sdio_std_groups,
  71 };
  72
  73 static int sdio_read_fbr(struct sdio_func *func)
  74 {
  75         int ret;
  76         unsigned char data;
  77
  78         if (mmc_card_nonstd_func_interface(func->card)) {
  79                 func->class = SDIO_CLASS_NONE;
  80                 return 0;
  81         }
  82
  83         ret = mmc_io_rw_direct(func->card, 0, 0,
  84                 SDIO_FBR_BASE(func->num) + SDIO_FBR_STD_IF, 0, &data);
  85         if (ret)
  86                 goto out;
  87
  88         data &= 0x0f;
  89
  90         if (data == 0x0f) {
  91                 ret = mmc_io_rw_direct(func->card, 0, 0,
  92                         SDIO_FBR_BASE(func->num) + SDIO_FBR_STD_IF_EXT, 0, &data);
  93                 if (ret)
  94                         goto out;
  95         }
  96
  97         func->class = data;
  98
  99 out:
 100         return ret;
 101 }
 102
 103 static int sdio_init_func(struct mmc_card *card, unsigned int fn)
 104 {
 105         int ret;
 106         struct sdio_func *func;
 107
 108         if (WARN_ON(fn > SDIO_MAX_FUNCS))
 109                 return -EINVAL;
 110
 111         func = sdio_alloc_func(card);
 112         if (IS_ERR(func))
 113                 return PTR_ERR(func);
 114
 115         func->num = fn;
 116
 117         if (!(card->quirks & MMC_QUIRK_NONSTD_SDIO)) {
 118                 ret = sdio_read_fbr(func);
 119                 if (ret)
 120                         goto fail;
 121
 122                 ret = sdio_read_func_cis(func);
 123                 if (ret)
 124                         goto fail;
 125         } else {
 126                 func->vendor = func->card->cis.vendor;
 127                 func->device = func->card->cis.device;
 128                 func->max_blksize = func->card->cis.blksize;
 129         }
 130
 131         card->sdio_func[fn - 1] = func;
 132
 133         return 0;
 134
 135 fail:
 136         /*
 137          * It is okay to remove the function here even though we hold
 138          * the host lock as we haven't registered the device yet.
 139          */
 140         sdio_remove_func(func);
 141         return ret;
 142 }
 143
 144 static int sdio_read_cccr(struct mmc_card *card, u32 ocr)
 145 {
 146         int ret;
 147         int cccr_vsn;
 148         int uhs = ocr & R4_18V_PRESENT;
 149         unsigned char data;
 150         unsigned char speed;
 151
 152         ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_CCCR, 0, &data);
 153         if (ret)
 154                 goto out;
 155
 156         cccr_vsn = data & 0x0f;
 157
 158         if (cccr_vsn > SDIO_CCCR_REV_3_00) {
 159                 pr_err("%s: unrecognised CCCR structure version %d\n",
 160                         mmc_hostname(card->host), cccr_vsn);
 161                 return -EINVAL;
 162         }
 163
 164         card->cccr.sdio_vsn = (data & 0xf0) >> 4;
 165
 166         ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_CAPS, 0, &data);
 167         if (ret)
 168                 goto out;
 169
 170         if (data & SDIO_CCCR_CAP_SMB)
 171                 card->cccr.multi_block = 1;
 172         if (data & SDIO_CCCR_CAP_LSC)
 173                 card->cccr.low_speed = 1;
 174         if (data & SDIO_CCCR_CAP_4BLS)
 175                 card->cccr.wide_bus = 1;
 176
 177         if (cccr_vsn >= SDIO_CCCR_REV_1_10) {
 178                 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_POWER, 0, &data);
 179                 if (ret)
 180                         goto out;
 181
 182                 if (data & SDIO_POWER_SMPC)
 183                         card->cccr.high_power = 1;
 184         }
 185
 186         if (cccr_vsn >= SDIO_CCCR_REV_1_20) {
 187                 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &speed);
 188                 if (ret)
 189                         goto out;
 190
 191                 card->scr.sda_spec3 = 0;
 192                 card->sw_caps.sd3_bus_mode = 0;
 193                 card->sw_caps.sd3_drv_type = 0;
 194                 if (cccr_vsn >= SDIO_CCCR_REV_3_00 && uhs) {
 195                         card->scr.sda_spec3 = 1;
 196                         ret = mmc_io_rw_direct(card, 0, 0,
 197                                 SDIO_CCCR_UHS, 0, &data);
 198                         if (ret)
 199                                 goto out;
 200
 201                         if (mmc_host_uhs(card->host)) {
 202                                 if (data & SDIO_UHS_DDR50)
 203                                         card->sw_caps.sd3_bus_mode
 204                                                 |= SD_MODE_UHS_DDR50 | SD_MODE_UHS_SDR50
 205                                                         | SD_MODE_UHS_SDR25 | SD_MODE_UHS_SDR12;
 206
 207                                 if (data & SDIO_UHS_SDR50)
 208                                         card->sw_caps.sd3_bus_mode
 209                                                 |= SD_MODE_UHS_SDR50 | SD_MODE_UHS_SDR25
 210                                                         | SD_MODE_UHS_SDR12;
 211
 212                                 if (data & SDIO_UHS_SDR104)
 213                                         card->sw_caps.sd3_bus_mode
 214                                                 |= SD_MODE_UHS_SDR104 | SD_MODE_UHS_SDR50
 215                                                         | SD_MODE_UHS_SDR25 | SD_MODE_UHS_SDR12;
 216                         }
 217
 218                         ret = mmc_io_rw_direct(card, 0, 0,
 219                                 SDIO_CCCR_DRIVE_STRENGTH, 0, &data);
 220                         if (ret)
 221                                 goto out;
 222
 223                         if (data & SDIO_DRIVE_SDTA)
 224                                 card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_A;
 225                         if (data & SDIO_DRIVE_SDTC)
 226                                 card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_C;
 227                         if (data & SDIO_DRIVE_SDTD)
 228                                 card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_D;
 229
 230                         ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_INTERRUPT_EXT, 0, &data);
 231                         if (ret)
 232                                 goto out;
 233
 234                         if (data & SDIO_INTERRUPT_EXT_SAI) {
 235                                 data |= SDIO_INTERRUPT_EXT_EAI;
 236                                 ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_INTERRUPT_EXT,
 237                                                        data, NULL);
 238                                 if (ret)
 239                                         goto out;
 240
 241                                 card->cccr.enable_async_irq = 1;
 242                         }
 243                 }
 244
 245                 /* if no uhs mode ensure we check for high speed */
 246                 if (!card->sw_caps.sd3_bus_mode) {
 247                         if (speed & SDIO_SPEED_SHS) {
 248                                 card->cccr.high_speed = 1;
 249                                 card->sw_caps.hs_max_dtr = 50000000;
 250                         } else {
 251                                 card->cccr.high_speed = 0;
 252                                 card->sw_caps.hs_max_dtr = 25000000;
 253                         }
 254                 }
 255         }
 256
 257 out:
 258         return ret;
 259 }
 260
 261 static int sdio_enable_wide(struct mmc_card *card)
 262 {
 263         int ret;
 264         u8 ctrl;
 265
 266         if (!(card->host->caps & MMC_CAP_4_BIT_DATA))
 267                 return 0;
 268
 269         if (card->cccr.low_speed && !card->cccr.wide_bus)
 270                 return 0;
 271
 272         ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl);
 273         if (ret)
 274                 return ret;
 275
 276         if ((ctrl & SDIO_BUS_WIDTH_MASK) == SDIO_BUS_WIDTH_RESERVED)
 277                 pr_warn("%s: SDIO_CCCR_IF is invalid: 0x%02x\n",
 278                         mmc_hostname(card->host), ctrl);
 279
 280         /* set as 4-bit bus width */
 281         ctrl &= ~SDIO_BUS_WIDTH_MASK;
 282         ctrl |= SDIO_BUS_WIDTH_4BIT;
 283
 284         ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL);
 285         if (ret)
 286                 return ret;
 287
 288         return 1;
 289 }
 290
 291 /*
 292  * If desired, disconnect the pull-up resistor on CD/DAT[3] (pin 1)
 293  * of the card. This may be required on certain setups of boards,
 294  * controllers and embedded sdio device which do not need the card's
 295  * pull-up. As a result, card detection is disabled and power is saved.
 296  */
 297 static int sdio_disable_cd(struct mmc_card *card)
 298 {
 299         int ret;
 300         u8 ctrl;
 301
 302         if (!mmc_card_disable_cd(card))
 303                 return 0;
 304
 305         ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl);
 306         if (ret)
 307                 return ret;
 308
 309         ctrl |= SDIO_BUS_CD_DISABLE;
 310
 311         return mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL);
 312 }
 313
 314 /*
 315  * Devices that remain active during a system suspend are
 316  * put back into 1-bit mode.
 317  */
 318 static int sdio_disable_wide(struct mmc_card *card)
 319 {
 320         int ret;
 321         u8 ctrl;
 322
 323         if (!(card->host->caps & MMC_CAP_4_BIT_DATA))
 324                 return 0;
 325
 326         if (card->cccr.low_speed && !card->cccr.wide_bus)
 327                 return 0;
 328
 329         ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl);
 330         if (ret)
 331                 return ret;
 332
 333         if (!(ctrl & SDIO_BUS_WIDTH_4BIT))
 334                 return 0;
 335
 336         ctrl &= ~SDIO_BUS_WIDTH_4BIT;
 337         ctrl |= SDIO_BUS_ASYNC_INT;
 338
 339         ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL);
 340         if (ret)
 341                 return ret;
 342
 343         mmc_set_bus_width(card->host, MMC_BUS_WIDTH_1);
 344
 345         return 0;
 346 }
 347
 348 static int sdio_disable_4bit_bus(struct mmc_card *card)
 349 {
 350         int err;
 351
 352         if (mmc_card_sdio(card))
 353                 goto out;
 354
 355         if (!(card->host->caps & MMC_CAP_4_BIT_DATA))
 356                 return 0;
 357
 358         if (!(card->scr.bus_widths & SD_SCR_BUS_WIDTH_4))
 359                 return 0;
 360
 361         err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_1);
 362         if (err)
 363                 return err;
 364
 365 out:
 366         return sdio_disable_wide(card);
 367 }
 368
 369
 370 static int sdio_enable_4bit_bus(struct mmc_card *card)
 371 {
 372         int err;
 373
 374         err = sdio_enable_wide(card);
 375         if (err <= 0)
 376                 return err;
 377         if (mmc_card_sdio(card))
 378                 goto out;
 379
 380         if (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4) {
 381                 err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
 382                 if (err) {
 383                         sdio_disable_wide(card);
 384                         return err;
 385                 }
 386         }
 387 out:
 388         mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
 389
 390         return 0;
 391 }
 392
 393
 394 /*
 395  * Test if the card supports high-speed mode and, if so, switch to it.
 396  */
 397 static int mmc_sdio_switch_hs(struct mmc_card *card, int enable)
 398 {
 399         int ret;
 400         u8 speed;
 401
 402         if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED))
 403                 return 0;
 404
 405         if (!card->cccr.high_speed)
 406                 return 0;
 407
 408         ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &speed);
 409         if (ret)
 410                 return ret;
 411
 412         if (enable)
 413                 speed |= SDIO_SPEED_EHS;
 414         else
 415                 speed &= ~SDIO_SPEED_EHS;
 416
 417         ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_SPEED, speed, NULL);
 418         if (ret)
 419                 return ret;
 420
 421         return 1;
 422 }
 423
 424 /*
 425  * Enable SDIO/combo card's high-speed mode. Return 0/1 if [not]supported.
 426  */
 427 static int sdio_enable_hs(struct mmc_card *card)
 428 {
 429         int ret;
 430
 431         ret = mmc_sdio_switch_hs(card, true);
 432         if (ret <= 0 || mmc_card_sdio(card))
 433                 return ret;
 434
 435         ret = mmc_sd_switch_hs(card);
 436         if (ret <= 0)
 437                 mmc_sdio_switch_hs(card, false);
 438
 439         return ret;
 440 }
 441
 442 static unsigned mmc_sdio_get_max_clock(struct mmc_card *card)
 443 {
 444         unsigned max_dtr;
 445
 446         if (mmc_card_hs(card)) {
 447                 /*
 448                  * The SDIO specification doesn't mention how
 449                  * the CIS transfer speed register relates to
 450                  * high-speed, but it seems that 50 MHz is
 451                  * mandatory.
 452                  */
 453                 max_dtr = 50000000;
 454         } else {
 455                 max_dtr = card->cis.max_dtr;
 456         }
 457
 458         if (mmc_card_sd_combo(card))
 459                 max_dtr = min(max_dtr, mmc_sd_get_max_clock(card));
 460
 461         return max_dtr;
 462 }
 463
 464 static unsigned char host_drive_to_sdio_drive(int host_strength)
 465 {
 466         switch (host_strength) {
 467         case MMC_SET_DRIVER_TYPE_A:
 468                 return SDIO_DTSx_SET_TYPE_A;
 469         case MMC_SET_DRIVER_TYPE_B:
 470                 return SDIO_DTSx_SET_TYPE_B;
 471         case MMC_SET_DRIVER_TYPE_C:
 472                 return SDIO_DTSx_SET_TYPE_C;
 473         case MMC_SET_DRIVER_TYPE_D:
 474                 return SDIO_DTSx_SET_TYPE_D;
 475         default:
 476                 return SDIO_DTSx_SET_TYPE_B;
 477         }
 478 }
 479
 480 static void sdio_select_driver_type(struct mmc_card *card)
 481 {
 482         int card_drv_type, drive_strength, drv_type;
 483         unsigned char card_strength;
 484         int err;
 485
 486         card->drive_strength = 0;
 487
 488         card_drv_type = card->sw_caps.sd3_drv_type | SD_DRIVER_TYPE_B;
 489
 490         drive_strength = mmc_select_drive_strength(card,
 491                                                    card->sw_caps.uhs_max_dtr,
 492                                                    card_drv_type, &drv_type);
 493
 494         if (drive_strength) {
 495                 /* if error just use default for drive strength B */
 496                 err = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_DRIVE_STRENGTH, 0,
 497                                        &card_strength);
 498                 if (err)
 499                         return;
 500
 501                 card_strength &= ~(SDIO_DRIVE_DTSx_MASK<<SDIO_DRIVE_DTSx_SHIFT);
 502                 card_strength |= host_drive_to_sdio_drive(drive_strength);
 503
 504                 /* if error default to drive strength B */
 505                 err = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_DRIVE_STRENGTH,
 506                                        card_strength, NULL);
 507                 if (err)
 508                         return;
 509                 card->drive_strength = drive_strength;
 510         }
 511
 512         if (drv_type)
 513                 mmc_set_driver_type(card->host, drv_type);
 514 }
 515
 516
 517 static int sdio_set_bus_speed_mode(struct mmc_card *card)
 518 {
 519         unsigned int bus_speed, timing;
 520         int err;
 521         unsigned char speed;
 522         unsigned int max_rate;
 523
 524         /*
 525          * If the host doesn't support any of the UHS-I modes, fallback on
 526          * default speed.
 527          */
 528         if (!mmc_host_uhs(card->host))
 529                 return 0;
 530
 531         bus_speed = SDIO_SPEED_SDR12;
 532         timing = MMC_TIMING_UHS_SDR12;
 533         if ((card->host->caps & MMC_CAP_UHS_SDR104) &&
 534             (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104)) {
 535                         bus_speed = SDIO_SPEED_SDR104;
 536                         timing = MMC_TIMING_UHS_SDR104;
 537                         card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR;
 538                         card->sd_bus_speed = UHS_SDR104_BUS_SPEED;
 539         } else if ((card->host->caps & MMC_CAP_UHS_DDR50) &&
 540                    (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50)) {
 541                         bus_speed = SDIO_SPEED_DDR50;
 542                         timing = MMC_TIMING_UHS_DDR50;
 543                         card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR;
 544                         card->sd_bus_speed = UHS_DDR50_BUS_SPEED;
 545         } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 546                     MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode &
 547                     SD_MODE_UHS_SDR50)) {
 548                         bus_speed = SDIO_SPEED_SDR50;
 549                         timing = MMC_TIMING_UHS_SDR50;
 550                         card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR;
 551                         card->sd_bus_speed = UHS_SDR50_BUS_SPEED;
 552         } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 553                     MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25)) &&
 554                    (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25)) {
 555                         bus_speed = SDIO_SPEED_SDR25;
 556                         timing = MMC_TIMING_UHS_SDR25;
 557                         card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR;
 558                         card->sd_bus_speed = UHS_SDR25_BUS_SPEED;
 559         } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 560                     MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25 |
 561                     MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode &
 562                     SD_MODE_UHS_SDR12)) {
 563                         bus_speed = SDIO_SPEED_SDR12;
 564                         timing = MMC_TIMING_UHS_SDR12;
 565                         card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR;
 566                         card->sd_bus_speed = UHS_SDR12_BUS_SPEED;
 567         }
 568
 569         err = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &speed);
 570         if (err)
 571                 return err;
 572
 573         speed &= ~SDIO_SPEED_BSS_MASK;
 574         speed |= bus_speed;
 575         err = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_SPEED, speed, NULL);
 576         if (err)
 577                 return err;
 578
 579         max_rate = min_not_zero(card->quirk_max_rate,
 580                                 card->sw_caps.uhs_max_dtr);
 581
 582         mmc_set_timing(card->host, timing);
 583         mmc_set_clock(card->host, max_rate);
 584
 585         return 0;
 586 }
 587
 588 /*
 589  * UHS-I specific initialization procedure
 590  */
 591 static int mmc_sdio_init_uhs_card(struct mmc_card *card)
 592 {
 593         int err;
 594
 595         if (!card->scr.sda_spec3)
 596                 return 0;
 597
 598         /* Switch to wider bus */
 599         err = sdio_enable_4bit_bus(card);
 600         if (err)
 601                 goto out;
 602
 603         /* Set the driver strength for the card */
 604         sdio_select_driver_type(card);
 605
 606         /* Set bus speed mode of the card */
 607         err = sdio_set_bus_speed_mode(card);
 608         if (err)
 609                 goto out;
 610
 611         /*
 612          * SPI mode doesn't define CMD19 and tuning is only valid for SDR50 and
 613          * SDR104 mode SD-cards. Note that tuning is mandatory for SDR104.
 614          */
 615         if (!mmc_host_is_spi(card->host) &&
 616             ((card->host->ios.timing == MMC_TIMING_UHS_SDR50) ||
 617               (card->host->ios.timing == MMC_TIMING_UHS_SDR104)))
 618                 err = mmc_execute_tuning(card);
 619 out:
 620         return err;
 621 }
 622
 623 static int mmc_sdio_pre_init(struct mmc_host *host, u32 ocr,
 624                              struct mmc_card *card)
 625 {
 626         if (card)
 627                 mmc_remove_card(card);
 628
 629         /*
 630          * Reset the card by performing the same steps that are taken by
 631          * mmc_rescan_try_freq() and mmc_attach_sdio() during a "normal" probe.
 632          *
 633          * sdio_reset() is technically not needed. Having just powered up the
 634          * hardware, it should already be in reset state. However, some
 635          * platforms (such as SD8686 on OLPC) do not instantly cut power,
 636          * meaning that a reset is required when restoring power soon after
 637          * powering off. It is harmless in other cases.
 638          *
 639          * The CMD5 reset (mmc_send_io_op_cond()), according to the SDIO spec,
 640          * is not necessary for non-removable cards. However, it is required
 641          * for OLPC SD8686 (which expects a [CMD5,5,3,7] init sequence), and
 642          * harmless in other situations.
 643          *
 644          */
 645
 646         sdio_reset(host);
 647         mmc_go_idle(host);
 648         mmc_send_if_cond(host, ocr);
 649         return mmc_send_io_op_cond(host, 0, NULL);
 650 }
 651
 652 /*
 653  * Handle the detection and initialisation of a card.
 654  *
 655  * In the case of a resume, "oldcard" will contain the card
 656  * we're trying to reinitialise.
 657  */
 658 static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
 659                               struct mmc_card *oldcard)
 660 {
 661         struct mmc_card *card;
 662         int err;
 663         int retries = 10;
 664         u32 rocr = 0;
 665         u32 ocr_card = ocr;
 666
 667         WARN_ON(!host->claimed);
 668
 669         /* to query card if 1.8V signalling is supported */
 670         if (mmc_host_uhs(host))
 671                 ocr |= R4_18V_PRESENT;
 672
 673 try_again:
 674         if (!retries) {
 675                 pr_warn("%s: Skipping voltage switch\n", mmc_hostname(host));
 676                 ocr &= ~R4_18V_PRESENT;
 677         }
 678
 679         /*
 680          * Inform the card of the voltage
 681          */
 682         err = mmc_send_io_op_cond(host, ocr, &rocr);
 683         if (err)
 684                 return err;
 685
 686         /*
 687          * For SPI, enable CRC as appropriate.
 688          */
 689         if (mmc_host_is_spi(host)) {
 690                 err = mmc_spi_set_crc(host, use_spi_crc);
 691                 if (err)
 692                         return err;
 693         }
 694
 695         /*
 696          * Allocate card structure.
 697          */
 698         card = mmc_alloc_card(host, &sdio_type);
 699         if (IS_ERR(card))
 700                 return PTR_ERR(card);
 701
 702         if ((rocr & R4_MEMORY_PRESENT) &&
 703             mmc_sd_get_cid(host, ocr & rocr, card->raw_cid, NULL) == 0) {
 704                 card->type = MMC_TYPE_SD_COMBO;
 705
 706                 if (oldcard && (!mmc_card_sd_combo(oldcard) ||
 707                     memcmp(card->raw_cid, oldcard->raw_cid, sizeof(card->raw_cid)) != 0)) {
 708                         err = -ENOENT;
 709                         goto mismatch;
 710                 }
 711         } else {
 712                 card->type = MMC_TYPE_SDIO;
 713
 714                 if (oldcard && !mmc_card_sdio(oldcard)) {
 715                         err = -ENOENT;
 716                         goto mismatch;
 717                 }
 718         }
 719
 720         /*
 721          * Call the optional HC's init_card function to handle quirks.
 722          */
 723         if (host->ops->init_card)
 724                 host->ops->init_card(host, card);
 725         mmc_fixup_device(card, sdio_card_init_methods);
 726
 727         card->ocr = ocr_card;
 728
 729         /*
 730          * If the host and card support UHS-I mode request the card
 731          * to switch to 1.8V signaling level.  No 1.8v signalling if
 732          * UHS mode is not enabled to maintain compatibility and some
 733          * systems that claim 1.8v signalling in fact do not support
 734          * it. Per SDIO spec v3, section 3.1.2, if the voltage is already
 735          * 1.8v, the card sets S18A to 0 in the R4 response. So it will
 736          * fails to check rocr & R4_18V_PRESENT,  but we still need to
 737          * try to init uhs card. sdio_read_cccr will take over this task
 738          * to make sure which speed mode should work.
 739          */
 740         if (rocr & ocr & R4_18V_PRESENT) {
 741                 err = mmc_set_uhs_voltage(host, ocr_card);
 742                 if (err == -EAGAIN) {
 743                         mmc_sdio_pre_init(host, ocr_card, card);
 744                         retries--;
 745                         goto try_again;
 746                 } else if (err) {
 747                         ocr &= ~R4_18V_PRESENT;
 748                 }
 749         }
 750
 751         /*
 752          * For native busses:  set card RCA and quit open drain mode.
 753          */
 754         if (!mmc_host_is_spi(host)) {
 755                 err = mmc_send_relative_addr(host, &card->rca);
 756                 if (err)
 757                         goto remove;
 758
 759                 /*
 760                  * Update oldcard with the new RCA received from the SDIO
 761                  * device -- we're doing this so that it's updated in the
 762                  * "card" struct when oldcard overwrites that later.
 763                  */
 764                 if (oldcard)
 765                         oldcard->rca = card->rca;
 766         }
 767
 768         /*
 769          * Read CSD, before selecting the card
 770          */
 771         if (!oldcard && mmc_card_sd_combo(card)) {
 772                 err = mmc_sd_get_csd(card);
 773                 if (err)
 774                         goto remove;
 775
 776                 mmc_decode_cid(card);
 777         }
 778
 779         /*
 780          * Select card, as all following commands rely on that.
 781          */
 782         if (!mmc_host_is_spi(host)) {
 783                 err = mmc_select_card(card);
 784                 if (err)
 785                         goto remove;
 786         }
 787
 788         if (card->quirks & MMC_QUIRK_NONSTD_SDIO) {
 789                 /*
 790                  * This is non-standard SDIO device, meaning it doesn't
 791                  * have any CIA (Common I/O area) registers present.
 792                  * It's host's responsibility to fill cccr and cis
 793                  * structures in init_card().
 794                  */
 795                 mmc_set_clock(host, card->cis.max_dtr);
 796
 797                 if (card->cccr.high_speed) {
 798                         mmc_set_timing(card->host, MMC_TIMING_SD_HS);
 799                 }
 800
 801                 if (oldcard)
 802                         mmc_remove_card(card);
 803                 else
 804                         host->card = card;
 805
 806                 return 0;
 807         }
 808
 809         /*
 810          * Read the common registers. Note that we should try to
 811          * validate whether UHS would work or not.
 812          */
 813         err = sdio_read_cccr(card, ocr);
 814         if (err) {
 815                 mmc_sdio_pre_init(host, ocr_card, card);
 816                 if (ocr & R4_18V_PRESENT) {
 817                         /* Retry init sequence, but without R4_18V_PRESENT. */
 818                         retries = 0;
 819                         goto try_again;
 820                 }
 821                 return err;
 822         }
 823
 824         /*
 825          * Read the common CIS tuples.
 826          */
 827         err = sdio_read_common_cis(card);
 828         if (err)
 829                 goto remove;
 830
 831         if (oldcard) {
 832                 if (card->cis.vendor == oldcard->cis.vendor &&
 833                     card->cis.device == oldcard->cis.device) {
 834                         mmc_remove_card(card);
 835                         card = oldcard;
 836                 } else {
 837                         err = -ENOENT;
 838                         goto mismatch;
 839                 }
 840         }
 841
 842         mmc_fixup_device(card, sdio_fixup_methods);
 843
 844         if (mmc_card_sd_combo(card)) {
 845                 err = mmc_sd_setup_card(host, card, oldcard != NULL);
 846                 /* handle as SDIO-only card if memory init failed */
 847                 if (err) {
 848                         mmc_go_idle(host);
 849                         if (mmc_host_is_spi(host))
 850                                 /* should not fail, as it worked previously */
 851                                 mmc_spi_set_crc(host, use_spi_crc);
 852                         card->type = MMC_TYPE_SDIO;
 853                 } else
 854                         card->dev.type = &sd_type;
 855         }
 856
 857         /*
 858          * If needed, disconnect card detection pull-up resistor.
 859          */
 860         err = sdio_disable_cd(card);
 861         if (err)
 862                 goto remove;
 863
 864         /* Initialization sequence for UHS-I cards */
 865         /* Only if card supports 1.8v and UHS signaling */
 866         if ((ocr & R4_18V_PRESENT) && card->sw_caps.sd3_bus_mode) {
 867                 err = mmc_sdio_init_uhs_card(card);
 868                 if (err)
 869                         goto remove;
 870         } else {
 871                 /*
 872                  * Switch to high-speed (if supported).
 873                  */
 874                 err = sdio_enable_hs(card);
 875                 if (err > 0)
 876                         mmc_set_timing(card->host, MMC_TIMING_SD_HS);
 877                 else if (err)
 878                         goto remove;
 879
 880                 /*
 881                  * Change to the card's maximum speed.
 882                  */
 883                 mmc_set_clock(host, mmc_sdio_get_max_clock(card));
 884
 885                 /*
 886                  * Switch to wider bus (if supported).
 887                  */
 888                 err = sdio_enable_4bit_bus(card);
 889                 if (err)
 890                         goto remove;
 891         }
 892
 893         if (host->caps2 & MMC_CAP2_AVOID_3_3V &&
 894             host->ios.signal_voltage == MMC_SIGNAL_VOLTAGE_330) {
 895                 pr_err("%s: Host failed to negotiate down from 3.3V\n",
 896                         mmc_hostname(host));
 897                 err = -EINVAL;
 898                 goto remove;
 899         }
 900
 901         host->card = card;
 902         return 0;
 903
 904 mismatch:
 905         pr_debug("%s: Perhaps the card was replaced\n", mmc_hostname(host));
 906 remove:
 907         if (oldcard != card)
 908                 mmc_remove_card(card);
 909         return err;
 910 }
 911
 912 static int mmc_sdio_reinit_card(struct mmc_host *host)
 913 {
 914         int ret;
 915
 916         ret = mmc_sdio_pre_init(host, host->card->ocr, NULL);
 917         if (ret)
 918                 return ret;
 919
 920         return mmc_sdio_init_card(host, host->card->ocr, host->card);
 921 }
 922
 923 /*
 924  * Host is being removed. Free up the current card.
 925  */
 926 static void mmc_sdio_remove(struct mmc_host *host)
 927 {
 928         int i;
 929
 930         for (i = 0;i < host->card->sdio_funcs;i++) {
 931                 if (host->card->sdio_func[i]) {
 932                         sdio_remove_func(host->card->sdio_func[i]);
 933                         host->card->sdio_func[i] = NULL;
 934                 }
 935         }
 936
 937         mmc_remove_card(host->card);
 938         host->card = NULL;
 939 }
 940
 941 /*
 942  * Card detection - card is alive.
 943  */
 944 static int mmc_sdio_alive(struct mmc_host *host)
 945 {
 946         return mmc_select_card(host->card);
 947 }
 948
 949 /*
 950  * Card detection callback from host.
 951  */
 952 static void mmc_sdio_detect(struct mmc_host *host)
 953 {
 954         int err;
 955
 956         /* Make sure card is powered before detecting it */
 957         if (host->caps & MMC_CAP_POWER_OFF_CARD) {
 958                 err = pm_runtime_resume_and_get(&host->card->dev);
 959                 if (err < 0)
 960                         goto out;
 961         }
 962
 963         mmc_claim_host(host);
 964
 965         /*
 966          * Just check if our card has been removed.
 967          */
 968         err = _mmc_detect_card_removed(host);
 969
 970         mmc_release_host(host);
 971
 972         /*
 973          * Tell PM core it's OK to power off the card now.
 974          *
 975          * The _sync variant is used in order to ensure that the card
 976          * is left powered off in case an error occurred, and the card
 977          * is going to be removed.
 978          *
 979          * Since there is no specific reason to believe a new user
 980          * is about to show up at this point, the _sync variant is
 981          * desirable anyway.
 982          */
 983         if (host->caps & MMC_CAP_POWER_OFF_CARD)
 984                 pm_runtime_put_sync(&host->card->dev);
 985
 986 out:
 987         if (err) {
 988                 mmc_sdio_remove(host);
 989
 990                 mmc_claim_host(host);
 991                 mmc_detach_bus(host);
 992                 mmc_power_off(host);
 993                 mmc_release_host(host);
 994         }
 995 }
 996
 997 /*
 998  * SDIO pre_suspend.  We need to suspend all functions separately.
 999  * Therefore all registered functions must have drivers with suspend
1000  * and resume methods.  Failing that we simply remove the whole card.
1001  */
1002 static int mmc_sdio_pre_suspend(struct mmc_host *host)
1003 {
1004         int i;
1005
1006         for (i = 0; i < host->card->sdio_funcs; i++) {
1007                 struct sdio_func *func = host->card->sdio_func[i];
1008                 if (func && sdio_func_present(func) && func->dev.driver) {
1009                         const struct dev_pm_ops *pmops = func->dev.driver->pm;
1010                         if (!pmops || !pmops->suspend || !pmops->resume)
1011                                 /* force removal of entire card in that case */
1012                                 goto remove;
1013                 }
1014         }
1015
1016         return 0;
1017
1018 remove:
1019         if (!mmc_card_is_removable(host)) {
1020                 dev_warn(mmc_dev(host),
1021                          "missing suspend/resume ops for non-removable SDIO card\n");
1022                 /* Don't remove a non-removable card - we can't re-detect it. */
1023                 return 0;
1024         }
1025
1026         /* Remove the SDIO card and let it be re-detected later on. */
1027         mmc_sdio_remove(host);
1028         mmc_claim_host(host);
1029         mmc_detach_bus(host);
1030         mmc_power_off(host);
1031         mmc_release_host(host);
1032         host->pm_flags = 0;
1033
1034         return 0;
1035 }
1036
1037 /*
1038  * SDIO suspend.  Suspend all functions separately.
1039  */
1040 static int mmc_sdio_suspend(struct mmc_host *host)
1041 {
1042         WARN_ON(host->sdio_irqs && !mmc_card_keep_power(host));
1043
1044         /* Prevent processing of SDIO IRQs in suspended state. */
1045         mmc_card_set_suspended(host->card);
1046         cancel_work_sync(&host->sdio_irq_work);
1047
1048         mmc_claim_host(host);
1049
1050         if (mmc_card_keep_power(host) && mmc_card_wake_sdio_irq(host))
1051                 sdio_disable_4bit_bus(host->card);
1052
1053         if (!mmc_card_keep_power(host)) {
1054                 mmc_power_off(host);
1055         } else if (host->retune_period) {
1056                 mmc_retune_timer_stop(host);
1057                 mmc_retune_needed(host);
1058         }
1059
1060         mmc_release_host(host);
1061
1062         return 0;
1063 }
1064
1065 static int mmc_sdio_resume(struct mmc_host *host)
1066 {
1067         int err = 0;
1068
1069         /* Basic card reinitialization. */
1070         mmc_claim_host(host);
1071
1072         /*
1073          * Restore power and reinitialize the card when needed. Note that a
1074          * removable card is checked from a detect work later on in the resume
1075          * process.
1076          */
1077         if (!mmc_card_keep_power(host)) {
1078                 mmc_power_up(host, host->card->ocr);
1079                 /*
1080                  * Tell runtime PM core we just powered up the card,
1081                  * since it still believes the card is powered off.
1082                  * Note that currently runtime PM is only enabled
1083                  * for SDIO cards that are MMC_CAP_POWER_OFF_CARD
1084                  */
1085                 if (host->caps & MMC_CAP_POWER_OFF_CARD) {
1086                         pm_runtime_disable(&host->card->dev);
1087                         pm_runtime_set_active(&host->card->dev);
1088                         pm_runtime_enable(&host->card->dev);
1089                 }
1090                 err = mmc_sdio_reinit_card(host);
1091         } else if (mmc_card_wake_sdio_irq(host)) {
1092                 /*
1093                  * We may have switched to 1-bit mode during suspend,
1094                  * need to hold retuning, because tuning only supprt
1095                  * 4-bit mode or 8 bit mode.
1096                  */
1097                 mmc_retune_hold_now(host);
1098                 err = sdio_enable_4bit_bus(host->card);
1099                 mmc_retune_release(host);
1100         }
1101
1102         if (err)
1103                 goto out;
1104
1105         /* Allow SDIO IRQs to be processed again. */
1106         mmc_card_clr_suspended(host->card);
1107
1108         if (host->sdio_irqs) {
1109                 if (!(host->caps2 & MMC_CAP2_SDIO_IRQ_NOTHREAD))
1110                         wake_up_process(host->sdio_irq_thread);
1111                 else if (host->caps & MMC_CAP_SDIO_IRQ)
1112                         schedule_work(&host->sdio_irq_work);
1113         }
1114
1115 out:
1116         mmc_release_host(host);
1117
1118         host->pm_flags &= ~MMC_PM_KEEP_POWER;
1119         return err;
1120 }
1121
1122 static int mmc_sdio_runtime_suspend(struct mmc_host *host)
1123 {
1124         /* No references to the card, cut the power to it. */
1125         mmc_claim_host(host);
1126         mmc_power_off(host);
1127         mmc_release_host(host);
1128
1129         return 0;
1130 }
1131
1132 static int mmc_sdio_runtime_resume(struct mmc_host *host)
1133 {
1134         int ret;
1135
1136         /* Restore power and re-initialize. */
1137         mmc_claim_host(host);
1138         mmc_power_up(host, host->card->ocr);
1139         ret = mmc_sdio_reinit_card(host);
1140         mmc_release_host(host);
1141
1142         return ret;
1143 }
1144
1145 /*
1146  * SDIO HW reset
1147  *
1148  * Returns 0 if the HW reset was executed synchronously, returns 1 if the HW
1149  * reset was asynchronously scheduled, else a negative error code.
1150  */
1151 static int mmc_sdio_hw_reset(struct mmc_host *host)
1152 {
1153         struct mmc_card *card = host->card;
1154
1155         /*
1156          * In case the card is shared among multiple func drivers, reset the
1157          * card through a rescan work. In this way it will be removed and
1158          * re-detected, thus all func drivers becomes informed about it.
1159          */
1160         if (atomic_read(&card->sdio_funcs_probed) > 1) {
1161                 if (mmc_card_removed(card))
1162                         return 1;
1163                 host->rescan_entered = 0;
1164                 mmc_card_set_removed(card);
1165                 _mmc_detect_change(host, 0, false);
1166                 return 1;
1167         }
1168
1169         /*
1170          * A single func driver has been probed, then let's skip the heavy
1171          * hotplug dance above and execute the reset immediately.
1172          */
1173         mmc_power_cycle(host, card->ocr);
1174         return mmc_sdio_reinit_card(host);
1175 }
1176
1177 static int mmc_sdio_sw_reset(struct mmc_host *host)
1178 {
1179         mmc_set_clock(host, host->f_init);
1180         sdio_reset(host);
1181         mmc_go_idle(host);
1182
1183         mmc_set_initial_state(host);
1184         mmc_set_initial_signal_voltage(host);
1185
1186         return mmc_sdio_reinit_card(host);
1187 }
1188
1189 static const struct mmc_bus_ops mmc_sdio_ops = {
1190         .remove = mmc_sdio_remove,
1191         .detect = mmc_sdio_detect,
1192         .pre_suspend = mmc_sdio_pre_suspend,
1193         .suspend = mmc_sdio_suspend,
1194         .resume = mmc_sdio_resume,
1195         .runtime_suspend = mmc_sdio_runtime_suspend,
1196         .runtime_resume = mmc_sdio_runtime_resume,
1197         .alive = mmc_sdio_alive,
1198         .hw_reset = mmc_sdio_hw_reset,
1199         .sw_reset = mmc_sdio_sw_reset,
1200 };
1201
1202
1203 /*
1204  * Starting point for SDIO card init.
1205  */
1206 int mmc_attach_sdio(struct mmc_host *host)
1207 {
1208         int err, i, funcs;
1209         u32 ocr, rocr;
1210         struct mmc_card *card;
1211
1212         WARN_ON(!host->claimed);
1213
1214         err = mmc_send_io_op_cond(host, 0, &ocr);
1215         if (err)
1216                 return err;
1217
1218         mmc_attach_bus(host, &mmc_sdio_ops);
1219         if (host->ocr_avail_sdio)
1220                 host->ocr_avail = host->ocr_avail_sdio;
1221
1222
1223         rocr = mmc_select_voltage(host, ocr);
1224
1225         /*
1226          * Can we support the voltage(s) of the card(s)?
1227          */
1228         if (!rocr) {
1229                 err = -EINVAL;
1230                 goto err;
1231         }
1232
1233         /*
1234          * Detect and init the card.
1235          */
1236         err = mmc_sdio_init_card(host, rocr, NULL);
1237         if (err)
1238                 goto err;
1239
1240         card = host->card;
1241
1242         /*
1243          * Enable runtime PM only if supported by host+card+board
1244          */
1245         if (host->caps & MMC_CAP_POWER_OFF_CARD) {
1246                 /*
1247                  * Do not allow runtime suspend until after SDIO function
1248                  * devices are added.
1249                  */
1250                 pm_runtime_get_noresume(&card->dev);
1251
1252                 /*
1253                  * Let runtime PM core know our card is active
1254                  */
1255                 err = pm_runtime_set_active(&card->dev);
1256                 if (err)
1257                         goto remove;
1258
1259                 /*
1260                  * Enable runtime PM for this card
1261                  */
1262                 pm_runtime_enable(&card->dev);
1263         }
1264
1265         /*
1266          * The number of functions on the card is encoded inside
1267          * the ocr.
1268          */
1269         funcs = (ocr & 0x70000000) >> 28;
1270         card->sdio_funcs = 0;
1271
1272         /*
1273          * Initialize (but don't add) all present functions.
1274          */
1275         for (i = 0; i < funcs; i++, card->sdio_funcs++) {
1276                 err = sdio_init_func(host->card, i + 1);
1277                 if (err)
1278                         goto remove;
1279
1280                 /*
1281                  * Enable Runtime PM for this func (if supported)
1282                  */
1283                 if (host->caps & MMC_CAP_POWER_OFF_CARD)
1284                         pm_runtime_enable(&card->sdio_func[i]->dev);
1285         }
1286
1287         /*
1288          * First add the card to the driver model...
1289          */
1290         mmc_release_host(host);
1291         err = mmc_add_card(host->card);
1292         if (err)
1293                 goto remove_added;
1294
1295         /*
1296          * ...then the SDIO functions.
1297          */
1298         for (i = 0;i < funcs;i++) {
1299                 err = sdio_add_func(host->card->sdio_func[i]);
1300                 if (err)
1301                         goto remove_added;
1302         }
1303
1304         if (host->caps & MMC_CAP_POWER_OFF_CARD)
1305                 pm_runtime_put(&card->dev);
1306
1307         mmc_claim_host(host);
1308         return 0;
1309
1310
1311 remove:
1312         mmc_release_host(host);
1313 remove_added:
1314         /*
1315          * The devices are being deleted so it is not necessary to disable
1316          * runtime PM. Similarly we also don't pm_runtime_put() the SDIO card
1317          * because it needs to be active to remove any function devices that
1318          * were probed, and after that it gets deleted.
1319          */
1320         mmc_sdio_remove(host);
1321         mmc_claim_host(host);
1322 err:
1323         mmc_detach_bus(host);
1324
1325         pr_err("%s: error %d whilst initialising SDIO card\n",
1326                 mmc_hostname(host), err);
1327
1328         return err;
1329 }
1330