root/drivers/soundwire/bus_type.c

DEFINITIONS

1. sdw_get_device_id
2. sdw_bus_match
3. sdw_slave_modalias
4. sdw_uevent
5. sdw_drv_probe
6. sdw_drv_remove
7. sdw_drv_shutdown
8. __sdw_register_driver
9. sdw_unregister_driver
10. sdw_bus_init
11. sdw_bus_exit

   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 
  11 /**
  12  * sdw_get_device_id - find the matching SoundWire device id
  13  * @slave: SoundWire Slave Device
  14  * @drv: SoundWire Slave Driver
  15  *
  16  * The match is done by comparing the mfg_id and part_id from the
  17  * struct sdw_device_id.
  18  */
  19 static const struct sdw_device_id *
  20 sdw_get_device_id(struct sdw_slave *slave, struct sdw_driver *drv)
  21 {
  22         const struct sdw_device_id *id = drv->id_table;
  23 
  24         while (id && id->mfg_id) {
  25                 if (slave->id.mfg_id == id->mfg_id &&
  26                     slave->id.part_id == id->part_id)
  27                         return id;
  28                 id++;
  29         }
  30 
  31         return NULL;
  32 }
  33 
  34 static int sdw_bus_match(struct device *dev, struct device_driver *ddrv)
  35 {
  36         struct sdw_slave *slave = dev_to_sdw_dev(dev);
  37         struct sdw_driver *drv = drv_to_sdw_driver(ddrv);
  38 
  39         return !!sdw_get_device_id(slave, drv);
  40 }
  41 
  42 int sdw_slave_modalias(const struct sdw_slave *slave, char *buf, size_t size)
  43 {
  44         /* modalias is sdw:m<mfg_id>p<part_id> */
  45 
  46         return snprintf(buf, size, "sdw:m%04Xp%04X\n",
  47                         slave->id.mfg_id, slave->id.part_id);
  48 }
  49 
  50 static int sdw_uevent(struct device *dev, struct kobj_uevent_env *env)
  51 {
  52         struct sdw_slave *slave = dev_to_sdw_dev(dev);
  53         char modalias[32];
  54 
  55         sdw_slave_modalias(slave, modalias, sizeof(modalias));
  56 
  57         if (add_uevent_var(env, "MODALIAS=%s", modalias))
  58                 return -ENOMEM;
  59 
  60         return 0;
  61 }
  62 
  63 struct bus_type sdw_bus_type = {
  64         .name = "soundwire",
  65         .match = sdw_bus_match,
  66         .uevent = sdw_uevent,
  67 };
  68 EXPORT_SYMBOL_GPL(sdw_bus_type);
  69 
  70 static int sdw_drv_probe(struct device *dev)
  71 {
  72         struct sdw_slave *slave = dev_to_sdw_dev(dev);
  73         struct sdw_driver *drv = drv_to_sdw_driver(dev->driver);
  74         const struct sdw_device_id *id;
  75         int ret;
  76 
  77         id = sdw_get_device_id(slave, drv);
  78         if (!id)
  79                 return -ENODEV;
  80 
  81         slave->ops = drv->ops;
  82 
  83         /*
  84          * attach to power domain but don't turn on (last arg)
  85          */
  86         ret = dev_pm_domain_attach(dev, false);
  87         if (ret)
  88                 return ret;
  89 
  90         ret = drv->probe(slave, id);
  91         if (ret) {
  92                 dev_err(dev, "Probe of %s failed: %d\n", drv->name, ret);
  93                 dev_pm_domain_detach(dev, false);
  94                 return ret;
  95         }
  96 
  97         /* device is probed so let's read the properties now */
  98         if (slave->ops && slave->ops->read_prop)
  99                 slave->ops->read_prop(slave);
 100 
 101         /*
 102          * Check for valid clk_stop_timeout, use DisCo worst case value of
 103          * 300ms
 104          *
 105          * TODO: check the timeouts and driver removal case
 106          */
 107         if (slave->prop.clk_stop_timeout == 0)
 108                 slave->prop.clk_stop_timeout = 300;
 109 
 110         slave->bus->clk_stop_timeout = max_t(u32, slave->bus->clk_stop_timeout,
 111                                              slave->prop.clk_stop_timeout);
 112 
 113         return 0;
 114 }
 115 
 116 static int sdw_drv_remove(struct device *dev)
 117 {
 118         struct sdw_slave *slave = dev_to_sdw_dev(dev);
 119         struct sdw_driver *drv = drv_to_sdw_driver(dev->driver);
 120         int ret = 0;
 121 
 122         if (drv->remove)
 123                 ret = drv->remove(slave);
 124 
 125         dev_pm_domain_detach(dev, false);
 126 
 127         return ret;
 128 }
 129 
 130 static void sdw_drv_shutdown(struct device *dev)
 131 {
 132         struct sdw_slave *slave = dev_to_sdw_dev(dev);
 133         struct sdw_driver *drv = drv_to_sdw_driver(dev->driver);
 134 
 135         if (drv->shutdown)
 136                 drv->shutdown(slave);
 137 }
 138 
 139 /**
 140  * __sdw_register_driver() - register a SoundWire Slave driver
 141  * @drv: driver to register
 142  * @owner: owning module/driver
 143  *
 144  * Return: zero on success, else a negative error code.
 145  */
 146 int __sdw_register_driver(struct sdw_driver *drv, struct module *owner)
 147 {
 148         drv->driver.bus = &sdw_bus_type;
 149 
 150         if (!drv->probe) {
 151                 pr_err("driver %s didn't provide SDW probe routine\n",
 152                        drv->name);
 153                 return -EINVAL;
 154         }
 155 
 156         drv->driver.owner = owner;
 157         drv->driver.probe = sdw_drv_probe;
 158 
 159         if (drv->remove)
 160                 drv->driver.remove = sdw_drv_remove;
 161 
 162         if (drv->shutdown)
 163                 drv->driver.shutdown = sdw_drv_shutdown;
 164 
 165         return driver_register(&drv->driver);
 166 }
 167 EXPORT_SYMBOL_GPL(__sdw_register_driver);
 168 
 169 /**
 170  * sdw_unregister_driver() - unregisters the SoundWire Slave driver
 171  * @drv: driver to unregister
 172  */
 173 void sdw_unregister_driver(struct sdw_driver *drv)
 174 {
 175         driver_unregister(&drv->driver);
 176 }
 177 EXPORT_SYMBOL_GPL(sdw_unregister_driver);
 178 
 179 static int __init sdw_bus_init(void)
 180 {
 181         sdw_debugfs_init();
 182         return bus_register(&sdw_bus_type);
 183 }
 184 
 185 static void __exit sdw_bus_exit(void)
 186 {
 187         sdw_debugfs_exit();
 188         bus_unregister(&sdw_bus_type);
 189 }
 190 
 191 postcore_initcall(sdw_bus_init);
 192 module_exit(sdw_bus_exit);
 193 
 194 MODULE_DESCRIPTION("SoundWire bus");
 195 MODULE_LICENSE("GPL v2");