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
  31MMC_DEV_ATTR(vendor, "0x%04x\n", card->cis.vendor);
  32MMC_DEV_ATTR(device, "0x%04x\n", card->cis.device);
  33MMC_DEV_ATTR(revision, "%u.%u\n", card->major_rev, card->minor_rev);
  34MMC_DEV_ATTR(ocr, "0x%08x\n", card->ocr);
  35MMC_DEV_ATTR(rca, "0x%04x\n", card->rca);
  36
  37#define sdio_info_attr(num)									\
  38static 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}												\
  48static DEVICE_ATTR_RO(info##num)
  49
  50sdio_info_attr(1);
  51sdio_info_attr(2);
  52sdio_info_attr(3);
  53sdio_info_attr(4);
  54
  55static 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};
  67ATTRIBUTE_GROUPS(sdio_std);
  68
  69static struct device_type sdio_type = {
  70	.groups = sdio_std_groups,
  71};
  72
  73static 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
  99out:
 100	return ret;
 101}
 102
 103static 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
 135fail:
 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
 144static 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
 257out:
 258	return ret;
 259}
 260
 261static 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 */
 297static 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 */
 318static 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
 348static 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
 365out:
 366	return sdio_disable_wide(card);
 367}
 368
 369
 370static 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	}
 387out:
 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 */
 397static 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 */
 427static 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
 442static 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
 464static 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
 480static 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
 517static 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 */
 591static 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);
 619out:
 620	return err;
 621}
 622
 623static 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 */
 658static 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
 673try_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
 904mismatch:
 905	pr_debug("%s: Perhaps the card was replaced\n", mmc_hostname(host));
 906remove:
 907	if (oldcard != card)
 908		mmc_remove_card(card);
 909	return err;
 910}
 911
 912static 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 */
 926static 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 */
 944static 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 */
 952static 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
 986out:
 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 */
1002static 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
1018remove:
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 */
1040static 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
1065static 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
1115out:
1116	mmc_release_host(host);
1117
1118	host->pm_flags &= ~MMC_PM_KEEP_POWER;
1119	return err;
1120}
1121
1122static 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
1132static 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 */
1151static 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
1177static 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
1189static 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 */
1206int 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
1311remove:
1312	mmc_release_host(host);
1313remove_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);
1322err:
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