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 /* Unbound SDIO functions are always suspended. 142 * During probe, the function is set active and the usage count 143 * is incremented. If the driver supports runtime PM, 144 * it should call pm_runtime_put_noidle() in its probe routine and 145 * pm_runtime_get_noresume() in its remove routine. 146 */ 147 if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD) { 148 ret = pm_runtime_get_sync(dev); 149 if (ret < 0) 150 goto disable_runtimepm; 151 } 152 153 /* Set the default block size so the driver is sure it's something 154 * sensible. */ 155 sdio_claim_host(func); 156 ret = sdio_set_block_size(func, 0); 157 sdio_release_host(func); 158 if (ret) 159 goto disable_runtimepm; 160 161 ret = drv->probe(func, id); 162 if (ret) 163 goto disable_runtimepm; 164 165 return 0; 166 167 disable_runtimepm: 168 if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD) 169 pm_runtime_put_noidle(dev); 170 dev_pm_domain_detach(dev, false); 171 return ret; 172 } 173 174 static int sdio_bus_remove(struct device *dev) 175 { 176 struct sdio_driver *drv = to_sdio_driver(dev->driver); 177 struct sdio_func *func = dev_to_sdio_func(dev); 178 179 /* Make sure card is powered before invoking ->remove() */ 180 if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD) 181 pm_runtime_get_sync(dev); 182 183 drv->remove(func); 184 185 if (func->irq_handler) { 186 pr_warn("WARNING: driver %s did not remove its interrupt handler!\n", 187 drv->name); 188 sdio_claim_host(func); 189 sdio_release_irq(func); 190 sdio_release_host(func); 191 } 192 193 /* First, undo the increment made directly above */ 194 if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD) 195 pm_runtime_put_noidle(dev); 196 197 /* Then undo the runtime PM settings in sdio_bus_probe() */ 198 if (func->card->host->caps & MMC_CAP_POWER_OFF_CARD) 199 pm_runtime_put_sync(dev); 200 201 dev_pm_domain_detach(dev, false); 202 203 return 0; 204 } 205 206 static const struct dev_pm_ops sdio_bus_pm_ops = { 207 SET_SYSTEM_SLEEP_PM_OPS(pm_generic_suspend, pm_generic_resume) 208 SET_RUNTIME_PM_OPS( 209 pm_generic_runtime_suspend, 210 pm_generic_runtime_resume, 211 NULL 212 ) 213 }; 214 215 static struct bus_type sdio_bus_type = { 216 .name = "sdio", 217 .dev_groups = sdio_dev_groups, 218 .match = sdio_bus_match, 219 .uevent = sdio_bus_uevent, 220 .probe = sdio_bus_probe, 221 .remove = sdio_bus_remove, 222 .pm = &sdio_bus_pm_ops, 223 }; 224 225 int sdio_register_bus(void) 226 { 227 return bus_register(&sdio_bus_type); 228 } 229 230 void sdio_unregister_bus(void) 231 { 232 bus_unregister(&sdio_bus_type); 233 } 234 235 /** 236 * sdio_register_driver - register a function driver 237 * @drv: SDIO function driver 238 */ 239 int sdio_register_driver(struct sdio_driver *drv) 240 { 241 drv->drv.name = drv->name; 242 drv->drv.bus = &sdio_bus_type; 243 return driver_register(&drv->drv); 244 } 245 EXPORT_SYMBOL_GPL(sdio_register_driver); 246 247 /** 248 * sdio_unregister_driver - unregister a function driver 249 * @drv: SDIO function driver 250 */ 251 void sdio_unregister_driver(struct sdio_driver *drv) 252 { 253 drv->drv.bus = &sdio_bus_type; 254 driver_unregister(&drv->drv); 255 } 256 EXPORT_SYMBOL_GPL(sdio_unregister_driver); 257 258 static void sdio_release_func(struct device *dev) 259 { 260 struct sdio_func *func = dev_to_sdio_func(dev); 261 262 sdio_free_func_cis(func); 263 264 kfree(func->info); 265 kfree(func->tmpbuf); 266 kfree(func); 267 } 268 269 /* 270 * Allocate and initialise a new SDIO function structure. 271 */ 272 struct sdio_func *sdio_alloc_func(struct mmc_card *card) 273 { 274 struct sdio_func *func; 275 276 func = kzalloc(sizeof(struct sdio_func), GFP_KERNEL); 277 if (!func) 278 return ERR_PTR(-ENOMEM); 279 280 /* 281 * allocate buffer separately to make sure it's properly aligned for 282 * DMA usage (incl. 64 bit DMA) 283 */ 284 func->tmpbuf = kmalloc(4, GFP_KERNEL); 285 if (!func->tmpbuf) { 286 kfree(func); 287 return ERR_PTR(-ENOMEM); 288 } 289 290 func->card = card; 291 292 device_initialize(&func->dev); 293 294 func->dev.parent = &card->dev; 295 func->dev.bus = &sdio_bus_type; 296 func->dev.release = sdio_release_func; 297 298 return func; 299 } 300 301 #ifdef CONFIG_ACPI 302 static void sdio_acpi_set_handle(struct sdio_func *func) 303 { 304 struct mmc_host *host = func->card->host; 305 u64 addr = ((u64)host->slotno << 16) | func->num; 306 307 acpi_preset_companion(&func->dev, ACPI_COMPANION(host->parent), addr); 308 } 309 #else 310 static inline void sdio_acpi_set_handle(struct sdio_func *func) {} 311 #endif 312 313 static void sdio_set_of_node(struct sdio_func *func) 314 { 315 struct mmc_host *host = func->card->host; 316 317 func->dev.of_node = mmc_of_find_child_device(host, func->num); 318 } 319 320 /* 321 * Register a new SDIO function with the driver model. 322 */ 323 int sdio_add_func(struct sdio_func *func) 324 { 325 int ret; 326 327 dev_set_name(&func->dev, "%s:%d", mmc_card_id(func->card), func->num); 328 329 sdio_set_of_node(func); 330 sdio_acpi_set_handle(func); 331 device_enable_async_suspend(&func->dev); 332 ret = device_add(&func->dev); 333 if (ret == 0) 334 sdio_func_set_present(func); 335 336 return ret; 337 } 338 339 /* 340 * Unregister a SDIO function with the driver model, and 341 * (eventually) free it. 342 * This function can be called through error paths where sdio_add_func() was 343 * never executed (because a failure occurred at an earlier point). 344 */ 345 void sdio_remove_func(struct sdio_func *func) 346 { 347 if (!sdio_func_present(func)) 348 return; 349 350 device_del(&func->dev); 351 of_node_put(func->dev.of_node); 352 put_device(&func->dev); 353 } 354 355