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 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