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 */
21static const struct sdw_device_id *
22sdw_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
38static 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
53int 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
62int 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
75const struct bus_type sdw_bus_type = {
76	.name = "soundwire",
77	.match = sdw_bus_match,
78};
79EXPORT_SYMBOL_GPL(sdw_bus_type);
80
81static 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
166static 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
189static 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 */
205int __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}
227EXPORT_SYMBOL_GPL(__sdw_register_driver);
228
229/**
230 * sdw_unregister_driver() - unregisters the SoundWire Slave driver
231 * @drv: driver to unregister
232 */
233void sdw_unregister_driver(struct sdw_driver *drv)
234{
235	driver_unregister(&drv->driver);
236}
237EXPORT_SYMBOL_GPL(sdw_unregister_driver);
238
239static int __init sdw_bus_init(void)
240{
241	sdw_debugfs_init();
242	return bus_register(&sdw_bus_type);
243}
244
245static void __exit sdw_bus_exit(void)
246{
247	sdw_debugfs_exit();
248	bus_unregister(&sdw_bus_type);
249}
250
251postcore_initcall(sdw_bus_init);
252module_exit(sdw_bus_exit);
253
254MODULE_DESCRIPTION("SoundWire bus");
255MODULE_LICENSE("GPL v2");
256