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 */
27static DEFINE_MUTEX(ac97_controllers_mutex);
28static DEFINE_IDR(ac97_adapter_idr);
29static LIST_HEAD(ac97_controllers);
30
31static struct bus_type ac97_bus_type;
32
33static inline struct ac97_controller*
34to_ac97_controller(struct device *ac97_adapter)
35{
36 return container_of(ac97_adapter, struct ac97_controller, adap);
37}
38
39static int ac97_unbound_ctrl_write(struct ac97_controller *adrv, int slot,
40 unsigned short reg, unsigned short val)
41{
42 return -ENODEV;
43}
44
45static int ac97_unbound_ctrl_read(struct ac97_controller *adrv, int slot,
46 unsigned short reg)
47{
48 return -ENODEV;
49}
50
51static const struct ac97_controller_ops ac97_unbound_ctrl_ops = {
52 .write = ac97_unbound_ctrl_write,
53 .read = ac97_unbound_ctrl_read,
54};
55
56static struct ac97_controller ac97_unbound_ctrl = {
57 .ops = &ac97_unbound_ctrl_ops,
58};
59
60static struct ac97_codec_device *
61ac97_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
69static struct device_node *
70ac97_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: &reg)) ||
82 !of_device_is_compatible(device: node, compat))
83 continue;
84 return node;
85 }
86
87 return NULL;
88}
89
90static 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
102static 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
133unsigned 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
154static 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
175static 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 */
191int 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}
196EXPORT_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 */
204void snd_ac97_codec_driver_unregister(struct ac97_codec_driver *drv)
205{
206 driver_unregister(drv: &drv->driver);
207}
208EXPORT_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 */
220void *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}
226EXPORT_SYMBOL_GPL(snd_ac97_codec_get_platdata);
227
228static 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
239static 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}
251static DEVICE_ATTR_WO(cold_reset);
252
253static 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}
268static DEVICE_ATTR_WO(warm_reset);
269
270static struct attribute *ac97_controller_device_attrs[] = {
271 &dev_attr_cold_reset.attr,
272 &dev_attr_warm_reset.attr,
273 NULL
274};
275
276static const struct attribute_group ac97_adapter_attr_group = {
277 .name = "ac97_operations",
278 .attrs = ac97_controller_device_attrs,
279};
280
281static const struct attribute_group *ac97_adapter_groups[] = {
282 &ac97_adapter_attr_group,
283 NULL,
284};
285
286static 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
296static 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
306static const struct device_type ac97_adapter_type = {
307 .groups = ac97_adapter_groups,
308 .release = ac97_adapter_release,
309};
310
311static 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 */
348struct 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;
373err:
374 kfree(objp: ac97_ctrl);
375 return ERR_PTR(error: ret);
376}
377EXPORT_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 */
384void snd_ac97_controller_unregister(struct ac97_controller *ac97_ctrl)
385{
386 ac97_del_adapter(ac97_ctrl);
387}
388EXPORT_SYMBOL_GPL(snd_ac97_controller_unregister);
389
390#ifdef CONFIG_PM
391static 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
406static 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
424static 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
437static 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
452static 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
458static 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}
465static DEVICE_ATTR_RO(vendor_id);
466
467static struct attribute *ac97_dev_attrs[] = {
468 &dev_attr_vendor_id.attr,
469 NULL,
470};
471ATTRIBUTE_GROUPS(ac97_dev);
472
473static 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
491static 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
517static 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
534static 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
543static int __init ac97_bus_init(void)
544{
545 return bus_register(bus: &ac97_bus_type);
546}
547subsys_initcall(ac97_bus_init);
548
549static void __exit ac97_bus_exit(void)
550{
551 bus_unregister(bus: &ac97_bus_type);
552}
553module_exit(ac97_bus_exit);
554
555MODULE_LICENSE("GPL");
556MODULE_AUTHOR("Robert Jarzmik <robert.jarzmik@free.fr>");
557

source code of linux/sound/ac97/bus.c