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