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 int ret; 86 87 id = sdw_get_device_id(slave, drv); 88 if (!id) 89 return -ENODEV; 90 91 slave->ops = drv->ops; 92 93 /* 94 * attach to power domain but don't turn on (last arg) 95 */ 96 ret = dev_pm_domain_attach(dev, false); 97 if (ret) 98 return ret; 99 100 ret = drv->probe(slave, id); 101 if (ret) { 102 dev_err(dev, "Probe of %s failed: %d\n", drv->name, ret); 103 dev_pm_domain_detach(dev, false); 104 return ret; 105 } 106 107 /* device is probed so let's read the properties now */ 108 if (slave->ops && slave->ops->read_prop) 109 slave->ops->read_prop(slave); 110 111 /* init the sysfs as we have properties now */ 112 ret = sdw_slave_sysfs_init(slave); 113 if (ret < 0) 114 dev_warn(dev, "Slave sysfs init failed:%d\n", ret); 115 116 /* 117 * Check for valid clk_stop_timeout, use DisCo worst case value of 118 * 300ms 119 * 120 * TODO: check the timeouts and driver removal case 121 */ 122 if (slave->prop.clk_stop_timeout == 0) 123 slave->prop.clk_stop_timeout = 300; 124 125 slave->bus->clk_stop_timeout = max_t(u32, slave->bus->clk_stop_timeout, 126 slave->prop.clk_stop_timeout); 127 128 slave->probed = true; 129 complete(&slave->probe_complete); 130 131 dev_dbg(dev, "probe complete\n"); 132 133 return 0; 134 } 135 136 static int sdw_drv_remove(struct device *dev) 137 { 138 struct sdw_slave *slave = dev_to_sdw_dev(dev); 139 struct sdw_driver *drv = drv_to_sdw_driver(dev->driver); 140 int ret = 0; 141 142 if (drv->remove) 143 ret = drv->remove(slave); 144 145 dev_pm_domain_detach(dev, false); 146 147 return ret; 148 } 149 150 static void sdw_drv_shutdown(struct device *dev) 151 { 152 struct sdw_slave *slave = dev_to_sdw_dev(dev); 153 struct sdw_driver *drv = drv_to_sdw_driver(dev->driver); 154 155 if (drv->shutdown) 156 drv->shutdown(slave); 157 } 158 159 /** 160 * __sdw_register_driver() - register a SoundWire Slave driver 161 * @drv: driver to register 162 * @owner: owning module/driver 163 * 164 * Return: zero on success, else a negative error code. 165 */ 166 int __sdw_register_driver(struct sdw_driver *drv, struct module *owner) 167 { 168 drv->driver.bus = &sdw_bus_type; 169 170 if (!drv->probe) { 171 pr_err("driver %s didn't provide SDW probe routine\n", 172 drv->name); 173 return -EINVAL; 174 } 175 176 drv->driver.owner = owner; 177 drv->driver.probe = sdw_drv_probe; 178 179 if (drv->remove) 180 drv->driver.remove = sdw_drv_remove; 181 182 if (drv->shutdown) 183 drv->driver.shutdown = sdw_drv_shutdown; 184 185 return driver_register(&drv->driver); 186 } 187 EXPORT_SYMBOL_GPL(__sdw_register_driver); 188 189 /** 190 * sdw_unregister_driver() - unregisters the SoundWire Slave driver 191 * @drv: driver to unregister 192 */ 193 void sdw_unregister_driver(struct sdw_driver *drv) 194 { 195 driver_unregister(&drv->driver); 196 } 197 EXPORT_SYMBOL_GPL(sdw_unregister_driver); 198 199 static int __init sdw_bus_init(void) 200 { 201 sdw_debugfs_init(); 202 return bus_register(&sdw_bus_type); 203 } 204 205 static void __exit sdw_bus_exit(void) 206 { 207 sdw_debugfs_exit(); 208 bus_unregister(&sdw_bus_type); 209 } 210 211 postcore_initcall(sdw_bus_init); 212 module_exit(sdw_bus_exit); 213 214 MODULE_DESCRIPTION("SoundWire bus"); 215 MODULE_LICENSE("GPL v2"); 216