1 /* 2 * linux/drivers/mmc/core/sdio_bus.c 3 * 4 * Copyright 2007 Pierre Ossman 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or (at 9 * your option) any later version. 10 * 11 * SDIO function driver model 12 */ 13 14 #include <linux/device.h> 15 #include <linux/err.h> 16 #include <linux/slab.h> 17 #include <linux/pm_runtime.h> 18 19 #include <linux/mmc/card.h> 20 #include <linux/mmc/sdio_func.h> 21 22 #include "sdio_cis.h" 23 #include "sdio_bus.h" 24 25 /* show configuration fields */ 26 #define sdio_config_attr(field, format_string) \ 27 static ssize_t \ 28 field##_show(struct device *dev, struct device_attribute *attr, char *buf) \ 29 { \ 30 struct sdio_func *func; \ 31 \ 32 func = dev_to_sdio_func (dev); \ 33 return sprintf (buf, format_string, func->field); \ 34 } 35 36 sdio_config_attr(class, "0x%02x\n"); 37 sdio_config_attr(vendor, "0x%04x\n"); 38 sdio_config_attr(device, "0x%04x\n"); 39 40 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf) 41 { 42 struct sdio_func *func = dev_to_sdio_func (dev); 43 44 return sprintf(buf, "sdio:c%02Xv%04Xd%04X\n", 45 func->class, func->vendor, func->device); 46 } 47 48 static struct device_attribute sdio_dev_attrs[] = { 49 __ATTR_RO(class), 50 __ATTR_RO(vendor), 51 __ATTR_RO(device), 52 __ATTR_RO(modalias), 53 __ATTR_NULL, 54 }; 55 56 static const struct sdio_device_id *sdio_match_one(struct sdio_func *func, 57 const struct sdio_device_id *id) 58 { 59 if (id->class != (__u8)SDIO_ANY_ID && id->class != func->class) 60 return NULL; 61 if (id->vendor != (__u16)SDIO_ANY_ID && id->vendor != func->vendor) 62 return NULL; 63 if (id->device != (__u16)SDIO_ANY_ID && id->device != func->device) 64 return NULL; 65 return id; 66 } 67 68 static const struct sdio_device_id *sdio_match_device(struct sdio_func *func, 69 struct sdio_driver *sdrv) 70 { 71 const struct sdio_device_id *ids; 72 73 ids = sdrv->id_table; 74 75 if (ids) { 76 while (ids->class || ids->vendor || ids->device) { 77 if (sdio_match_one(func, ids)) 78 return ids; 79 ids++; 80 } 81 } 82 83 return NULL; 84 } 85 86 static int sdio_bus_match(struct device *dev, struct device_driver *drv) 87 { 88 struct sdio_func *func = dev_to_sdio_func(dev); 89 struct sdio_driver *sdrv = to_sdio_driver(drv); 90 91 if (sdio_match_device(func, sdrv)) 92 return 1; 93 94 return 0; 95 } 96 97 static int 98 sdio_bus_uevent(struct device *dev, struct kobj_uevent_env *env) 99 { 100 struct sdio_func *func = dev_to_sdio_func(dev); 101 102 if (add_uevent_var(env, 103 "SDIO_CLASS=%02X", func->class)) 104 return -ENOMEM; 105 106 if (add_uevent_var(env, 107 "SDIO_ID=%04X:%04X", func->vendor, func->device)) 108 return -ENOMEM; 109 110 if (add_uevent_var(env, 111 "MODALIAS=sdio:c%02Xv%04Xd%04X", 112 func->class, func->vendor, func->device)) 113 return -ENOMEM; 114 115 return 0; 116 } 117 118 static int sdio_bus_probe(struct device *dev) 119 { 120 struct sdio_driver *drv = to_sdio_driver(dev->driver); 121 struct sdio_func *func = dev_to_sdio_func(dev); 122 const struct sdio_device_id *id; 123 int ret; 124 125 id = sdio_match_device(func, drv); 126 if (!id) 127 return -ENODEV; 128 129 /* Unbound SDIO functions are always suspended. 130 * During probe, the function is set active and the usage count 131 * is incremented. If the driver supports runtime PM, 132 * it should call pm_runtime_put_noidle() in its probe routine and 133 * pm_runtime_get_noresume() in its remove routine. 134 */ 135 ret = pm_runtime_get_sync(dev); 136 if (ret < 0) 137 goto out; 138 139 /* Set the default block size so the driver is sure it's something 140 * sensible. */ 141 sdio_claim_host(func); 142 ret = sdio_set_block_size(func, 0); 143 sdio_release_host(func); 144 if (ret) 145 goto disable_runtimepm; 146 147 ret = drv->probe(func, id); 148 if (ret) 149 goto disable_runtimepm; 150 151 return 0; 152 153 disable_runtimepm: 154 pm_runtime_put_noidle(dev); 155 out: 156 return ret; 157 } 158 159 static int sdio_bus_remove(struct device *dev) 160 { 161 struct sdio_driver *drv = to_sdio_driver(dev->driver); 162 struct sdio_func *func = dev_to_sdio_func(dev); 163 int ret; 164 165 /* Make sure card is powered before invoking ->remove() */ 166 ret = pm_runtime_get_sync(dev); 167 if (ret < 0) 168 goto out; 169 170 drv->remove(func); 171 172 if (func->irq_handler) { 173 printk(KERN_WARNING "WARNING: driver %s did not remove " 174 "its interrupt handler!\n", drv->name); 175 sdio_claim_host(func); 176 sdio_release_irq(func); 177 sdio_release_host(func); 178 } 179 180 /* First, undo the increment made directly above */ 181 pm_runtime_put_noidle(dev); 182 183 /* Then undo the runtime PM settings in sdio_bus_probe() */ 184 pm_runtime_put_noidle(dev); 185 186 out: 187 return ret; 188 } 189 190 #ifdef CONFIG_PM_RUNTIME 191 192 static int sdio_bus_pm_prepare(struct device *dev) 193 { 194 /* 195 * Resume an SDIO device which was suspended at run time at this 196 * point, in order to allow standard SDIO suspend/resume paths 197 * to keep working as usual. 198 * 199 * Ultimately, the SDIO driver itself will decide (in its 200 * suspend handler, or lack thereof) whether the card should be 201 * removed or kept, and if kept, at what power state. 202 * 203 * At this point, PM core have increased our use count, so it's 204 * safe to directly resume the device. After system is resumed 205 * again, PM core will drop back its runtime PM use count, and if 206 * needed device will be suspended again. 207 * 208 * The end result is guaranteed to be a power state that is 209 * coherent with the device's runtime PM use count. 210 * 211 * The return value of pm_runtime_resume is deliberately unchecked 212 * since there is little point in failing system suspend if a 213 * device can't be resumed. 214 */ 215 pm_runtime_resume(dev); 216 217 return 0; 218 } 219 220 static const struct dev_pm_ops sdio_bus_pm_ops = { 221 SET_RUNTIME_PM_OPS( 222 pm_generic_runtime_suspend, 223 pm_generic_runtime_resume, 224 pm_generic_runtime_idle 225 ) 226 .prepare = sdio_bus_pm_prepare, 227 }; 228 229 #define SDIO_PM_OPS_PTR (&sdio_bus_pm_ops) 230 231 #else /* !CONFIG_PM_RUNTIME */ 232 233 #define SDIO_PM_OPS_PTR NULL 234 235 #endif /* !CONFIG_PM_RUNTIME */ 236 237 static struct bus_type sdio_bus_type = { 238 .name = "sdio", 239 .dev_attrs = sdio_dev_attrs, 240 .match = sdio_bus_match, 241 .uevent = sdio_bus_uevent, 242 .probe = sdio_bus_probe, 243 .remove = sdio_bus_remove, 244 .pm = SDIO_PM_OPS_PTR, 245 }; 246 247 int sdio_register_bus(void) 248 { 249 return bus_register(&sdio_bus_type); 250 } 251 252 void sdio_unregister_bus(void) 253 { 254 bus_unregister(&sdio_bus_type); 255 } 256 257 /** 258 * sdio_register_driver - register a function driver 259 * @drv: SDIO function driver 260 */ 261 int sdio_register_driver(struct sdio_driver *drv) 262 { 263 drv->drv.name = drv->name; 264 drv->drv.bus = &sdio_bus_type; 265 return driver_register(&drv->drv); 266 } 267 EXPORT_SYMBOL_GPL(sdio_register_driver); 268 269 /** 270 * sdio_unregister_driver - unregister a function driver 271 * @drv: SDIO function driver 272 */ 273 void sdio_unregister_driver(struct sdio_driver *drv) 274 { 275 drv->drv.bus = &sdio_bus_type; 276 driver_unregister(&drv->drv); 277 } 278 EXPORT_SYMBOL_GPL(sdio_unregister_driver); 279 280 static void sdio_release_func(struct device *dev) 281 { 282 struct sdio_func *func = dev_to_sdio_func(dev); 283 284 sdio_free_func_cis(func); 285 286 if (func->info) 287 kfree(func->info); 288 289 kfree(func); 290 } 291 292 /* 293 * Allocate and initialise a new SDIO function structure. 294 */ 295 struct sdio_func *sdio_alloc_func(struct mmc_card *card) 296 { 297 struct sdio_func *func; 298 299 func = kzalloc(sizeof(struct sdio_func), GFP_KERNEL); 300 if (!func) 301 return ERR_PTR(-ENOMEM); 302 303 func->card = card; 304 305 device_initialize(&func->dev); 306 307 func->dev.parent = &card->dev; 308 func->dev.bus = &sdio_bus_type; 309 func->dev.release = sdio_release_func; 310 311 return func; 312 } 313 314 /* 315 * Register a new SDIO function with the driver model. 316 */ 317 int sdio_add_func(struct sdio_func *func) 318 { 319 int ret; 320 321 dev_set_name(&func->dev, "%s:%d", mmc_card_id(func->card), func->num); 322 323 ret = device_add(&func->dev); 324 if (ret == 0) 325 sdio_func_set_present(func); 326 327 return ret; 328 } 329 330 /* 331 * Unregister a SDIO function with the driver model, and 332 * (eventually) free it. 333 * This function can be called through error paths where sdio_add_func() was 334 * never executed (because a failure occurred at an earlier point). 335 */ 336 void sdio_remove_func(struct sdio_func *func) 337 { 338 if (!sdio_func_present(func)) 339 return; 340 341 device_del(&func->dev); 342 put_device(&func->dev); 343 } 344 345