Merge branch 'fix/intel' of https://git.kernel.org/pub/scm/linux/kernel/git/broonie...
[sfrench/cifs-2.6.git] / sound / ac97 / bus.c
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>");