12874c5fdSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later
25c4e6f13SPierre Ossman /*
35c4e6f13SPierre Ossman * linux/drivers/mmc/sdio.c
45c4e6f13SPierre Ossman *
55c4e6f13SPierre Ossman * Copyright 2006-2007 Pierre Ossman
65c4e6f13SPierre Ossman */
75c4e6f13SPierre Ossman
85c4e6f13SPierre Ossman #include <linux/err.h>
981968561SOhad Ben-Cohen #include <linux/pm_runtime.h>
10f5d8a5feSSergey Shtylyov #include <linux/sysfs.h>
115c4e6f13SPierre Ossman
125c4e6f13SPierre Ossman #include <linux/mmc/host.h>
135c4e6f13SPierre Ossman #include <linux/mmc/card.h>
14a4924c71SGirish K S #include <linux/mmc/mmc.h>
1535c66c19SPierre Ossman #include <linux/mmc/sdio.h>
16e29a7d73SPierre Ossman #include <linux/mmc/sdio_func.h>
17eab40687SOhad Ben-Cohen #include <linux/mmc/sdio_ids.h>
185c4e6f13SPierre Ossman
195c4e6f13SPierre Ossman #include "core.h"
204facdde1SUlf Hansson #include "card.h"
215857b29bSUlf Hansson #include "host.h"
225c4e6f13SPierre Ossman #include "bus.h"
2328fc64afSShawn Lin #include "quirks.h"
2471578a1eSMichal Miroslaw #include "sd.h"
25e29a7d73SPierre Ossman #include "sdio_bus.h"
265c4e6f13SPierre Ossman #include "mmc_ops.h"
275c4e6f13SPierre Ossman #include "sd_ops.h"
285c4e6f13SPierre Ossman #include "sdio_ops.h"
29b7261261SNicolas Pitre #include "sdio_cis.h"
305c4e6f13SPierre Ossman
31254e1754SPali Rohár MMC_DEV_ATTR(vendor, "0x%04x\n", card->cis.vendor);
32254e1754SPali Rohár MMC_DEV_ATTR(device, "0x%04x\n", card->cis.device);
33b698f6abSPali Rohár MMC_DEV_ATTR(revision, "%u.%u\n", card->major_rev, card->minor_rev);
34254e1754SPali Rohár MMC_DEV_ATTR(ocr, "0x%08x\n", card->ocr);
35254e1754SPali Rohár MMC_DEV_ATTR(rca, "0x%04x\n", card->rca);
36254e1754SPali Rohár
37b698f6abSPali Rohár #define sdio_info_attr(num) \
38b698f6abSPali Rohár static ssize_t info##num##_show(struct device *dev, struct device_attribute *attr, char *buf) \
39b698f6abSPali Rohár { \
40b698f6abSPali Rohár struct mmc_card *card = mmc_dev_to_card(dev); \
41b698f6abSPali Rohár \
42b698f6abSPali Rohár if (num > card->num_info) \
43b698f6abSPali Rohár return -ENODATA; \
44b698f6abSPali Rohár if (!card->info[num - 1][0]) \
45b698f6abSPali Rohár return 0; \
46f5d8a5feSSergey Shtylyov return sysfs_emit(buf, "%s\n", card->info[num - 1]); \
47b698f6abSPali Rohár } \
48b698f6abSPali Rohár static DEVICE_ATTR_RO(info##num)
49b698f6abSPali Rohár
50b698f6abSPali Rohár sdio_info_attr(1);
51b698f6abSPali Rohár sdio_info_attr(2);
52b698f6abSPali Rohár sdio_info_attr(3);
53b698f6abSPali Rohár sdio_info_attr(4);
54b698f6abSPali Rohár
55254e1754SPali Rohár static struct attribute *sdio_std_attrs[] = {
56254e1754SPali Rohár &dev_attr_vendor.attr,
57254e1754SPali Rohár &dev_attr_device.attr,
58b698f6abSPali Rohár &dev_attr_revision.attr,
59b698f6abSPali Rohár &dev_attr_info1.attr,
60b698f6abSPali Rohár &dev_attr_info2.attr,
61b698f6abSPali Rohár &dev_attr_info3.attr,
62b698f6abSPali Rohár &dev_attr_info4.attr,
63254e1754SPali Rohár &dev_attr_ocr.attr,
64254e1754SPali Rohár &dev_attr_rca.attr,
65254e1754SPali Rohár NULL,
66254e1754SPali Rohár };
67254e1754SPali Rohár ATTRIBUTE_GROUPS(sdio_std);
68254e1754SPali Rohár
69*68f5630aSRicardo B. Marliere static const struct device_type sdio_type = {
70254e1754SPali Rohár .groups = sdio_std_groups,
71254e1754SPali Rohár };
72254e1754SPali Rohár
sdio_read_fbr(struct sdio_func * func)730597007fSPierre Ossman static int sdio_read_fbr(struct sdio_func *func)
740597007fSPierre Ossman {
750597007fSPierre Ossman int ret;
760597007fSPierre Ossman unsigned char data;
770597007fSPierre Ossman
78eab40687SOhad Ben-Cohen if (mmc_card_nonstd_func_interface(func->card)) {
79eab40687SOhad Ben-Cohen func->class = SDIO_CLASS_NONE;
80eab40687SOhad Ben-Cohen return 0;
81eab40687SOhad Ben-Cohen }
82eab40687SOhad Ben-Cohen
830597007fSPierre Ossman ret = mmc_io_rw_direct(func->card, 0, 0,
847616ee95SDavid Vrabel SDIO_FBR_BASE(func->num) + SDIO_FBR_STD_IF, 0, &data);
850597007fSPierre Ossman if (ret)
860597007fSPierre Ossman goto out;
870597007fSPierre Ossman
880597007fSPierre Ossman data &= 0x0f;
890597007fSPierre Ossman
900597007fSPierre Ossman if (data == 0x0f) {
910597007fSPierre Ossman ret = mmc_io_rw_direct(func->card, 0, 0,
927616ee95SDavid Vrabel SDIO_FBR_BASE(func->num) + SDIO_FBR_STD_IF_EXT, 0, &data);
930597007fSPierre Ossman if (ret)
940597007fSPierre Ossman goto out;
950597007fSPierre Ossman }
960597007fSPierre Ossman
970597007fSPierre Ossman func->class = data;
980597007fSPierre Ossman
990597007fSPierre Ossman out:
1000597007fSPierre Ossman return ret;
1010597007fSPierre Ossman }
1020597007fSPierre Ossman
sdio_init_func(struct mmc_card * card,unsigned int fn)103e29a7d73SPierre Ossman static int sdio_init_func(struct mmc_card *card, unsigned int fn)
104e29a7d73SPierre Ossman {
1050597007fSPierre Ossman int ret;
106e29a7d73SPierre Ossman struct sdio_func *func;
107e29a7d73SPierre Ossman
1085df0e823SShawn Lin if (WARN_ON(fn > SDIO_MAX_FUNCS))
1095df0e823SShawn Lin return -EINVAL;
110e29a7d73SPierre Ossman
111e29a7d73SPierre Ossman func = sdio_alloc_func(card);
112e29a7d73SPierre Ossman if (IS_ERR(func))
113e29a7d73SPierre Ossman return PTR_ERR(func);
114e29a7d73SPierre Ossman
115e29a7d73SPierre Ossman func->num = fn;
116e29a7d73SPierre Ossman
1176f51be3dSGrazvydas Ignotas if (!(card->quirks & MMC_QUIRK_NONSTD_SDIO)) {
1180597007fSPierre Ossman ret = sdio_read_fbr(func);
1190597007fSPierre Ossman if (ret)
1200597007fSPierre Ossman goto fail;
1210597007fSPierre Ossman
1221a632f8cSPierre Ossman ret = sdio_read_func_cis(func);
123b7261261SNicolas Pitre if (ret)
124b7261261SNicolas Pitre goto fail;
1256f51be3dSGrazvydas Ignotas } else {
1266f51be3dSGrazvydas Ignotas func->vendor = func->card->cis.vendor;
1276f51be3dSGrazvydas Ignotas func->device = func->card->cis.device;
1286f51be3dSGrazvydas Ignotas func->max_blksize = func->card->cis.blksize;
1296f51be3dSGrazvydas Ignotas }
130b7261261SNicolas Pitre
131e29a7d73SPierre Ossman card->sdio_func[fn - 1] = func;
132e29a7d73SPierre Ossman
133e29a7d73SPierre Ossman return 0;
1340597007fSPierre Ossman
1350597007fSPierre Ossman fail:
1360597007fSPierre Ossman /*
1370597007fSPierre Ossman * It is okay to remove the function here even though we hold
1380597007fSPierre Ossman * the host lock as we haven't registered the device yet.
1390597007fSPierre Ossman */
1400597007fSPierre Ossman sdio_remove_func(func);
1410597007fSPierre Ossman return ret;
142e29a7d73SPierre Ossman }
143e29a7d73SPierre Ossman
sdio_read_cccr(struct mmc_card * card,u32 ocr)1442d0d68f5SPhilip Rakity static int sdio_read_cccr(struct mmc_card *card, u32 ocr)
14535c66c19SPierre Ossman {
14635c66c19SPierre Ossman int ret;
14735c66c19SPierre Ossman int cccr_vsn;
1482d0d68f5SPhilip Rakity int uhs = ocr & R4_18V_PRESENT;
14935c66c19SPierre Ossman unsigned char data;
150a303c531SPhilip Rakity unsigned char speed;
15135c66c19SPierre Ossman
15235c66c19SPierre Ossman ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_CCCR, 0, &data);
15335c66c19SPierre Ossman if (ret)
15435c66c19SPierre Ossman goto out;
15535c66c19SPierre Ossman
15635c66c19SPierre Ossman cccr_vsn = data & 0x0f;
15735c66c19SPierre Ossman
158b4625dabSBing Zhao if (cccr_vsn > SDIO_CCCR_REV_3_00) {
159a3c76eb9SGirish K S pr_err("%s: unrecognised CCCR structure version %d\n",
16035c66c19SPierre Ossman mmc_hostname(card->host), cccr_vsn);
16135c66c19SPierre Ossman return -EINVAL;
16235c66c19SPierre Ossman }
16335c66c19SPierre Ossman
16435c66c19SPierre Ossman card->cccr.sdio_vsn = (data & 0xf0) >> 4;
16535c66c19SPierre Ossman
16635c66c19SPierre Ossman ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_CAPS, 0, &data);
16735c66c19SPierre Ossman if (ret)
16835c66c19SPierre Ossman goto out;
16935c66c19SPierre Ossman
17035c66c19SPierre Ossman if (data & SDIO_CCCR_CAP_SMB)
17135c66c19SPierre Ossman card->cccr.multi_block = 1;
17235c66c19SPierre Ossman if (data & SDIO_CCCR_CAP_LSC)
17335c66c19SPierre Ossman card->cccr.low_speed = 1;
17435c66c19SPierre Ossman if (data & SDIO_CCCR_CAP_4BLS)
17535c66c19SPierre Ossman card->cccr.wide_bus = 1;
17635c66c19SPierre Ossman
17735c66c19SPierre Ossman if (cccr_vsn >= SDIO_CCCR_REV_1_10) {
17835c66c19SPierre Ossman ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_POWER, 0, &data);
17935c66c19SPierre Ossman if (ret)
18035c66c19SPierre Ossman goto out;
18135c66c19SPierre Ossman
18235c66c19SPierre Ossman if (data & SDIO_POWER_SMPC)
18335c66c19SPierre Ossman card->cccr.high_power = 1;
18435c66c19SPierre Ossman }
18535c66c19SPierre Ossman
18635c66c19SPierre Ossman if (cccr_vsn >= SDIO_CCCR_REV_1_20) {
187a303c531SPhilip Rakity ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &speed);
18835c66c19SPierre Ossman if (ret)
18935c66c19SPierre Ossman goto out;
19035c66c19SPierre Ossman
191a303c531SPhilip Rakity card->scr.sda_spec3 = 0;
192a303c531SPhilip Rakity card->sw_caps.sd3_bus_mode = 0;
193a303c531SPhilip Rakity card->sw_caps.sd3_drv_type = 0;
1942d0d68f5SPhilip Rakity if (cccr_vsn >= SDIO_CCCR_REV_3_00 && uhs) {
195a303c531SPhilip Rakity card->scr.sda_spec3 = 1;
196a303c531SPhilip Rakity ret = mmc_io_rw_direct(card, 0, 0,
197a303c531SPhilip Rakity SDIO_CCCR_UHS, 0, &data);
198a303c531SPhilip Rakity if (ret)
199a303c531SPhilip Rakity goto out;
200a303c531SPhilip Rakity
20141875e38SSujit Reddy Thumma if (mmc_host_uhs(card->host)) {
202a303c531SPhilip Rakity if (data & SDIO_UHS_DDR50)
203a303c531SPhilip Rakity card->sw_caps.sd3_bus_mode
204e8151555SHaibo Chen |= SD_MODE_UHS_DDR50 | SD_MODE_UHS_SDR50
205e8151555SHaibo Chen | SD_MODE_UHS_SDR25 | SD_MODE_UHS_SDR12;
206a303c531SPhilip Rakity
207a303c531SPhilip Rakity if (data & SDIO_UHS_SDR50)
208a303c531SPhilip Rakity card->sw_caps.sd3_bus_mode
209e8151555SHaibo Chen |= SD_MODE_UHS_SDR50 | SD_MODE_UHS_SDR25
210e8151555SHaibo Chen | SD_MODE_UHS_SDR12;
211a303c531SPhilip Rakity
212a303c531SPhilip Rakity if (data & SDIO_UHS_SDR104)
213a303c531SPhilip Rakity card->sw_caps.sd3_bus_mode
214e8151555SHaibo Chen |= SD_MODE_UHS_SDR104 | SD_MODE_UHS_SDR50
215e8151555SHaibo Chen | SD_MODE_UHS_SDR25 | SD_MODE_UHS_SDR12;
216a303c531SPhilip Rakity }
217a303c531SPhilip Rakity
218a303c531SPhilip Rakity ret = mmc_io_rw_direct(card, 0, 0,
219a303c531SPhilip Rakity SDIO_CCCR_DRIVE_STRENGTH, 0, &data);
220a303c531SPhilip Rakity if (ret)
221a303c531SPhilip Rakity goto out;
222a303c531SPhilip Rakity
223a303c531SPhilip Rakity if (data & SDIO_DRIVE_SDTA)
224a303c531SPhilip Rakity card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_A;
225a303c531SPhilip Rakity if (data & SDIO_DRIVE_SDTC)
226a303c531SPhilip Rakity card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_C;
227a303c531SPhilip Rakity if (data & SDIO_DRIVE_SDTD)
228a303c531SPhilip Rakity card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_D;
229019e442bSAxe Yang
230019e442bSAxe Yang ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_INTERRUPT_EXT, 0, &data);
231019e442bSAxe Yang if (ret)
232019e442bSAxe Yang goto out;
233019e442bSAxe Yang
234019e442bSAxe Yang if (data & SDIO_INTERRUPT_EXT_SAI) {
235019e442bSAxe Yang data |= SDIO_INTERRUPT_EXT_EAI;
236019e442bSAxe Yang ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_INTERRUPT_EXT,
237019e442bSAxe Yang data, NULL);
238019e442bSAxe Yang if (ret)
239019e442bSAxe Yang goto out;
240019e442bSAxe Yang
241019e442bSAxe Yang card->cccr.enable_async_irq = 1;
242019e442bSAxe Yang }
243a303c531SPhilip Rakity }
244a303c531SPhilip Rakity
245a303c531SPhilip Rakity /* if no uhs mode ensure we check for high speed */
246a303c531SPhilip Rakity if (!card->sw_caps.sd3_bus_mode) {
247a303c531SPhilip Rakity if (speed & SDIO_SPEED_SHS) {
24835c66c19SPierre Ossman card->cccr.high_speed = 1;
249a303c531SPhilip Rakity card->sw_caps.hs_max_dtr = 50000000;
250a303c531SPhilip Rakity } else {
251a303c531SPhilip Rakity card->cccr.high_speed = 0;
252a303c531SPhilip Rakity card->sw_caps.hs_max_dtr = 25000000;
253a303c531SPhilip Rakity }
254a303c531SPhilip Rakity }
25535c66c19SPierre Ossman }
25635c66c19SPierre Ossman
25735c66c19SPierre Ossman out:
25835c66c19SPierre Ossman return ret;
25935c66c19SPierre Ossman }
26035c66c19SPierre Ossman
sdio_enable_wide(struct mmc_card * card)2614ff6471cSPierre Ossman static int sdio_enable_wide(struct mmc_card *card)
2624ff6471cSPierre Ossman {
2634ff6471cSPierre Ossman int ret;
2644ff6471cSPierre Ossman u8 ctrl;
2654ff6471cSPierre Ossman
2664ff6471cSPierre Ossman if (!(card->host->caps & MMC_CAP_4_BIT_DATA))
2674ff6471cSPierre Ossman return 0;
2684ff6471cSPierre Ossman
2694ff6471cSPierre Ossman if (card->cccr.low_speed && !card->cccr.wide_bus)
2704ff6471cSPierre Ossman return 0;
2714ff6471cSPierre Ossman
2724ff6471cSPierre Ossman ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl);
2734ff6471cSPierre Ossman if (ret)
2744ff6471cSPierre Ossman return ret;
2754ff6471cSPierre Ossman
2762a0fe914SYong Ding if ((ctrl & SDIO_BUS_WIDTH_MASK) == SDIO_BUS_WIDTH_RESERVED)
2776606110dSJoe Perches pr_warn("%s: SDIO_CCCR_IF is invalid: 0x%02x\n",
2782a0fe914SYong Ding mmc_hostname(card->host), ctrl);
2792a0fe914SYong Ding
2802a0fe914SYong Ding /* set as 4-bit bus width */
2812a0fe914SYong Ding ctrl &= ~SDIO_BUS_WIDTH_MASK;
2824ff6471cSPierre Ossman ctrl |= SDIO_BUS_WIDTH_4BIT;
2834ff6471cSPierre Ossman
2844ff6471cSPierre Ossman ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL);
2854ff6471cSPierre Ossman if (ret)
2864ff6471cSPierre Ossman return ret;
2874ff6471cSPierre Ossman
2887310ece8SMichal Miroslaw return 1;
2894ff6471cSPierre Ossman }
2904ff6471cSPierre Ossman
2915c4e6f13SPierre Ossman /*
292006ebd5dSOhad Ben-Cohen * If desired, disconnect the pull-up resistor on CD/DAT[3] (pin 1)
293006ebd5dSOhad Ben-Cohen * of the card. This may be required on certain setups of boards,
294006ebd5dSOhad Ben-Cohen * controllers and embedded sdio device which do not need the card's
295006ebd5dSOhad Ben-Cohen * pull-up. As a result, card detection is disabled and power is saved.
296006ebd5dSOhad Ben-Cohen */
sdio_disable_cd(struct mmc_card * card)297006ebd5dSOhad Ben-Cohen static int sdio_disable_cd(struct mmc_card *card)
298006ebd5dSOhad Ben-Cohen {
299006ebd5dSOhad Ben-Cohen int ret;
300006ebd5dSOhad Ben-Cohen u8 ctrl;
301006ebd5dSOhad Ben-Cohen
3022059a02dSOhad Ben-Cohen if (!mmc_card_disable_cd(card))
303006ebd5dSOhad Ben-Cohen return 0;
304006ebd5dSOhad Ben-Cohen
305006ebd5dSOhad Ben-Cohen ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl);
306006ebd5dSOhad Ben-Cohen if (ret)
307006ebd5dSOhad Ben-Cohen return ret;
308006ebd5dSOhad Ben-Cohen
309006ebd5dSOhad Ben-Cohen ctrl |= SDIO_BUS_CD_DISABLE;
310006ebd5dSOhad Ben-Cohen
311006ebd5dSOhad Ben-Cohen return mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL);
312006ebd5dSOhad Ben-Cohen }
313006ebd5dSOhad Ben-Cohen
314006ebd5dSOhad Ben-Cohen /*
3156b5eda36SDaniel Drake * Devices that remain active during a system suspend are
3166b5eda36SDaniel Drake * put back into 1-bit mode.
3176b5eda36SDaniel Drake */
sdio_disable_wide(struct mmc_card * card)3186b5eda36SDaniel Drake static int sdio_disable_wide(struct mmc_card *card)
3196b5eda36SDaniel Drake {
3206b5eda36SDaniel Drake int ret;
3216b5eda36SDaniel Drake u8 ctrl;
3226b5eda36SDaniel Drake
3236b5eda36SDaniel Drake if (!(card->host->caps & MMC_CAP_4_BIT_DATA))
3246b5eda36SDaniel Drake return 0;
3256b5eda36SDaniel Drake
3266b5eda36SDaniel Drake if (card->cccr.low_speed && !card->cccr.wide_bus)
3276b5eda36SDaniel Drake return 0;
3286b5eda36SDaniel Drake
3296b5eda36SDaniel Drake ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl);
3306b5eda36SDaniel Drake if (ret)
3316b5eda36SDaniel Drake return ret;
3326b5eda36SDaniel Drake
3336b5eda36SDaniel Drake if (!(ctrl & SDIO_BUS_WIDTH_4BIT))
3346b5eda36SDaniel Drake return 0;
3356b5eda36SDaniel Drake
3366b5eda36SDaniel Drake ctrl &= ~SDIO_BUS_WIDTH_4BIT;
3376b5eda36SDaniel Drake ctrl |= SDIO_BUS_ASYNC_INT;
3386b5eda36SDaniel Drake
3396b5eda36SDaniel Drake ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL);
3406b5eda36SDaniel Drake if (ret)
3416b5eda36SDaniel Drake return ret;
3426b5eda36SDaniel Drake
3436b5eda36SDaniel Drake mmc_set_bus_width(card->host, MMC_BUS_WIDTH_1);
3446b5eda36SDaniel Drake
3456b5eda36SDaniel Drake return 0;
3466b5eda36SDaniel Drake }
3476b5eda36SDaniel Drake
sdio_disable_4bit_bus(struct mmc_card * card)34840e6c479SYue Hu static int sdio_disable_4bit_bus(struct mmc_card *card)
34940e6c479SYue Hu {
35040e6c479SYue Hu int err;
35140e6c479SYue Hu
3523beb0ab5SSeunghui Lee if (mmc_card_sdio(card))
35340e6c479SYue Hu goto out;
35440e6c479SYue Hu
35540e6c479SYue Hu if (!(card->host->caps & MMC_CAP_4_BIT_DATA))
35640e6c479SYue Hu return 0;
35740e6c479SYue Hu
35840e6c479SYue Hu if (!(card->scr.bus_widths & SD_SCR_BUS_WIDTH_4))
35940e6c479SYue Hu return 0;
36040e6c479SYue Hu
36140e6c479SYue Hu err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_1);
36240e6c479SYue Hu if (err)
36340e6c479SYue Hu return err;
36440e6c479SYue Hu
36540e6c479SYue Hu out:
36640e6c479SYue Hu return sdio_disable_wide(card);
36740e6c479SYue Hu }
36840e6c479SYue Hu
3697310ece8SMichal Miroslaw
sdio_enable_4bit_bus(struct mmc_card * card)3707310ece8SMichal Miroslaw static int sdio_enable_4bit_bus(struct mmc_card *card)
3717310ece8SMichal Miroslaw {
3727310ece8SMichal Miroslaw int err;
3737310ece8SMichal Miroslaw
3747310ece8SMichal Miroslaw err = sdio_enable_wide(card);
3757310ece8SMichal Miroslaw if (err <= 0)
3767310ece8SMichal Miroslaw return err;
3773beb0ab5SSeunghui Lee if (mmc_card_sdio(card))
378ec97863cSYue Hu goto out;
379ec97863cSYue Hu
380ec97863cSYue Hu if (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4) {
381ec97863cSYue Hu err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
382ec97863cSYue Hu if (err) {
383ec97863cSYue Hu sdio_disable_wide(card);
384ec97863cSYue Hu return err;
385ec97863cSYue Hu }
386ec97863cSYue Hu }
387ec97863cSYue Hu out:
388ec97863cSYue Hu mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
389ec97863cSYue Hu
390ec97863cSYue Hu return 0;
3917310ece8SMichal Miroslaw }
3927310ece8SMichal Miroslaw
3937310ece8SMichal Miroslaw
3946b5eda36SDaniel Drake /*
395d16f5770SPierre Ossman * Test if the card supports high-speed mode and, if so, switch to it.
396d16f5770SPierre Ossman */
mmc_sdio_switch_hs(struct mmc_card * card,int enable)3977310ece8SMichal Miroslaw static int mmc_sdio_switch_hs(struct mmc_card *card, int enable)
398d16f5770SPierre Ossman {
399d16f5770SPierre Ossman int ret;
400d16f5770SPierre Ossman u8 speed;
401d16f5770SPierre Ossman
402d16f5770SPierre Ossman if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED))
403d16f5770SPierre Ossman return 0;
404d16f5770SPierre Ossman
405d16f5770SPierre Ossman if (!card->cccr.high_speed)
406d16f5770SPierre Ossman return 0;
407d16f5770SPierre Ossman
408d16f5770SPierre Ossman ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &speed);
409d16f5770SPierre Ossman if (ret)
410d16f5770SPierre Ossman return ret;
411d16f5770SPierre Ossman
4127310ece8SMichal Miroslaw if (enable)
413d16f5770SPierre Ossman speed |= SDIO_SPEED_EHS;
4147310ece8SMichal Miroslaw else
4157310ece8SMichal Miroslaw speed &= ~SDIO_SPEED_EHS;
416d16f5770SPierre Ossman
417d16f5770SPierre Ossman ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_SPEED, speed, NULL);
418d16f5770SPierre Ossman if (ret)
419d16f5770SPierre Ossman return ret;
420d16f5770SPierre Ossman
42171578a1eSMichal Miroslaw return 1;
42271578a1eSMichal Miroslaw }
423d16f5770SPierre Ossman
4247310ece8SMichal Miroslaw /*
4257310ece8SMichal Miroslaw * Enable SDIO/combo card's high-speed mode. Return 0/1 if [not]supported.
4267310ece8SMichal Miroslaw */
sdio_enable_hs(struct mmc_card * card)4277310ece8SMichal Miroslaw static int sdio_enable_hs(struct mmc_card *card)
4287310ece8SMichal Miroslaw {
4297310ece8SMichal Miroslaw int ret;
4307310ece8SMichal Miroslaw
4317310ece8SMichal Miroslaw ret = mmc_sdio_switch_hs(card, true);
4323beb0ab5SSeunghui Lee if (ret <= 0 || mmc_card_sdio(card))
4337310ece8SMichal Miroslaw return ret;
4347310ece8SMichal Miroslaw
4357310ece8SMichal Miroslaw ret = mmc_sd_switch_hs(card);
4367310ece8SMichal Miroslaw if (ret <= 0)
4377310ece8SMichal Miroslaw mmc_sdio_switch_hs(card, false);
4387310ece8SMichal Miroslaw
4397310ece8SMichal Miroslaw return ret;
4407310ece8SMichal Miroslaw }
4417310ece8SMichal Miroslaw
mmc_sdio_get_max_clock(struct mmc_card * card)44271578a1eSMichal Miroslaw static unsigned mmc_sdio_get_max_clock(struct mmc_card *card)
44371578a1eSMichal Miroslaw {
44471578a1eSMichal Miroslaw unsigned max_dtr;
44571578a1eSMichal Miroslaw
446cdc99179SSeungwon Jeon if (mmc_card_hs(card)) {
44771578a1eSMichal Miroslaw /*
44871578a1eSMichal Miroslaw * The SDIO specification doesn't mention how
44971578a1eSMichal Miroslaw * the CIS transfer speed register relates to
45071578a1eSMichal Miroslaw * high-speed, but it seems that 50 MHz is
45171578a1eSMichal Miroslaw * mandatory.
45271578a1eSMichal Miroslaw */
45371578a1eSMichal Miroslaw max_dtr = 50000000;
45471578a1eSMichal Miroslaw } else {
45571578a1eSMichal Miroslaw max_dtr = card->cis.max_dtr;
45671578a1eSMichal Miroslaw }
45771578a1eSMichal Miroslaw
4583beb0ab5SSeunghui Lee if (mmc_card_sd_combo(card))
4597310ece8SMichal Miroslaw max_dtr = min(max_dtr, mmc_sd_get_max_clock(card));
4607310ece8SMichal Miroslaw
46171578a1eSMichal Miroslaw return max_dtr;
462d16f5770SPierre Ossman }
463d16f5770SPierre Ossman
host_drive_to_sdio_drive(int host_strength)464a303c531SPhilip Rakity static unsigned char host_drive_to_sdio_drive(int host_strength)
465a303c531SPhilip Rakity {
466a303c531SPhilip Rakity switch (host_strength) {
467a303c531SPhilip Rakity case MMC_SET_DRIVER_TYPE_A:
468a303c531SPhilip Rakity return SDIO_DTSx_SET_TYPE_A;
469a303c531SPhilip Rakity case MMC_SET_DRIVER_TYPE_B:
470a303c531SPhilip Rakity return SDIO_DTSx_SET_TYPE_B;
471a303c531SPhilip Rakity case MMC_SET_DRIVER_TYPE_C:
472a303c531SPhilip Rakity return SDIO_DTSx_SET_TYPE_C;
473a303c531SPhilip Rakity case MMC_SET_DRIVER_TYPE_D:
474a303c531SPhilip Rakity return SDIO_DTSx_SET_TYPE_D;
475a303c531SPhilip Rakity default:
476a303c531SPhilip Rakity return SDIO_DTSx_SET_TYPE_B;
477a303c531SPhilip Rakity }
478a303c531SPhilip Rakity }
479a303c531SPhilip Rakity
sdio_select_driver_type(struct mmc_card * card)480a303c531SPhilip Rakity static void sdio_select_driver_type(struct mmc_card *card)
481a303c531SPhilip Rakity {
482fa021cefSAdrian Hunter int card_drv_type, drive_strength, drv_type;
483a303c531SPhilip Rakity unsigned char card_strength;
484a303c531SPhilip Rakity int err;
485a303c531SPhilip Rakity
4863853a042SAdrian Hunter card->drive_strength = 0;
4873853a042SAdrian Hunter
488fa021cefSAdrian Hunter card_drv_type = card->sw_caps.sd3_drv_type | SD_DRIVER_TYPE_B;
489a303c531SPhilip Rakity
490e23350b3SAdrian Hunter drive_strength = mmc_select_drive_strength(card,
491a303c531SPhilip Rakity card->sw_caps.uhs_max_dtr,
492e23350b3SAdrian Hunter card_drv_type, &drv_type);
493a303c531SPhilip Rakity
494b4f30a17SAdrian Hunter if (drive_strength) {
495a303c531SPhilip Rakity /* if error just use default for drive strength B */
496a303c531SPhilip Rakity err = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_DRIVE_STRENGTH, 0,
497a303c531SPhilip Rakity &card_strength);
498a303c531SPhilip Rakity if (err)
499a303c531SPhilip Rakity return;
500a303c531SPhilip Rakity
501a303c531SPhilip Rakity card_strength &= ~(SDIO_DRIVE_DTSx_MASK<<SDIO_DRIVE_DTSx_SHIFT);
502a303c531SPhilip Rakity card_strength |= host_drive_to_sdio_drive(drive_strength);
503a303c531SPhilip Rakity
504b4f30a17SAdrian Hunter /* if error default to drive strength B */
505a303c531SPhilip Rakity err = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_DRIVE_STRENGTH,
506a303c531SPhilip Rakity card_strength, NULL);
507b4f30a17SAdrian Hunter if (err)
508b4f30a17SAdrian Hunter return;
5093853a042SAdrian Hunter card->drive_strength = drive_strength;
510b4f30a17SAdrian Hunter }
511a303c531SPhilip Rakity
512b4f30a17SAdrian Hunter if (drv_type)
513b4f30a17SAdrian Hunter mmc_set_driver_type(card->host, drv_type);
514a303c531SPhilip Rakity }
515a303c531SPhilip Rakity
516a303c531SPhilip Rakity
sdio_set_bus_speed_mode(struct mmc_card * card)517a303c531SPhilip Rakity static int sdio_set_bus_speed_mode(struct mmc_card *card)
518a303c531SPhilip Rakity {
519a303c531SPhilip Rakity unsigned int bus_speed, timing;
520a303c531SPhilip Rakity int err;
521a303c531SPhilip Rakity unsigned char speed;
522ebc5a1bfSharish_kandiga@mentor.com unsigned int max_rate;
523a303c531SPhilip Rakity
524a303c531SPhilip Rakity /*
525a303c531SPhilip Rakity * If the host doesn't support any of the UHS-I modes, fallback on
526a303c531SPhilip Rakity * default speed.
527a303c531SPhilip Rakity */
52841875e38SSujit Reddy Thumma if (!mmc_host_uhs(card->host))
529a303c531SPhilip Rakity return 0;
530a303c531SPhilip Rakity
531a303c531SPhilip Rakity bus_speed = SDIO_SPEED_SDR12;
532a303c531SPhilip Rakity timing = MMC_TIMING_UHS_SDR12;
533a303c531SPhilip Rakity if ((card->host->caps & MMC_CAP_UHS_SDR104) &&
534a303c531SPhilip Rakity (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104)) {
535a303c531SPhilip Rakity bus_speed = SDIO_SPEED_SDR104;
536a303c531SPhilip Rakity timing = MMC_TIMING_UHS_SDR104;
537a303c531SPhilip Rakity card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR;
53877e2ff08SSubhash Jadavani card->sd_bus_speed = UHS_SDR104_BUS_SPEED;
539a303c531SPhilip Rakity } else if ((card->host->caps & MMC_CAP_UHS_DDR50) &&
540a303c531SPhilip Rakity (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50)) {
541a303c531SPhilip Rakity bus_speed = SDIO_SPEED_DDR50;
542a303c531SPhilip Rakity timing = MMC_TIMING_UHS_DDR50;
543a303c531SPhilip Rakity card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR;
54477e2ff08SSubhash Jadavani card->sd_bus_speed = UHS_DDR50_BUS_SPEED;
545a303c531SPhilip Rakity } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
546a303c531SPhilip Rakity MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode &
547a303c531SPhilip Rakity SD_MODE_UHS_SDR50)) {
548a303c531SPhilip Rakity bus_speed = SDIO_SPEED_SDR50;
549a303c531SPhilip Rakity timing = MMC_TIMING_UHS_SDR50;
550a303c531SPhilip Rakity card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR;
55177e2ff08SSubhash Jadavani card->sd_bus_speed = UHS_SDR50_BUS_SPEED;
552a303c531SPhilip Rakity } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
553a303c531SPhilip Rakity MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25)) &&
554a303c531SPhilip Rakity (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25)) {
555a303c531SPhilip Rakity bus_speed = SDIO_SPEED_SDR25;
556a303c531SPhilip Rakity timing = MMC_TIMING_UHS_SDR25;
557a303c531SPhilip Rakity card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR;
55877e2ff08SSubhash Jadavani card->sd_bus_speed = UHS_SDR25_BUS_SPEED;
559a303c531SPhilip Rakity } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
560a303c531SPhilip Rakity MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25 |
561a303c531SPhilip Rakity MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode &
562a303c531SPhilip Rakity SD_MODE_UHS_SDR12)) {
563a303c531SPhilip Rakity bus_speed = SDIO_SPEED_SDR12;
564a303c531SPhilip Rakity timing = MMC_TIMING_UHS_SDR12;
565a303c531SPhilip Rakity card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR;
56677e2ff08SSubhash Jadavani card->sd_bus_speed = UHS_SDR12_BUS_SPEED;
567a303c531SPhilip Rakity }
568a303c531SPhilip Rakity
569a303c531SPhilip Rakity err = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &speed);
570a303c531SPhilip Rakity if (err)
571a303c531SPhilip Rakity return err;
572a303c531SPhilip Rakity
573a303c531SPhilip Rakity speed &= ~SDIO_SPEED_BSS_MASK;
574a303c531SPhilip Rakity speed |= bus_speed;
575a303c531SPhilip Rakity err = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_SPEED, speed, NULL);
576a303c531SPhilip Rakity if (err)
577a303c531SPhilip Rakity return err;
578a303c531SPhilip Rakity
579ebc5a1bfSharish_kandiga@mentor.com max_rate = min_not_zero(card->quirk_max_rate,
580ebc5a1bfSharish_kandiga@mentor.com card->sw_caps.uhs_max_dtr);
581ebc5a1bfSharish_kandiga@mentor.com
582a303c531SPhilip Rakity mmc_set_timing(card->host, timing);
583ebc5a1bfSharish_kandiga@mentor.com mmc_set_clock(card->host, max_rate);
584a303c531SPhilip Rakity
585a303c531SPhilip Rakity return 0;
586a303c531SPhilip Rakity }
587a303c531SPhilip Rakity
588a303c531SPhilip Rakity /*
589a303c531SPhilip Rakity * UHS-I specific initialization procedure
590a303c531SPhilip Rakity */
mmc_sdio_init_uhs_card(struct mmc_card * card)591a303c531SPhilip Rakity static int mmc_sdio_init_uhs_card(struct mmc_card *card)
592a303c531SPhilip Rakity {
593a303c531SPhilip Rakity int err;
594a303c531SPhilip Rakity
595a303c531SPhilip Rakity if (!card->scr.sda_spec3)
596a303c531SPhilip Rakity return 0;
597a303c531SPhilip Rakity
5981e178270SShawn Lin /* Switch to wider bus */
599a303c531SPhilip Rakity err = sdio_enable_4bit_bus(card);
6001e178270SShawn Lin if (err)
6011e178270SShawn Lin goto out;
602a303c531SPhilip Rakity
603a303c531SPhilip Rakity /* Set the driver strength for the card */
604a303c531SPhilip Rakity sdio_select_driver_type(card);
605a303c531SPhilip Rakity
606a303c531SPhilip Rakity /* Set bus speed mode of the card */
607a303c531SPhilip Rakity err = sdio_set_bus_speed_mode(card);
608a303c531SPhilip Rakity if (err)
609a303c531SPhilip Rakity goto out;
610a303c531SPhilip Rakity
611810e08eeSFredrik Soderstedt /*
612810e08eeSFredrik Soderstedt * SPI mode doesn't define CMD19 and tuning is only valid for SDR50 and
613810e08eeSFredrik Soderstedt * SDR104 mode SD-cards. Note that tuning is mandatory for SDR104.
614810e08eeSFredrik Soderstedt */
61563e415c6SAdrian Hunter if (!mmc_host_is_spi(card->host) &&
616e10c3219SCarlo Caione ((card->host->ios.timing == MMC_TIMING_UHS_SDR50) ||
617e10c3219SCarlo Caione (card->host->ios.timing == MMC_TIMING_UHS_SDR104)))
61863e415c6SAdrian Hunter err = mmc_execute_tuning(card);
619a303c531SPhilip Rakity out:
620a303c531SPhilip Rakity return err;
621a303c531SPhilip Rakity }
622a303c531SPhilip Rakity
mmc_sdio_pre_init(struct mmc_host * host,u32 ocr,struct mmc_card * card)6231dc5a615SUlf Hansson static int mmc_sdio_pre_init(struct mmc_host *host, u32 ocr,
6240eb51a58SShawn Lin struct mmc_card *card)
6250eb51a58SShawn Lin {
6261dc5a615SUlf Hansson if (card)
6271dc5a615SUlf Hansson mmc_remove_card(card);
6281dc5a615SUlf Hansson
6291dc5a615SUlf Hansson /*
6301dc5a615SUlf Hansson * Reset the card by performing the same steps that are taken by
6311dc5a615SUlf Hansson * mmc_rescan_try_freq() and mmc_attach_sdio() during a "normal" probe.
6321dc5a615SUlf Hansson *
6331dc5a615SUlf Hansson * sdio_reset() is technically not needed. Having just powered up the
6341dc5a615SUlf Hansson * hardware, it should already be in reset state. However, some
6351dc5a615SUlf Hansson * platforms (such as SD8686 on OLPC) do not instantly cut power,
6361dc5a615SUlf Hansson * meaning that a reset is required when restoring power soon after
6371dc5a615SUlf Hansson * powering off. It is harmless in other cases.
6381dc5a615SUlf Hansson *
6391dc5a615SUlf Hansson * The CMD5 reset (mmc_send_io_op_cond()), according to the SDIO spec,
6401dc5a615SUlf Hansson * is not necessary for non-removable cards. However, it is required
6411dc5a615SUlf Hansson * for OLPC SD8686 (which expects a [CMD5,5,3,7] init sequence), and
6421dc5a615SUlf Hansson * harmless in other situations.
6431dc5a615SUlf Hansson *
6441dc5a615SUlf Hansson */
6451dc5a615SUlf Hansson
6460eb51a58SShawn Lin sdio_reset(host);
6470eb51a58SShawn Lin mmc_go_idle(host);
648fa1e3191SUlf Hansson mmc_send_if_cond(host, ocr);
6491dc5a615SUlf Hansson return mmc_send_io_op_cond(host, 0, NULL);
6500eb51a58SShawn Lin }
6510eb51a58SShawn Lin
652d16f5770SPierre Ossman /*
65317d33e14SNicolas Pitre * Handle the detection and initialisation of a card.
65417d33e14SNicolas Pitre *
65517d33e14SNicolas Pitre * In the case of a resume, "oldcard" will contain the card
65617d33e14SNicolas Pitre * we're trying to reinitialise.
65717d33e14SNicolas Pitre */
mmc_sdio_init_card(struct mmc_host * host,u32 ocr,struct mmc_card * oldcard)65817d33e14SNicolas Pitre static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr,
6594aaaf3abSUlf Hansson struct mmc_card *oldcard)
66017d33e14SNicolas Pitre {
66117d33e14SNicolas Pitre struct mmc_card *card;
66217d33e14SNicolas Pitre int err;
6630797e5f1SJohan Rudholm int retries = 10;
664db4a0d05SUlf Hansson u32 rocr = 0;
66569041150SUlf Hansson u32 ocr_card = ocr;
66617d33e14SNicolas Pitre
66717d33e14SNicolas Pitre WARN_ON(!host->claimed);
66817d33e14SNicolas Pitre
669db4a0d05SUlf Hansson /* to query card if 1.8V signalling is supported */
670db4a0d05SUlf Hansson if (mmc_host_uhs(host))
671db4a0d05SUlf Hansson ocr |= R4_18V_PRESENT;
672db4a0d05SUlf Hansson
6730797e5f1SJohan Rudholm try_again:
6740797e5f1SJohan Rudholm if (!retries) {
6756606110dSJoe Perches pr_warn("%s: Skipping voltage switch\n", mmc_hostname(host));
6760797e5f1SJohan Rudholm ocr &= ~R4_18V_PRESENT;
6770797e5f1SJohan Rudholm }
6780797e5f1SJohan Rudholm
67917d33e14SNicolas Pitre /*
68017d33e14SNicolas Pitre * Inform the card of the voltage
68117d33e14SNicolas Pitre */
682db4a0d05SUlf Hansson err = mmc_send_io_op_cond(host, ocr, &rocr);
68317d33e14SNicolas Pitre if (err)
684a94a59f4SUlf Hansson return err;
68517d33e14SNicolas Pitre
68617d33e14SNicolas Pitre /*
68717d33e14SNicolas Pitre * For SPI, enable CRC as appropriate.
68817d33e14SNicolas Pitre */
68917d33e14SNicolas Pitre if (mmc_host_is_spi(host)) {
69017d33e14SNicolas Pitre err = mmc_spi_set_crc(host, use_spi_crc);
69117d33e14SNicolas Pitre if (err)
692a94a59f4SUlf Hansson return err;
69317d33e14SNicolas Pitre }
69417d33e14SNicolas Pitre
69517d33e14SNicolas Pitre /*
69617d33e14SNicolas Pitre * Allocate card structure.
69717d33e14SNicolas Pitre */
698254e1754SPali Rohár card = mmc_alloc_card(host, &sdio_type);
699a94a59f4SUlf Hansson if (IS_ERR(card))
700a94a59f4SUlf Hansson return PTR_ERR(card);
70117d33e14SNicolas Pitre
702db4a0d05SUlf Hansson if ((rocr & R4_MEMORY_PRESENT) &&
703db4a0d05SUlf Hansson mmc_sd_get_cid(host, ocr & rocr, card->raw_cid, NULL) == 0) {
7047310ece8SMichal Miroslaw card->type = MMC_TYPE_SD_COMBO;
7057310ece8SMichal Miroslaw
7063beb0ab5SSeunghui Lee if (oldcard && (!mmc_card_sd_combo(oldcard) ||
7077310ece8SMichal Miroslaw memcmp(card->raw_cid, oldcard->raw_cid, sizeof(card->raw_cid)) != 0)) {
708a94a59f4SUlf Hansson err = -ENOENT;
709a94a59f4SUlf Hansson goto mismatch;
7107310ece8SMichal Miroslaw }
7117310ece8SMichal Miroslaw } else {
71217d33e14SNicolas Pitre card->type = MMC_TYPE_SDIO;
71317d33e14SNicolas Pitre
7143beb0ab5SSeunghui Lee if (oldcard && !mmc_card_sdio(oldcard)) {
715a94a59f4SUlf Hansson err = -ENOENT;
716a94a59f4SUlf Hansson goto mismatch;
7177310ece8SMichal Miroslaw }
7187310ece8SMichal Miroslaw }
7197310ece8SMichal Miroslaw
72017d33e14SNicolas Pitre /*
7213fcb027dSDaniel Mack * Call the optional HC's init_card function to handle quirks.
7223fcb027dSDaniel Mack */
7233fcb027dSDaniel Mack if (host->ops->init_card)
7243fcb027dSDaniel Mack host->ops->init_card(host, card);
725818cd405SH. Nikolaus Schaller mmc_fixup_device(card, sdio_card_init_methods);
7263fcb027dSDaniel Mack
7278c3e5b74SUlf Hansson card->ocr = ocr_card;
7288c3e5b74SUlf Hansson
7293fcb027dSDaniel Mack /*
730a303c531SPhilip Rakity * If the host and card support UHS-I mode request the card
731a303c531SPhilip Rakity * to switch to 1.8V signaling level. No 1.8v signalling if
7327122bbb0SMasanari Iida * UHS mode is not enabled to maintain compatibility and some
733a303c531SPhilip Rakity * systems that claim 1.8v signalling in fact do not support
7345fc3d80eSShawn Lin * it. Per SDIO spec v3, section 3.1.2, if the voltage is already
7355fc3d80eSShawn Lin * 1.8v, the card sets S18A to 0 in the R4 response. So it will
7365fc3d80eSShawn Lin * fails to check rocr & R4_18V_PRESENT, but we still need to
7375fc3d80eSShawn Lin * try to init uhs card. sdio_read_cccr will take over this task
7385fc3d80eSShawn Lin * to make sure which speed mode should work.
739a303c531SPhilip Rakity */
7404aaaf3abSUlf Hansson if (rocr & ocr & R4_18V_PRESENT) {
7412ed573b6SUlf Hansson err = mmc_set_uhs_voltage(host, ocr_card);
7420797e5f1SJohan Rudholm if (err == -EAGAIN) {
7431dc5a615SUlf Hansson mmc_sdio_pre_init(host, ocr_card, card);
7440797e5f1SJohan Rudholm retries--;
7450797e5f1SJohan Rudholm goto try_again;
7460797e5f1SJohan Rudholm } else if (err) {
747a303c531SPhilip Rakity ocr &= ~R4_18V_PRESENT;
748a303c531SPhilip Rakity }
749a303c531SPhilip Rakity }
750a303c531SPhilip Rakity
751a303c531SPhilip Rakity /*
75217d33e14SNicolas Pitre * For native busses: set card RCA and quit open drain mode.
75317d33e14SNicolas Pitre */
7544aaaf3abSUlf Hansson if (!mmc_host_is_spi(host)) {
75517d33e14SNicolas Pitre err = mmc_send_relative_addr(host, &card->rca);
75617d33e14SNicolas Pitre if (err)
75717d33e14SNicolas Pitre goto remove;
75817d33e14SNicolas Pitre
7590aab3995SStefan Nilsson XK /*
7600aab3995SStefan Nilsson XK * Update oldcard with the new RCA received from the SDIO
7610aab3995SStefan Nilsson XK * device -- we're doing this so that it's updated in the
7620aab3995SStefan Nilsson XK * "card" struct when oldcard overwrites that later.
7630aab3995SStefan Nilsson XK */
7640aab3995SStefan Nilsson XK if (oldcard)
7650aab3995SStefan Nilsson XK oldcard->rca = card->rca;
76617d33e14SNicolas Pitre }
76717d33e14SNicolas Pitre
76817d33e14SNicolas Pitre /*
7697310ece8SMichal Miroslaw * Read CSD, before selecting the card
7707310ece8SMichal Miroslaw */
7713beb0ab5SSeunghui Lee if (!oldcard && mmc_card_sd_combo(card)) {
772bd7342feSYue Hu err = mmc_sd_get_csd(card);
7737310ece8SMichal Miroslaw if (err)
774a94a59f4SUlf Hansson goto remove;
7757310ece8SMichal Miroslaw
7767310ece8SMichal Miroslaw mmc_decode_cid(card);
7777310ece8SMichal Miroslaw }
7787310ece8SMichal Miroslaw
7797310ece8SMichal Miroslaw /*
78017d33e14SNicolas Pitre * Select card, as all following commands rely on that.
78117d33e14SNicolas Pitre */
7824aaaf3abSUlf Hansson if (!mmc_host_is_spi(host)) {
78317d33e14SNicolas Pitre err = mmc_select_card(card);
78417d33e14SNicolas Pitre if (err)
78517d33e14SNicolas Pitre goto remove;
78617d33e14SNicolas Pitre }
78717d33e14SNicolas Pitre
7886f51be3dSGrazvydas Ignotas if (card->quirks & MMC_QUIRK_NONSTD_SDIO) {
7896f51be3dSGrazvydas Ignotas /*
7906f51be3dSGrazvydas Ignotas * This is non-standard SDIO device, meaning it doesn't
7916f51be3dSGrazvydas Ignotas * have any CIA (Common I/O area) registers present.
7926f51be3dSGrazvydas Ignotas * It's host's responsibility to fill cccr and cis
7936f51be3dSGrazvydas Ignotas * structures in init_card().
7946f51be3dSGrazvydas Ignotas */
7956f51be3dSGrazvydas Ignotas mmc_set_clock(host, card->cis.max_dtr);
7966f51be3dSGrazvydas Ignotas
7976f51be3dSGrazvydas Ignotas if (card->cccr.high_speed) {
7986f51be3dSGrazvydas Ignotas mmc_set_timing(card->host, MMC_TIMING_SD_HS);
7996f51be3dSGrazvydas Ignotas }
8006f51be3dSGrazvydas Ignotas
801a94a59f4SUlf Hansson if (oldcard)
802a94a59f4SUlf Hansson mmc_remove_card(card);
803a94a59f4SUlf Hansson else
804a94a59f4SUlf Hansson host->card = card;
805a94a59f4SUlf Hansson
806a94a59f4SUlf Hansson return 0;
8076f51be3dSGrazvydas Ignotas }
8086f51be3dSGrazvydas Ignotas
80917d33e14SNicolas Pitre /*
8105fc3d80eSShawn Lin * Read the common registers. Note that we should try to
8115fc3d80eSShawn Lin * validate whether UHS would work or not.
81217d33e14SNicolas Pitre */
8132d0d68f5SPhilip Rakity err = sdio_read_cccr(card, ocr);
8145fc3d80eSShawn Lin if (err) {
8151dc5a615SUlf Hansson mmc_sdio_pre_init(host, ocr_card, card);
8165fc3d80eSShawn Lin if (ocr & R4_18V_PRESENT) {
8175fc3d80eSShawn Lin /* Retry init sequence, but without R4_18V_PRESENT. */
8185fc3d80eSShawn Lin retries = 0;
8195fc3d80eSShawn Lin goto try_again;
8205fc3d80eSShawn Lin }
821f04086c2SUlf Hansson return err;
8225fc3d80eSShawn Lin }
82317d33e14SNicolas Pitre
82417d33e14SNicolas Pitre /*
82517d33e14SNicolas Pitre * Read the common CIS tuples.
82617d33e14SNicolas Pitre */
82717d33e14SNicolas Pitre err = sdio_read_common_cis(card);
82817d33e14SNicolas Pitre if (err)
82917d33e14SNicolas Pitre goto remove;
83017d33e14SNicolas Pitre
83117d33e14SNicolas Pitre if (oldcard) {
832a94a59f4SUlf Hansson if (card->cis.vendor == oldcard->cis.vendor &&
833a94a59f4SUlf Hansson card->cis.device == oldcard->cis.device) {
83417d33e14SNicolas Pitre mmc_remove_card(card);
83517d33e14SNicolas Pitre card = oldcard;
836a94a59f4SUlf Hansson } else {
837a94a59f4SUlf Hansson err = -ENOENT;
838a94a59f4SUlf Hansson goto mismatch;
839a94a59f4SUlf Hansson }
84017d33e14SNicolas Pitre }
8418c3e5b74SUlf Hansson
8421144c1e4SShawn Lin mmc_fixup_device(card, sdio_fixup_methods);
84317d33e14SNicolas Pitre
8443beb0ab5SSeunghui Lee if (mmc_card_sd_combo(card)) {
8457310ece8SMichal Miroslaw err = mmc_sd_setup_card(host, card, oldcard != NULL);
8467310ece8SMichal Miroslaw /* handle as SDIO-only card if memory init failed */
8477310ece8SMichal Miroslaw if (err) {
8487310ece8SMichal Miroslaw mmc_go_idle(host);
8497310ece8SMichal Miroslaw if (mmc_host_is_spi(host))
8507310ece8SMichal Miroslaw /* should not fail, as it worked previously */
8517310ece8SMichal Miroslaw mmc_spi_set_crc(host, use_spi_crc);
8527310ece8SMichal Miroslaw card->type = MMC_TYPE_SDIO;
8537310ece8SMichal Miroslaw } else
8547310ece8SMichal Miroslaw card->dev.type = &sd_type;
8557310ece8SMichal Miroslaw }
8567310ece8SMichal Miroslaw
8577310ece8SMichal Miroslaw /*
8587310ece8SMichal Miroslaw * If needed, disconnect card detection pull-up resistor.
8597310ece8SMichal Miroslaw */
8607310ece8SMichal Miroslaw err = sdio_disable_cd(card);
8617310ece8SMichal Miroslaw if (err)
8627310ece8SMichal Miroslaw goto remove;
8637310ece8SMichal Miroslaw
864a303c531SPhilip Rakity /* Initialization sequence for UHS-I cards */
865a303c531SPhilip Rakity /* Only if card supports 1.8v and UHS signaling */
866a303c531SPhilip Rakity if ((ocr & R4_18V_PRESENT) && card->sw_caps.sd3_bus_mode) {
867a303c531SPhilip Rakity err = mmc_sdio_init_uhs_card(card);
868a303c531SPhilip Rakity if (err)
869a303c531SPhilip Rakity goto remove;
870a303c531SPhilip Rakity } else {
87117d33e14SNicolas Pitre /*
87217d33e14SNicolas Pitre * Switch to high-speed (if supported).
87317d33e14SNicolas Pitre */
87417d33e14SNicolas Pitre err = sdio_enable_hs(card);
87571578a1eSMichal Miroslaw if (err > 0)
876cdc99179SSeungwon Jeon mmc_set_timing(card->host, MMC_TIMING_SD_HS);
87771578a1eSMichal Miroslaw else if (err)
87817d33e14SNicolas Pitre goto remove;
87917d33e14SNicolas Pitre
88017d33e14SNicolas Pitre /*
88117d33e14SNicolas Pitre * Change to the card's maximum speed.
88217d33e14SNicolas Pitre */
88371578a1eSMichal Miroslaw mmc_set_clock(host, mmc_sdio_get_max_clock(card));
88417d33e14SNicolas Pitre
88517d33e14SNicolas Pitre /*
88617d33e14SNicolas Pitre * Switch to wider bus (if supported).
88717d33e14SNicolas Pitre */
8887310ece8SMichal Miroslaw err = sdio_enable_4bit_bus(card);
889303dbedcSNeilBrown if (err)
89017d33e14SNicolas Pitre goto remove;
891a303c531SPhilip Rakity }
892247cfe53SKyle Roeschley
893247cfe53SKyle Roeschley if (host->caps2 & MMC_CAP2_AVOID_3_3V &&
894247cfe53SKyle Roeschley host->ios.signal_voltage == MMC_SIGNAL_VOLTAGE_330) {
895247cfe53SKyle Roeschley pr_err("%s: Host failed to negotiate down from 3.3V\n",
896247cfe53SKyle Roeschley mmc_hostname(host));
897247cfe53SKyle Roeschley err = -EINVAL;
898247cfe53SKyle Roeschley goto remove;
899247cfe53SKyle Roeschley }
900a94a59f4SUlf Hansson
90117d33e14SNicolas Pitre host->card = card;
90217d33e14SNicolas Pitre return 0;
90317d33e14SNicolas Pitre
904a94a59f4SUlf Hansson mismatch:
905a94a59f4SUlf Hansson pr_debug("%s: Perhaps the card was replaced\n", mmc_hostname(host));
90617d33e14SNicolas Pitre remove:
907a94a59f4SUlf Hansson if (oldcard != card)
90817d33e14SNicolas Pitre mmc_remove_card(card);
90917d33e14SNicolas Pitre return err;
91017d33e14SNicolas Pitre }
91117d33e14SNicolas Pitre
mmc_sdio_reinit_card(struct mmc_host * host)9123c30e739SUlf Hansson static int mmc_sdio_reinit_card(struct mmc_host *host)
913fb09f44eSUlf Hansson {
914fb09f44eSUlf Hansson int ret;
915fb09f44eSUlf Hansson
9161dc5a615SUlf Hansson ret = mmc_sdio_pre_init(host, host->card->ocr, NULL);
917fb09f44eSUlf Hansson if (ret)
918fb09f44eSUlf Hansson return ret;
919fb09f44eSUlf Hansson
9204aaaf3abSUlf Hansson return mmc_sdio_init_card(host, host->card->ocr, host->card);
921fb09f44eSUlf Hansson }
922fb09f44eSUlf Hansson
92317d33e14SNicolas Pitre /*
9245c4e6f13SPierre Ossman * Host is being removed. Free up the current card.
9255c4e6f13SPierre Ossman */
mmc_sdio_remove(struct mmc_host * host)9265c4e6f13SPierre Ossman static void mmc_sdio_remove(struct mmc_host *host)
9275c4e6f13SPierre Ossman {
928e29a7d73SPierre Ossman int i;
929e29a7d73SPierre Ossman
930e29a7d73SPierre Ossman for (i = 0;i < host->card->sdio_funcs;i++) {
931e29a7d73SPierre Ossman if (host->card->sdio_func[i]) {
932e29a7d73SPierre Ossman sdio_remove_func(host->card->sdio_func[i]);
933e29a7d73SPierre Ossman host->card->sdio_func[i] = NULL;
934e29a7d73SPierre Ossman }
935e29a7d73SPierre Ossman }
936e29a7d73SPierre Ossman
9375c4e6f13SPierre Ossman mmc_remove_card(host->card);
9385c4e6f13SPierre Ossman host->card = NULL;
9395c4e6f13SPierre Ossman }
9405c4e6f13SPierre Ossman
9415c4e6f13SPierre Ossman /*
942d3049504SAdrian Hunter * Card detection - card is alive.
943d3049504SAdrian Hunter */
mmc_sdio_alive(struct mmc_host * host)944d3049504SAdrian Hunter static int mmc_sdio_alive(struct mmc_host *host)
945d3049504SAdrian Hunter {
946d3049504SAdrian Hunter return mmc_select_card(host->card);
947d3049504SAdrian Hunter }
948d3049504SAdrian Hunter
949d3049504SAdrian Hunter /*
9505c4e6f13SPierre Ossman * Card detection callback from host.
9515c4e6f13SPierre Ossman */
mmc_sdio_detect(struct mmc_host * host)9525c4e6f13SPierre Ossman static void mmc_sdio_detect(struct mmc_host *host)
9535c4e6f13SPierre Ossman {
9545c4e6f13SPierre Ossman int err;
9555c4e6f13SPierre Ossman
95687973ba2SOhad Ben-Cohen /* Make sure card is powered before detecting it */
957ed919b01SOhad Ben-Cohen if (host->caps & MMC_CAP_POWER_OFF_CARD) {
95805335af1STian Tao err = pm_runtime_resume_and_get(&host->card->dev);
95905335af1STian Tao if (err < 0)
96087973ba2SOhad Ben-Cohen goto out;
961ed919b01SOhad Ben-Cohen }
96287973ba2SOhad Ben-Cohen
9635c4e6f13SPierre Ossman mmc_claim_host(host);
9645c4e6f13SPierre Ossman
9655c4e6f13SPierre Ossman /*
9665c4e6f13SPierre Ossman * Just check if our card has been removed.
9675c4e6f13SPierre Ossman */
968d3049504SAdrian Hunter err = _mmc_detect_card_removed(host);
9695c4e6f13SPierre Ossman
9705c4e6f13SPierre Ossman mmc_release_host(host);
9715c4e6f13SPierre Ossman
9724d0812c3SOhad Ben-Cohen /*
9734d0812c3SOhad Ben-Cohen * Tell PM core it's OK to power off the card now.
9744d0812c3SOhad Ben-Cohen *
9754d0812c3SOhad Ben-Cohen * The _sync variant is used in order to ensure that the card
9764d0812c3SOhad Ben-Cohen * is left powered off in case an error occurred, and the card
9774d0812c3SOhad Ben-Cohen * is going to be removed.
9784d0812c3SOhad Ben-Cohen *
9794d0812c3SOhad Ben-Cohen * Since there is no specific reason to believe a new user
9804d0812c3SOhad Ben-Cohen * is about to show up at this point, the _sync variant is
9814d0812c3SOhad Ben-Cohen * desirable anyway.
9824d0812c3SOhad Ben-Cohen */
983ed919b01SOhad Ben-Cohen if (host->caps & MMC_CAP_POWER_OFF_CARD)
9844d0812c3SOhad Ben-Cohen pm_runtime_put_sync(&host->card->dev);
9854d0812c3SOhad Ben-Cohen
98687973ba2SOhad Ben-Cohen out:
9875c4e6f13SPierre Ossman if (err) {
9885c4e6f13SPierre Ossman mmc_sdio_remove(host);
9895c4e6f13SPierre Ossman
9905c4e6f13SPierre Ossman mmc_claim_host(host);
9915c4e6f13SPierre Ossman mmc_detach_bus(host);
9927f7e4129SUlf Hansson mmc_power_off(host);
9935c4e6f13SPierre Ossman mmc_release_host(host);
9945c4e6f13SPierre Ossman }
9955c4e6f13SPierre Ossman }
9965c4e6f13SPierre Ossman
99717d33e14SNicolas Pitre /*
998810caddbSUlf Hansson * SDIO pre_suspend. We need to suspend all functions separately.
99917d33e14SNicolas Pitre * Therefore all registered functions must have drivers with suspend
100017d33e14SNicolas Pitre * and resume methods. Failing that we simply remove the whole card.
100117d33e14SNicolas Pitre */
mmc_sdio_pre_suspend(struct mmc_host * host)1002810caddbSUlf Hansson static int mmc_sdio_pre_suspend(struct mmc_host *host)
100317d33e14SNicolas Pitre {
100417a17bf5SUlf Hansson int i;
100517d33e14SNicolas Pitre
100617d33e14SNicolas Pitre for (i = 0; i < host->card->sdio_funcs; i++) {
100717d33e14SNicolas Pitre struct sdio_func *func = host->card->sdio_func[i];
100817d33e14SNicolas Pitre if (func && sdio_func_present(func) && func->dev.driver) {
100917d33e14SNicolas Pitre const struct dev_pm_ops *pmops = func->dev.driver->pm;
101017a17bf5SUlf Hansson if (!pmops || !pmops->suspend || !pmops->resume)
101195cdfb72SNicolas Pitre /* force removal of entire card in that case */
101217a17bf5SUlf Hansson goto remove;
1013810caddbSUlf Hansson }
1014810caddbSUlf Hansson }
1015810caddbSUlf Hansson
101617a17bf5SUlf Hansson return 0;
101717a17bf5SUlf Hansson
101817a17bf5SUlf Hansson remove:
101917a17bf5SUlf Hansson if (!mmc_card_is_removable(host)) {
102017a17bf5SUlf Hansson dev_warn(mmc_dev(host),
102117a17bf5SUlf Hansson "missing suspend/resume ops for non-removable SDIO card\n");
102217a17bf5SUlf Hansson /* Don't remove a non-removable card - we can't re-detect it. */
102317a17bf5SUlf Hansson return 0;
102417a17bf5SUlf Hansson }
102517a17bf5SUlf Hansson
102617a17bf5SUlf Hansson /* Remove the SDIO card and let it be re-detected later on. */
102717a17bf5SUlf Hansson mmc_sdio_remove(host);
102817a17bf5SUlf Hansson mmc_claim_host(host);
102917a17bf5SUlf Hansson mmc_detach_bus(host);
103017a17bf5SUlf Hansson mmc_power_off(host);
103117a17bf5SUlf Hansson mmc_release_host(host);
103217a17bf5SUlf Hansson host->pm_flags = 0;
103317a17bf5SUlf Hansson
103417a17bf5SUlf Hansson return 0;
1035810caddbSUlf Hansson }
1036810caddbSUlf Hansson
1037810caddbSUlf Hansson /*
1038810caddbSUlf Hansson * SDIO suspend. Suspend all functions separately.
1039810caddbSUlf Hansson */
mmc_sdio_suspend(struct mmc_host * host)1040810caddbSUlf Hansson static int mmc_sdio_suspend(struct mmc_host *host)
1041810caddbSUlf Hansson {
1042c5d3e8faSUlf Hansson WARN_ON(host->sdio_irqs && !mmc_card_keep_power(host));
1043c5d3e8faSUlf Hansson
104483293386SUlf Hansson /* Prevent processing of SDIO IRQs in suspended state. */
104583293386SUlf Hansson mmc_card_set_suspended(host->card);
10461dd611a9SHeiner Kallweit cancel_work_sync(&host->sdio_irq_work);
104783293386SUlf Hansson
10486b5eda36SDaniel Drake mmc_claim_host(host);
10498d1ffc8cSUlf Hansson
10508d1ffc8cSUlf Hansson if (mmc_card_keep_power(host) && mmc_card_wake_sdio_irq(host))
105140e6c479SYue Hu sdio_disable_4bit_bus(host->card);
10526b5eda36SDaniel Drake
105379d5a65aSAdrian Hunter if (!mmc_card_keep_power(host)) {
105474590263SUlf Hansson mmc_power_off(host);
105579d5a65aSAdrian Hunter } else if (host->retune_period) {
105679d5a65aSAdrian Hunter mmc_retune_timer_stop(host);
105779d5a65aSAdrian Hunter mmc_retune_needed(host);
105879d5a65aSAdrian Hunter }
105974590263SUlf Hansson
10608d1ffc8cSUlf Hansson mmc_release_host(host);
10618d1ffc8cSUlf Hansson
1062573185ccSUlf Hansson return 0;
106395cdfb72SNicolas Pitre }
106495cdfb72SNicolas Pitre
mmc_sdio_resume(struct mmc_host * host)106595cdfb72SNicolas Pitre static int mmc_sdio_resume(struct mmc_host *host)
106695cdfb72SNicolas Pitre {
1067573185ccSUlf Hansson int err = 0;
106895cdfb72SNicolas Pitre
106995cdfb72SNicolas Pitre /* Basic card reinitialization. */
107095cdfb72SNicolas Pitre mmc_claim_host(host);
1071080bc977SOhad Ben-Cohen
10726ebc581cSUlf Hansson /*
10736ebc581cSUlf Hansson * Restore power and reinitialize the card when needed. Note that a
10746ebc581cSUlf Hansson * removable card is checked from a detect work later on in the resume
10756ebc581cSUlf Hansson * process.
10766ebc581cSUlf Hansson */
107774590263SUlf Hansson if (!mmc_card_keep_power(host)) {
107869041150SUlf Hansson mmc_power_up(host, host->card->ocr);
107974590263SUlf Hansson /*
108074590263SUlf Hansson * Tell runtime PM core we just powered up the card,
108174590263SUlf Hansson * since it still believes the card is powered off.
108274590263SUlf Hansson * Note that currently runtime PM is only enabled
108374590263SUlf Hansson * for SDIO cards that are MMC_CAP_POWER_OFF_CARD
108474590263SUlf Hansson */
108574590263SUlf Hansson if (host->caps & MMC_CAP_POWER_OFF_CARD) {
108674590263SUlf Hansson pm_runtime_disable(&host->card->dev);
108774590263SUlf Hansson pm_runtime_set_active(&host->card->dev);
108874590263SUlf Hansson pm_runtime_enable(&host->card->dev);
108974590263SUlf Hansson }
10903c30e739SUlf Hansson err = mmc_sdio_reinit_card(host);
10916ebc581cSUlf Hansson } else if (mmc_card_wake_sdio_irq(host)) {
109232a9cdb8SHaibo Chen /*
109332a9cdb8SHaibo Chen * We may have switched to 1-bit mode during suspend,
109432a9cdb8SHaibo Chen * need to hold retuning, because tuning only supprt
109532a9cdb8SHaibo Chen * 4-bit mode or 8 bit mode.
109632a9cdb8SHaibo Chen */
109732a9cdb8SHaibo Chen mmc_retune_hold_now(host);
1098080bc977SOhad Ben-Cohen err = sdio_enable_4bit_bus(host->card);
109932a9cdb8SHaibo Chen mmc_retune_release(host);
1100080bc977SOhad Ben-Cohen }
1101080bc977SOhad Ben-Cohen
110283293386SUlf Hansson if (err)
110383293386SUlf Hansson goto out;
110483293386SUlf Hansson
110583293386SUlf Hansson /* Allow SDIO IRQs to be processed again. */
110683293386SUlf Hansson mmc_card_clr_suspended(host->card);
110783293386SUlf Hansson
110883293386SUlf Hansson if (host->sdio_irqs) {
11099eadcc05SUlf Hansson if (!(host->caps2 & MMC_CAP2_SDIO_IRQ_NOTHREAD))
1110bbbc4c4dSNicolas Pitre wake_up_process(host->sdio_irq_thread);
11119eadcc05SUlf Hansson else if (host->caps & MMC_CAP_SDIO_IRQ)
11121dd611a9SHeiner Kallweit schedule_work(&host->sdio_irq_work);
1113dea67c4eSFu Zhonghui }
1114dea67c4eSFu Zhonghui
111583293386SUlf Hansson out:
111695cdfb72SNicolas Pitre mmc_release_host(host);
111795cdfb72SNicolas Pitre
111874590263SUlf Hansson host->pm_flags &= ~MMC_PM_KEEP_POWER;
111995cdfb72SNicolas Pitre return err;
112017d33e14SNicolas Pitre }
11215c4e6f13SPierre Ossman
mmc_sdio_runtime_suspend(struct mmc_host * host)112212d01d0bSUlf Hansson static int mmc_sdio_runtime_suspend(struct mmc_host *host)
112312d01d0bSUlf Hansson {
112412d01d0bSUlf Hansson /* No references to the card, cut the power to it. */
11258d1ffc8cSUlf Hansson mmc_claim_host(host);
112612d01d0bSUlf Hansson mmc_power_off(host);
11278d1ffc8cSUlf Hansson mmc_release_host(host);
11288d1ffc8cSUlf Hansson
112912d01d0bSUlf Hansson return 0;
113012d01d0bSUlf Hansson }
113112d01d0bSUlf Hansson
mmc_sdio_runtime_resume(struct mmc_host * host)113212d01d0bSUlf Hansson static int mmc_sdio_runtime_resume(struct mmc_host *host)
113312d01d0bSUlf Hansson {
11348d1ffc8cSUlf Hansson int ret;
11358d1ffc8cSUlf Hansson
113612d01d0bSUlf Hansson /* Restore power and re-initialize. */
11378d1ffc8cSUlf Hansson mmc_claim_host(host);
113869041150SUlf Hansson mmc_power_up(host, host->card->ocr);
11393c30e739SUlf Hansson ret = mmc_sdio_reinit_card(host);
11408d1ffc8cSUlf Hansson mmc_release_host(host);
11418d1ffc8cSUlf Hansson
11428d1ffc8cSUlf Hansson return ret;
114312d01d0bSUlf Hansson }
114412d01d0bSUlf Hansson
11452ac55d5eSUlf Hansson /*
11462ac55d5eSUlf Hansson * SDIO HW reset
11472ac55d5eSUlf Hansson *
11482ac55d5eSUlf Hansson * Returns 0 if the HW reset was executed synchronously, returns 1 if the HW
11492ac55d5eSUlf Hansson * reset was asynchronously scheduled, else a negative error code.
11502ac55d5eSUlf Hansson */
mmc_sdio_hw_reset(struct mmc_host * host)11513a3db603SUlf Hansson static int mmc_sdio_hw_reset(struct mmc_host *host)
11521fb654fdSAndreas Fenkart {
11532ac55d5eSUlf Hansson struct mmc_card *card = host->card;
11542ac55d5eSUlf Hansson
11552ac55d5eSUlf Hansson /*
11562ac55d5eSUlf Hansson * In case the card is shared among multiple func drivers, reset the
11572ac55d5eSUlf Hansson * card through a rescan work. In this way it will be removed and
11582ac55d5eSUlf Hansson * re-detected, thus all func drivers becomes informed about it.
11592ac55d5eSUlf Hansson */
11602ac55d5eSUlf Hansson if (atomic_read(&card->sdio_funcs_probed) > 1) {
11612ac55d5eSUlf Hansson if (mmc_card_removed(card))
11622ac55d5eSUlf Hansson return 1;
11632ac55d5eSUlf Hansson host->rescan_entered = 0;
11642ac55d5eSUlf Hansson mmc_card_set_removed(card);
11652ac55d5eSUlf Hansson _mmc_detect_change(host, 0, false);
11662ac55d5eSUlf Hansson return 1;
11672ac55d5eSUlf Hansson }
11682ac55d5eSUlf Hansson
11692ac55d5eSUlf Hansson /*
11702ac55d5eSUlf Hansson * A single func driver has been probed, then let's skip the heavy
11712ac55d5eSUlf Hansson * hotplug dance above and execute the reset immediately.
11722ac55d5eSUlf Hansson */
11732ac55d5eSUlf Hansson mmc_power_cycle(host, card->ocr);
11743c30e739SUlf Hansson return mmc_sdio_reinit_card(host);
11751fb654fdSAndreas Fenkart }
11761fb654fdSAndreas Fenkart
mmc_sdio_sw_reset(struct mmc_host * host)11777405df4cSUlf Hansson static int mmc_sdio_sw_reset(struct mmc_host *host)
11787405df4cSUlf Hansson {
11797405df4cSUlf Hansson mmc_set_clock(host, host->f_init);
11807405df4cSUlf Hansson sdio_reset(host);
11817405df4cSUlf Hansson mmc_go_idle(host);
11827405df4cSUlf Hansson
11837405df4cSUlf Hansson mmc_set_initial_state(host);
11847405df4cSUlf Hansson mmc_set_initial_signal_voltage(host);
11857405df4cSUlf Hansson
11863c30e739SUlf Hansson return mmc_sdio_reinit_card(host);
11877405df4cSUlf Hansson }
11887405df4cSUlf Hansson
11895c4e6f13SPierre Ossman static const struct mmc_bus_ops mmc_sdio_ops = {
11905c4e6f13SPierre Ossman .remove = mmc_sdio_remove,
11915c4e6f13SPierre Ossman .detect = mmc_sdio_detect,
1192810caddbSUlf Hansson .pre_suspend = mmc_sdio_pre_suspend,
119317d33e14SNicolas Pitre .suspend = mmc_sdio_suspend,
119417d33e14SNicolas Pitre .resume = mmc_sdio_resume,
119512d01d0bSUlf Hansson .runtime_suspend = mmc_sdio_runtime_suspend,
119612d01d0bSUlf Hansson .runtime_resume = mmc_sdio_runtime_resume,
1197d3049504SAdrian Hunter .alive = mmc_sdio_alive,
11983a3db603SUlf Hansson .hw_reset = mmc_sdio_hw_reset,
11997405df4cSUlf Hansson .sw_reset = mmc_sdio_sw_reset,
12005c4e6f13SPierre Ossman };
12015c4e6f13SPierre Ossman
12025c4e6f13SPierre Ossman
12035c4e6f13SPierre Ossman /*
12045c4e6f13SPierre Ossman * Starting point for SDIO card init.
12055c4e6f13SPierre Ossman */
mmc_attach_sdio(struct mmc_host * host)1206807e8e40SAndy Ross int mmc_attach_sdio(struct mmc_host *host)
12075c4e6f13SPierre Ossman {
1208807e8e40SAndy Ross int err, i, funcs;
120969041150SUlf Hansson u32 ocr, rocr;
12105c4e6f13SPierre Ossman struct mmc_card *card;
12115c4e6f13SPierre Ossman
1212d84075c8SPierre Ossman WARN_ON(!host->claimed);
12135c4e6f13SPierre Ossman
1214807e8e40SAndy Ross err = mmc_send_io_op_cond(host, 0, &ocr);
1215807e8e40SAndy Ross if (err)
1216807e8e40SAndy Ross return err;
1217807e8e40SAndy Ross
12185c4e6f13SPierre Ossman mmc_attach_bus(host, &mmc_sdio_ops);
12198f230f45STakashi Iwai if (host->ocr_avail_sdio)
12208f230f45STakashi Iwai host->ocr_avail = host->ocr_avail_sdio;
12215c4e6f13SPierre Ossman
12225c4e6f13SPierre Ossman
122369041150SUlf Hansson rocr = mmc_select_voltage(host, ocr);
12245c4e6f13SPierre Ossman
12255c4e6f13SPierre Ossman /*
12265c4e6f13SPierre Ossman * Can we support the voltage(s) of the card(s)?
12275c4e6f13SPierre Ossman */
122869041150SUlf Hansson if (!rocr) {
12295c4e6f13SPierre Ossman err = -EINVAL;
12305c4e6f13SPierre Ossman goto err;
12315c4e6f13SPierre Ossman }
12325c4e6f13SPierre Ossman
12335c4e6f13SPierre Ossman /*
123417d33e14SNicolas Pitre * Detect and init the card.
12355c4e6f13SPierre Ossman */
12364aaaf3abSUlf Hansson err = mmc_sdio_init_card(host, rocr, NULL);
12375c4e6f13SPierre Ossman if (err)
12385c4e6f13SPierre Ossman goto err;
1239ec2ed700SUlf Hansson
124017d33e14SNicolas Pitre card = host->card;
1241af517150SDavid Brownell
1242af517150SDavid Brownell /*
1243ed919b01SOhad Ben-Cohen * Enable runtime PM only if supported by host+card+board
1244ed919b01SOhad Ben-Cohen */
1245ed919b01SOhad Ben-Cohen if (host->caps & MMC_CAP_POWER_OFF_CARD) {
1246ed919b01SOhad Ben-Cohen /*
12474760257cSAdrian Hunter * Do not allow runtime suspend until after SDIO function
12484760257cSAdrian Hunter * devices are added.
12494760257cSAdrian Hunter */
12504760257cSAdrian Hunter pm_runtime_get_noresume(&card->dev);
12514760257cSAdrian Hunter
12524760257cSAdrian Hunter /*
125381968561SOhad Ben-Cohen * Let runtime PM core know our card is active
125481968561SOhad Ben-Cohen */
125581968561SOhad Ben-Cohen err = pm_runtime_set_active(&card->dev);
125681968561SOhad Ben-Cohen if (err)
125781968561SOhad Ben-Cohen goto remove;
125881968561SOhad Ben-Cohen
125981968561SOhad Ben-Cohen /*
126081968561SOhad Ben-Cohen * Enable runtime PM for this card
126181968561SOhad Ben-Cohen */
126281968561SOhad Ben-Cohen pm_runtime_enable(&card->dev);
1263ed919b01SOhad Ben-Cohen }
126481968561SOhad Ben-Cohen
126581968561SOhad Ben-Cohen /*
12665c4e6f13SPierre Ossman * The number of functions on the card is encoded inside
12675c4e6f13SPierre Ossman * the ocr.
12685c4e6f13SPierre Ossman */
1269e8812793SMatt Fleming funcs = (ocr & 0x70000000) >> 28;
1270e8812793SMatt Fleming card->sdio_funcs = 0;
12714ff6471cSPierre Ossman
12724ff6471cSPierre Ossman /*
1273e29a7d73SPierre Ossman * Initialize (but don't add) all present functions.
1274e29a7d73SPierre Ossman */
1275e8812793SMatt Fleming for (i = 0; i < funcs; i++, card->sdio_funcs++) {
1276e29a7d73SPierre Ossman err = sdio_init_func(host->card, i + 1);
1277e29a7d73SPierre Ossman if (err)
1278e29a7d73SPierre Ossman goto remove;
127940bba0c1SOhad Ben-Cohen
128040bba0c1SOhad Ben-Cohen /*
1281ed919b01SOhad Ben-Cohen * Enable Runtime PM for this func (if supported)
128240bba0c1SOhad Ben-Cohen */
1283ed919b01SOhad Ben-Cohen if (host->caps & MMC_CAP_POWER_OFF_CARD)
128440bba0c1SOhad Ben-Cohen pm_runtime_enable(&card->sdio_func[i]->dev);
1285e29a7d73SPierre Ossman }
12865c4e6f13SPierre Ossman
1287e29a7d73SPierre Ossman /*
1288e29a7d73SPierre Ossman * First add the card to the driver model...
1289e29a7d73SPierre Ossman */
1290807e8e40SAndy Ross mmc_release_host(host);
12915c4e6f13SPierre Ossman err = mmc_add_card(host->card);
12925c4e6f13SPierre Ossman if (err)
1293e29a7d73SPierre Ossman goto remove_added;
1294e29a7d73SPierre Ossman
1295e29a7d73SPierre Ossman /*
1296e29a7d73SPierre Ossman * ...then the SDIO functions.
1297e29a7d73SPierre Ossman */
1298e29a7d73SPierre Ossman for (i = 0;i < funcs;i++) {
1299e29a7d73SPierre Ossman err = sdio_add_func(host->card->sdio_func[i]);
1300e29a7d73SPierre Ossman if (err)
1301e29a7d73SPierre Ossman goto remove_added;
1302e29a7d73SPierre Ossman }
13035c4e6f13SPierre Ossman
13044760257cSAdrian Hunter if (host->caps & MMC_CAP_POWER_OFF_CARD)
13054760257cSAdrian Hunter pm_runtime_put(&card->dev);
13064760257cSAdrian Hunter
130734497913SDmitry Shmidt mmc_claim_host(host);
13085c4e6f13SPierre Ossman return 0;
13095c4e6f13SPierre Ossman
1310e29a7d73SPierre Ossman
1311e29a7d73SPierre Ossman remove:
1312807e8e40SAndy Ross mmc_release_host(host);
131382e7edc2SAdrian Hunter remove_added:
131482e7edc2SAdrian Hunter /*
131582e7edc2SAdrian Hunter * The devices are being deleted so it is not necessary to disable
13164760257cSAdrian Hunter * runtime PM. Similarly we also don't pm_runtime_put() the SDIO card
13174760257cSAdrian Hunter * because it needs to be active to remove any function devices that
13184760257cSAdrian Hunter * were probed, and after that it gets deleted.
131982e7edc2SAdrian Hunter */
1320e29a7d73SPierre Ossman mmc_sdio_remove(host);
1321807e8e40SAndy Ross mmc_claim_host(host);
13225c4e6f13SPierre Ossman err:
13235c4e6f13SPierre Ossman mmc_detach_bus(host);
13245c4e6f13SPierre Ossman
1325a3c76eb9SGirish K S pr_err("%s: error %d whilst initialising SDIO card\n",
13265c4e6f13SPierre Ossman mmc_hostname(host), err);
13275c4e6f13SPierre Ossman
13285c4e6f13SPierre Ossman return err;
13295c4e6f13SPierre Ossman }
13305c4e6f13SPierre Ossman
1331