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