1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * linux/drivers/mmc/core/sdio_bus.c 4 * 5 * Copyright 2007 Pierre Ossman 6 * 7 * SDIO function driver model 8 */ 9 10 #include <linux/device.h> 11 #include <linux/err.h> 12 #include <linux/export.h> 13 #include <linux/slab.h> 14 #include <linux/pm_runtime.h> 15 #include <linux/pm_domain.h> 16 #include <linux/acpi.h> 17 18 #include <linux/mmc/card.h> 19 #include <linux/mmc/host.h> 20 #include <linux/mmc/sdio_func.h> 21 #include <linux/of.h> 22 23 #include "core.h" 24 #include "card.h" 25 #include "sdio_cis.h" 26 #include "sdio_bus.h" 27 28 #define to_sdio_driver(d) container_of(d, struct sdio_driver, drv) 29 30 /* show configuration fields */ 31 #define sdio_config_attr(field, format_string, args...) \ 32 static ssize_t \ 33 field##_show(struct device *dev, struct device_attribute *attr, char *buf) \ 34 { \ 35 struct sdio_func *func; \ 36 \ 37 func = dev_to_sdio_func (dev); \ 38 return sprintf(buf, format_string, args); \ 39 } \ 40 static DEVICE_ATTR_RO(field) 41 42 sdio_config_attr(class, "0x%02x\n", func->class); 43 sdio_config_attr(vendor, "0x%04x\n", func->vendor); 44 sdio_config_attr(device, "0x%04x\n", func->device); 45 sdio_config_attr(revision, "%u.%u\n", func->major_rev, func->minor_rev); 46 sdio_config_attr(modalias, "sdio:c%02Xv%04Xd%04X\n", func->class, func->vendor, func->device); 47 48 #define sdio_info_attr(num) \ 49 static ssize_t info##num##_show(struct device *dev, struct device_attribute *attr, char *buf) \ 50 { \ 51 struct sdio_func *func = dev_to_sdio_func(dev); \ 52 \ 53 if (num > func->num_info) \ 54 return -ENODATA; \ 55 if (!func->info[num-1][0]) \ 56 return 0; \ 57 return sprintf(buf, "%s\n", func->info[num-1]); \ 58 } \ 59 static DEVICE_ATTR_RO(info##num) 60 61 sdio_info_attr(1); 62 sdio_info_attr(2); 63 sdio_info_attr(3); 64 sdio_info_attr(4); 65 66 static struct attribute *sdio_dev_attrs[] = { 67 &dev_attr_class.attr, 68 &dev_attr_vendor.attr, 69 &dev_attr_device.attr, 70 &dev_attr_revision.attr, 71 &dev_attr_info1.attr, 72 &dev_attr_info2.attr, 73 &dev_attr_info3.attr, 74 &dev_attr_info4.attr, 75 &dev_attr_modalias.attr, 76 NULL, 77 }; 78 ATTRIBUTE_GROUPS(sdio_dev); 79 80 static const struct sdio_device_id *sdio_match_one(struct sdio_func *func, 81 const struct sdio_device_id *id) 82 { 83 if (id->class != (__u8)SDIO_ANY_ID && id->class != func->class) 84 return NULL; 85 if (id->vendor != (__u16)SDIO_ANY_ID && id->vendor != func->vendor) 86 return NULL; 87 if (id->device != (__u16)SDIO_ANY_ID && id->device != func->device) 88 return NULL; 89 return id; 90 } 91 92 static const struct sdio_device_id *sdio_match_device(struct sdio_func *func, 93 struct sdio_driver *sdrv) 94 { 95 const struct sdio_device_id *ids; 96 97 ids = sdrv->id_table; 98 99 if (ids) { 100 while (ids->class || ids->vendor || ids->device) { 101 if (sdio_match_one(func, ids)) 102 return ids; 103 ids++; 104 } 105 } 106 107 return NULL; 108 } 109 110 static int sdio_bus_match(struct device *dev, struct device_driver *drv) 111 { 112 struct sdio_func *func = dev_to_sdio_func(dev); 113 struct sdio_driver *sdrv = to_sdio_driver(drv); 114 115 if (sdio_match_device(func, sdrv)) 116 return 1; 117 118 return 0; 119 } 120 121 static int 122 sdio_bus_uevent(struct device *dev, struct kobj_uevent_env *env) 123 { 124 struct sdio_func *func = dev_to_sdio_func(dev); 125 unsigned int i; 126 127 if (add_uevent_var(env, 128 "SDIO_CLASS=%02X", func->class)) 129 return -ENOMEM; 130 131 if (add_uevent_var(env, 132 "SDIO_ID=%04X:%04X", func->vendor, func->device)) 133 return -ENOMEM; 134 135 if (add_uevent_var(env, 136 "SDIO_REVISION=%u.%u", func->major_rev, func->minor_rev)) 137 return -ENOMEM; 138 139 for (i = 0; i < func->num_info; i++) { 140 if (add_uevent_var(env, "SDIO_INFO%u=%s", i+1, func->info[i])) 141 return -ENOMEM; 142 } 143 144 if (add_uevent_var(env, 145 "MODALIAS=sdio:c%02Xv%04Xd%04X", 146 func->class, func->vendor, func->device)) 147 return -ENOMEM; 148 149 return 0; 150 } 151 152 static int sdio_bus_probe(struct device *dev) 153 { 154 struct sdio_driver *drv = to_sdio_driver(dev->driver); 155 struct sdio_func *func = dev_to_sdio_func(dev); 156 const struct sdio_device_id *id; 157 int ret; 158 159 id = sdio_match_device(func, drv); 160 if (!id) 161 return -ENODEV; 162 163 ret = dev_pm_domain_attach(dev, false); 164 if (ret) 165 return ret; 166 167 atomic_inc(&func->card->sdio_funcs_probed); 168 169 /* Unbound SDIO functions are always suspended. 170 * During probe, the function is set active and the usage count 171 * is incremented. If the driver supports runtime PM, 172 * it should call pm_runtime_put_noidle() in its probe routine and 173 * pm_runtime_get_noresume() in its remove routine. 174 */ 175 if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD) { 176 ret = pm_runtime_get_sync(dev); 177 if (ret < 0) 178 goto disable_runtimepm; 179 } 180 181 /* Set the default block size so the driver is sure it's something 182 * sensible. */ 183 sdio_claim_host(func); 184 if (mmc_card_removed(func->card)) 185 ret = -ENOMEDIUM; 186 else 187 ret = sdio_set_block_size(func, 0); 188 sdio_release_host(func); 189 if (ret) 190 goto disable_runtimepm; 191 192 ret = drv->probe(func, id); 193 if (ret) 194 goto disable_runtimepm; 195 196 return 0; 197 198 disable_runtimepm: 199 atomic_dec(&func->card->sdio_funcs_probed); 200 if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD) 201 pm_runtime_put_noidle(dev); 202 dev_pm_domain_detach(dev, false); 203 return ret; 204 } 205 206 static int sdio_bus_remove(struct device *dev) 207 { 208 struct sdio_driver *drv = to_sdio_driver(dev->driver); 209 struct sdio_func *func = dev_to_sdio_func(dev); 210 211 /* Make sure card is powered before invoking ->remove() */ 212 if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD) 213 pm_runtime_get_sync(dev); 214 215 drv->remove(func); 216 atomic_dec(&func->card->sdio_funcs_probed); 217 218 if (func->irq_handler) { 219 pr_warn("WARNING: driver %s did not remove its interrupt handler!\n", 220 drv->name); 221 sdio_claim_host(func); 222 sdio_release_irq(func); 223 sdio_release_host(func); 224 } 225 226 /* First, undo the increment made directly above */ 227 if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD) 228 pm_runtime_put_noidle(dev); 229 230 /* Then undo the runtime PM settings in sdio_bus_probe() */ 231 if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD) 232 pm_runtime_put_sync(dev); 233 234 dev_pm_domain_detach(dev, false); 235 236 return 0; 237 } 238 239 static const struct dev_pm_ops sdio_bus_pm_ops = { 240 SET_SYSTEM_SLEEP_PM_OPS(pm_generic_suspend, pm_generic_resume) 241 SET_RUNTIME_PM_OPS( 242 pm_generic_runtime_suspend, 243 pm_generic_runtime_resume, 244 NULL 245 ) 246 }; 247 248 static struct bus_type sdio_bus_type = { 249 .name = "sdio", 250 .dev_groups = sdio_dev_groups, 251 .match = sdio_bus_match, 252 .uevent = sdio_bus_uevent, 253 .probe = sdio_bus_probe, 254 .remove = sdio_bus_remove, 255 .pm = &sdio_bus_pm_ops, 256 }; 257 258 int sdio_register_bus(void) 259 { 260 return bus_register(&sdio_bus_type); 261 } 262 263 void sdio_unregister_bus(void) 264 { 265 bus_unregister(&sdio_bus_type); 266 } 267 268 /** 269 * sdio_register_driver - register a function driver 270 * @drv: SDIO function driver 271 */ 272 int sdio_register_driver(struct sdio_driver *drv) 273 { 274 drv->drv.name = drv->name; 275 drv->drv.bus = &sdio_bus_type; 276 return driver_register(&drv->drv); 277 } 278 EXPORT_SYMBOL_GPL(sdio_register_driver); 279 280 /** 281 * sdio_unregister_driver - unregister a function driver 282 * @drv: SDIO function driver 283 */ 284 void sdio_unregister_driver(struct sdio_driver *drv) 285 { 286 drv->drv.bus = &sdio_bus_type; 287 driver_unregister(&drv->drv); 288 } 289 EXPORT_SYMBOL_GPL(sdio_unregister_driver); 290 291 static void sdio_release_func(struct device *dev) 292 { 293 struct sdio_func *func = dev_to_sdio_func(dev); 294 295 sdio_free_func_cis(func); 296 297 kfree(func->info); 298 kfree(func->tmpbuf); 299 kfree(func); 300 } 301 302 /* 303 * Allocate and initialise a new SDIO function structure. 304 */ 305 struct sdio_func *sdio_alloc_func(struct mmc_card *card) 306 { 307 struct sdio_func *func; 308 309 func = kzalloc(sizeof(struct sdio_func), GFP_KERNEL); 310 if (!func) 311 return ERR_PTR(-ENOMEM); 312 313 /* 314 * allocate buffer separately to make sure it's properly aligned for 315 * DMA usage (incl. 64 bit DMA) 316 */ 317 func->tmpbuf = kmalloc(4, GFP_KERNEL); 318 if (!func->tmpbuf) { 319 kfree(func); 320 return ERR_PTR(-ENOMEM); 321 } 322 323 func->card = card; 324 325 device_initialize(&func->dev); 326 327 func->dev.parent = &card->dev; 328 func->dev.bus = &sdio_bus_type; 329 func->dev.release = sdio_release_func; 330 331 return func; 332 } 333 334 #ifdef CONFIG_ACPI 335 static void sdio_acpi_set_handle(struct sdio_func *func) 336 { 337 struct mmc_host *host = func->card->host; 338 u64 addr = ((u64)host->slotno << 16) | func->num; 339 340 acpi_preset_companion(&func->dev, ACPI_COMPANION(host->parent), addr); 341 } 342 #else 343 static inline void sdio_acpi_set_handle(struct sdio_func *func) {} 344 #endif 345 346 static void sdio_set_of_node(struct sdio_func *func) 347 { 348 struct mmc_host *host = func->card->host; 349 350 func->dev.of_node = mmc_of_find_child_device(host, func->num); 351 } 352 353 /* 354 * Register a new SDIO function with the driver model. 355 */ 356 int sdio_add_func(struct sdio_func *func) 357 { 358 int ret; 359 360 dev_set_name(&func->dev, "%s:%d", mmc_card_id(func->card), func->num); 361 362 sdio_set_of_node(func); 363 sdio_acpi_set_handle(func); 364 device_enable_async_suspend(&func->dev); 365 ret = device_add(&func->dev); 366 if (ret == 0) 367 sdio_func_set_present(func); 368 369 return ret; 370 } 371 372 /* 373 * Unregister a SDIO function with the driver model, and 374 * (eventually) free it. 375 * This function can be called through error paths where sdio_add_func() was 376 * never executed (because a failure occurred at an earlier point). 377 */ 378 void sdio_remove_func(struct sdio_func *func) 379 { 380 if (!sdio_func_present(func)) 381 return; 382 383 device_del(&func->dev); 384 of_node_put(func->dev.of_node); 385 put_device(&func->dev); 386 } 387 388