1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Copyright (C) 2016 Robert Jarzmik <robert.jarzmik@free.fr> |
4 | */ |
5 | |
6 | #include <linux/module.h> |
7 | #include <linux/bitops.h> |
8 | #include <linux/clk.h> |
9 | #include <linux/device.h> |
10 | #include <linux/idr.h> |
11 | #include <linux/list.h> |
12 | #include <linux/mutex.h> |
13 | #include <linux/of.h> |
14 | #include <linux/pm.h> |
15 | #include <linux/pm_runtime.h> |
16 | #include <linux/slab.h> |
17 | #include <linux/sysfs.h> |
18 | #include <sound/ac97/codec.h> |
19 | #include <sound/ac97/controller.h> |
20 | #include <sound/ac97/regs.h> |
21 | |
22 | #include "ac97_core.h" |
23 | |
24 | /* |
25 | * Protects ac97_controllers and each ac97_controller structure. |
26 | */ |
27 | static DEFINE_MUTEX(ac97_controllers_mutex); |
28 | static DEFINE_IDR(ac97_adapter_idr); |
29 | static LIST_HEAD(ac97_controllers); |
30 | |
31 | static struct bus_type ac97_bus_type; |
32 | |
33 | static inline struct ac97_controller* |
34 | to_ac97_controller(struct device *ac97_adapter) |
35 | { |
36 | return container_of(ac97_adapter, struct ac97_controller, adap); |
37 | } |
38 | |
39 | static int ac97_unbound_ctrl_write(struct ac97_controller *adrv, int slot, |
40 | unsigned short reg, unsigned short val) |
41 | { |
42 | return -ENODEV; |
43 | } |
44 | |
45 | static int ac97_unbound_ctrl_read(struct ac97_controller *adrv, int slot, |
46 | unsigned short reg) |
47 | { |
48 | return -ENODEV; |
49 | } |
50 | |
51 | static const struct ac97_controller_ops ac97_unbound_ctrl_ops = { |
52 | .write = ac97_unbound_ctrl_write, |
53 | .read = ac97_unbound_ctrl_read, |
54 | }; |
55 | |
56 | static struct ac97_controller ac97_unbound_ctrl = { |
57 | .ops = &ac97_unbound_ctrl_ops, |
58 | }; |
59 | |
60 | static struct ac97_codec_device * |
61 | ac97_codec_find(struct ac97_controller *ac97_ctrl, unsigned int codec_num) |
62 | { |
63 | if (codec_num >= AC97_BUS_MAX_CODECS) |
64 | return ERR_PTR(error: -EINVAL); |
65 | |
66 | return ac97_ctrl->codecs[codec_num]; |
67 | } |
68 | |
69 | static struct device_node * |
70 | ac97_of_get_child_device(struct ac97_controller *ac97_ctrl, int idx, |
71 | unsigned int vendor_id) |
72 | { |
73 | struct device_node *node; |
74 | u32 reg; |
75 | char compat[] = "ac97,0000,0000" ; |
76 | |
77 | snprintf(buf: compat, size: sizeof(compat), fmt: "ac97,%04x,%04x" , |
78 | vendor_id >> 16, vendor_id & 0xffff); |
79 | |
80 | for_each_child_of_node(ac97_ctrl->parent->of_node, node) { |
81 | if ((idx != of_property_read_u32(np: node, propname: "reg" , out_value: ®)) || |
82 | !of_device_is_compatible(device: node, compat)) |
83 | continue; |
84 | return node; |
85 | } |
86 | |
87 | return NULL; |
88 | } |
89 | |
90 | static void ac97_codec_release(struct device *dev) |
91 | { |
92 | struct ac97_codec_device *adev; |
93 | struct ac97_controller *ac97_ctrl; |
94 | |
95 | adev = to_ac97_device(d: dev); |
96 | ac97_ctrl = adev->ac97_ctrl; |
97 | ac97_ctrl->codecs[adev->num] = NULL; |
98 | of_node_put(node: dev->of_node); |
99 | kfree(objp: adev); |
100 | } |
101 | |
102 | static int ac97_codec_add(struct ac97_controller *ac97_ctrl, int idx, |
103 | unsigned int vendor_id) |
104 | { |
105 | struct ac97_codec_device *codec; |
106 | int ret; |
107 | |
108 | codec = kzalloc(size: sizeof(*codec), GFP_KERNEL); |
109 | if (!codec) |
110 | return -ENOMEM; |
111 | ac97_ctrl->codecs[idx] = codec; |
112 | codec->vendor_id = vendor_id; |
113 | codec->dev.release = ac97_codec_release; |
114 | codec->dev.bus = &ac97_bus_type; |
115 | codec->dev.parent = &ac97_ctrl->adap; |
116 | codec->num = idx; |
117 | codec->ac97_ctrl = ac97_ctrl; |
118 | |
119 | device_initialize(dev: &codec->dev); |
120 | dev_set_name(dev: &codec->dev, name: "%s:%u" , dev_name(dev: ac97_ctrl->parent), idx); |
121 | codec->dev.of_node = ac97_of_get_child_device(ac97_ctrl, idx, |
122 | vendor_id); |
123 | |
124 | ret = device_add(dev: &codec->dev); |
125 | if (ret) { |
126 | put_device(dev: &codec->dev); |
127 | return ret; |
128 | } |
129 | |
130 | return 0; |
131 | } |
132 | |
133 | unsigned int snd_ac97_bus_scan_one(struct ac97_controller *adrv, |
134 | unsigned int codec_num) |
135 | { |
136 | unsigned short vid1, vid2; |
137 | int ret; |
138 | |
139 | ret = adrv->ops->read(adrv, codec_num, AC97_VENDOR_ID1); |
140 | vid1 = (ret & 0xffff); |
141 | if (ret < 0) |
142 | return 0; |
143 | |
144 | ret = adrv->ops->read(adrv, codec_num, AC97_VENDOR_ID2); |
145 | vid2 = (ret & 0xffff); |
146 | if (ret < 0) |
147 | return 0; |
148 | |
149 | dev_dbg(&adrv->adap, "%s(codec_num=%u): vendor_id=0x%08x\n" , |
150 | __func__, codec_num, AC97_ID(vid1, vid2)); |
151 | return AC97_ID(vid1, vid2); |
152 | } |
153 | |
154 | static int ac97_bus_scan(struct ac97_controller *ac97_ctrl) |
155 | { |
156 | int ret, i; |
157 | unsigned int vendor_id; |
158 | |
159 | for (i = 0; i < AC97_BUS_MAX_CODECS; i++) { |
160 | if (ac97_codec_find(ac97_ctrl, codec_num: i)) |
161 | continue; |
162 | if (!(ac97_ctrl->slots_available & BIT(i))) |
163 | continue; |
164 | vendor_id = snd_ac97_bus_scan_one(adrv: ac97_ctrl, codec_num: i); |
165 | if (!vendor_id) |
166 | continue; |
167 | |
168 | ret = ac97_codec_add(ac97_ctrl, idx: i, vendor_id); |
169 | if (ret < 0) |
170 | return ret; |
171 | } |
172 | return 0; |
173 | } |
174 | |
175 | static int ac97_bus_reset(struct ac97_controller *ac97_ctrl) |
176 | { |
177 | ac97_ctrl->ops->reset(ac97_ctrl); |
178 | |
179 | return 0; |
180 | } |
181 | |
182 | /** |
183 | * snd_ac97_codec_driver_register - register an AC97 codec driver |
184 | * @dev: AC97 driver codec to register |
185 | * |
186 | * Register an AC97 codec driver to the ac97 bus driver, aka. the AC97 digital |
187 | * controller. |
188 | * |
189 | * Returns 0 on success or error code |
190 | */ |
191 | int snd_ac97_codec_driver_register(struct ac97_codec_driver *drv) |
192 | { |
193 | drv->driver.bus = &ac97_bus_type; |
194 | return driver_register(drv: &drv->driver); |
195 | } |
196 | EXPORT_SYMBOL_GPL(snd_ac97_codec_driver_register); |
197 | |
198 | /** |
199 | * snd_ac97_codec_driver_unregister - unregister an AC97 codec driver |
200 | * @dev: AC97 codec driver to unregister |
201 | * |
202 | * Unregister a previously registered ac97 codec driver. |
203 | */ |
204 | void snd_ac97_codec_driver_unregister(struct ac97_codec_driver *drv) |
205 | { |
206 | driver_unregister(drv: &drv->driver); |
207 | } |
208 | EXPORT_SYMBOL_GPL(snd_ac97_codec_driver_unregister); |
209 | |
210 | /** |
211 | * snd_ac97_codec_get_platdata - get platform_data |
212 | * @adev: the ac97 codec device |
213 | * |
214 | * For legacy platforms, in order to have platform_data in codec drivers |
215 | * available, while ac97 device are auto-created upon probe, this retrieves the |
216 | * platdata which was setup on ac97 controller registration. |
217 | * |
218 | * Returns the platform data pointer |
219 | */ |
220 | void *snd_ac97_codec_get_platdata(const struct ac97_codec_device *adev) |
221 | { |
222 | struct ac97_controller *ac97_ctrl = adev->ac97_ctrl; |
223 | |
224 | return ac97_ctrl->codecs_pdata[adev->num]; |
225 | } |
226 | EXPORT_SYMBOL_GPL(snd_ac97_codec_get_platdata); |
227 | |
228 | static void ac97_ctrl_codecs_unregister(struct ac97_controller *ac97_ctrl) |
229 | { |
230 | int i; |
231 | |
232 | for (i = 0; i < AC97_BUS_MAX_CODECS; i++) |
233 | if (ac97_ctrl->codecs[i]) { |
234 | ac97_ctrl->codecs[i]->ac97_ctrl = &ac97_unbound_ctrl; |
235 | device_unregister(dev: &ac97_ctrl->codecs[i]->dev); |
236 | } |
237 | } |
238 | |
239 | static ssize_t cold_reset_store(struct device *dev, |
240 | struct device_attribute *attr, const char *buf, |
241 | size_t len) |
242 | { |
243 | struct ac97_controller *ac97_ctrl; |
244 | |
245 | mutex_lock(&ac97_controllers_mutex); |
246 | ac97_ctrl = to_ac97_controller(ac97_adapter: dev); |
247 | ac97_ctrl->ops->reset(ac97_ctrl); |
248 | mutex_unlock(lock: &ac97_controllers_mutex); |
249 | return len; |
250 | } |
251 | static DEVICE_ATTR_WO(cold_reset); |
252 | |
253 | static ssize_t warm_reset_store(struct device *dev, |
254 | struct device_attribute *attr, const char *buf, |
255 | size_t len) |
256 | { |
257 | struct ac97_controller *ac97_ctrl; |
258 | |
259 | if (!dev) |
260 | return -ENODEV; |
261 | |
262 | mutex_lock(&ac97_controllers_mutex); |
263 | ac97_ctrl = to_ac97_controller(ac97_adapter: dev); |
264 | ac97_ctrl->ops->warm_reset(ac97_ctrl); |
265 | mutex_unlock(lock: &ac97_controllers_mutex); |
266 | return len; |
267 | } |
268 | static DEVICE_ATTR_WO(warm_reset); |
269 | |
270 | static struct attribute *ac97_controller_device_attrs[] = { |
271 | &dev_attr_cold_reset.attr, |
272 | &dev_attr_warm_reset.attr, |
273 | NULL |
274 | }; |
275 | |
276 | static const struct attribute_group ac97_adapter_attr_group = { |
277 | .name = "ac97_operations" , |
278 | .attrs = ac97_controller_device_attrs, |
279 | }; |
280 | |
281 | static const struct attribute_group *ac97_adapter_groups[] = { |
282 | &ac97_adapter_attr_group, |
283 | NULL, |
284 | }; |
285 | |
286 | static void ac97_del_adapter(struct ac97_controller *ac97_ctrl) |
287 | { |
288 | mutex_lock(&ac97_controllers_mutex); |
289 | ac97_ctrl_codecs_unregister(ac97_ctrl); |
290 | list_del(entry: &ac97_ctrl->controllers); |
291 | mutex_unlock(lock: &ac97_controllers_mutex); |
292 | |
293 | device_unregister(dev: &ac97_ctrl->adap); |
294 | } |
295 | |
296 | static void ac97_adapter_release(struct device *dev) |
297 | { |
298 | struct ac97_controller *ac97_ctrl; |
299 | |
300 | ac97_ctrl = to_ac97_controller(ac97_adapter: dev); |
301 | idr_remove(&ac97_adapter_idr, id: ac97_ctrl->nr); |
302 | dev_dbg(&ac97_ctrl->adap, "adapter unregistered by %s\n" , |
303 | dev_name(ac97_ctrl->parent)); |
304 | } |
305 | |
306 | static const struct device_type ac97_adapter_type = { |
307 | .groups = ac97_adapter_groups, |
308 | .release = ac97_adapter_release, |
309 | }; |
310 | |
311 | static int ac97_add_adapter(struct ac97_controller *ac97_ctrl) |
312 | { |
313 | int ret; |
314 | |
315 | mutex_lock(&ac97_controllers_mutex); |
316 | ret = idr_alloc(&ac97_adapter_idr, ptr: ac97_ctrl, start: 0, end: 0, GFP_KERNEL); |
317 | ac97_ctrl->nr = ret; |
318 | if (ret >= 0) { |
319 | dev_set_name(dev: &ac97_ctrl->adap, name: "ac97-%d" , ret); |
320 | ac97_ctrl->adap.type = &ac97_adapter_type; |
321 | ac97_ctrl->adap.parent = ac97_ctrl->parent; |
322 | ret = device_register(dev: &ac97_ctrl->adap); |
323 | if (ret) |
324 | put_device(dev: &ac97_ctrl->adap); |
325 | } |
326 | if (!ret) |
327 | list_add(new: &ac97_ctrl->controllers, head: &ac97_controllers); |
328 | mutex_unlock(lock: &ac97_controllers_mutex); |
329 | |
330 | if (!ret) |
331 | dev_dbg(&ac97_ctrl->adap, "adapter registered by %s\n" , |
332 | dev_name(ac97_ctrl->parent)); |
333 | return ret; |
334 | } |
335 | |
336 | /** |
337 | * snd_ac97_controller_register - register an ac97 controller |
338 | * @ops: the ac97 bus operations |
339 | * @dev: the device providing the ac97 DC function |
340 | * @slots_available: mask of the ac97 codecs that can be scanned and probed |
341 | * bit0 => codec 0, bit1 => codec 1 ... bit 3 => codec 3 |
342 | * |
343 | * Register a digital controller which can control up to 4 ac97 codecs. This is |
344 | * the controller side of the AC97 AC-link, while the slave side are the codecs. |
345 | * |
346 | * Returns a valid controller upon success, negative pointer value upon error |
347 | */ |
348 | struct ac97_controller *snd_ac97_controller_register( |
349 | const struct ac97_controller_ops *ops, struct device *dev, |
350 | unsigned short slots_available, void **codecs_pdata) |
351 | { |
352 | struct ac97_controller *ac97_ctrl; |
353 | int ret, i; |
354 | |
355 | ac97_ctrl = kzalloc(size: sizeof(*ac97_ctrl), GFP_KERNEL); |
356 | if (!ac97_ctrl) |
357 | return ERR_PTR(error: -ENOMEM); |
358 | |
359 | for (i = 0; i < AC97_BUS_MAX_CODECS && codecs_pdata; i++) |
360 | ac97_ctrl->codecs_pdata[i] = codecs_pdata[i]; |
361 | |
362 | ac97_ctrl->ops = ops; |
363 | ac97_ctrl->slots_available = slots_available; |
364 | ac97_ctrl->parent = dev; |
365 | ret = ac97_add_adapter(ac97_ctrl); |
366 | |
367 | if (ret) |
368 | goto err; |
369 | ac97_bus_reset(ac97_ctrl); |
370 | ac97_bus_scan(ac97_ctrl); |
371 | |
372 | return ac97_ctrl; |
373 | err: |
374 | kfree(objp: ac97_ctrl); |
375 | return ERR_PTR(error: ret); |
376 | } |
377 | EXPORT_SYMBOL_GPL(snd_ac97_controller_register); |
378 | |
379 | /** |
380 | * snd_ac97_controller_unregister - unregister an ac97 controller |
381 | * @ac97_ctrl: the device previously provided to ac97_controller_register() |
382 | * |
383 | */ |
384 | void snd_ac97_controller_unregister(struct ac97_controller *ac97_ctrl) |
385 | { |
386 | ac97_del_adapter(ac97_ctrl); |
387 | } |
388 | EXPORT_SYMBOL_GPL(snd_ac97_controller_unregister); |
389 | |
390 | #ifdef CONFIG_PM |
391 | static int ac97_pm_runtime_suspend(struct device *dev) |
392 | { |
393 | struct ac97_codec_device *codec = to_ac97_device(d: dev); |
394 | int ret = pm_generic_runtime_suspend(dev); |
395 | |
396 | if (ret == 0 && dev->driver) { |
397 | if (pm_runtime_is_irq_safe(dev)) |
398 | clk_disable(clk: codec->clk); |
399 | else |
400 | clk_disable_unprepare(clk: codec->clk); |
401 | } |
402 | |
403 | return ret; |
404 | } |
405 | |
406 | static int ac97_pm_runtime_resume(struct device *dev) |
407 | { |
408 | struct ac97_codec_device *codec = to_ac97_device(d: dev); |
409 | int ret; |
410 | |
411 | if (dev->driver) { |
412 | if (pm_runtime_is_irq_safe(dev)) |
413 | ret = clk_enable(clk: codec->clk); |
414 | else |
415 | ret = clk_prepare_enable(clk: codec->clk); |
416 | if (ret) |
417 | return ret; |
418 | } |
419 | |
420 | return pm_generic_runtime_resume(dev); |
421 | } |
422 | #endif /* CONFIG_PM */ |
423 | |
424 | static const struct dev_pm_ops ac97_pm = { |
425 | .suspend = pm_generic_suspend, |
426 | .resume = pm_generic_resume, |
427 | .freeze = pm_generic_freeze, |
428 | .thaw = pm_generic_thaw, |
429 | .poweroff = pm_generic_poweroff, |
430 | .restore = pm_generic_restore, |
431 | SET_RUNTIME_PM_OPS( |
432 | ac97_pm_runtime_suspend, |
433 | ac97_pm_runtime_resume, |
434 | NULL) |
435 | }; |
436 | |
437 | static int ac97_get_enable_clk(struct ac97_codec_device *adev) |
438 | { |
439 | int ret; |
440 | |
441 | adev->clk = clk_get(dev: &adev->dev, id: "ac97_clk" ); |
442 | if (IS_ERR(ptr: adev->clk)) |
443 | return PTR_ERR(ptr: adev->clk); |
444 | |
445 | ret = clk_prepare_enable(clk: adev->clk); |
446 | if (ret) |
447 | clk_put(clk: adev->clk); |
448 | |
449 | return ret; |
450 | } |
451 | |
452 | static void ac97_put_disable_clk(struct ac97_codec_device *adev) |
453 | { |
454 | clk_disable_unprepare(clk: adev->clk); |
455 | clk_put(clk: adev->clk); |
456 | } |
457 | |
458 | static ssize_t vendor_id_show(struct device *dev, |
459 | struct device_attribute *attr, char *buf) |
460 | { |
461 | struct ac97_codec_device *codec = to_ac97_device(d: dev); |
462 | |
463 | return sysfs_emit(buf, fmt: "%08x" , codec->vendor_id); |
464 | } |
465 | static DEVICE_ATTR_RO(vendor_id); |
466 | |
467 | static struct attribute *ac97_dev_attrs[] = { |
468 | &dev_attr_vendor_id.attr, |
469 | NULL, |
470 | }; |
471 | ATTRIBUTE_GROUPS(ac97_dev); |
472 | |
473 | static int ac97_bus_match(struct device *dev, struct device_driver *drv) |
474 | { |
475 | struct ac97_codec_device *adev = to_ac97_device(d: dev); |
476 | struct ac97_codec_driver *adrv = to_ac97_driver(d: drv); |
477 | const struct ac97_id *id = adrv->id_table; |
478 | int i = 0; |
479 | |
480 | if (adev->vendor_id == 0x0 || adev->vendor_id == 0xffffffff) |
481 | return false; |
482 | |
483 | do { |
484 | if (ac97_ids_match(id1: id[i].id, id2: adev->vendor_id, mask: id[i].mask)) |
485 | return true; |
486 | } while (id[i++].id); |
487 | |
488 | return false; |
489 | } |
490 | |
491 | static int ac97_bus_probe(struct device *dev) |
492 | { |
493 | struct ac97_codec_device *adev = to_ac97_device(d: dev); |
494 | struct ac97_codec_driver *adrv = to_ac97_driver(d: dev->driver); |
495 | int ret; |
496 | |
497 | ret = ac97_get_enable_clk(adev); |
498 | if (ret) |
499 | return ret; |
500 | |
501 | pm_runtime_get_noresume(dev); |
502 | pm_runtime_set_active(dev); |
503 | pm_runtime_enable(dev); |
504 | |
505 | ret = adrv->probe(adev); |
506 | if (ret == 0) |
507 | return 0; |
508 | |
509 | pm_runtime_disable(dev); |
510 | pm_runtime_set_suspended(dev); |
511 | pm_runtime_put_noidle(dev); |
512 | ac97_put_disable_clk(adev); |
513 | |
514 | return ret; |
515 | } |
516 | |
517 | static void ac97_bus_remove(struct device *dev) |
518 | { |
519 | struct ac97_codec_device *adev = to_ac97_device(d: dev); |
520 | struct ac97_codec_driver *adrv = to_ac97_driver(d: dev->driver); |
521 | int ret; |
522 | |
523 | ret = pm_runtime_resume_and_get(dev); |
524 | if (ret < 0) |
525 | return; |
526 | |
527 | adrv->remove(adev); |
528 | pm_runtime_put_noidle(dev); |
529 | ac97_put_disable_clk(adev); |
530 | |
531 | pm_runtime_disable(dev); |
532 | } |
533 | |
534 | static struct bus_type ac97_bus_type = { |
535 | .name = "ac97bus" , |
536 | .dev_groups = ac97_dev_groups, |
537 | .match = ac97_bus_match, |
538 | .pm = &ac97_pm, |
539 | .probe = ac97_bus_probe, |
540 | .remove = ac97_bus_remove, |
541 | }; |
542 | |
543 | static int __init ac97_bus_init(void) |
544 | { |
545 | return bus_register(bus: &ac97_bus_type); |
546 | } |
547 | subsys_initcall(ac97_bus_init); |
548 | |
549 | static void __exit ac97_bus_exit(void) |
550 | { |
551 | bus_unregister(bus: &ac97_bus_type); |
552 | } |
553 | module_exit(ac97_bus_exit); |
554 | |
555 | MODULE_LICENSE("GPL" ); |
556 | MODULE_AUTHOR("Robert Jarzmik <robert.jarzmik@free.fr>" ); |
557 | |