drivers/mmc/core/sdio_bus.c

   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         if (!(func->card->quirks & MMC_QUIRK_NONSTD_SDIO))
 296                 sdio_free_func_cis(func);
 297
 298         /*
 299          * We have now removed the link to the tuples in the
 300          * card structure, so remove the reference.
 301          */
 302         put_device(&func->card->dev);
 303
 304         kfree(func->info);
 305         kfree(func->tmpbuf);
 306         kfree(func);
 307 }
 308
 309 /*
 310  * Allocate and initialise a new SDIO function structure.
 311  */
 312 struct sdio_func *sdio_alloc_func(struct mmc_card *card)
 313 {
 314         struct sdio_func *func;
 315
 316         func = kzalloc(sizeof(struct sdio_func), GFP_KERNEL);
 317         if (!func)
 318                 return ERR_PTR(-ENOMEM);
 319
 320         /*
 321          * allocate buffer separately to make sure it's properly aligned for
 322          * DMA usage (incl. 64 bit DMA)
 323          */
 324         func->tmpbuf = kmalloc(4, GFP_KERNEL);
 325         if (!func->tmpbuf) {
 326                 kfree(func);
 327                 return ERR_PTR(-ENOMEM);
 328         }
 329
 330         func->card = card;
 331
 332         device_initialize(&func->dev);
 333
 334         /*
 335          * We may link to tuples in the card structure,
 336          * we need make sure we have a reference to it.
 337          */
 338         get_device(&func->card->dev);
 339
 340         func->dev.parent = &card->dev;
 341         func->dev.bus = &sdio_bus_type;
 342         func->dev.release = sdio_release_func;
 343
 344         return func;
 345 }
 346
 347 #ifdef CONFIG_ACPI
 348 static void sdio_acpi_set_handle(struct sdio_func *func)
 349 {
 350         struct mmc_host *host = func->card->host;
 351         u64 addr = ((u64)host->slotno << 16) | func->num;
 352
 353         acpi_preset_companion(&func->dev, ACPI_COMPANION(host->parent), addr);
 354 }
 355 #else
 356 static inline void sdio_acpi_set_handle(struct sdio_func *func) {}
 357 #endif
 358
 359 static void sdio_set_of_node(struct sdio_func *func)
 360 {
 361         struct mmc_host *host = func->card->host;
 362
 363         func->dev.of_node = mmc_of_find_child_device(host, func->num);
 364 }
 365
 366 /*
 367  * Register a new SDIO function with the driver model.
 368  */
 369 int sdio_add_func(struct sdio_func *func)
 370 {
 371         int ret;
 372
 373         dev_set_name(&func->dev, "%s:%d", mmc_card_id(func->card), func->num);
 374
 375         sdio_set_of_node(func);
 376         sdio_acpi_set_handle(func);
 377         device_enable_async_suspend(&func->dev);
 378         ret = device_add(&func->dev);
 379         if (ret == 0)
 380                 sdio_func_set_present(func);
 381
 382         return ret;
 383 }
 384
 385 /*
 386  * Unregister a SDIO function with the driver model, and
 387  * (eventually) free it.
 388  * This function can be called through error paths where sdio_add_func() was
 389  * never executed (because a failure occurred at an earlier point).
 390  */
 391 void sdio_remove_func(struct sdio_func *func)
 392 {
 393         if (sdio_func_present(func))
 394                 device_del(&func->dev);
 395
 396         of_node_put(func->dev.of_node);
 397         put_device(&func->dev);
 398 }
 399