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 *
sdw_get_device_id(struct sdw_slave * slave,struct sdw_driver * drv)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 
sdw_bus_match(struct device * dev,struct device_driver * ddrv)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 
sdw_slave_modalias(const struct sdw_slave * slave,char * buf,size_t size)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 
sdw_slave_uevent(struct device * dev,struct kobj_uevent_env * env)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 
sdw_drv_probe(struct device * dev)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 
sdw_drv_remove(struct device * dev)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 
sdw_drv_shutdown(struct device * dev)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  */
__sdw_register_driver(struct sdw_driver * drv,struct module * owner)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  */
sdw_unregister_driver(struct sdw_driver * drv)227 void sdw_unregister_driver(struct sdw_driver *drv)
228 {
229 	driver_unregister(&drv->driver);
230 }
231 EXPORT_SYMBOL_GPL(sdw_unregister_driver);
232 
sdw_bus_init(void)233 static int __init sdw_bus_init(void)
234 {
235 	sdw_debugfs_init();
236 	return bus_register(&sdw_bus_type);
237 }
238 
sdw_bus_exit(void)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