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 void 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 237 static const struct dev_pm_ops sdio_bus_pm_ops = { 238 SET_SYSTEM_SLEEP_PM_OPS(pm_generic_suspend, pm_generic_resume) 239 SET_RUNTIME_PM_OPS( 240 pm_generic_runtime_suspend, 241 pm_generic_runtime_resume, 242 NULL 243 ) 244 }; 245 246 static struct bus_type sdio_bus_type = { 247 .name = "sdio", 248 .dev_groups = sdio_dev_groups, 249 .match = sdio_bus_match, 250 .uevent = sdio_bus_uevent, 251 .probe = sdio_bus_probe, 252 .remove = sdio_bus_remove, 253 .pm = &sdio_bus_pm_ops, 254 }; 255 256 int sdio_register_bus(void) 257 { 258 return bus_register(&sdio_bus_type); 259 } 260 261 void sdio_unregister_bus(void) 262 { 263 bus_unregister(&sdio_bus_type); 264 } 265 266 /** 267 * sdio_register_driver - register a function driver 268 * @drv: SDIO function driver 269 */ 270 int sdio_register_driver(struct sdio_driver *drv) 271 { 272 drv->drv.name = drv->name; 273 drv->drv.bus = &sdio_bus_type; 274 return driver_register(&drv->drv); 275 } 276 EXPORT_SYMBOL_GPL(sdio_register_driver); 277 278 /** 279 * sdio_unregister_driver - unregister a function driver 280 * @drv: SDIO function driver 281 */ 282 void sdio_unregister_driver(struct sdio_driver *drv) 283 { 284 drv->drv.bus = &sdio_bus_type; 285 driver_unregister(&drv->drv); 286 } 287 EXPORT_SYMBOL_GPL(sdio_unregister_driver); 288 289 static void sdio_release_func(struct device *dev) 290 { 291 struct sdio_func *func = dev_to_sdio_func(dev); 292 293 sdio_free_func_cis(func); 294 295 kfree(func->info); 296 kfree(func->tmpbuf); 297 kfree(func); 298 } 299 300 /* 301 * Allocate and initialise a new SDIO function structure. 302 */ 303 struct sdio_func *sdio_alloc_func(struct mmc_card *card) 304 { 305 struct sdio_func *func; 306 307 func = kzalloc(sizeof(struct sdio_func), GFP_KERNEL); 308 if (!func) 309 return ERR_PTR(-ENOMEM); 310 311 /* 312 * allocate buffer separately to make sure it's properly aligned for 313 * DMA usage (incl. 64 bit DMA) 314 */ 315 func->tmpbuf = kmalloc(4, GFP_KERNEL); 316 if (!func->tmpbuf) { 317 kfree(func); 318 return ERR_PTR(-ENOMEM); 319 } 320 321 func->card = card; 322 323 device_initialize(&func->dev); 324 325 func->dev.parent = &card->dev; 326 func->dev.bus = &sdio_bus_type; 327 func->dev.release = sdio_release_func; 328 329 return func; 330 } 331 332 #ifdef CONFIG_ACPI 333 static void sdio_acpi_set_handle(struct sdio_func *func) 334 { 335 struct mmc_host *host = func->card->host; 336 u64 addr = ((u64)host->slotno << 16) | func->num; 337 338 acpi_preset_companion(&func->dev, ACPI_COMPANION(host->parent), addr); 339 } 340 #else 341 static inline void sdio_acpi_set_handle(struct sdio_func *func) {} 342 #endif 343 344 static void sdio_set_of_node(struct sdio_func *func) 345 { 346 struct mmc_host *host = func->card->host; 347 348 func->dev.of_node = mmc_of_find_child_device(host, func->num); 349 } 350 351 /* 352 * Register a new SDIO function with the driver model. 353 */ 354 int sdio_add_func(struct sdio_func *func) 355 { 356 int ret; 357 358 dev_set_name(&func->dev, "%s:%d", mmc_card_id(func->card), func->num); 359 360 sdio_set_of_node(func); 361 sdio_acpi_set_handle(func); 362 device_enable_async_suspend(&func->dev); 363 ret = device_add(&func->dev); 364 if (ret == 0) 365 sdio_func_set_present(func); 366 367 return ret; 368 } 369 370 /* 371 * Unregister a SDIO function with the driver model, and 372 * (eventually) free it. 373 * This function can be called through error paths where sdio_add_func() was 374 * never executed (because a failure occurred at an earlier point). 375 */ 376 void sdio_remove_func(struct sdio_func *func) 377 { 378 if (!sdio_func_present(func)) 379 return; 380 381 device_del(&func->dev); 382 of_node_put(func->dev.of_node); 383 put_device(&func->dev); 384 } 385 386