mmc/core/bus.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  *  linux/drivers/mmc/core/bus.c
0004  *
0005  *  Copyright (C) 2003 Russell King, All Rights Reserved.
0006  *  Copyright (C) 2007 Pierre Ossman
0007  *
0008  *  MMC card bus driver model
0009  */
0010
0011 #include <linux/export.h>
0012 #include <linux/device.h>
0013 #include <linux/err.h>
0014 #include <linux/slab.h>
0015 #include <linux/stat.h>
0016 #include <linux/of.h>
0017 #include <linux/pm_runtime.h>
0018 #include <linux/sysfs.h>
0019
0020 #include <linux/mmc/card.h>
0021 #include <linux/mmc/host.h>
0022
0023 #include "core.h"
0024 #include "card.h"
0025 #include "host.h"
0026 #include "sdio_cis.h"
0027 #include "bus.h"
0028
0029 #define to_mmc_driver(d)    container_of(d, struct mmc_driver, drv)
0030
0031 static ssize_t type_show(struct device *dev,
0032     struct device_attribute *attr, char *buf)
0033 {
0034     struct mmc_card *card = mmc_dev_to_card(dev);
0035
0036     switch (card->type) {
0037     case MMC_TYPE_MMC:
0038         return sysfs_emit(buf, "MMC\n");
0039     case MMC_TYPE_SD:
0040         return sysfs_emit(buf, "SD\n");
0041     case MMC_TYPE_SDIO:
0042         return sysfs_emit(buf, "SDIO\n");
0043     case MMC_TYPE_SD_COMBO:
0044         return sysfs_emit(buf, "SDcombo\n");
0045     default:
0046         return -EFAULT;
0047     }
0048 }
0049 static DEVICE_ATTR_RO(type);
0050
0051 static struct attribute *mmc_dev_attrs[] = {
0052     &dev_attr_type.attr,
0053     NULL,
0054 };
0055 ATTRIBUTE_GROUPS(mmc_dev);
0056
0057 static int
0058 mmc_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
0059 {
0060     struct mmc_card *card = mmc_dev_to_card(dev);
0061     const char *type;
0062     unsigned int i;
0063     int retval = 0;
0064
0065     switch (card->type) {
0066     case MMC_TYPE_MMC:
0067         type = "MMC";
0068         break;
0069     case MMC_TYPE_SD:
0070         type = "SD";
0071         break;
0072     case MMC_TYPE_SDIO:
0073         type = "SDIO";
0074         break;
0075     case MMC_TYPE_SD_COMBO:
0076         type = "SDcombo";
0077         break;
0078     default:
0079         type = NULL;
0080     }
0081
0082     if (type) {
0083         retval = add_uevent_var(env, "MMC_TYPE=%s", type);
0084         if (retval)
0085             return retval;
0086     }
0087
0088     if (mmc_card_sdio(card) || mmc_card_sd_combo(card)) {
0089         retval = add_uevent_var(env, "SDIO_ID=%04X:%04X",
0090                     card->cis.vendor, card->cis.device);
0091         if (retval)
0092             return retval;
0093
0094         retval = add_uevent_var(env, "SDIO_REVISION=%u.%u",
0095                     card->major_rev, card->minor_rev);
0096         if (retval)
0097             return retval;
0098
0099         for (i = 0; i < card->num_info; i++) {
0100             retval = add_uevent_var(env, "SDIO_INFO%u=%s", i+1, card->info[i]);
0101             if (retval)
0102                 return retval;
0103         }
0104     }
0105
0106     /*
0107      * SDIO (non-combo) cards are not handled by mmc_block driver and do not
0108      * have accessible CID register which used by mmc_card_name() function.
0109      */
0110     if (mmc_card_sdio(card))
0111         return 0;
0112
0113     retval = add_uevent_var(env, "MMC_NAME=%s", mmc_card_name(card));
0114     if (retval)
0115         return retval;
0116
0117     /*
0118      * Request the mmc_block device.  Note: that this is a direct request
0119      * for the module it carries no information as to what is inserted.
0120      */
0121     retval = add_uevent_var(env, "MODALIAS=mmc:block");
0122
0123     return retval;
0124 }
0125
0126 static int mmc_bus_probe(struct device *dev)
0127 {
0128     struct mmc_driver *drv = to_mmc_driver(dev->driver);
0129     struct mmc_card *card = mmc_dev_to_card(dev);
0130
0131     return drv->probe(card);
0132 }
0133
0134 static void mmc_bus_remove(struct device *dev)
0135 {
0136     struct mmc_driver *drv = to_mmc_driver(dev->driver);
0137     struct mmc_card *card = mmc_dev_to_card(dev);
0138
0139     drv->remove(card);
0140 }
0141
0142 static void mmc_bus_shutdown(struct device *dev)
0143 {
0144     struct mmc_driver *drv = to_mmc_driver(dev->driver);
0145     struct mmc_card *card = mmc_dev_to_card(dev);
0146     struct mmc_host *host = card->host;
0147     int ret;
0148
0149     if (dev->driver && drv->shutdown)
0150         drv->shutdown(card);
0151
0152     if (host->bus_ops->shutdown) {
0153         ret = host->bus_ops->shutdown(host);
0154         if (ret)
0155             pr_warn("%s: error %d during shutdown\n",
0156                 mmc_hostname(host), ret);
0157     }
0158 }
0159
0160 #ifdef CONFIG_PM_SLEEP
0161 static int mmc_bus_suspend(struct device *dev)
0162 {
0163     struct mmc_card *card = mmc_dev_to_card(dev);
0164     struct mmc_host *host = card->host;
0165     int ret;
0166
0167     ret = pm_generic_suspend(dev);
0168     if (ret)
0169         return ret;
0170
0171     ret = host->bus_ops->suspend(host);
0172     if (ret)
0173         pm_generic_resume(dev);
0174
0175     return ret;
0176 }
0177
0178 static int mmc_bus_resume(struct device *dev)
0179 {
0180     struct mmc_card *card = mmc_dev_to_card(dev);
0181     struct mmc_host *host = card->host;
0182     int ret;
0183
0184     ret = host->bus_ops->resume(host);
0185     if (ret)
0186         pr_warn("%s: error %d during resume (card was removed?)\n",
0187             mmc_hostname(host), ret);
0188
0189     ret = pm_generic_resume(dev);
0190     return ret;
0191 }
0192 #endif
0193
0194 #ifdef CONFIG_PM
0195 static int mmc_runtime_suspend(struct device *dev)
0196 {
0197     struct mmc_card *card = mmc_dev_to_card(dev);
0198     struct mmc_host *host = card->host;
0199
0200     return host->bus_ops->runtime_suspend(host);
0201 }
0202
0203 static int mmc_runtime_resume(struct device *dev)
0204 {
0205     struct mmc_card *card = mmc_dev_to_card(dev);
0206     struct mmc_host *host = card->host;
0207
0208     return host->bus_ops->runtime_resume(host);
0209 }
0210 #endif /* !CONFIG_PM */
0211
0212 static const struct dev_pm_ops mmc_bus_pm_ops = {
0213     SET_RUNTIME_PM_OPS(mmc_runtime_suspend, mmc_runtime_resume, NULL)
0214     SET_SYSTEM_SLEEP_PM_OPS(mmc_bus_suspend, mmc_bus_resume)
0215 };
0216
0217 static struct bus_type mmc_bus_type = {
0218     .name       = "mmc",
0219     .dev_groups = mmc_dev_groups,
0220     .uevent     = mmc_bus_uevent,
0221     .probe      = mmc_bus_probe,
0222     .remove     = mmc_bus_remove,
0223     .shutdown   = mmc_bus_shutdown,
0224     .pm     = &mmc_bus_pm_ops,
0225 };
0226
0227 int mmc_register_bus(void)
0228 {
0229     return bus_register(&mmc_bus_type);
0230 }
0231
0232 void mmc_unregister_bus(void)
0233 {
0234     bus_unregister(&mmc_bus_type);
0235 }
0236
0237 /**
0238  *  mmc_register_driver - register a media driver
0239  *  @drv: MMC media driver
0240  */
0241 int mmc_register_driver(struct mmc_driver *drv)
0242 {
0243     drv->drv.bus = &mmc_bus_type;
0244     return driver_register(&drv->drv);
0245 }
0246
0247 EXPORT_SYMBOL(mmc_register_driver);
0248
0249 /**
0250  *  mmc_unregister_driver - unregister a media driver
0251  *  @drv: MMC media driver
0252  */
0253 void mmc_unregister_driver(struct mmc_driver *drv)
0254 {
0255     drv->drv.bus = &mmc_bus_type;
0256     driver_unregister(&drv->drv);
0257 }
0258
0259 EXPORT_SYMBOL(mmc_unregister_driver);
0260
0261 static void mmc_release_card(struct device *dev)
0262 {
0263     struct mmc_card *card = mmc_dev_to_card(dev);
0264
0265     sdio_free_common_cis(card);
0266
0267     kfree(card->info);
0268
0269     kfree(card);
0270 }
0271
0272 /*
0273  * Allocate and initialise a new MMC card structure.
0274  */
0275 struct mmc_card *mmc_alloc_card(struct mmc_host *host, struct device_type *type)
0276 {
0277     struct mmc_card *card;
0278
0279     card = kzalloc(sizeof(struct mmc_card), GFP_KERNEL);
0280     if (!card)
0281         return ERR_PTR(-ENOMEM);
0282
0283     card->host = host;
0284
0285     device_initialize(&card->dev);
0286
0287     card->dev.parent = mmc_classdev(host);
0288     card->dev.bus = &mmc_bus_type;
0289     card->dev.release = mmc_release_card;
0290     card->dev.type = type;
0291
0292     return card;
0293 }
0294
0295 /*
0296  * Register a new MMC card with the driver model.
0297  */
0298 int mmc_add_card(struct mmc_card *card)
0299 {
0300     int ret;
0301     const char *type;
0302     const char *uhs_bus_speed_mode = "";
0303     static const char *const uhs_speeds[] = {
0304         [UHS_SDR12_BUS_SPEED] = "SDR12 ",
0305         [UHS_SDR25_BUS_SPEED] = "SDR25 ",
0306         [UHS_SDR50_BUS_SPEED] = "SDR50 ",
0307         [UHS_SDR104_BUS_SPEED] = "SDR104 ",
0308         [UHS_DDR50_BUS_SPEED] = "DDR50 ",
0309     };
0310
0311
0312     dev_set_name(&card->dev, "%s:%04x", mmc_hostname(card->host), card->rca);
0313
0314     switch (card->type) {
0315     case MMC_TYPE_MMC:
0316         type = "MMC";
0317         break;
0318     case MMC_TYPE_SD:
0319         type = "SD";
0320         if (mmc_card_blockaddr(card)) {
0321             if (mmc_card_ext_capacity(card))
0322                 type = "SDXC";
0323             else
0324                 type = "SDHC";
0325         }
0326         break;
0327     case MMC_TYPE_SDIO:
0328         type = "SDIO";
0329         break;
0330     case MMC_TYPE_SD_COMBO:
0331         type = "SD-combo";
0332         if (mmc_card_blockaddr(card))
0333             type = "SDHC-combo";
0334         break;
0335     default:
0336         type = "?";
0337         break;
0338     }
0339
0340     if (mmc_card_uhs(card) &&
0341         (card->sd_bus_speed < ARRAY_SIZE(uhs_speeds)))
0342         uhs_bus_speed_mode = uhs_speeds[card->sd_bus_speed];
0343
0344     if (mmc_host_is_spi(card->host)) {
0345         pr_info("%s: new %s%s%s card on SPI\n",
0346             mmc_hostname(card->host),
0347             mmc_card_hs(card) ? "high speed " : "",
0348             mmc_card_ddr52(card) ? "DDR " : "",
0349             type);
0350     } else {
0351         pr_info("%s: new %s%s%s%s%s%s card at address %04x\n",
0352             mmc_hostname(card->host),
0353             mmc_card_uhs(card) ? "ultra high speed " :
0354             (mmc_card_hs(card) ? "high speed " : ""),
0355             mmc_card_hs400(card) ? "HS400 " :
0356             (mmc_card_hs200(card) ? "HS200 " : ""),
0357             mmc_card_hs400es(card) ? "Enhanced strobe " : "",
0358             mmc_card_ddr52(card) ? "DDR " : "",
0359             uhs_bus_speed_mode, type, card->rca);
0360     }
0361
0362 #ifdef CONFIG_DEBUG_FS
0363     mmc_add_card_debugfs(card);
0364 #endif
0365     card->dev.of_node = mmc_of_find_child_device(card->host, 0);
0366
0367     device_enable_async_suspend(&card->dev);
0368
0369     ret = device_add(&card->dev);
0370     if (ret)
0371         return ret;
0372
0373     mmc_card_set_present(card);
0374
0375     return 0;
0376 }
0377
0378 /*
0379  * Unregister a new MMC card with the driver model, and
0380  * (eventually) free it.
0381  */
0382 void mmc_remove_card(struct mmc_card *card)
0383 {
0384     struct mmc_host *host = card->host;
0385
0386 #ifdef CONFIG_DEBUG_FS
0387     mmc_remove_card_debugfs(card);
0388 #endif
0389
0390     if (mmc_card_present(card)) {
0391         if (mmc_host_is_spi(card->host)) {
0392             pr_info("%s: SPI card removed\n",
0393                 mmc_hostname(card->host));
0394         } else {
0395             pr_info("%s: card %04x removed\n",
0396                 mmc_hostname(card->host), card->rca);
0397         }
0398         device_del(&card->dev);
0399         of_node_put(card->dev.of_node);
0400     }
0401
0402     if (host->cqe_enabled) {
0403         host->cqe_ops->cqe_disable(host);
0404         host->cqe_enabled = false;
0405     }
0406
0407     put_device(&card->dev);
0408 }