Commit | Line | Data |
---|---|---|
9251345d VK |
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> | |
bf03473d | 9 | #include "bus.h" |
3b6c4a11 | 10 | #include "irq.h" |
bcac5902 | 11 | #include "sysfs_local.h" |
9251345d VK |
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 | */ | |
21 | static const struct sdw_device_id * | |
22 | sdw_get_device_id(struct sdw_slave *slave, struct sdw_driver *drv) | |
23 | { | |
ee9173db | 24 | const struct sdw_device_id *id; |
9251345d | 25 | |
ee9173db | 26 | for (id = drv->id_table; id && id->mfg_id; id++) |
9251345d | 27 | if (slave->id.mfg_id == id->mfg_id && |
b5924268 PLB |
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)) | |
9251345d | 33 | return id; |
9251345d VK |
34 | |
35 | return NULL; | |
36 | } | |
37 | ||
38 | static int sdw_bus_match(struct device *dev, struct device_driver *ddrv) | |
39 | { | |
90acca1d PLB |
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); | |
9251345d | 47 | |
90acca1d PLB |
48 | ret = !!sdw_get_device_id(slave, drv); |
49 | } | |
50 | return ret; | |
9251345d VK |
51 | } |
52 | ||
bcac5902 | 53 | int sdw_slave_modalias(const struct sdw_slave *slave, char *buf, size_t size) |
9251345d | 54 | { |
b5924268 | 55 | /* modalias is sdw:m<mfg_id>p<part_id>v<version>c<class_id> */ |
9251345d | 56 | |
b5924268 PLB |
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); | |
9251345d VK |
60 | } |
61 | ||
162736b0 | 62 | int sdw_slave_uevent(const struct device *dev, struct kobj_uevent_env *env) |
9251345d | 63 | { |
162736b0 | 64 | const struct sdw_slave *slave = dev_to_sdw_dev(dev); |
9251345d VK |
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 | ||
81a7d0c4 | 75 | const struct bus_type sdw_bus_type = { |
9251345d VK |
76 | .name = "soundwire", |
77 | .match = sdw_bus_match, | |
9251345d VK |
78 | }; |
79 | EXPORT_SYMBOL_GPL(sdw_bus_type); | |
80 | ||
81 | static 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; | |
0196b52b | 86 | const char *name; |
9251345d VK |
87 | int ret; |
88 | ||
fcb9d730 SK |
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 | ||
9251345d VK |
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); | |
56d4fe31 VK |
106 | if (ret) |
107 | return ret; | |
108 | ||
29ffcc88 UH |
109 | ret = drv->probe(slave, id); |
110 | if (ret) { | |
0196b52b PLB |
111 | name = drv->name; |
112 | if (!name) | |
113 | name = drv->driver.name; | |
bd29c00e | 114 | |
0196b52b | 115 | dev_err(dev, "Probe of %s failed: %d\n", name, ret); |
29ffcc88 UH |
116 | dev_pm_domain_detach(dev, false); |
117 | return ret; | |
118 | } | |
119 | ||
3dca1f89 RF |
120 | mutex_lock(&slave->sdw_dev_lock); |
121 | ||
56d4fe31 | 122 | /* device is probed so let's read the properties now */ |
bd29c00e PLB |
123 | if (drv->ops && drv->ops->read_prop) |
124 | drv->ops->read_prop(slave); | |
56d4fe31 | 125 | |
3b6c4a11 CK |
126 | if (slave->prop.use_domain_irq) |
127 | sdw_irq_create_mapping(slave); | |
12a95123 | 128 | |
bcac5902 PLB |
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 | ||
56d4fe31 VK |
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, | |
74a8d802 | 144 | slave->prop.clk_stop_timeout); |
56d4fe31 | 145 | |
2140b66b | 146 | slave->probed = true; |
bd29c00e PLB |
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); | |
2140b66b PLB |
160 | |
161 | dev_dbg(dev, "probe complete\n"); | |
162 | ||
56d4fe31 | 163 | return 0; |
9251345d VK |
164 | } |
165 | ||
166 | static 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 | ||
bd29c00e | 172 | mutex_lock(&slave->sdw_dev_lock); |
12a95123 | 173 | |
bd29c00e | 174 | slave->probed = false; |
12a95123 LT |
175 | |
176 | if (slave->prop.use_domain_irq) | |
3b6c4a11 | 177 | sdw_irq_dispose_mapping(slave); |
12a95123 | 178 | |
3dca1f89 | 179 | mutex_unlock(&slave->sdw_dev_lock); |
bd29c00e | 180 | |
9251345d VK |
181 | if (drv->remove) |
182 | ret = drv->remove(slave); | |
183 | ||
184 | dev_pm_domain_detach(dev, false); | |
185 | ||
186 | return ret; | |
187 | } | |
188 | ||
189 | static 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 | */ | |
205 | int __sdw_register_driver(struct sdw_driver *drv, struct module *owner) | |
206 | { | |
0196b52b PLB |
207 | const char *name; |
208 | ||
9251345d VK |
209 | drv->driver.bus = &sdw_bus_type; |
210 | ||
211 | if (!drv->probe) { | |
0196b52b PLB |
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); | |
9251345d VK |
217 | return -EINVAL; |
218 | } | |
219 | ||
220 | drv->driver.owner = owner; | |
221 | drv->driver.probe = sdw_drv_probe; | |
df640778 PLB |
222 | drv->driver.remove = sdw_drv_remove; |
223 | drv->driver.shutdown = sdw_drv_shutdown; | |
9251345d VK |
224 | |
225 | return driver_register(&drv->driver); | |
226 | } | |
227 | EXPORT_SYMBOL_GPL(__sdw_register_driver); | |
228 | ||
229 | /** | |
230 | * sdw_unregister_driver() - unregisters the SoundWire Slave driver | |
231 | * @drv: driver to unregister | |
232 | */ | |
233 | void sdw_unregister_driver(struct sdw_driver *drv) | |
234 | { | |
235 | driver_unregister(&drv->driver); | |
236 | } | |
237 | EXPORT_SYMBOL_GPL(sdw_unregister_driver); | |
238 | ||
239 | static int __init sdw_bus_init(void) | |
240 | { | |
bf03473d | 241 | sdw_debugfs_init(); |
9251345d VK |
242 | return bus_register(&sdw_bus_type); |
243 | } | |
244 | ||
245 | static void __exit sdw_bus_exit(void) | |
246 | { | |
bf03473d | 247 | sdw_debugfs_exit(); |
9251345d VK |
248 | bus_unregister(&sdw_bus_type); |
249 | } | |
250 | ||
251 | postcore_initcall(sdw_bus_init); | |
252 | module_exit(sdw_bus_exit); | |
253 | ||
254 | MODULE_DESCRIPTION("SoundWire bus"); | |
255 | MODULE_LICENSE("GPL v2"); |