1 | /* |
2 | * Copyright 2014 Advanced Micro Devices, Inc. |
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 shall be included in |
12 | * all copies or substantial portions of the Software. |
13 | * |
14 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
15 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
16 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
17 | * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR |
18 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
19 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
20 | * OTHER DEALINGS IN THE SOFTWARE. |
21 | * |
22 | * Authors: Slava Grigorev <slava.grigorev@amd.com> |
23 | */ |
24 | |
25 | #include <linux/gcd.h> |
26 | #include <linux/component.h> |
27 | |
28 | #include <drm/drm_crtc.h> |
29 | #include "dce6_afmt.h" |
30 | #include "evergreen_hdmi.h" |
31 | #include "radeon.h" |
32 | #include "atom.h" |
33 | #include "r600.h" |
34 | #include "radeon_audio.h" |
35 | |
36 | void dce6_audio_enable(struct radeon_device *rdev, struct r600_audio_pin *pin, |
37 | u8 enable_mask); |
38 | struct r600_audio_pin* r600_audio_get_pin(struct radeon_device *rdev); |
39 | struct r600_audio_pin* dce6_audio_get_pin(struct radeon_device *rdev); |
40 | static void radeon_audio_hdmi_mode_set(struct drm_encoder *encoder, |
41 | struct drm_display_mode *mode); |
42 | static void radeon_audio_dp_mode_set(struct drm_encoder *encoder, |
43 | struct drm_display_mode *mode); |
44 | |
45 | static const u32 pin_offsets[7] = |
46 | { |
47 | (0x5e00 - 0x5e00), |
48 | (0x5e18 - 0x5e00), |
49 | (0x5e30 - 0x5e00), |
50 | (0x5e48 - 0x5e00), |
51 | (0x5e60 - 0x5e00), |
52 | (0x5e78 - 0x5e00), |
53 | (0x5e90 - 0x5e00), |
54 | }; |
55 | |
56 | static u32 radeon_audio_rreg(struct radeon_device *rdev, u32 offset, u32 reg) |
57 | { |
58 | return RREG32(reg); |
59 | } |
60 | |
61 | static void radeon_audio_wreg(struct radeon_device *rdev, u32 offset, |
62 | u32 reg, u32 v) |
63 | { |
64 | WREG32(reg, v); |
65 | } |
66 | |
67 | static struct radeon_audio_basic_funcs r600_funcs = { |
68 | .endpoint_rreg = radeon_audio_rreg, |
69 | .endpoint_wreg = radeon_audio_wreg, |
70 | .enable = r600_audio_enable, |
71 | }; |
72 | |
73 | static struct radeon_audio_basic_funcs dce32_funcs = { |
74 | .endpoint_rreg = radeon_audio_rreg, |
75 | .endpoint_wreg = radeon_audio_wreg, |
76 | .enable = r600_audio_enable, |
77 | }; |
78 | |
79 | static struct radeon_audio_basic_funcs dce4_funcs = { |
80 | .endpoint_rreg = radeon_audio_rreg, |
81 | .endpoint_wreg = radeon_audio_wreg, |
82 | .enable = dce4_audio_enable, |
83 | }; |
84 | |
85 | static struct radeon_audio_basic_funcs dce6_funcs = { |
86 | .endpoint_rreg = dce6_endpoint_rreg, |
87 | .endpoint_wreg = dce6_endpoint_wreg, |
88 | .enable = dce6_audio_enable, |
89 | }; |
90 | |
91 | static struct radeon_audio_funcs r600_hdmi_funcs = { |
92 | .get_pin = r600_audio_get_pin, |
93 | .set_dto = r600_hdmi_audio_set_dto, |
94 | .update_acr = r600_hdmi_update_acr, |
95 | .set_vbi_packet = r600_set_vbi_packet, |
96 | .set_avi_packet = r600_set_avi_packet, |
97 | .set_audio_packet = r600_set_audio_packet, |
98 | .set_mute = r600_set_mute, |
99 | .mode_set = radeon_audio_hdmi_mode_set, |
100 | .dpms = r600_hdmi_enable, |
101 | }; |
102 | |
103 | static struct radeon_audio_funcs dce32_hdmi_funcs = { |
104 | .get_pin = r600_audio_get_pin, |
105 | .write_sad_regs = dce3_2_afmt_write_sad_regs, |
106 | .write_speaker_allocation = dce3_2_afmt_hdmi_write_speaker_allocation, |
107 | .set_dto = dce3_2_audio_set_dto, |
108 | .update_acr = dce3_2_hdmi_update_acr, |
109 | .set_vbi_packet = r600_set_vbi_packet, |
110 | .set_avi_packet = r600_set_avi_packet, |
111 | .set_audio_packet = dce3_2_set_audio_packet, |
112 | .set_mute = dce3_2_set_mute, |
113 | .mode_set = radeon_audio_hdmi_mode_set, |
114 | .dpms = r600_hdmi_enable, |
115 | }; |
116 | |
117 | static struct radeon_audio_funcs dce32_dp_funcs = { |
118 | .get_pin = r600_audio_get_pin, |
119 | .write_sad_regs = dce3_2_afmt_write_sad_regs, |
120 | .write_speaker_allocation = dce3_2_afmt_dp_write_speaker_allocation, |
121 | .set_dto = dce3_2_audio_set_dto, |
122 | .set_avi_packet = r600_set_avi_packet, |
123 | .set_audio_packet = dce3_2_set_audio_packet, |
124 | }; |
125 | |
126 | static struct radeon_audio_funcs dce4_hdmi_funcs = { |
127 | .get_pin = r600_audio_get_pin, |
128 | .write_sad_regs = evergreen_hdmi_write_sad_regs, |
129 | .write_speaker_allocation = dce4_afmt_hdmi_write_speaker_allocation, |
130 | .write_latency_fields = dce4_afmt_write_latency_fields, |
131 | .set_dto = dce4_hdmi_audio_set_dto, |
132 | .update_acr = evergreen_hdmi_update_acr, |
133 | .set_vbi_packet = dce4_set_vbi_packet, |
134 | .set_color_depth = dce4_hdmi_set_color_depth, |
135 | .set_avi_packet = evergreen_set_avi_packet, |
136 | .set_audio_packet = dce4_set_audio_packet, |
137 | .set_mute = dce4_set_mute, |
138 | .mode_set = radeon_audio_hdmi_mode_set, |
139 | .dpms = evergreen_hdmi_enable, |
140 | }; |
141 | |
142 | static struct radeon_audio_funcs dce4_dp_funcs = { |
143 | .get_pin = r600_audio_get_pin, |
144 | .write_sad_regs = evergreen_hdmi_write_sad_regs, |
145 | .write_speaker_allocation = dce4_afmt_dp_write_speaker_allocation, |
146 | .write_latency_fields = dce4_afmt_write_latency_fields, |
147 | .set_dto = dce4_dp_audio_set_dto, |
148 | .set_avi_packet = evergreen_set_avi_packet, |
149 | .set_audio_packet = dce4_set_audio_packet, |
150 | .mode_set = radeon_audio_dp_mode_set, |
151 | .dpms = evergreen_dp_enable, |
152 | }; |
153 | |
154 | static struct radeon_audio_funcs dce6_hdmi_funcs = { |
155 | .select_pin = dce6_afmt_select_pin, |
156 | .get_pin = dce6_audio_get_pin, |
157 | .write_sad_regs = dce6_afmt_write_sad_regs, |
158 | .write_speaker_allocation = dce6_afmt_hdmi_write_speaker_allocation, |
159 | .write_latency_fields = dce6_afmt_write_latency_fields, |
160 | .set_dto = dce6_hdmi_audio_set_dto, |
161 | .update_acr = evergreen_hdmi_update_acr, |
162 | .set_vbi_packet = dce4_set_vbi_packet, |
163 | .set_color_depth = dce4_hdmi_set_color_depth, |
164 | .set_avi_packet = evergreen_set_avi_packet, |
165 | .set_audio_packet = dce4_set_audio_packet, |
166 | .set_mute = dce4_set_mute, |
167 | .mode_set = radeon_audio_hdmi_mode_set, |
168 | .dpms = evergreen_hdmi_enable, |
169 | }; |
170 | |
171 | static struct radeon_audio_funcs dce6_dp_funcs = { |
172 | .select_pin = dce6_afmt_select_pin, |
173 | .get_pin = dce6_audio_get_pin, |
174 | .write_sad_regs = dce6_afmt_write_sad_regs, |
175 | .write_speaker_allocation = dce6_afmt_dp_write_speaker_allocation, |
176 | .write_latency_fields = dce6_afmt_write_latency_fields, |
177 | .set_dto = dce6_dp_audio_set_dto, |
178 | .set_avi_packet = evergreen_set_avi_packet, |
179 | .set_audio_packet = dce4_set_audio_packet, |
180 | .mode_set = radeon_audio_dp_mode_set, |
181 | .dpms = evergreen_dp_enable, |
182 | }; |
183 | |
184 | static void radeon_audio_component_notify(struct radeon_device *rdev, int port); |
185 | |
186 | static void radeon_audio_enable(struct radeon_device *rdev, |
187 | struct r600_audio_pin *pin, u8 enable_mask) |
188 | { |
189 | struct drm_encoder *encoder; |
190 | struct radeon_encoder *radeon_encoder; |
191 | struct radeon_encoder_atom_dig *dig; |
192 | int pin_count = 0; |
193 | |
194 | if (!pin) |
195 | return; |
196 | |
197 | if (rdev->mode_info.mode_config_initialized) { |
198 | list_for_each_entry(encoder, &rdev->ddev->mode_config.encoder_list, head) { |
199 | if (radeon_encoder_is_digital(encoder)) { |
200 | radeon_encoder = to_radeon_encoder(encoder); |
201 | dig = radeon_encoder->enc_priv; |
202 | if (dig->pin == pin) |
203 | pin_count++; |
204 | } |
205 | } |
206 | |
207 | if ((pin_count > 1) && (enable_mask == 0)) |
208 | return; |
209 | } |
210 | |
211 | if (rdev->audio.funcs->enable) |
212 | rdev->audio.funcs->enable(rdev, pin, enable_mask); |
213 | |
214 | radeon_audio_component_notify(rdev, port: pin->id); |
215 | } |
216 | |
217 | static void radeon_audio_interface_init(struct radeon_device *rdev) |
218 | { |
219 | if (ASIC_IS_DCE6(rdev)) { |
220 | rdev->audio.funcs = &dce6_funcs; |
221 | rdev->audio.hdmi_funcs = &dce6_hdmi_funcs; |
222 | rdev->audio.dp_funcs = &dce6_dp_funcs; |
223 | } else if (ASIC_IS_DCE4(rdev)) { |
224 | rdev->audio.funcs = &dce4_funcs; |
225 | rdev->audio.hdmi_funcs = &dce4_hdmi_funcs; |
226 | rdev->audio.dp_funcs = &dce4_dp_funcs; |
227 | } else if (ASIC_IS_DCE32(rdev)) { |
228 | rdev->audio.funcs = &dce32_funcs; |
229 | rdev->audio.hdmi_funcs = &dce32_hdmi_funcs; |
230 | rdev->audio.dp_funcs = &dce32_dp_funcs; |
231 | } else { |
232 | rdev->audio.funcs = &r600_funcs; |
233 | rdev->audio.hdmi_funcs = &r600_hdmi_funcs; |
234 | rdev->audio.dp_funcs = NULL; |
235 | } |
236 | } |
237 | |
238 | static int radeon_audio_chipset_supported(struct radeon_device *rdev) |
239 | { |
240 | return ASIC_IS_DCE2(rdev) && !ASIC_IS_NODCE(rdev); |
241 | } |
242 | |
243 | int radeon_audio_init(struct radeon_device *rdev) |
244 | { |
245 | int i; |
246 | |
247 | if (!radeon_audio || !radeon_audio_chipset_supported(rdev)) |
248 | return 0; |
249 | |
250 | rdev->audio.enabled = true; |
251 | |
252 | if (ASIC_IS_DCE83(rdev)) /* KB: 2 streams, 3 endpoints */ |
253 | rdev->audio.num_pins = 3; |
254 | else if (ASIC_IS_DCE81(rdev)) /* KV: 4 streams, 7 endpoints */ |
255 | rdev->audio.num_pins = 7; |
256 | else if (ASIC_IS_DCE8(rdev)) /* BN/HW: 6 streams, 7 endpoints */ |
257 | rdev->audio.num_pins = 7; |
258 | else if (ASIC_IS_DCE64(rdev)) /* OL: 2 streams, 2 endpoints */ |
259 | rdev->audio.num_pins = 2; |
260 | else if (ASIC_IS_DCE61(rdev)) /* TN: 4 streams, 6 endpoints */ |
261 | rdev->audio.num_pins = 6; |
262 | else if (ASIC_IS_DCE6(rdev)) /* SI: 6 streams, 6 endpoints */ |
263 | rdev->audio.num_pins = 6; |
264 | else |
265 | rdev->audio.num_pins = 1; |
266 | |
267 | for (i = 0; i < rdev->audio.num_pins; i++) { |
268 | rdev->audio.pin[i].channels = -1; |
269 | rdev->audio.pin[i].rate = -1; |
270 | rdev->audio.pin[i].bits_per_sample = -1; |
271 | rdev->audio.pin[i].status_bits = 0; |
272 | rdev->audio.pin[i].category_code = 0; |
273 | rdev->audio.pin[i].connected = false; |
274 | rdev->audio.pin[i].offset = pin_offsets[i]; |
275 | rdev->audio.pin[i].id = i; |
276 | } |
277 | |
278 | radeon_audio_interface_init(rdev); |
279 | |
280 | /* disable audio. it will be set up later */ |
281 | for (i = 0; i < rdev->audio.num_pins; i++) |
282 | radeon_audio_enable(rdev, pin: &rdev->audio.pin[i], enable_mask: 0); |
283 | |
284 | return 0; |
285 | } |
286 | |
287 | u32 radeon_audio_endpoint_rreg(struct radeon_device *rdev, u32 offset, u32 reg) |
288 | { |
289 | if (rdev->audio.funcs->endpoint_rreg) |
290 | return rdev->audio.funcs->endpoint_rreg(rdev, offset, reg); |
291 | |
292 | return 0; |
293 | } |
294 | |
295 | void radeon_audio_endpoint_wreg(struct radeon_device *rdev, u32 offset, |
296 | u32 reg, u32 v) |
297 | { |
298 | if (rdev->audio.funcs->endpoint_wreg) |
299 | rdev->audio.funcs->endpoint_wreg(rdev, offset, reg, v); |
300 | } |
301 | |
302 | static void radeon_audio_write_sad_regs(struct drm_encoder *encoder) |
303 | { |
304 | struct drm_connector *connector = radeon_get_connector_for_encoder(encoder); |
305 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
306 | struct cea_sad *sads; |
307 | int sad_count; |
308 | |
309 | if (!connector) |
310 | return; |
311 | |
312 | sad_count = drm_edid_to_sad(edid: radeon_connector_edid(connector), sads: &sads); |
313 | if (sad_count < 0) |
314 | DRM_ERROR("Couldn't read SADs: %d\n" , sad_count); |
315 | if (sad_count <= 0) |
316 | return; |
317 | BUG_ON(!sads); |
318 | |
319 | if (radeon_encoder->audio && radeon_encoder->audio->write_sad_regs) |
320 | radeon_encoder->audio->write_sad_regs(encoder, sads, sad_count); |
321 | |
322 | kfree(objp: sads); |
323 | } |
324 | |
325 | static void radeon_audio_write_speaker_allocation(struct drm_encoder *encoder) |
326 | { |
327 | struct drm_connector *connector = radeon_get_connector_for_encoder(encoder); |
328 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
329 | u8 *sadb = NULL; |
330 | int sad_count; |
331 | |
332 | if (!connector) |
333 | return; |
334 | |
335 | sad_count = drm_edid_to_speaker_allocation(edid: radeon_connector_edid(connector), |
336 | sadb: &sadb); |
337 | if (sad_count < 0) { |
338 | DRM_DEBUG("Couldn't read Speaker Allocation Data Block: %d\n" , |
339 | sad_count); |
340 | sad_count = 0; |
341 | } |
342 | |
343 | if (radeon_encoder->audio && radeon_encoder->audio->write_speaker_allocation) |
344 | radeon_encoder->audio->write_speaker_allocation(encoder, sadb, sad_count); |
345 | |
346 | kfree(objp: sadb); |
347 | } |
348 | |
349 | static void radeon_audio_write_latency_fields(struct drm_encoder *encoder, |
350 | struct drm_display_mode *mode) |
351 | { |
352 | struct drm_connector *connector = radeon_get_connector_for_encoder(encoder); |
353 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
354 | |
355 | if (!connector) |
356 | return; |
357 | |
358 | if (radeon_encoder->audio && radeon_encoder->audio->write_latency_fields) |
359 | radeon_encoder->audio->write_latency_fields(encoder, connector, mode); |
360 | } |
361 | |
362 | struct r600_audio_pin* radeon_audio_get_pin(struct drm_encoder *encoder) |
363 | { |
364 | struct radeon_device *rdev = encoder->dev->dev_private; |
365 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
366 | |
367 | if (radeon_encoder->audio && radeon_encoder->audio->get_pin) |
368 | return radeon_encoder->audio->get_pin(rdev); |
369 | |
370 | return NULL; |
371 | } |
372 | |
373 | static void radeon_audio_select_pin(struct drm_encoder *encoder) |
374 | { |
375 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
376 | |
377 | if (radeon_encoder->audio && radeon_encoder->audio->select_pin) |
378 | radeon_encoder->audio->select_pin(encoder); |
379 | } |
380 | |
381 | void radeon_audio_detect(struct drm_connector *connector, |
382 | struct drm_encoder *encoder, |
383 | enum drm_connector_status status) |
384 | { |
385 | struct drm_device *dev = connector->dev; |
386 | struct radeon_device *rdev = dev->dev_private; |
387 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
388 | struct radeon_encoder_atom_dig *dig; |
389 | |
390 | if (!radeon_audio_chipset_supported(rdev)) |
391 | return; |
392 | |
393 | if (!radeon_encoder_is_digital(encoder)) |
394 | return; |
395 | |
396 | dig = radeon_encoder->enc_priv; |
397 | |
398 | if (status == connector_status_connected) { |
399 | if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort) { |
400 | struct radeon_connector *radeon_connector = to_radeon_connector(connector); |
401 | |
402 | if (radeon_dp_getsinktype(radeon_connector) == |
403 | CONNECTOR_OBJECT_ID_DISPLAYPORT) |
404 | radeon_encoder->audio = rdev->audio.dp_funcs; |
405 | else |
406 | radeon_encoder->audio = rdev->audio.hdmi_funcs; |
407 | } else { |
408 | radeon_encoder->audio = rdev->audio.hdmi_funcs; |
409 | } |
410 | |
411 | if (drm_detect_monitor_audio(edid: radeon_connector_edid(connector))) { |
412 | if (!dig->pin) |
413 | dig->pin = radeon_audio_get_pin(encoder); |
414 | radeon_audio_enable(rdev, pin: dig->pin, enable_mask: 0xf); |
415 | } else { |
416 | radeon_audio_enable(rdev, pin: dig->pin, enable_mask: 0); |
417 | dig->pin = NULL; |
418 | } |
419 | } else { |
420 | radeon_audio_enable(rdev, pin: dig->pin, enable_mask: 0); |
421 | dig->pin = NULL; |
422 | } |
423 | } |
424 | |
425 | void radeon_audio_fini(struct radeon_device *rdev) |
426 | { |
427 | int i; |
428 | |
429 | if (!rdev->audio.enabled) |
430 | return; |
431 | |
432 | for (i = 0; i < rdev->audio.num_pins; i++) |
433 | radeon_audio_enable(rdev, pin: &rdev->audio.pin[i], enable_mask: 0); |
434 | |
435 | rdev->audio.enabled = false; |
436 | } |
437 | |
438 | static void radeon_audio_set_dto(struct drm_encoder *encoder, unsigned int clock) |
439 | { |
440 | struct radeon_device *rdev = encoder->dev->dev_private; |
441 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
442 | struct radeon_crtc *crtc = to_radeon_crtc(encoder->crtc); |
443 | |
444 | if (radeon_encoder->audio && radeon_encoder->audio->set_dto) |
445 | radeon_encoder->audio->set_dto(rdev, crtc, clock); |
446 | } |
447 | |
448 | static int radeon_audio_set_avi_packet(struct drm_encoder *encoder, |
449 | struct drm_display_mode *mode) |
450 | { |
451 | struct radeon_device *rdev = encoder->dev->dev_private; |
452 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
453 | struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv; |
454 | struct drm_connector *connector = radeon_get_connector_for_encoder(encoder); |
455 | u8 buffer[HDMI_INFOFRAME_HEADER_SIZE + HDMI_AVI_INFOFRAME_SIZE]; |
456 | struct hdmi_avi_infoframe frame; |
457 | int err; |
458 | |
459 | if (!connector) |
460 | return -EINVAL; |
461 | |
462 | err = drm_hdmi_avi_infoframe_from_display_mode(frame: &frame, connector, mode); |
463 | if (err < 0) { |
464 | DRM_ERROR("failed to setup AVI infoframe: %d\n" , err); |
465 | return err; |
466 | } |
467 | |
468 | if (radeon_encoder->output_csc != RADEON_OUTPUT_CSC_BYPASS) { |
469 | drm_hdmi_avi_infoframe_quant_range(frame: &frame, connector, mode, |
470 | rgb_quant_range: radeon_encoder->output_csc == RADEON_OUTPUT_CSC_TVRGB ? |
471 | HDMI_QUANTIZATION_RANGE_LIMITED : |
472 | HDMI_QUANTIZATION_RANGE_FULL); |
473 | } |
474 | |
475 | err = hdmi_avi_infoframe_pack(frame: &frame, buffer, size: sizeof(buffer)); |
476 | if (err < 0) { |
477 | DRM_ERROR("failed to pack AVI infoframe: %d\n" , err); |
478 | return err; |
479 | } |
480 | |
481 | if (dig && dig->afmt && radeon_encoder->audio && |
482 | radeon_encoder->audio->set_avi_packet) |
483 | radeon_encoder->audio->set_avi_packet(rdev, dig->afmt->offset, |
484 | buffer, sizeof(buffer)); |
485 | |
486 | return 0; |
487 | } |
488 | |
489 | /* |
490 | * calculate CTS and N values if they are not found in the table |
491 | */ |
492 | static void radeon_audio_calc_cts(unsigned int clock, int *CTS, int *N, int freq) |
493 | { |
494 | int n, cts; |
495 | unsigned long div, mul; |
496 | |
497 | /* Safe, but overly large values */ |
498 | n = 128 * freq; |
499 | cts = clock * 1000; |
500 | |
501 | /* Smallest valid fraction */ |
502 | div = gcd(a: n, b: cts); |
503 | |
504 | n /= div; |
505 | cts /= div; |
506 | |
507 | /* |
508 | * The optimal N is 128*freq/1000. Calculate the closest larger |
509 | * value that doesn't truncate any bits. |
510 | */ |
511 | mul = ((128*freq/1000) + (n-1))/n; |
512 | |
513 | n *= mul; |
514 | cts *= mul; |
515 | |
516 | /* Check that we are in spec (not always possible) */ |
517 | if (n < (128*freq/1500)) |
518 | pr_warn("Calculated ACR N value is too small. You may experience audio problems.\n" ); |
519 | if (n > (128*freq/300)) |
520 | pr_warn("Calculated ACR N value is too large. You may experience audio problems.\n" ); |
521 | |
522 | *N = n; |
523 | *CTS = cts; |
524 | |
525 | DRM_DEBUG("Calculated ACR timing N=%d CTS=%d for frequency %d\n" , |
526 | *N, *CTS, freq); |
527 | } |
528 | |
529 | static const struct radeon_hdmi_acr* radeon_audio_acr(unsigned int clock) |
530 | { |
531 | static struct radeon_hdmi_acr res; |
532 | u8 i; |
533 | |
534 | static const struct radeon_hdmi_acr hdmi_predefined_acr[] = { |
535 | /* 32kHz 44.1kHz 48kHz */ |
536 | /* Clock N CTS N CTS N CTS */ |
537 | { 25175, 4096, 25175, 28224, 125875, 6144, 25175 }, /* 25,20/1.001 MHz */ |
538 | { 25200, 4096, 25200, 6272, 28000, 6144, 25200 }, /* 25.20 MHz */ |
539 | { 27000, 4096, 27000, 6272, 30000, 6144, 27000 }, /* 27.00 MHz */ |
540 | { 27027, 4096, 27027, 6272, 30030, 6144, 27027 }, /* 27.00*1.001 MHz */ |
541 | { 54000, 4096, 54000, 6272, 60000, 6144, 54000 }, /* 54.00 MHz */ |
542 | { 54054, 4096, 54054, 6272, 60060, 6144, 54054 }, /* 54.00*1.001 MHz */ |
543 | { 74176, 4096, 74176, 5733, 75335, 6144, 74176 }, /* 74.25/1.001 MHz */ |
544 | { 74250, 4096, 74250, 6272, 82500, 6144, 74250 }, /* 74.25 MHz */ |
545 | { 148352, 4096, 148352, 5733, 150670, 6144, 148352 }, /* 148.50/1.001 MHz */ |
546 | { 148500, 4096, 148500, 6272, 165000, 6144, 148500 }, /* 148.50 MHz */ |
547 | }; |
548 | |
549 | /* Precalculated values for common clocks */ |
550 | for (i = 0; i < ARRAY_SIZE(hdmi_predefined_acr); i++) |
551 | if (hdmi_predefined_acr[i].clock == clock) |
552 | return &hdmi_predefined_acr[i]; |
553 | |
554 | /* And odd clocks get manually calculated */ |
555 | radeon_audio_calc_cts(clock, CTS: &res.cts_32khz, N: &res.n_32khz, freq: 32000); |
556 | radeon_audio_calc_cts(clock, CTS: &res.cts_44_1khz, N: &res.n_44_1khz, freq: 44100); |
557 | radeon_audio_calc_cts(clock, CTS: &res.cts_48khz, N: &res.n_48khz, freq: 48000); |
558 | |
559 | return &res; |
560 | } |
561 | |
562 | /* |
563 | * update the N and CTS parameters for a given pixel clock rate |
564 | */ |
565 | static void radeon_audio_update_acr(struct drm_encoder *encoder, unsigned int clock) |
566 | { |
567 | const struct radeon_hdmi_acr *acr = radeon_audio_acr(clock); |
568 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
569 | struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv; |
570 | |
571 | if (!dig || !dig->afmt) |
572 | return; |
573 | |
574 | if (radeon_encoder->audio && radeon_encoder->audio->update_acr) |
575 | radeon_encoder->audio->update_acr(encoder, dig->afmt->offset, acr); |
576 | } |
577 | |
578 | static void radeon_audio_set_vbi_packet(struct drm_encoder *encoder) |
579 | { |
580 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
581 | struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv; |
582 | |
583 | if (!dig || !dig->afmt) |
584 | return; |
585 | |
586 | if (radeon_encoder->audio && radeon_encoder->audio->set_vbi_packet) |
587 | radeon_encoder->audio->set_vbi_packet(encoder, dig->afmt->offset); |
588 | } |
589 | |
590 | static void radeon_hdmi_set_color_depth(struct drm_encoder *encoder) |
591 | { |
592 | int bpc = 8; |
593 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
594 | struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv; |
595 | |
596 | if (!dig || !dig->afmt) |
597 | return; |
598 | |
599 | if (encoder->crtc) { |
600 | struct radeon_crtc *radeon_crtc = to_radeon_crtc(encoder->crtc); |
601 | bpc = radeon_crtc->bpc; |
602 | } |
603 | |
604 | if (radeon_encoder->audio && radeon_encoder->audio->set_color_depth) |
605 | radeon_encoder->audio->set_color_depth(encoder, dig->afmt->offset, bpc); |
606 | } |
607 | |
608 | static void radeon_audio_set_audio_packet(struct drm_encoder *encoder) |
609 | { |
610 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
611 | struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv; |
612 | |
613 | if (!dig || !dig->afmt) |
614 | return; |
615 | |
616 | if (radeon_encoder->audio && radeon_encoder->audio->set_audio_packet) |
617 | radeon_encoder->audio->set_audio_packet(encoder, dig->afmt->offset); |
618 | } |
619 | |
620 | static void radeon_audio_set_mute(struct drm_encoder *encoder, bool mute) |
621 | { |
622 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
623 | struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv; |
624 | |
625 | if (!dig || !dig->afmt) |
626 | return; |
627 | |
628 | if (radeon_encoder->audio && radeon_encoder->audio->set_mute) |
629 | radeon_encoder->audio->set_mute(encoder, dig->afmt->offset, mute); |
630 | } |
631 | |
632 | /* |
633 | * update the info frames with the data from the current display mode |
634 | */ |
635 | static void radeon_audio_hdmi_mode_set(struct drm_encoder *encoder, |
636 | struct drm_display_mode *mode) |
637 | { |
638 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
639 | struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv; |
640 | struct drm_connector *connector = radeon_get_connector_for_encoder(encoder); |
641 | |
642 | if (!dig || !dig->afmt) |
643 | return; |
644 | |
645 | if (!connector) |
646 | return; |
647 | |
648 | if (drm_detect_monitor_audio(edid: radeon_connector_edid(connector))) { |
649 | radeon_audio_set_mute(encoder, mute: true); |
650 | |
651 | radeon_audio_write_speaker_allocation(encoder); |
652 | radeon_audio_write_sad_regs(encoder); |
653 | radeon_audio_write_latency_fields(encoder, mode); |
654 | radeon_audio_set_dto(encoder, clock: mode->clock); |
655 | radeon_audio_set_vbi_packet(encoder); |
656 | radeon_hdmi_set_color_depth(encoder); |
657 | radeon_audio_update_acr(encoder, clock: mode->clock); |
658 | radeon_audio_set_audio_packet(encoder); |
659 | radeon_audio_select_pin(encoder); |
660 | |
661 | if (radeon_audio_set_avi_packet(encoder, mode) < 0) |
662 | return; |
663 | |
664 | radeon_audio_set_mute(encoder, mute: false); |
665 | } else { |
666 | radeon_hdmi_set_color_depth(encoder); |
667 | |
668 | if (radeon_audio_set_avi_packet(encoder, mode) < 0) |
669 | return; |
670 | } |
671 | } |
672 | |
673 | static void radeon_audio_dp_mode_set(struct drm_encoder *encoder, |
674 | struct drm_display_mode *mode) |
675 | { |
676 | struct drm_device *dev = encoder->dev; |
677 | struct radeon_device *rdev = dev->dev_private; |
678 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
679 | struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv; |
680 | struct drm_connector *connector = radeon_get_connector_for_encoder(encoder); |
681 | |
682 | if (!dig || !dig->afmt) |
683 | return; |
684 | |
685 | if (!connector) |
686 | return; |
687 | |
688 | if (drm_detect_monitor_audio(edid: radeon_connector_edid(connector))) { |
689 | radeon_audio_write_speaker_allocation(encoder); |
690 | radeon_audio_write_sad_regs(encoder); |
691 | radeon_audio_write_latency_fields(encoder, mode); |
692 | radeon_audio_set_dto(encoder, clock: rdev->clock.vco_freq * 10); |
693 | radeon_audio_set_audio_packet(encoder); |
694 | radeon_audio_select_pin(encoder); |
695 | |
696 | if (radeon_audio_set_avi_packet(encoder, mode) < 0) |
697 | return; |
698 | } |
699 | } |
700 | |
701 | void radeon_audio_mode_set(struct drm_encoder *encoder, |
702 | struct drm_display_mode *mode) |
703 | { |
704 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
705 | |
706 | if (radeon_encoder->audio && radeon_encoder->audio->mode_set) |
707 | radeon_encoder->audio->mode_set(encoder, mode); |
708 | } |
709 | |
710 | void radeon_audio_dpms(struct drm_encoder *encoder, int mode) |
711 | { |
712 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
713 | |
714 | if (radeon_encoder->audio && radeon_encoder->audio->dpms) |
715 | radeon_encoder->audio->dpms(encoder, mode == DRM_MODE_DPMS_ON); |
716 | } |
717 | |
718 | unsigned int radeon_audio_decode_dfs_div(unsigned int div) |
719 | { |
720 | if (div >= 8 && div < 64) |
721 | return (div - 8) * 25 + 200; |
722 | else if (div >= 64 && div < 96) |
723 | return (div - 64) * 50 + 1600; |
724 | else if (div >= 96 && div < 128) |
725 | return (div - 96) * 100 + 3200; |
726 | else |
727 | return 0; |
728 | } |
729 | |
730 | /* |
731 | * Audio component support |
732 | */ |
733 | static void radeon_audio_component_notify(struct radeon_device *rdev, int port) |
734 | { |
735 | struct drm_audio_component *acomp; |
736 | |
737 | mutex_lock(&rdev->audio.component_mutex); |
738 | acomp = rdev->audio.component; |
739 | if (acomp && acomp->audio_ops && acomp->audio_ops->pin_eld_notify) |
740 | acomp->audio_ops->pin_eld_notify(acomp->audio_ops->audio_ptr, |
741 | port, -1); |
742 | mutex_unlock(lock: &rdev->audio.component_mutex); |
743 | } |
744 | |
745 | static int radeon_audio_component_get_eld(struct device *kdev, int port, |
746 | int pipe, bool *enabled, |
747 | unsigned char *buf, int max_bytes) |
748 | { |
749 | struct drm_device *dev = dev_get_drvdata(dev: kdev); |
750 | struct radeon_device *rdev = dev->dev_private; |
751 | struct drm_encoder *encoder; |
752 | struct radeon_encoder *radeon_encoder; |
753 | struct radeon_encoder_atom_dig *dig; |
754 | struct drm_connector *connector; |
755 | int ret = 0; |
756 | |
757 | *enabled = false; |
758 | if (!rdev->audio.enabled || !rdev->mode_info.mode_config_initialized) |
759 | return 0; |
760 | |
761 | list_for_each_entry(encoder, &rdev->ddev->mode_config.encoder_list, head) { |
762 | if (!radeon_encoder_is_digital(encoder)) |
763 | continue; |
764 | radeon_encoder = to_radeon_encoder(encoder); |
765 | dig = radeon_encoder->enc_priv; |
766 | if (!dig->pin || dig->pin->id != port) |
767 | continue; |
768 | connector = radeon_get_connector_for_encoder(encoder); |
769 | if (!connector) |
770 | continue; |
771 | *enabled = true; |
772 | ret = drm_eld_size(eld: connector->eld); |
773 | memcpy(buf, connector->eld, min(max_bytes, ret)); |
774 | break; |
775 | } |
776 | |
777 | return ret; |
778 | } |
779 | |
780 | static const struct drm_audio_component_ops radeon_audio_component_ops = { |
781 | .get_eld = radeon_audio_component_get_eld, |
782 | }; |
783 | |
784 | static int radeon_audio_component_bind(struct device *kdev, |
785 | struct device *hda_kdev, void *data) |
786 | { |
787 | struct drm_device *dev = dev_get_drvdata(dev: kdev); |
788 | struct radeon_device *rdev = dev->dev_private; |
789 | struct drm_audio_component *acomp = data; |
790 | |
791 | if (WARN_ON(!device_link_add(hda_kdev, kdev, DL_FLAG_STATELESS))) |
792 | return -ENOMEM; |
793 | |
794 | mutex_lock(&rdev->audio.component_mutex); |
795 | acomp->ops = &radeon_audio_component_ops; |
796 | acomp->dev = kdev; |
797 | rdev->audio.component = acomp; |
798 | mutex_unlock(lock: &rdev->audio.component_mutex); |
799 | |
800 | return 0; |
801 | } |
802 | |
803 | static void radeon_audio_component_unbind(struct device *kdev, |
804 | struct device *hda_kdev, void *data) |
805 | { |
806 | struct drm_device *dev = dev_get_drvdata(dev: kdev); |
807 | struct radeon_device *rdev = dev->dev_private; |
808 | struct drm_audio_component *acomp = data; |
809 | |
810 | device_link_remove(consumer: hda_kdev, supplier: kdev); |
811 | |
812 | mutex_lock(&rdev->audio.component_mutex); |
813 | rdev->audio.component = NULL; |
814 | acomp->ops = NULL; |
815 | acomp->dev = NULL; |
816 | mutex_unlock(lock: &rdev->audio.component_mutex); |
817 | } |
818 | |
819 | static const struct component_ops radeon_audio_component_bind_ops = { |
820 | .bind = radeon_audio_component_bind, |
821 | .unbind = radeon_audio_component_unbind, |
822 | }; |
823 | |
824 | void radeon_audio_component_init(struct radeon_device *rdev) |
825 | { |
826 | if (rdev->audio.component_registered || |
827 | !radeon_audio || !radeon_audio_chipset_supported(rdev)) |
828 | return; |
829 | |
830 | if (!component_add(rdev->dev, &radeon_audio_component_bind_ops)) |
831 | rdev->audio.component_registered = true; |
832 | } |
833 | |
834 | void radeon_audio_component_fini(struct radeon_device *rdev) |
835 | { |
836 | if (rdev->audio.component_registered) { |
837 | component_del(rdev->dev, &radeon_audio_component_bind_ops); |
838 | rdev->audio.component_registered = false; |
839 | } |
840 | } |
841 | |