Merge tag 'davinci-fixes-for-v5.0-part2' of git://git.kernel.org/pub/scm/linux/kernel...
[sfrench/cifs-2.6.git] / sound / hda / hdac_component.c
1 // SPDX-License-Identifier: GPL-2.0
2 // hdac_component.c - routines for sync between HD-A core and DRM driver
3
4 #include <linux/init.h>
5 #include <linux/module.h>
6 #include <linux/pci.h>
7 #include <linux/component.h>
8 #include <sound/core.h>
9 #include <sound/hdaudio.h>
10 #include <sound/hda_component.h>
11 #include <sound/hda_register.h>
12
13 static void hdac_acomp_release(struct device *dev, void *res)
14 {
15 }
16
17 static struct drm_audio_component *hdac_get_acomp(struct device *dev)
18 {
19         return devres_find(dev, hdac_acomp_release, NULL, NULL);
20 }
21
22 /**
23  * snd_hdac_set_codec_wakeup - Enable / disable HDMI/DP codec wakeup
24  * @bus: HDA core bus
25  * @enable: enable or disable the wakeup
26  *
27  * This function is supposed to be used only by a HD-audio controller
28  * driver that needs the interaction with graphics driver.
29  *
30  * This function should be called during the chip reset, also called at
31  * resume for updating STATESTS register read.
32  *
33  * Returns zero for success or a negative error code.
34  */
35 int snd_hdac_set_codec_wakeup(struct hdac_bus *bus, bool enable)
36 {
37         struct drm_audio_component *acomp = bus->audio_component;
38
39         if (!acomp || !acomp->ops)
40                 return -ENODEV;
41
42         if (!acomp->ops->codec_wake_override)
43                 return 0;
44
45         dev_dbg(bus->dev, "%s codec wakeup\n",
46                 enable ? "enable" : "disable");
47
48         acomp->ops->codec_wake_override(acomp->dev, enable);
49
50         return 0;
51 }
52 EXPORT_SYMBOL_GPL(snd_hdac_set_codec_wakeup);
53
54 /**
55  * snd_hdac_display_power - Power up / down the power refcount
56  * @bus: HDA core bus
57  * @idx: HDA codec address, pass HDA_CODEC_IDX_CONTROLLER for controller
58  * @enable: power up or down
59  *
60  * This function is used by either HD-audio controller or codec driver that
61  * needs the interaction with graphics driver.
62  *
63  * This function updates the power status, and calls the get_power() and
64  * put_power() ops accordingly, toggling the codec wakeup, too.
65  */
66 void snd_hdac_display_power(struct hdac_bus *bus, unsigned int idx, bool enable)
67 {
68         struct drm_audio_component *acomp = bus->audio_component;
69
70         dev_dbg(bus->dev, "display power %s\n",
71                 enable ? "enable" : "disable");
72         if (enable)
73                 set_bit(idx, &bus->display_power_status);
74         else
75                 clear_bit(idx, &bus->display_power_status);
76
77         if (!acomp || !acomp->ops)
78                 return;
79
80         if (bus->display_power_status) {
81                 if (!bus->display_power_active) {
82                         if (acomp->ops->get_power)
83                                 acomp->ops->get_power(acomp->dev);
84                         snd_hdac_set_codec_wakeup(bus, true);
85                         snd_hdac_set_codec_wakeup(bus, false);
86                         bus->display_power_active = true;
87                 }
88         } else {
89                 if (bus->display_power_active) {
90                         if (acomp->ops->put_power)
91                                 acomp->ops->put_power(acomp->dev);
92                         bus->display_power_active = false;
93                 }
94         }
95 }
96 EXPORT_SYMBOL_GPL(snd_hdac_display_power);
97
98 /**
99  * snd_hdac_sync_audio_rate - Set N/CTS based on the sample rate
100  * @codec: HDA codec
101  * @nid: the pin widget NID
102  * @dev_id: device identifier
103  * @rate: the sample rate to set
104  *
105  * This function is supposed to be used only by a HD-audio controller
106  * driver that needs the interaction with graphics driver.
107  *
108  * This function sets N/CTS value based on the given sample rate.
109  * Returns zero for success, or a negative error code.
110  */
111 int snd_hdac_sync_audio_rate(struct hdac_device *codec, hda_nid_t nid,
112                              int dev_id, int rate)
113 {
114         struct hdac_bus *bus = codec->bus;
115         struct drm_audio_component *acomp = bus->audio_component;
116         int port, pipe;
117
118         if (!acomp || !acomp->ops || !acomp->ops->sync_audio_rate)
119                 return -ENODEV;
120         port = nid;
121         if (acomp->audio_ops && acomp->audio_ops->pin2port) {
122                 port = acomp->audio_ops->pin2port(codec, nid);
123                 if (port < 0)
124                         return -EINVAL;
125         }
126         pipe = dev_id;
127         return acomp->ops->sync_audio_rate(acomp->dev, port, pipe, rate);
128 }
129 EXPORT_SYMBOL_GPL(snd_hdac_sync_audio_rate);
130
131 /**
132  * snd_hdac_acomp_get_eld - Get the audio state and ELD via component
133  * @codec: HDA codec
134  * @nid: the pin widget NID
135  * @dev_id: device identifier
136  * @audio_enabled: the pointer to store the current audio state
137  * @buffer: the buffer pointer to store ELD bytes
138  * @max_bytes: the max bytes to be stored on @buffer
139  *
140  * This function is supposed to be used only by a HD-audio controller
141  * driver that needs the interaction with graphics driver.
142  *
143  * This function queries the current state of the audio on the given
144  * digital port and fetches the ELD bytes onto the given buffer.
145  * It returns the number of bytes for the total ELD data, zero for
146  * invalid ELD, or a negative error code.
147  *
148  * The return size is the total bytes required for the whole ELD bytes,
149  * thus it may be over @max_bytes.  If it's over @max_bytes, it implies
150  * that only a part of ELD bytes have been fetched.
151  */
152 int snd_hdac_acomp_get_eld(struct hdac_device *codec, hda_nid_t nid, int dev_id,
153                            bool *audio_enabled, char *buffer, int max_bytes)
154 {
155         struct hdac_bus *bus = codec->bus;
156         struct drm_audio_component *acomp = bus->audio_component;
157         int port, pipe;
158
159         if (!acomp || !acomp->ops || !acomp->ops->get_eld)
160                 return -ENODEV;
161
162         port = nid;
163         if (acomp->audio_ops && acomp->audio_ops->pin2port) {
164                 port = acomp->audio_ops->pin2port(codec, nid);
165                 if (port < 0)
166                         return -EINVAL;
167         }
168         pipe = dev_id;
169         return acomp->ops->get_eld(acomp->dev, port, pipe, audio_enabled,
170                                    buffer, max_bytes);
171 }
172 EXPORT_SYMBOL_GPL(snd_hdac_acomp_get_eld);
173
174 static int hdac_component_master_bind(struct device *dev)
175 {
176         struct drm_audio_component *acomp = hdac_get_acomp(dev);
177         int ret;
178
179         if (WARN_ON(!acomp))
180                 return -EINVAL;
181
182         ret = component_bind_all(dev, acomp);
183         if (ret < 0)
184                 return ret;
185
186         if (WARN_ON(!(acomp->dev && acomp->ops))) {
187                 ret = -EINVAL;
188                 goto out_unbind;
189         }
190
191         /* pin the module to avoid dynamic unbinding, but only if given */
192         if (!try_module_get(acomp->ops->owner)) {
193                 ret = -ENODEV;
194                 goto out_unbind;
195         }
196
197         if (acomp->audio_ops && acomp->audio_ops->master_bind) {
198                 ret = acomp->audio_ops->master_bind(dev, acomp);
199                 if (ret < 0)
200                         goto module_put;
201         }
202
203         return 0;
204
205  module_put:
206         module_put(acomp->ops->owner);
207 out_unbind:
208         component_unbind_all(dev, acomp);
209
210         return ret;
211 }
212
213 static void hdac_component_master_unbind(struct device *dev)
214 {
215         struct drm_audio_component *acomp = hdac_get_acomp(dev);
216
217         if (acomp->audio_ops && acomp->audio_ops->master_unbind)
218                 acomp->audio_ops->master_unbind(dev, acomp);
219         module_put(acomp->ops->owner);
220         component_unbind_all(dev, acomp);
221         WARN_ON(acomp->ops || acomp->dev);
222 }
223
224 static const struct component_master_ops hdac_component_master_ops = {
225         .bind = hdac_component_master_bind,
226         .unbind = hdac_component_master_unbind,
227 };
228
229 /**
230  * snd_hdac_acomp_register_notifier - Register audio component ops
231  * @bus: HDA core bus
232  * @aops: audio component ops
233  *
234  * This function is supposed to be used only by a HD-audio controller
235  * driver that needs the interaction with graphics driver.
236  *
237  * This function sets the given ops to be called by the graphics driver.
238  *
239  * Returns zero for success or a negative error code.
240  */
241 int snd_hdac_acomp_register_notifier(struct hdac_bus *bus,
242                                     const struct drm_audio_component_audio_ops *aops)
243 {
244         if (!bus->audio_component)
245                 return -ENODEV;
246
247         bus->audio_component->audio_ops = aops;
248         return 0;
249 }
250 EXPORT_SYMBOL_GPL(snd_hdac_acomp_register_notifier);
251
252 /**
253  * snd_hdac_acomp_init - Initialize audio component
254  * @bus: HDA core bus
255  * @match_master: match function for finding components
256  * @extra_size: Extra bytes to allocate
257  *
258  * This function is supposed to be used only by a HD-audio controller
259  * driver that needs the interaction with graphics driver.
260  *
261  * This function initializes and sets up the audio component to communicate
262  * with graphics driver.
263  *
264  * Unlike snd_hdac_i915_init(), this function doesn't synchronize with the
265  * binding with the DRM component.  Each caller needs to sync via master_bind
266  * audio_ops.
267  *
268  * Returns zero for success or a negative error code.
269  */
270 int snd_hdac_acomp_init(struct hdac_bus *bus,
271                         const struct drm_audio_component_audio_ops *aops,
272                         int (*match_master)(struct device *, void *),
273                         size_t extra_size)
274 {
275         struct component_match *match = NULL;
276         struct device *dev = bus->dev;
277         struct drm_audio_component *acomp;
278         int ret;
279
280         if (WARN_ON(hdac_get_acomp(dev)))
281                 return -EBUSY;
282
283         acomp = devres_alloc(hdac_acomp_release, sizeof(*acomp) + extra_size,
284                              GFP_KERNEL);
285         if (!acomp)
286                 return -ENOMEM;
287         acomp->audio_ops = aops;
288         bus->audio_component = acomp;
289         devres_add(dev, acomp);
290
291         component_match_add(dev, &match, match_master, bus);
292         ret = component_master_add_with_match(dev, &hdac_component_master_ops,
293                                               match);
294         if (ret < 0)
295                 goto out_err;
296
297         return 0;
298
299 out_err:
300         bus->audio_component = NULL;
301         devres_destroy(dev, hdac_acomp_release, NULL, NULL);
302         dev_info(dev, "failed to add audio component master (%d)\n", ret);
303
304         return ret;
305 }
306 EXPORT_SYMBOL_GPL(snd_hdac_acomp_init);
307
308 /**
309  * snd_hdac_acomp_exit - Finalize audio component
310  * @bus: HDA core bus
311  *
312  * This function is supposed to be used only by a HD-audio controller
313  * driver that needs the interaction with graphics driver.
314  *
315  * This function releases the audio component that has been used.
316  *
317  * Returns zero for success or a negative error code.
318  */
319 int snd_hdac_acomp_exit(struct hdac_bus *bus)
320 {
321         struct device *dev = bus->dev;
322         struct drm_audio_component *acomp = bus->audio_component;
323
324         if (!acomp)
325                 return 0;
326
327         if (WARN_ON(bus->display_power_active) && acomp->ops)
328                 acomp->ops->put_power(acomp->dev);
329
330         bus->display_power_active = false;
331         bus->display_power_status = 0;
332
333         component_master_del(dev, &hdac_component_master_ops);
334
335         bus->audio_component = NULL;
336         devres_destroy(dev, hdac_acomp_release, NULL, NULL);
337
338         return 0;
339 }
340 EXPORT_SYMBOL_GPL(snd_hdac_acomp_exit);