linux/drivers/mmc/core/sdio_bus.c
<<
>>
Prefs
   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...)                 \
  32static ssize_t                                                          \
  33field##_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}                                                                       \
  40static DEVICE_ATTR_RO(field)
  41
  42sdio_config_attr(class, "0x%02x\n", func->class);
  43sdio_config_attr(vendor, "0x%04x\n", func->vendor);
  44sdio_config_attr(device, "0x%04x\n", func->device);
  45sdio_config_attr(revision, "%u.%u\n", func->major_rev, func->minor_rev);
  46sdio_config_attr(modalias, "sdio:c%02Xv%04Xd%04X\n", func->class, func->vendor, func->device);
  47
  48#define sdio_info_attr(num)                                                                     \
  49static 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}                                                                                               \
  59static DEVICE_ATTR_RO(info##num)
  60
  61sdio_info_attr(1);
  62sdio_info_attr(2);
  63sdio_info_attr(3);
  64sdio_info_attr(4);
  65
  66static 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};
  78ATTRIBUTE_GROUPS(sdio_dev);
  79
  80static 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
  92static 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
 110static 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
 121static int
 122sdio_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
 152static 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
 198disable_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
 206static 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
 239static 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
 248static 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
 258int sdio_register_bus(void)
 259{
 260        return bus_register(&sdio_bus_type);
 261}
 262
 263void 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 */
 272int 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}
 278EXPORT_SYMBOL_GPL(sdio_register_driver);
 279
 280/**
 281 *      sdio_unregister_driver - unregister a function driver
 282 *      @drv: SDIO function driver
 283 */
 284void sdio_unregister_driver(struct sdio_driver *drv)
 285{
 286        drv->drv.bus = &sdio_bus_type;
 287        driver_unregister(&drv->drv);
 288}
 289EXPORT_SYMBOL_GPL(sdio_unregister_driver);
 290
 291static void sdio_release_func(struct device *dev)
 292{
 293        struct sdio_func *func = dev_to_sdio_func(dev);
 294
 295        sdio_free_func_cis(func);
 296
 297        kfree(func->info);
 298        kfree(func->tmpbuf);
 299        kfree(func);
 300}
 301
 302/*
 303 * Allocate and initialise a new SDIO function structure.
 304 */
 305struct sdio_func *sdio_alloc_func(struct mmc_card *card)
 306{
 307        struct sdio_func *func;
 308
 309        func = kzalloc(sizeof(struct sdio_func), GFP_KERNEL);
 310        if (!func)
 311                return ERR_PTR(-ENOMEM);
 312
 313        /*
 314         * allocate buffer separately to make sure it's properly aligned for
 315         * DMA usage (incl. 64 bit DMA)
 316         */
 317        func->tmpbuf = kmalloc(4, GFP_KERNEL);
 318        if (!func->tmpbuf) {
 319                kfree(func);
 320                return ERR_PTR(-ENOMEM);
 321        }
 322
 323        func->card = card;
 324
 325        device_initialize(&func->dev);
 326
 327        func->dev.parent = &card->dev;
 328        func->dev.bus = &sdio_bus_type;
 329        func->dev.release = sdio_release_func;
 330
 331        return func;
 332}
 333
 334#ifdef CONFIG_ACPI
 335static void sdio_acpi_set_handle(struct sdio_func *func)
 336{
 337        struct mmc_host *host = func->card->host;
 338        u64 addr = ((u64)host->slotno << 16) | func->num;
 339
 340        acpi_preset_companion(&func->dev, ACPI_COMPANION(host->parent), addr);
 341}
 342#else
 343static inline void sdio_acpi_set_handle(struct sdio_func *func) {}
 344#endif
 345
 346static void sdio_set_of_node(struct sdio_func *func)
 347{
 348        struct mmc_host *host = func->card->host;
 349
 350        func->dev.of_node = mmc_of_find_child_device(host, func->num);
 351}
 352
 353/*
 354 * Register a new SDIO function with the driver model.
 355 */
 356int sdio_add_func(struct sdio_func *func)
 357{
 358        int ret;
 359
 360        dev_set_name(&func->dev, "%s:%d", mmc_card_id(func->card), func->num);
 361
 362        sdio_set_of_node(func);
 363        sdio_acpi_set_handle(func);
 364        device_enable_async_suspend(&func->dev);
 365        ret = device_add(&func->dev);
 366        if (ret == 0)
 367                sdio_func_set_present(func);
 368
 369        return ret;
 370}
 371
 372/*
 373 * Unregister a SDIO function with the driver model, and
 374 * (eventually) free it.
 375 * This function can be called through error paths where sdio_add_func() was
 376 * never executed (because a failure occurred at an earlier point).
 377 */
 378void sdio_remove_func(struct sdio_func *func)
 379{
 380        if (!sdio_func_present(func))
 381                return;
 382
 383        device_del(&func->dev);
 384        of_node_put(func->dev.of_node);
 385        put_device(&func->dev);
 386}
 387
 388