1 | /* |
2 | * Copyright © 2016 Intel Corporation |
3 | * |
4 | * Permission is hereby granted, free of charge, to any person obtaining a |
5 | * copy of this software and associated documentation files (the "Software"), |
6 | * to deal in the Software without restriction, including without limitation |
7 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
8 | * and/or sell copies of the Software, and to permit persons to whom the |
9 | * Software is furnished to do so, subject to the following conditions: |
10 | * |
11 | * The above copyright notice and this permission notice (including the next |
12 | * paragraph) shall be included in all copies or substantial portions of the |
13 | * Software. |
14 | * |
15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
18 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
20 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
21 | * IN THE SOFTWARE. |
22 | * |
23 | * Authors: |
24 | * Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com> |
25 | * Jerome Anand <jerome.anand@intel.com> |
26 | * based on VED patches |
27 | * |
28 | */ |
29 | |
30 | /** |
31 | * DOC: LPE Audio integration for HDMI or DP playback |
32 | * |
33 | * Motivation: |
34 | * Atom platforms (e.g. valleyview and cherryTrail) integrates a DMA-based |
35 | * interface as an alternative to the traditional HDaudio path. While this |
36 | * mode is unrelated to the LPE aka SST audio engine, the documentation refers |
37 | * to this mode as LPE so we keep this notation for the sake of consistency. |
38 | * |
39 | * The interface is handled by a separate standalone driver maintained in the |
40 | * ALSA subsystem for simplicity. To minimize the interaction between the two |
41 | * subsystems, a bridge is setup between the hdmi-lpe-audio and i915: |
42 | * 1. Create a platform device to share MMIO/IRQ resources |
43 | * 2. Make the platform device child of i915 device for runtime PM. |
44 | * 3. Create IRQ chip to forward the LPE audio irqs. |
45 | * the hdmi-lpe-audio driver probes the lpe audio device and creates a new |
46 | * sound card |
47 | * |
48 | * Threats: |
49 | * Due to the restriction in Linux platform device model, user need manually |
50 | * uninstall the hdmi-lpe-audio driver before uninstalling i915 module, |
51 | * otherwise we might run into use-after-free issues after i915 removes the |
52 | * platform device: even though hdmi-lpe-audio driver is released, the modules |
53 | * is still in "installed" status. |
54 | * |
55 | * Implementation: |
56 | * The MMIO/REG platform resources are created according to the registers |
57 | * specification. |
58 | * When forwarding LPE audio irqs, the flow control handler selection depends |
59 | * on the platform, for example on valleyview handle_simple_irq is enough. |
60 | * |
61 | */ |
62 | |
63 | #include <linux/acpi.h> |
64 | #include <linux/delay.h> |
65 | #include <linux/device.h> |
66 | #include <linux/irq.h> |
67 | #include <linux/pci.h> |
68 | #include <linux/platform_device.h> |
69 | #include <linux/pm_runtime.h> |
70 | |
71 | #include <drm/intel_lpe_audio.h> |
72 | |
73 | #include "i915_drv.h" |
74 | #include "i915_irq.h" |
75 | #include "i915_reg.h" |
76 | #include "intel_de.h" |
77 | #include "intel_lpe_audio.h" |
78 | #include "intel_pci_config.h" |
79 | |
80 | #define HAS_LPE_AUDIO(dev_priv) ((dev_priv)->display.audio.lpe.platdev != NULL) |
81 | |
82 | static struct platform_device * |
83 | lpe_audio_platdev_create(struct drm_i915_private *dev_priv) |
84 | { |
85 | struct pci_dev *pdev = to_pci_dev(dev_priv->drm.dev); |
86 | struct platform_device_info pinfo = {}; |
87 | struct resource *rsc; |
88 | struct platform_device *platdev; |
89 | struct intel_hdmi_lpe_audio_pdata *pdata; |
90 | |
91 | pdata = kzalloc(size: sizeof(*pdata), GFP_KERNEL); |
92 | if (!pdata) |
93 | return ERR_PTR(error: -ENOMEM); |
94 | |
95 | rsc = kcalloc(n: 2, size: sizeof(*rsc), GFP_KERNEL); |
96 | if (!rsc) { |
97 | kfree(objp: pdata); |
98 | return ERR_PTR(error: -ENOMEM); |
99 | } |
100 | |
101 | rsc[0].start = rsc[0].end = dev_priv->display.audio.lpe.irq; |
102 | rsc[0].flags = IORESOURCE_IRQ; |
103 | rsc[0].name = "hdmi-lpe-audio-irq" ; |
104 | |
105 | rsc[1].start = pci_resource_start(pdev, GEN4_GTTMMADR_BAR) + |
106 | I915_HDMI_LPE_AUDIO_BASE; |
107 | rsc[1].end = pci_resource_start(pdev, GEN4_GTTMMADR_BAR) + |
108 | I915_HDMI_LPE_AUDIO_BASE + I915_HDMI_LPE_AUDIO_SIZE - 1; |
109 | rsc[1].flags = IORESOURCE_MEM; |
110 | rsc[1].name = "hdmi-lpe-audio-mmio" ; |
111 | |
112 | pinfo.parent = dev_priv->drm.dev; |
113 | pinfo.name = "hdmi-lpe-audio" ; |
114 | pinfo.id = -1; |
115 | pinfo.res = rsc; |
116 | pinfo.num_res = 2; |
117 | pinfo.data = pdata; |
118 | pinfo.size_data = sizeof(*pdata); |
119 | pinfo.dma_mask = DMA_BIT_MASK(32); |
120 | |
121 | pdata->num_pipes = INTEL_NUM_PIPES(dev_priv); |
122 | pdata->num_ports = IS_CHERRYVIEW(dev_priv) ? 3 : 2; /* B,C,D or B,C */ |
123 | pdata->port[0].pipe = -1; |
124 | pdata->port[1].pipe = -1; |
125 | pdata->port[2].pipe = -1; |
126 | spin_lock_init(&pdata->lpe_audio_slock); |
127 | |
128 | platdev = platform_device_register_full(pdevinfo: &pinfo); |
129 | kfree(objp: rsc); |
130 | kfree(objp: pdata); |
131 | |
132 | if (IS_ERR(ptr: platdev)) { |
133 | drm_err(&dev_priv->drm, |
134 | "Failed to allocate LPE audio platform device\n" ); |
135 | return platdev; |
136 | } |
137 | |
138 | pm_runtime_no_callbacks(dev: &platdev->dev); |
139 | |
140 | return platdev; |
141 | } |
142 | |
143 | static void lpe_audio_platdev_destroy(struct drm_i915_private *dev_priv) |
144 | { |
145 | /* XXX Note that platform_device_register_full() allocates a dma_mask |
146 | * and never frees it. We can't free it here as we cannot guarantee |
147 | * this is the last reference (i.e. that the dma_mask will not be |
148 | * used after our unregister). So ee choose to leak the sizeof(u64) |
149 | * allocation here - it should be fixed in the platform_device rather |
150 | * than us fiddle with its internals. |
151 | */ |
152 | |
153 | platform_device_unregister(dev_priv->display.audio.lpe.platdev); |
154 | } |
155 | |
156 | static void lpe_audio_irq_unmask(struct irq_data *d) |
157 | { |
158 | } |
159 | |
160 | static void lpe_audio_irq_mask(struct irq_data *d) |
161 | { |
162 | } |
163 | |
164 | static struct irq_chip lpe_audio_irqchip = { |
165 | .name = "hdmi_lpe_audio_irqchip" , |
166 | .irq_mask = lpe_audio_irq_mask, |
167 | .irq_unmask = lpe_audio_irq_unmask, |
168 | }; |
169 | |
170 | static int lpe_audio_irq_init(struct drm_i915_private *dev_priv) |
171 | { |
172 | int irq = dev_priv->display.audio.lpe.irq; |
173 | |
174 | drm_WARN_ON(&dev_priv->drm, !intel_irqs_enabled(dev_priv)); |
175 | irq_set_chip_and_handler_name(irq, |
176 | chip: &lpe_audio_irqchip, |
177 | handle: handle_simple_irq, |
178 | name: "hdmi_lpe_audio_irq_handler" ); |
179 | |
180 | return irq_set_chip_data(irq, data: dev_priv); |
181 | } |
182 | |
183 | static bool lpe_audio_detect(struct drm_i915_private *dev_priv) |
184 | { |
185 | int lpe_present = false; |
186 | |
187 | if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) { |
188 | static const struct pci_device_id atom_hdaudio_ids[] = { |
189 | /* Baytrail */ |
190 | {PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x0f04)}, |
191 | /* Braswell */ |
192 | {PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2284)}, |
193 | {} |
194 | }; |
195 | |
196 | if (!pci_dev_present(ids: atom_hdaudio_ids)) { |
197 | drm_info(&dev_priv->drm, |
198 | "HDaudio controller not detected, using LPE audio instead\n" ); |
199 | lpe_present = true; |
200 | } |
201 | } |
202 | return lpe_present; |
203 | } |
204 | |
205 | static int lpe_audio_setup(struct drm_i915_private *dev_priv) |
206 | { |
207 | int ret; |
208 | |
209 | dev_priv->display.audio.lpe.irq = irq_alloc_desc(0); |
210 | if (dev_priv->display.audio.lpe.irq < 0) { |
211 | drm_err(&dev_priv->drm, "Failed to allocate IRQ desc: %d\n" , |
212 | dev_priv->display.audio.lpe.irq); |
213 | ret = dev_priv->display.audio.lpe.irq; |
214 | goto err; |
215 | } |
216 | |
217 | drm_dbg(&dev_priv->drm, "irq = %d\n" , dev_priv->display.audio.lpe.irq); |
218 | |
219 | ret = lpe_audio_irq_init(dev_priv); |
220 | |
221 | if (ret) { |
222 | drm_err(&dev_priv->drm, |
223 | "Failed to initialize irqchip for lpe audio: %d\n" , |
224 | ret); |
225 | goto err_free_irq; |
226 | } |
227 | |
228 | dev_priv->display.audio.lpe.platdev = lpe_audio_platdev_create(dev_priv); |
229 | |
230 | if (IS_ERR(ptr: dev_priv->display.audio.lpe.platdev)) { |
231 | ret = PTR_ERR(ptr: dev_priv->display.audio.lpe.platdev); |
232 | drm_err(&dev_priv->drm, |
233 | "Failed to create lpe audio platform device: %d\n" , |
234 | ret); |
235 | goto err_free_irq; |
236 | } |
237 | |
238 | /* enable chicken bit; at least this is required for Dell Wyse 3040 |
239 | * with DP outputs (but only sometimes by some reason!) |
240 | */ |
241 | intel_de_write(i915: dev_priv, VLV_AUD_CHICKEN_BIT_REG, |
242 | VLV_CHICKEN_BIT_DBG_ENABLE); |
243 | |
244 | return 0; |
245 | err_free_irq: |
246 | irq_free_desc(irq: dev_priv->display.audio.lpe.irq); |
247 | err: |
248 | dev_priv->display.audio.lpe.irq = -1; |
249 | dev_priv->display.audio.lpe.platdev = NULL; |
250 | return ret; |
251 | } |
252 | |
253 | /** |
254 | * intel_lpe_audio_irq_handler() - forwards the LPE audio irq |
255 | * @dev_priv: the i915 drm device private data |
256 | * |
257 | * the LPE Audio irq is forwarded to the irq handler registered by LPE audio |
258 | * driver. |
259 | */ |
260 | void intel_lpe_audio_irq_handler(struct drm_i915_private *dev_priv) |
261 | { |
262 | int ret; |
263 | |
264 | if (!HAS_LPE_AUDIO(dev_priv)) |
265 | return; |
266 | |
267 | ret = generic_handle_irq(irq: dev_priv->display.audio.lpe.irq); |
268 | if (ret) |
269 | drm_err_ratelimited(&dev_priv->drm, |
270 | "error handling LPE audio irq: %d\n" , ret); |
271 | } |
272 | |
273 | /** |
274 | * intel_lpe_audio_init() - detect and setup the bridge between HDMI LPE Audio |
275 | * driver and i915 |
276 | * @dev_priv: the i915 drm device private data |
277 | * |
278 | * Return: 0 if successful. non-zero if detection or |
279 | * llocation/initialization fails |
280 | */ |
281 | int intel_lpe_audio_init(struct drm_i915_private *dev_priv) |
282 | { |
283 | int ret = -ENODEV; |
284 | |
285 | if (lpe_audio_detect(dev_priv)) { |
286 | ret = lpe_audio_setup(dev_priv); |
287 | if (ret < 0) |
288 | drm_err(&dev_priv->drm, |
289 | "failed to setup LPE Audio bridge\n" ); |
290 | } |
291 | return ret; |
292 | } |
293 | |
294 | /** |
295 | * intel_lpe_audio_teardown() - destroy the bridge between HDMI LPE |
296 | * audio driver and i915 |
297 | * @dev_priv: the i915 drm device private data |
298 | * |
299 | * release all the resources for LPE audio <-> i915 bridge. |
300 | */ |
301 | void intel_lpe_audio_teardown(struct drm_i915_private *dev_priv) |
302 | { |
303 | if (!HAS_LPE_AUDIO(dev_priv)) |
304 | return; |
305 | |
306 | lpe_audio_platdev_destroy(dev_priv); |
307 | |
308 | irq_free_desc(irq: dev_priv->display.audio.lpe.irq); |
309 | |
310 | dev_priv->display.audio.lpe.irq = -1; |
311 | dev_priv->display.audio.lpe.platdev = NULL; |
312 | } |
313 | |
314 | /** |
315 | * intel_lpe_audio_notify() - notify lpe audio event |
316 | * audio driver and i915 |
317 | * @dev_priv: the i915 drm device private data |
318 | * @cpu_transcoder: CPU transcoder |
319 | * @port: port |
320 | * @eld : ELD data |
321 | * @ls_clock: Link symbol clock in kHz |
322 | * @dp_output: Driving a DP output? |
323 | * |
324 | * Notify lpe audio driver of eld change. |
325 | */ |
326 | void intel_lpe_audio_notify(struct drm_i915_private *dev_priv, |
327 | enum transcoder cpu_transcoder, enum port port, |
328 | const void *eld, int ls_clock, bool dp_output) |
329 | { |
330 | unsigned long irqflags; |
331 | struct intel_hdmi_lpe_audio_pdata *pdata; |
332 | struct intel_hdmi_lpe_audio_port_pdata *ppdata; |
333 | u32 audio_enable; |
334 | |
335 | if (!HAS_LPE_AUDIO(dev_priv)) |
336 | return; |
337 | |
338 | pdata = dev_get_platdata(dev: &dev_priv->display.audio.lpe.platdev->dev); |
339 | ppdata = &pdata->port[port - PORT_B]; |
340 | |
341 | spin_lock_irqsave(&pdata->lpe_audio_slock, irqflags); |
342 | |
343 | audio_enable = intel_de_read(i915: dev_priv, VLV_AUD_PORT_EN_DBG(port)); |
344 | |
345 | if (eld != NULL) { |
346 | memcpy(ppdata->eld, eld, HDMI_MAX_ELD_BYTES); |
347 | ppdata->pipe = cpu_transcoder; |
348 | ppdata->ls_clock = ls_clock; |
349 | ppdata->dp_output = dp_output; |
350 | |
351 | /* Unmute the amp for both DP and HDMI */ |
352 | intel_de_write(i915: dev_priv, VLV_AUD_PORT_EN_DBG(port), |
353 | val: audio_enable & ~VLV_AMP_MUTE); |
354 | } else { |
355 | memset(ppdata->eld, 0, HDMI_MAX_ELD_BYTES); |
356 | ppdata->pipe = -1; |
357 | ppdata->ls_clock = 0; |
358 | ppdata->dp_output = false; |
359 | |
360 | /* Mute the amp for both DP and HDMI */ |
361 | intel_de_write(i915: dev_priv, VLV_AUD_PORT_EN_DBG(port), |
362 | val: audio_enable | VLV_AMP_MUTE); |
363 | } |
364 | |
365 | if (pdata->notify_audio_lpe) |
366 | pdata->notify_audio_lpe(dev_priv->display.audio.lpe.platdev, port - PORT_B); |
367 | |
368 | spin_unlock_irqrestore(lock: &pdata->lpe_audio_slock, flags: irqflags); |
369 | } |
370 | |