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