1 /* 2 * linux/drivers/mmc/core/bus.c 3 * 4 * Copyright (C) 2003 Russell King, All Rights Reserved. 5 * Copyright (C) 2007 Pierre Ossman 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 * 11 * MMC card bus driver model 12 */ 13 14 #include <linux/export.h> 15 #include <linux/device.h> 16 #include <linux/err.h> 17 #include <linux/slab.h> 18 #include <linux/stat.h> 19 #include <linux/pm_runtime.h> 20 21 #include <linux/mmc/card.h> 22 #include <linux/mmc/host.h> 23 24 #include "core.h" 25 #include "sdio_cis.h" 26 #include "bus.h" 27 28 #define to_mmc_driver(d) container_of(d, struct mmc_driver, drv) 29 30 static ssize_t mmc_type_show(struct device *dev, 31 struct device_attribute *attr, char *buf) 32 { 33 struct mmc_card *card = mmc_dev_to_card(dev); 34 35 switch (card->type) { 36 case MMC_TYPE_MMC: 37 return sprintf(buf, "MMC\n"); 38 case MMC_TYPE_SD: 39 return sprintf(buf, "SD\n"); 40 case MMC_TYPE_SDIO: 41 return sprintf(buf, "SDIO\n"); 42 case MMC_TYPE_SD_COMBO: 43 return sprintf(buf, "SDcombo\n"); 44 default: 45 return -EFAULT; 46 } 47 } 48 49 static struct device_attribute mmc_dev_attrs[] = { 50 __ATTR(type, S_IRUGO, mmc_type_show, NULL), 51 __ATTR_NULL, 52 }; 53 54 /* 55 * This currently matches any MMC driver to any MMC card - drivers 56 * themselves make the decision whether to drive this card in their 57 * probe method. 58 */ 59 static int mmc_bus_match(struct device *dev, struct device_driver *drv) 60 { 61 return 1; 62 } 63 64 static int 65 mmc_bus_uevent(struct device *dev, struct kobj_uevent_env *env) 66 { 67 struct mmc_card *card = mmc_dev_to_card(dev); 68 const char *type; 69 int retval = 0; 70 71 switch (card->type) { 72 case MMC_TYPE_MMC: 73 type = "MMC"; 74 break; 75 case MMC_TYPE_SD: 76 type = "SD"; 77 break; 78 case MMC_TYPE_SDIO: 79 type = "SDIO"; 80 break; 81 case MMC_TYPE_SD_COMBO: 82 type = "SDcombo"; 83 break; 84 default: 85 type = NULL; 86 } 87 88 if (type) { 89 retval = add_uevent_var(env, "MMC_TYPE=%s", type); 90 if (retval) 91 return retval; 92 } 93 94 retval = add_uevent_var(env, "MMC_NAME=%s", mmc_card_name(card)); 95 if (retval) 96 return retval; 97 98 /* 99 * Request the mmc_block device. Note: that this is a direct request 100 * for the module it carries no information as to what is inserted. 101 */ 102 retval = add_uevent_var(env, "MODALIAS=mmc:block"); 103 104 return retval; 105 } 106 107 static int mmc_bus_probe(struct device *dev) 108 { 109 struct mmc_driver *drv = to_mmc_driver(dev->driver); 110 struct mmc_card *card = mmc_dev_to_card(dev); 111 112 return drv->probe(card); 113 } 114 115 static int mmc_bus_remove(struct device *dev) 116 { 117 struct mmc_driver *drv = to_mmc_driver(dev->driver); 118 struct mmc_card *card = mmc_dev_to_card(dev); 119 120 drv->remove(card); 121 122 return 0; 123 } 124 125 static void mmc_bus_shutdown(struct device *dev) 126 { 127 struct mmc_driver *drv = to_mmc_driver(dev->driver); 128 struct mmc_card *card = mmc_dev_to_card(dev); 129 struct mmc_host *host = card->host; 130 int ret; 131 132 if (dev->driver && drv->shutdown) 133 drv->shutdown(card); 134 135 if (host->bus_ops->shutdown) { 136 ret = host->bus_ops->shutdown(host); 137 if (ret) 138 pr_warn("%s: error %d during shutdown\n", 139 mmc_hostname(host), ret); 140 } 141 } 142 143 #ifdef CONFIG_PM_SLEEP 144 static int mmc_bus_suspend(struct device *dev) 145 { 146 struct mmc_driver *drv = to_mmc_driver(dev->driver); 147 struct mmc_card *card = mmc_dev_to_card(dev); 148 struct mmc_host *host = card->host; 149 int ret; 150 151 if (dev->driver && drv->suspend) { 152 ret = drv->suspend(card); 153 if (ret) 154 return ret; 155 } 156 157 ret = host->bus_ops->suspend(host); 158 return ret; 159 } 160 161 static int mmc_bus_resume(struct device *dev) 162 { 163 struct mmc_driver *drv = to_mmc_driver(dev->driver); 164 struct mmc_card *card = mmc_dev_to_card(dev); 165 struct mmc_host *host = card->host; 166 int ret; 167 168 ret = host->bus_ops->resume(host); 169 if (ret) 170 pr_warn("%s: error %d during resume (card was removed?)\n", 171 mmc_hostname(host), ret); 172 173 if (dev->driver && drv->resume) 174 ret = drv->resume(card); 175 176 return ret; 177 } 178 #endif 179 180 #ifdef CONFIG_PM_RUNTIME 181 182 static int mmc_runtime_suspend(struct device *dev) 183 { 184 struct mmc_card *card = mmc_dev_to_card(dev); 185 struct mmc_host *host = card->host; 186 int ret = 0; 187 188 if (host->bus_ops->runtime_suspend) 189 ret = host->bus_ops->runtime_suspend(host); 190 191 return ret; 192 } 193 194 static int mmc_runtime_resume(struct device *dev) 195 { 196 struct mmc_card *card = mmc_dev_to_card(dev); 197 struct mmc_host *host = card->host; 198 int ret = 0; 199 200 if (host->bus_ops->runtime_resume) 201 ret = host->bus_ops->runtime_resume(host); 202 203 return ret; 204 } 205 206 static int mmc_runtime_idle(struct device *dev) 207 { 208 return 0; 209 } 210 211 #endif /* !CONFIG_PM_RUNTIME */ 212 213 static const struct dev_pm_ops mmc_bus_pm_ops = { 214 SET_RUNTIME_PM_OPS(mmc_runtime_suspend, mmc_runtime_resume, 215 mmc_runtime_idle) 216 SET_SYSTEM_SLEEP_PM_OPS(mmc_bus_suspend, mmc_bus_resume) 217 }; 218 219 static struct bus_type mmc_bus_type = { 220 .name = "mmc", 221 .dev_attrs = mmc_dev_attrs, 222 .match = mmc_bus_match, 223 .uevent = mmc_bus_uevent, 224 .probe = mmc_bus_probe, 225 .remove = mmc_bus_remove, 226 .shutdown = mmc_bus_shutdown, 227 .pm = &mmc_bus_pm_ops, 228 }; 229 230 int mmc_register_bus(void) 231 { 232 return bus_register(&mmc_bus_type); 233 } 234 235 void mmc_unregister_bus(void) 236 { 237 bus_unregister(&mmc_bus_type); 238 } 239 240 /** 241 * mmc_register_driver - register a media driver 242 * @drv: MMC media driver 243 */ 244 int mmc_register_driver(struct mmc_driver *drv) 245 { 246 drv->drv.bus = &mmc_bus_type; 247 return driver_register(&drv->drv); 248 } 249 250 EXPORT_SYMBOL(mmc_register_driver); 251 252 /** 253 * mmc_unregister_driver - unregister a media driver 254 * @drv: MMC media driver 255 */ 256 void mmc_unregister_driver(struct mmc_driver *drv) 257 { 258 drv->drv.bus = &mmc_bus_type; 259 driver_unregister(&drv->drv); 260 } 261 262 EXPORT_SYMBOL(mmc_unregister_driver); 263 264 static void mmc_release_card(struct device *dev) 265 { 266 struct mmc_card *card = mmc_dev_to_card(dev); 267 268 sdio_free_common_cis(card); 269 270 kfree(card->info); 271 272 kfree(card); 273 } 274 275 /* 276 * Allocate and initialise a new MMC card structure. 277 */ 278 struct mmc_card *mmc_alloc_card(struct mmc_host *host, struct device_type *type) 279 { 280 struct mmc_card *card; 281 282 card = kzalloc(sizeof(struct mmc_card), GFP_KERNEL); 283 if (!card) 284 return ERR_PTR(-ENOMEM); 285 286 card->host = host; 287 288 device_initialize(&card->dev); 289 290 card->dev.parent = mmc_classdev(host); 291 card->dev.bus = &mmc_bus_type; 292 card->dev.release = mmc_release_card; 293 card->dev.type = type; 294 295 return card; 296 } 297 298 /* 299 * Register a new MMC card with the driver model. 300 */ 301 int mmc_add_card(struct mmc_card *card) 302 { 303 int ret; 304 const char *type; 305 const char *uhs_bus_speed_mode = ""; 306 static const char *const uhs_speeds[] = { 307 [UHS_SDR12_BUS_SPEED] = "SDR12 ", 308 [UHS_SDR25_BUS_SPEED] = "SDR25 ", 309 [UHS_SDR50_BUS_SPEED] = "SDR50 ", 310 [UHS_SDR104_BUS_SPEED] = "SDR104 ", 311 [UHS_DDR50_BUS_SPEED] = "DDR50 ", 312 }; 313 314 315 dev_set_name(&card->dev, "%s:%04x", mmc_hostname(card->host), card->rca); 316 317 switch (card->type) { 318 case MMC_TYPE_MMC: 319 type = "MMC"; 320 break; 321 case MMC_TYPE_SD: 322 type = "SD"; 323 if (mmc_card_blockaddr(card)) { 324 if (mmc_card_ext_capacity(card)) 325 type = "SDXC"; 326 else 327 type = "SDHC"; 328 } 329 break; 330 case MMC_TYPE_SDIO: 331 type = "SDIO"; 332 break; 333 case MMC_TYPE_SD_COMBO: 334 type = "SD-combo"; 335 if (mmc_card_blockaddr(card)) 336 type = "SDHC-combo"; 337 break; 338 default: 339 type = "?"; 340 break; 341 } 342 343 if (mmc_sd_card_uhs(card) && 344 (card->sd_bus_speed < ARRAY_SIZE(uhs_speeds))) 345 uhs_bus_speed_mode = uhs_speeds[card->sd_bus_speed]; 346 347 if (mmc_host_is_spi(card->host)) { 348 pr_info("%s: new %s%s%s card on SPI\n", 349 mmc_hostname(card->host), 350 mmc_card_highspeed(card) ? "high speed " : "", 351 mmc_card_ddr_mode(card) ? "DDR " : "", 352 type); 353 } else { 354 pr_info("%s: new %s%s%s%s%s card at address %04x\n", 355 mmc_hostname(card->host), 356 mmc_card_uhs(card) ? "ultra high speed " : 357 (mmc_card_highspeed(card) ? "high speed " : ""), 358 (mmc_card_hs200(card) ? "HS200 " : ""), 359 mmc_card_ddr_mode(card) ? "DDR " : "", 360 uhs_bus_speed_mode, type, card->rca); 361 } 362 363 #ifdef CONFIG_DEBUG_FS 364 mmc_add_card_debugfs(card); 365 #endif 366 mmc_init_context_info(card->host); 367 368 ret = device_add(&card->dev); 369 if (ret) 370 return ret; 371 372 mmc_card_set_present(card); 373 374 return 0; 375 } 376 377 /* 378 * Unregister a new MMC card with the driver model, and 379 * (eventually) free it. 380 */ 381 void mmc_remove_card(struct mmc_card *card) 382 { 383 #ifdef CONFIG_DEBUG_FS 384 mmc_remove_card_debugfs(card); 385 #endif 386 387 if (mmc_card_present(card)) { 388 if (mmc_host_is_spi(card->host)) { 389 pr_info("%s: SPI card removed\n", 390 mmc_hostname(card->host)); 391 } else { 392 pr_info("%s: card %04x removed\n", 393 mmc_hostname(card->host), card->rca); 394 } 395 device_del(&card->dev); 396 } 397 398 put_device(&card->dev); 399 } 400 401