drivers/soundwire/bus_type.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // Copyright(c) 2015-17 Intel Corporation.
   3
   4 #include <linux/module.h>
   5 #include <linux/mod_devicetable.h>
   6 #include <linux/pm_domain.h>
   7 #include <linux/soundwire/sdw.h>
   8 #include <linux/soundwire/sdw_type.h>
   9 #include "bus.h"
  10 #include "irq.h"
  11 #include "sysfs_local.h"
  12
  13 /**
  14  * sdw_get_device_id - find the matching SoundWire device id
  15  * @slave: SoundWire Slave Device
  16  * @drv: SoundWire Slave Driver
  17  *
  18  * The match is done by comparing the mfg_id and part_id from the
  19  * struct sdw_device_id.
  20  */
  21 static const struct sdw_device_id *
  22 sdw_get_device_id(struct sdw_slave *slave, struct sdw_driver *drv)
  23 {
  24         const struct sdw_device_id *id;
  25
  26         for (id = drv->id_table; id && id->mfg_id; id++)
  27                 if (slave->id.mfg_id == id->mfg_id &&
  28                     slave->id.part_id == id->part_id  &&
  29                     (!id->sdw_version ||
  30                      slave->id.sdw_version == id->sdw_version) &&
  31                     (!id->class_id ||
  32                      slave->id.class_id == id->class_id))
  33                         return id;
  34
  35         return NULL;
  36 }
  37
  38 static int sdw_bus_match(struct device *dev, struct device_driver *ddrv)
  39 {
  40         struct sdw_slave *slave;
  41         struct sdw_driver *drv;
  42         int ret = 0;
  43
  44         if (is_sdw_slave(dev)) {
  45                 slave = dev_to_sdw_dev(dev);
  46                 drv = drv_to_sdw_driver(ddrv);
  47
  48                 ret = !!sdw_get_device_id(slave, drv);
  49         }
  50         return ret;
  51 }
  52
  53 int sdw_slave_modalias(const struct sdw_slave *slave, char *buf, size_t size)
  54 {
  55         /* modalias is sdw:m<mfg_id>p<part_id>v<version>c<class_id> */
  56
  57         return snprintf(buf, size, "sdw:m%04Xp%04Xv%02Xc%02X\n",
  58                         slave->id.mfg_id, slave->id.part_id,
  59                         slave->id.sdw_version, slave->id.class_id);
  60 }
  61
  62 int sdw_slave_uevent(const struct device *dev, struct kobj_uevent_env *env)
  63 {
  64         const struct sdw_slave *slave = dev_to_sdw_dev(dev);
  65         char modalias[32];
  66
  67         sdw_slave_modalias(slave, modalias, sizeof(modalias));
  68
  69         if (add_uevent_var(env, "MODALIAS=%s", modalias))
  70                 return -ENOMEM;
  71
  72         return 0;
  73 }
  74
  75 const struct bus_type sdw_bus_type = {
  76         .name = "soundwire",
  77         .match = sdw_bus_match,
  78 };
  79 EXPORT_SYMBOL_GPL(sdw_bus_type);
  80
  81 static int sdw_drv_probe(struct device *dev)
  82 {
  83         struct sdw_slave *slave = dev_to_sdw_dev(dev);
  84         struct sdw_driver *drv = drv_to_sdw_driver(dev->driver);
  85         const struct sdw_device_id *id;
  86         const char *name;
  87         int ret;
  88
  89         /*
  90          * fw description is mandatory to bind
  91          */
  92         if (!dev->fwnode)
  93                 return -ENODEV;
  94
  95         if (!IS_ENABLED(CONFIG_ACPI) && !dev->of_node)
  96                 return -ENODEV;
  97
  98         id = sdw_get_device_id(slave, drv);
  99         if (!id)
 100                 return -ENODEV;
 101
 102         /*
 103          * attach to power domain but don't turn on (last arg)
 104          */
 105         ret = dev_pm_domain_attach(dev, false);
 106         if (ret)
 107                 return ret;
 108
 109         ret = drv->probe(slave, id);
 110         if (ret) {
 111                 name = drv->name;
 112                 if (!name)
 113                         name = drv->driver.name;
 114
 115                 dev_err(dev, "Probe of %s failed: %d\n", name, ret);
 116                 dev_pm_domain_detach(dev, false);
 117                 return ret;
 118         }
 119
 120         mutex_lock(&slave->sdw_dev_lock);
 121
 122         /* device is probed so let's read the properties now */
 123         if (drv->ops && drv->ops->read_prop)
 124                 drv->ops->read_prop(slave);
 125
 126         if (slave->prop.use_domain_irq)
 127                 sdw_irq_create_mapping(slave);
 128
 129         /* init the sysfs as we have properties now */
 130         ret = sdw_slave_sysfs_init(slave);
 131         if (ret < 0)
 132                 dev_warn(dev, "Slave sysfs init failed:%d\n", ret);
 133
 134         /*
 135          * Check for valid clk_stop_timeout, use DisCo worst case value of
 136          * 300ms
 137          *
 138          * TODO: check the timeouts and driver removal case
 139          */
 140         if (slave->prop.clk_stop_timeout == 0)
 141                 slave->prop.clk_stop_timeout = 300;
 142
 143         slave->bus->clk_stop_timeout = max_t(u32, slave->bus->clk_stop_timeout,
 144                                              slave->prop.clk_stop_timeout);
 145
 146         slave->probed = true;
 147
 148         /*
 149          * if the probe happened after the bus was started, notify the codec driver
 150          * of the current hardware status to e.g. start the initialization.
 151          * Errors are only logged as warnings to avoid failing the probe.
 152          */
 153         if (drv->ops && drv->ops->update_status) {
 154                 ret = drv->ops->update_status(slave, slave->status);
 155                 if (ret < 0)
 156                         dev_warn(dev, "%s: update_status failed with status %d\n", __func__, ret);
 157         }
 158
 159         mutex_unlock(&slave->sdw_dev_lock);
 160
 161         dev_dbg(dev, "probe complete\n");
 162
 163         return 0;
 164 }
 165
 166 static int sdw_drv_remove(struct device *dev)
 167 {
 168         struct sdw_slave *slave = dev_to_sdw_dev(dev);
 169         struct sdw_driver *drv = drv_to_sdw_driver(dev->driver);
 170         int ret = 0;
 171
 172         mutex_lock(&slave->sdw_dev_lock);
 173
 174         slave->probed = false;
 175
 176         if (slave->prop.use_domain_irq)
 177                 sdw_irq_dispose_mapping(slave);
 178
 179         mutex_unlock(&slave->sdw_dev_lock);
 180
 181         if (drv->remove)
 182                 ret = drv->remove(slave);
 183
 184         dev_pm_domain_detach(dev, false);
 185
 186         return ret;
 187 }
 188
 189 static void sdw_drv_shutdown(struct device *dev)
 190 {
 191         struct sdw_slave *slave = dev_to_sdw_dev(dev);
 192         struct sdw_driver *drv = drv_to_sdw_driver(dev->driver);
 193
 194         if (drv->shutdown)
 195                 drv->shutdown(slave);
 196 }
 197
 198 /**
 199  * __sdw_register_driver() - register a SoundWire Slave driver
 200  * @drv: driver to register
 201  * @owner: owning module/driver
 202  *
 203  * Return: zero on success, else a negative error code.
 204  */
 205 int __sdw_register_driver(struct sdw_driver *drv, struct module *owner)
 206 {
 207         const char *name;
 208
 209         drv->driver.bus = &sdw_bus_type;
 210
 211         if (!drv->probe) {
 212                 name = drv->name;
 213                 if (!name)
 214                         name = drv->driver.name;
 215
 216                 pr_err("driver %s didn't provide SDW probe routine\n", name);
 217                 return -EINVAL;
 218         }
 219
 220         drv->driver.owner = owner;
 221         drv->driver.probe = sdw_drv_probe;
 222         drv->driver.remove = sdw_drv_remove;
 223         drv->driver.shutdown = sdw_drv_shutdown;
 224
 225         return driver_register(&drv->driver);
 226 }
 227 EXPORT_SYMBOL_GPL(__sdw_register_driver);
 228
 229 /**
 230  * sdw_unregister_driver() - unregisters the SoundWire Slave driver
 231  * @drv: driver to unregister
 232  */
 233 void sdw_unregister_driver(struct sdw_driver *drv)
 234 {
 235         driver_unregister(&drv->driver);
 236 }
 237 EXPORT_SYMBOL_GPL(sdw_unregister_driver);
 238
 239 static int __init sdw_bus_init(void)
 240 {
 241         sdw_debugfs_init();
 242         return bus_register(&sdw_bus_type);
 243 }
 244
 245 static void __exit sdw_bus_exit(void)
 246 {
 247         sdw_debugfs_exit();
 248         bus_unregister(&sdw_bus_type);
 249 }
 250
 251 postcore_initcall(sdw_bus_init);
 252 module_exit(sdw_bus_exit);
 253
 254 MODULE_DESCRIPTION("SoundWire bus");
 255 MODULE_LICENSE("GPL v2");