Rev 3764 | Rev 5271 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
1403 | serge | 1 | /* |
2 | * Copyright 2008 Advanced Micro Devices, Inc. |
||
3 | * Copyright 2008 Red Hat Inc. |
||
4 | * Copyright 2009 Christian König. |
||
5 | * |
||
6 | * Permission is hereby granted, free of charge, to any person obtaining a |
||
7 | * copy of this software and associated documentation files (the "Software"), |
||
8 | * to deal in the Software without restriction, including without limitation |
||
9 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
||
10 | * and/or sell copies of the Software, and to permit persons to whom the |
||
11 | * Software is furnished to do so, subject to the following conditions: |
||
12 | * |
||
13 | * The above copyright notice and this permission notice shall be included in |
||
14 | * all copies or substantial portions of the Software. |
||
15 | * |
||
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
||
19 | * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR |
||
20 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
||
21 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
||
22 | * OTHER DEALINGS IN THE SOFTWARE. |
||
23 | * |
||
24 | * Authors: Christian König |
||
25 | */ |
||
3764 | Serge | 26 | #include |
2997 | Serge | 27 | #include |
28 | #include |
||
1403 | serge | 29 | #include "radeon.h" |
1963 | serge | 30 | #include "radeon_asic.h" |
2997 | Serge | 31 | #include "r600d.h" |
1403 | serge | 32 | #include "atom.h" |
33 | |||
34 | /* |
||
35 | * HDMI color format |
||
36 | */ |
||
37 | enum r600_hdmi_color_format { |
||
38 | RGB = 0, |
||
39 | YCC_422 = 1, |
||
40 | YCC_444 = 2 |
||
41 | }; |
||
42 | |||
43 | /* |
||
44 | * IEC60958 status bits |
||
45 | */ |
||
46 | enum r600_hdmi_iec_status_bits { |
||
47 | AUDIO_STATUS_DIG_ENABLE = 0x01, |
||
48 | AUDIO_STATUS_V = 0x02, |
||
49 | AUDIO_STATUS_VCFG = 0x04, |
||
50 | AUDIO_STATUS_EMPHASIS = 0x08, |
||
51 | AUDIO_STATUS_COPYRIGHT = 0x10, |
||
52 | AUDIO_STATUS_NONAUDIO = 0x20, |
||
53 | AUDIO_STATUS_PROFESSIONAL = 0x40, |
||
54 | AUDIO_STATUS_LEVEL = 0x80 |
||
55 | }; |
||
56 | |||
2997 | Serge | 57 | static const struct radeon_hdmi_acr r600_hdmi_predefined_acr[] = { |
1403 | serge | 58 | /* 32kHz 44.1kHz 48kHz */ |
59 | /* Clock N CTS N CTS N CTS */ |
||
5078 | serge | 60 | { 25175, 4096, 25175, 28224, 125875, 6144, 25175 }, /* 25,20/1.001 MHz */ |
1403 | serge | 61 | { 25200, 4096, 25200, 6272, 28000, 6144, 25200 }, /* 25.20 MHz */ |
62 | { 27000, 4096, 27000, 6272, 30000, 6144, 27000 }, /* 27.00 MHz */ |
||
63 | { 27027, 4096, 27027, 6272, 30030, 6144, 27027 }, /* 27.00*1.001 MHz */ |
||
64 | { 54000, 4096, 54000, 6272, 60000, 6144, 54000 }, /* 54.00 MHz */ |
||
65 | { 54054, 4096, 54054, 6272, 60060, 6144, 54054 }, /* 54.00*1.001 MHz */ |
||
5078 | serge | 66 | { 74176, 4096, 74176, 5733, 75335, 6144, 74176 }, /* 74.25/1.001 MHz */ |
1403 | serge | 67 | { 74250, 4096, 74250, 6272, 82500, 6144, 74250 }, /* 74.25 MHz */ |
5078 | serge | 68 | { 148352, 4096, 148352, 5733, 150670, 6144, 148352 }, /* 148.50/1.001 MHz */ |
1403 | serge | 69 | { 148500, 4096, 148500, 6272, 165000, 6144, 148500 }, /* 148.50 MHz */ |
70 | }; |
||
71 | |||
5078 | serge | 72 | |
1403 | serge | 73 | /* |
5078 | serge | 74 | * calculate CTS and N values if they are not found in the table |
1403 | serge | 75 | */ |
5078 | serge | 76 | static void r600_hdmi_calc_cts(uint32_t clock, int *CTS, int *N, int freq) |
1403 | serge | 77 | { |
5078 | serge | 78 | int n, cts; |
79 | unsigned long div, mul; |
||
80 | |||
81 | /* Safe, but overly large values */ |
||
82 | n = 128 * freq; |
||
83 | cts = clock * 1000; |
||
84 | |||
85 | /* Smallest valid fraction */ |
||
86 | div = gcd(n, cts); |
||
87 | |||
88 | n /= div; |
||
89 | cts /= div; |
||
90 | |||
91 | /* |
||
92 | * The optimal N is 128*freq/1000. Calculate the closest larger |
||
93 | * value that doesn't truncate any bits. |
||
94 | */ |
||
95 | mul = ((128*freq/1000) + (n-1))/n; |
||
96 | |||
97 | n *= mul; |
||
98 | cts *= mul; |
||
99 | |||
100 | /* Check that we are in spec (not always possible) */ |
||
101 | if (n < (128*freq/1500)) |
||
102 | printk(KERN_WARNING "Calculated ACR N value is too small. You may experience audio problems.\n"); |
||
103 | if (n > (128*freq/300)) |
||
104 | printk(KERN_WARNING "Calculated ACR N value is too large. You may experience audio problems.\n"); |
||
105 | |||
106 | *N = n; |
||
107 | *CTS = cts; |
||
108 | |||
109 | DRM_DEBUG("Calculated ACR timing N=%d CTS=%d for frequency %d\n", |
||
110 | *N, *CTS, freq); |
||
1403 | serge | 111 | } |
112 | |||
2997 | Serge | 113 | struct radeon_hdmi_acr r600_hdmi_acr(uint32_t clock) |
114 | { |
||
115 | struct radeon_hdmi_acr res; |
||
116 | u8 i; |
||
117 | |||
5078 | serge | 118 | /* Precalculated values for common clocks */ |
119 | for (i = 0; i < ARRAY_SIZE(r600_hdmi_predefined_acr); i++) { |
||
120 | if (r600_hdmi_predefined_acr[i].clock == clock) |
||
121 | return r600_hdmi_predefined_acr[i]; |
||
122 | } |
||
2997 | Serge | 123 | |
5078 | serge | 124 | /* And odd clocks get manually calculated */ |
125 | r600_hdmi_calc_cts(clock, &res.cts_32khz, &res.n_32khz, 32000); |
||
126 | r600_hdmi_calc_cts(clock, &res.cts_44_1khz, &res.n_44_1khz, 44100); |
||
127 | r600_hdmi_calc_cts(clock, &res.cts_48khz, &res.n_48khz, 48000); |
||
2997 | Serge | 128 | |
129 | return res; |
||
130 | } |
||
131 | |||
1403 | serge | 132 | /* |
133 | * update the N and CTS parameters for a given pixel clock rate |
||
134 | */ |
||
5078 | serge | 135 | void r600_hdmi_update_ACR(struct drm_encoder *encoder, uint32_t clock) |
1403 | serge | 136 | { |
137 | struct drm_device *dev = encoder->dev; |
||
138 | struct radeon_device *rdev = dev->dev_private; |
||
2997 | Serge | 139 | struct radeon_hdmi_acr acr = r600_hdmi_acr(clock); |
140 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
||
141 | struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv; |
||
142 | uint32_t offset = dig->afmt->offset; |
||
1403 | serge | 143 | |
5078 | serge | 144 | WREG32_P(HDMI0_ACR_32_0 + offset, |
145 | HDMI0_ACR_CTS_32(acr.cts_32khz), |
||
146 | ~HDMI0_ACR_CTS_32_MASK); |
||
147 | WREG32_P(HDMI0_ACR_32_1 + offset, |
||
148 | HDMI0_ACR_N_32(acr.n_32khz), |
||
149 | ~HDMI0_ACR_N_32_MASK); |
||
1403 | serge | 150 | |
5078 | serge | 151 | WREG32_P(HDMI0_ACR_44_0 + offset, |
152 | HDMI0_ACR_CTS_44(acr.cts_44_1khz), |
||
153 | ~HDMI0_ACR_CTS_44_MASK); |
||
154 | WREG32_P(HDMI0_ACR_44_1 + offset, |
||
155 | HDMI0_ACR_N_44(acr.n_44_1khz), |
||
156 | ~HDMI0_ACR_N_44_MASK); |
||
1403 | serge | 157 | |
5078 | serge | 158 | WREG32_P(HDMI0_ACR_48_0 + offset, |
159 | HDMI0_ACR_CTS_48(acr.cts_48khz), |
||
160 | ~HDMI0_ACR_CTS_48_MASK); |
||
161 | WREG32_P(HDMI0_ACR_48_1 + offset, |
||
162 | HDMI0_ACR_N_48(acr.n_48khz), |
||
163 | ~HDMI0_ACR_N_48_MASK); |
||
1403 | serge | 164 | } |
165 | |||
166 | /* |
||
167 | * build a HDMI Video Info Frame |
||
168 | */ |
||
5078 | serge | 169 | void r600_hdmi_update_avi_infoframe(struct drm_encoder *encoder, void *buffer, |
170 | size_t size) |
||
1403 | serge | 171 | { |
172 | struct drm_device *dev = encoder->dev; |
||
173 | struct radeon_device *rdev = dev->dev_private; |
||
2997 | Serge | 174 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
175 | struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv; |
||
176 | uint32_t offset = dig->afmt->offset; |
||
3764 | Serge | 177 | uint8_t *frame = buffer + 3; |
5078 | serge | 178 | uint8_t *header = buffer; |
1403 | serge | 179 | |
2997 | Serge | 180 | WREG32(HDMI0_AVI_INFO0 + offset, |
1403 | serge | 181 | frame[0x0] | (frame[0x1] << 8) | (frame[0x2] << 16) | (frame[0x3] << 24)); |
2997 | Serge | 182 | WREG32(HDMI0_AVI_INFO1 + offset, |
1403 | serge | 183 | frame[0x4] | (frame[0x5] << 8) | (frame[0x6] << 16) | (frame[0x7] << 24)); |
2997 | Serge | 184 | WREG32(HDMI0_AVI_INFO2 + offset, |
1403 | serge | 185 | frame[0x8] | (frame[0x9] << 8) | (frame[0xA] << 16) | (frame[0xB] << 24)); |
2997 | Serge | 186 | WREG32(HDMI0_AVI_INFO3 + offset, |
5078 | serge | 187 | frame[0xC] | (frame[0xD] << 8) | (header[1] << 24)); |
1403 | serge | 188 | } |
189 | |||
190 | /* |
||
191 | * build a Audio Info Frame |
||
192 | */ |
||
3764 | Serge | 193 | static void r600_hdmi_update_audio_infoframe(struct drm_encoder *encoder, |
194 | const void *buffer, size_t size) |
||
1403 | serge | 195 | { |
196 | struct drm_device *dev = encoder->dev; |
||
197 | struct radeon_device *rdev = dev->dev_private; |
||
2997 | Serge | 198 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
199 | struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv; |
||
200 | uint32_t offset = dig->afmt->offset; |
||
3764 | Serge | 201 | const u8 *frame = buffer + 3; |
1403 | serge | 202 | |
2997 | Serge | 203 | WREG32(HDMI0_AUDIO_INFO0 + offset, |
1403 | serge | 204 | frame[0x0] | (frame[0x1] << 8) | (frame[0x2] << 16) | (frame[0x3] << 24)); |
2997 | Serge | 205 | WREG32(HDMI0_AUDIO_INFO1 + offset, |
1403 | serge | 206 | frame[0x4] | (frame[0x5] << 8) | (frame[0x6] << 16) | (frame[0x8] << 24)); |
207 | } |
||
208 | |||
209 | /* |
||
210 | * test if audio buffer is filled enough to start playing |
||
211 | */ |
||
2997 | Serge | 212 | static bool r600_hdmi_is_audio_buffer_filled(struct drm_encoder *encoder) |
1403 | serge | 213 | { |
214 | struct drm_device *dev = encoder->dev; |
||
215 | struct radeon_device *rdev = dev->dev_private; |
||
2997 | Serge | 216 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
217 | struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv; |
||
218 | uint32_t offset = dig->afmt->offset; |
||
1403 | serge | 219 | |
2997 | Serge | 220 | return (RREG32(HDMI0_STATUS + offset) & 0x10) != 0; |
1403 | serge | 221 | } |
222 | |||
223 | /* |
||
224 | * have buffer status changed since last call? |
||
225 | */ |
||
226 | int r600_hdmi_buffer_status_changed(struct drm_encoder *encoder) |
||
227 | { |
||
228 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
||
2997 | Serge | 229 | struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv; |
1403 | serge | 230 | int status, result; |
231 | |||
2997 | Serge | 232 | if (!dig->afmt || !dig->afmt->enabled) |
1403 | serge | 233 | return 0; |
234 | |||
235 | status = r600_hdmi_is_audio_buffer_filled(encoder); |
||
2997 | Serge | 236 | result = dig->afmt->last_buffer_filled_status != status; |
237 | dig->afmt->last_buffer_filled_status = status; |
||
1403 | serge | 238 | |
239 | return result; |
||
240 | } |
||
241 | |||
242 | /* |
||
243 | * write the audio workaround status to the hardware |
||
244 | */ |
||
5078 | serge | 245 | void r600_hdmi_audio_workaround(struct drm_encoder *encoder) |
1403 | serge | 246 | { |
247 | struct drm_device *dev = encoder->dev; |
||
248 | struct radeon_device *rdev = dev->dev_private; |
||
249 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
||
2997 | Serge | 250 | struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv; |
251 | uint32_t offset = dig->afmt->offset; |
||
252 | bool hdmi_audio_workaround = false; /* FIXME */ |
||
253 | u32 value; |
||
1403 | serge | 254 | |
2997 | Serge | 255 | if (!hdmi_audio_workaround || |
256 | r600_hdmi_is_audio_buffer_filled(encoder)) |
||
257 | value = 0; /* disable workaround */ |
||
258 | else |
||
259 | value = HDMI0_AUDIO_TEST_EN; /* enable workaround */ |
||
260 | WREG32_P(HDMI0_AUDIO_PACKET_CONTROL + offset, |
||
261 | value, ~HDMI0_AUDIO_TEST_EN); |
||
1403 | serge | 262 | } |
263 | |||
3764 | Serge | 264 | void r600_audio_set_dto(struct drm_encoder *encoder, u32 clock) |
265 | { |
||
266 | struct drm_device *dev = encoder->dev; |
||
267 | struct radeon_device *rdev = dev->dev_private; |
||
268 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
||
269 | struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv; |
||
270 | u32 base_rate = 24000; |
||
5078 | serge | 271 | u32 max_ratio = clock / base_rate; |
272 | u32 dto_phase; |
||
273 | u32 dto_modulo = clock; |
||
274 | u32 wallclock_ratio; |
||
275 | u32 dto_cntl; |
||
1403 | serge | 276 | |
3764 | Serge | 277 | if (!dig || !dig->afmt) |
278 | return; |
||
279 | |||
5078 | serge | 280 | if (max_ratio >= 8) { |
281 | dto_phase = 192 * 1000; |
||
282 | wallclock_ratio = 3; |
||
283 | } else if (max_ratio >= 4) { |
||
284 | dto_phase = 96 * 1000; |
||
285 | wallclock_ratio = 2; |
||
286 | } else if (max_ratio >= 2) { |
||
287 | dto_phase = 48 * 1000; |
||
288 | wallclock_ratio = 1; |
||
289 | } else { |
||
290 | dto_phase = 24 * 1000; |
||
291 | wallclock_ratio = 0; |
||
292 | } |
||
293 | |||
3764 | Serge | 294 | /* there are two DTOs selected by DCCG_AUDIO_DTO_SELECT. |
295 | * doesn't matter which one you use. Just use the first one. |
||
296 | */ |
||
297 | /* XXX two dtos; generally use dto0 for hdmi */ |
||
298 | /* Express [24MHz / target pixel clock] as an exact rational |
||
299 | * number (coefficient of two integer numbers. DCCG_AUDIO_DTOx_PHASE |
||
300 | * is the numerator, DCCG_AUDIO_DTOx_MODULE is the denominator |
||
301 | */ |
||
5078 | serge | 302 | if (ASIC_IS_DCE32(rdev)) { |
303 | if (dig->dig_encoder == 0) { |
||
304 | dto_cntl = RREG32(DCCG_AUDIO_DTO0_CNTL) & ~DCCG_AUDIO_DTO_WALLCLOCK_RATIO_MASK; |
||
305 | dto_cntl |= DCCG_AUDIO_DTO_WALLCLOCK_RATIO(wallclock_ratio); |
||
306 | WREG32(DCCG_AUDIO_DTO0_CNTL, dto_cntl); |
||
307 | WREG32(DCCG_AUDIO_DTO0_PHASE, dto_phase); |
||
308 | WREG32(DCCG_AUDIO_DTO0_MODULE, dto_modulo); |
||
309 | WREG32(DCCG_AUDIO_DTO_SELECT, 0); /* select DTO0 */ |
||
310 | } else { |
||
311 | dto_cntl = RREG32(DCCG_AUDIO_DTO1_CNTL) & ~DCCG_AUDIO_DTO_WALLCLOCK_RATIO_MASK; |
||
312 | dto_cntl |= DCCG_AUDIO_DTO_WALLCLOCK_RATIO(wallclock_ratio); |
||
313 | WREG32(DCCG_AUDIO_DTO1_CNTL, dto_cntl); |
||
314 | WREG32(DCCG_AUDIO_DTO1_PHASE, dto_phase); |
||
315 | WREG32(DCCG_AUDIO_DTO1_MODULE, dto_modulo); |
||
316 | WREG32(DCCG_AUDIO_DTO_SELECT, 1); /* select DTO1 */ |
||
317 | } |
||
318 | } else { |
||
3764 | Serge | 319 | /* according to the reg specs, this should DCE3.2 only, but in |
5078 | serge | 320 | * practice it seems to cover DCE2.0/3.0/3.1 as well. |
3764 | Serge | 321 | */ |
5078 | serge | 322 | if (dig->dig_encoder == 0) { |
3764 | Serge | 323 | WREG32(DCCG_AUDIO_DTO0_PHASE, base_rate * 100); |
324 | WREG32(DCCG_AUDIO_DTO0_MODULE, clock * 100); |
||
325 | WREG32(DCCG_AUDIO_DTO_SELECT, 0); /* select DTO0 */ |
||
326 | } else { |
||
5078 | serge | 327 | WREG32(DCCG_AUDIO_DTO1_PHASE, base_rate * 100); |
328 | WREG32(DCCG_AUDIO_DTO1_MODULE, clock * 100); |
||
329 | WREG32(DCCG_AUDIO_DTO_SELECT, 1); /* select DTO1 */ |
||
330 | } |
||
3764 | Serge | 331 | } |
332 | } |
||
333 | |||
1403 | serge | 334 | /* |
335 | * update the info frames with the data from the current display mode |
||
336 | */ |
||
337 | void r600_hdmi_setmode(struct drm_encoder *encoder, struct drm_display_mode *mode) |
||
338 | { |
||
339 | struct drm_device *dev = encoder->dev; |
||
340 | struct radeon_device *rdev = dev->dev_private; |
||
2997 | Serge | 341 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
342 | struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv; |
||
3764 | Serge | 343 | u8 buffer[HDMI_INFOFRAME_HEADER_SIZE + HDMI_AVI_INFOFRAME_SIZE]; |
344 | struct hdmi_avi_infoframe frame; |
||
2997 | Serge | 345 | uint32_t offset; |
5078 | serge | 346 | uint32_t acr_ctl; |
3764 | Serge | 347 | ssize_t err; |
1403 | serge | 348 | |
5078 | serge | 349 | if (!dig || !dig->afmt) |
350 | return; |
||
351 | |||
2997 | Serge | 352 | /* Silent, r600_hdmi_enable will raise WARN for us */ |
353 | if (!dig->afmt->enabled) |
||
1963 | serge | 354 | return; |
2997 | Serge | 355 | offset = dig->afmt->offset; |
1963 | serge | 356 | |
5078 | serge | 357 | /* disable audio prior to setting up hw */ |
358 | dig->afmt->pin = r600_audio_get_pin(rdev); |
||
359 | r600_audio_enable(rdev, dig->afmt->pin, false); |
||
1403 | serge | 360 | |
5078 | serge | 361 | r600_audio_set_dto(encoder, mode->clock); |
1403 | serge | 362 | |
5078 | serge | 363 | WREG32_P(HDMI0_AUDIO_PACKET_CONTROL + offset, |
2997 | Serge | 364 | HDMI0_AUDIO_SAMPLE_SEND | /* send audio packets */ |
365 | HDMI0_AUDIO_DELAY_EN(1) | /* default audio delay */ |
||
366 | HDMI0_AUDIO_PACKETS_PER_LINE(3) | /* should be suffient for all audio modes and small enough for all hblanks */ |
||
5078 | serge | 367 | HDMI0_60958_CS_UPDATE, /* allow 60958 channel status fields to be updated */ |
368 | ~(HDMI0_AUDIO_SAMPLE_SEND | |
||
369 | HDMI0_AUDIO_DELAY_EN_MASK | |
||
370 | HDMI0_AUDIO_PACKETS_PER_LINE_MASK | |
||
371 | HDMI0_60958_CS_UPDATE)); |
||
1403 | serge | 372 | |
5078 | serge | 373 | /* DCE 3.0 uses register that's normally for CRC_CONTROL */ |
374 | acr_ctl = ASIC_IS_DCE3(rdev) ? DCE3_HDMI0_ACR_PACKET_CONTROL : |
||
375 | HDMI0_ACR_PACKET_CONTROL; |
||
376 | WREG32_P(acr_ctl + offset, |
||
377 | HDMI0_ACR_SOURCE | /* select SW CTS value - XXX verify that hw CTS works on all families */ |
||
378 | HDMI0_ACR_AUTO_SEND, /* allow hw to sent ACR packets when required */ |
||
379 | ~(HDMI0_ACR_SOURCE | |
||
380 | HDMI0_ACR_AUTO_SEND)); |
||
1403 | serge | 381 | |
5078 | serge | 382 | WREG32_OR(HDMI0_VBI_PACKET_CONTROL + offset, |
2997 | Serge | 383 | HDMI0_NULL_SEND | /* send null packets when required */ |
384 | HDMI0_GC_SEND | /* send general control packets */ |
||
385 | HDMI0_GC_CONT); /* send general control packets every frame */ |
||
1403 | serge | 386 | |
5078 | serge | 387 | WREG32_OR(HDMI0_INFOFRAME_CONTROL0 + offset, |
2997 | Serge | 388 | HDMI0_AVI_INFO_SEND | /* enable AVI info frames */ |
389 | HDMI0_AVI_INFO_CONT | /* send AVI info frames every frame/field */ |
||
390 | HDMI0_AUDIO_INFO_SEND | /* enable audio info frames (frames won't be set until audio is enabled) */ |
||
5078 | serge | 391 | HDMI0_AUDIO_INFO_UPDATE); /* required for audio info values to be updated */ |
2997 | Serge | 392 | |
5078 | serge | 393 | WREG32_P(HDMI0_INFOFRAME_CONTROL1 + offset, |
2997 | Serge | 394 | HDMI0_AVI_INFO_LINE(2) | /* anything other than 0 */ |
5078 | serge | 395 | HDMI0_AUDIO_INFO_LINE(2), /* anything other than 0 */ |
396 | ~(HDMI0_AVI_INFO_LINE_MASK | |
||
397 | HDMI0_AUDIO_INFO_LINE_MASK)); |
||
2997 | Serge | 398 | |
5078 | serge | 399 | WREG32_AND(HDMI0_GC + offset, |
400 | ~HDMI0_GC_AVMUTE); /* unset HDMI0_GC_AVMUTE */ |
||
2997 | Serge | 401 | |
3764 | Serge | 402 | err = drm_hdmi_avi_infoframe_from_display_mode(&frame, mode); |
403 | if (err < 0) { |
||
404 | DRM_ERROR("failed to setup AVI infoframe: %zd\n", err); |
||
405 | return; |
||
406 | } |
||
1403 | serge | 407 | |
3764 | Serge | 408 | err = hdmi_avi_infoframe_pack(&frame, buffer, sizeof(buffer)); |
409 | if (err < 0) { |
||
410 | DRM_ERROR("failed to pack AVI infoframe: %zd\n", err); |
||
411 | return; |
||
412 | } |
||
413 | |||
414 | r600_hdmi_update_avi_infoframe(encoder, buffer, sizeof(buffer)); |
||
5078 | serge | 415 | |
416 | /* fglrx duplicates INFOFRAME_CONTROL0 & INFOFRAME_CONTROL1 ops here */ |
||
417 | |||
418 | WREG32_AND(HDMI0_GENERIC_PACKET_CONTROL + offset, |
||
419 | ~(HDMI0_GENERIC0_SEND | |
||
420 | HDMI0_GENERIC0_CONT | |
||
421 | HDMI0_GENERIC0_UPDATE | |
||
422 | HDMI0_GENERIC1_SEND | |
||
423 | HDMI0_GENERIC1_CONT | |
||
424 | HDMI0_GENERIC0_LINE_MASK | |
||
425 | HDMI0_GENERIC1_LINE_MASK)); |
||
426 | |||
2997 | Serge | 427 | r600_hdmi_update_ACR(encoder, mode->clock); |
428 | |||
5078 | serge | 429 | WREG32_P(HDMI0_60958_0 + offset, |
430 | HDMI0_60958_CS_CHANNEL_NUMBER_L(1), |
||
431 | ~(HDMI0_60958_CS_CHANNEL_NUMBER_L_MASK | |
||
432 | HDMI0_60958_CS_CLOCK_ACCURACY_MASK)); |
||
433 | |||
434 | WREG32_P(HDMI0_60958_1 + offset, |
||
435 | HDMI0_60958_CS_CHANNEL_NUMBER_R(2), |
||
436 | ~HDMI0_60958_CS_CHANNEL_NUMBER_R_MASK); |
||
437 | |||
1963 | serge | 438 | /* it's unknown what these bits do excatly, but it's indeed quite useful for debugging */ |
2997 | Serge | 439 | WREG32(HDMI0_RAMP_CONTROL0 + offset, 0x00FFFFFF); |
440 | WREG32(HDMI0_RAMP_CONTROL1 + offset, 0x007FFFFF); |
||
441 | WREG32(HDMI0_RAMP_CONTROL2 + offset, 0x00000001); |
||
442 | WREG32(HDMI0_RAMP_CONTROL3 + offset, 0x00000001); |
||
1403 | serge | 443 | |
5078 | serge | 444 | /* enable audio after to setting up hw */ |
445 | r600_audio_enable(rdev, dig->afmt->pin, true); |
||
1403 | serge | 446 | } |
447 | |||
5078 | serge | 448 | /** |
449 | * r600_hdmi_update_audio_settings - Update audio infoframe |
||
450 | * |
||
451 | * @encoder: drm encoder |
||
452 | * |
||
453 | * Gets info about current audio stream and updates audio infoframe. |
||
1403 | serge | 454 | */ |
1963 | serge | 455 | void r600_hdmi_update_audio_settings(struct drm_encoder *encoder) |
1403 | serge | 456 | { |
457 | struct drm_device *dev = encoder->dev; |
||
458 | struct radeon_device *rdev = dev->dev_private; |
||
2997 | Serge | 459 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
460 | struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv; |
||
5078 | serge | 461 | struct r600_audio_pin audio = r600_audio_status(rdev); |
3764 | Serge | 462 | uint8_t buffer[HDMI_INFOFRAME_HEADER_SIZE + HDMI_AUDIO_INFOFRAME_SIZE]; |
463 | struct hdmi_audio_infoframe frame; |
||
2997 | Serge | 464 | uint32_t offset; |
5078 | serge | 465 | uint32_t value; |
3764 | Serge | 466 | ssize_t err; |
1403 | serge | 467 | |
2997 | Serge | 468 | if (!dig->afmt || !dig->afmt->enabled) |
1403 | serge | 469 | return; |
2997 | Serge | 470 | offset = dig->afmt->offset; |
1403 | serge | 471 | |
472 | DRM_DEBUG("%s with %d channels, %d Hz sampling rate, %d bits per sample,\n", |
||
473 | r600_hdmi_is_audio_buffer_filled(encoder) ? "playing" : "stopped", |
||
2997 | Serge | 474 | audio.channels, audio.rate, audio.bits_per_sample); |
1403 | serge | 475 | DRM_DEBUG("0x%02X IEC60958 status bits and 0x%02X category code\n", |
2997 | Serge | 476 | (int)audio.status_bits, (int)audio.category_code); |
1403 | serge | 477 | |
3764 | Serge | 478 | err = hdmi_audio_infoframe_init(&frame); |
479 | if (err < 0) { |
||
480 | DRM_ERROR("failed to setup audio infoframe\n"); |
||
481 | return; |
||
482 | } |
||
1403 | serge | 483 | |
3764 | Serge | 484 | frame.channels = audio.channels; |
485 | |||
486 | err = hdmi_audio_infoframe_pack(&frame, buffer, sizeof(buffer)); |
||
487 | if (err < 0) { |
||
488 | DRM_ERROR("failed to pack audio infoframe\n"); |
||
489 | return; |
||
490 | } |
||
491 | |||
5078 | serge | 492 | value = RREG32(HDMI0_AUDIO_PACKET_CONTROL + offset); |
493 | if (value & HDMI0_AUDIO_TEST_EN) |
||
494 | WREG32(HDMI0_AUDIO_PACKET_CONTROL + offset, |
||
495 | value & ~HDMI0_AUDIO_TEST_EN); |
||
496 | |||
497 | WREG32_OR(HDMI0_CONTROL + offset, |
||
498 | HDMI0_ERROR_ACK); |
||
499 | |||
500 | WREG32_AND(HDMI0_INFOFRAME_CONTROL0 + offset, |
||
501 | ~HDMI0_AUDIO_INFO_SOURCE); |
||
502 | |||
3764 | Serge | 503 | r600_hdmi_update_audio_infoframe(encoder, buffer, sizeof(buffer)); |
5078 | serge | 504 | |
505 | WREG32_OR(HDMI0_INFOFRAME_CONTROL0 + offset, |
||
506 | HDMI0_AUDIO_INFO_CONT | |
||
507 | HDMI0_AUDIO_INFO_UPDATE); |
||
1963 | serge | 508 | } |
509 | |||
1403 | serge | 510 | /* |
1963 | serge | 511 | * enable the HDMI engine |
1403 | serge | 512 | */ |
3764 | Serge | 513 | void r600_hdmi_enable(struct drm_encoder *encoder, bool enable) |
1403 | serge | 514 | { |
515 | struct drm_device *dev = encoder->dev; |
||
516 | struct radeon_device *rdev = dev->dev_private; |
||
517 | struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder); |
||
2997 | Serge | 518 | struct radeon_encoder_atom_dig *dig = radeon_encoder->enc_priv; |
3764 | Serge | 519 | u32 hdmi = HDMI0_ERROR_ACK; |
1403 | serge | 520 | |
5078 | serge | 521 | if (!dig || !dig->afmt) |
522 | return; |
||
523 | |||
2997 | Serge | 524 | /* Silent, r600_hdmi_enable will raise WARN for us */ |
3764 | Serge | 525 | if (enable && dig->afmt->enabled) |
1963 | serge | 526 | return; |
3764 | Serge | 527 | if (!enable && !dig->afmt->enabled) |
528 | return; |
||
1403 | serge | 529 | |
2997 | Serge | 530 | /* Older chipsets require setting HDMI and routing manually */ |
3764 | Serge | 531 | if (!ASIC_IS_DCE3(rdev)) { |
532 | if (enable) |
||
533 | hdmi |= HDMI0_ENABLE; |
||
1403 | serge | 534 | switch (radeon_encoder->encoder_id) { |
535 | case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_TMDS1: |
||
3764 | Serge | 536 | if (enable) { |
537 | WREG32_OR(AVIVO_TMDSA_CNTL, AVIVO_TMDSA_CNTL_HDMI_EN); |
||
2997 | Serge | 538 | hdmi |= HDMI0_STREAM(HDMI0_STREAM_TMDSA); |
3764 | Serge | 539 | } else { |
540 | WREG32_AND(AVIVO_TMDSA_CNTL, ~AVIVO_TMDSA_CNTL_HDMI_EN); |
||
541 | } |
||
1403 | serge | 542 | break; |
543 | case ENCODER_OBJECT_ID_INTERNAL_LVTM1: |
||
3764 | Serge | 544 | if (enable) { |
545 | WREG32_OR(AVIVO_LVTMA_CNTL, AVIVO_LVTMA_CNTL_HDMI_EN); |
||
2997 | Serge | 546 | hdmi |= HDMI0_STREAM(HDMI0_STREAM_LVTMA); |
3764 | Serge | 547 | } else { |
548 | WREG32_AND(AVIVO_LVTMA_CNTL, ~AVIVO_LVTMA_CNTL_HDMI_EN); |
||
549 | } |
||
2997 | Serge | 550 | break; |
551 | case ENCODER_OBJECT_ID_INTERNAL_DDI: |
||
3764 | Serge | 552 | if (enable) { |
553 | WREG32_OR(DDIA_CNTL, DDIA_HDMI_EN); |
||
2997 | Serge | 554 | hdmi |= HDMI0_STREAM(HDMI0_STREAM_DDIA); |
3764 | Serge | 555 | } else { |
556 | WREG32_AND(DDIA_CNTL, ~DDIA_HDMI_EN); |
||
557 | } |
||
2997 | Serge | 558 | break; |
559 | case ENCODER_OBJECT_ID_INTERNAL_KLDSCP_DVO1: |
||
3764 | Serge | 560 | if (enable) |
2997 | Serge | 561 | hdmi |= HDMI0_STREAM(HDMI0_STREAM_DVOA); |
1403 | serge | 562 | break; |
563 | default: |
||
2997 | Serge | 564 | dev_err(rdev->dev, "Invalid encoder for HDMI: 0x%X\n", |
565 | radeon_encoder->encoder_id); |
||
1403 | serge | 566 | break; |
567 | } |
||
3764 | Serge | 568 | WREG32(HDMI0_CONTROL + dig->afmt->offset, hdmi); |
1963 | serge | 569 | } |
570 | |||
2997 | Serge | 571 | if (rdev->irq.installed) { |
1963 | serge | 572 | /* if irq is available use it */ |
3764 | Serge | 573 | /* XXX: shouldn't need this on any asics. Double check DCE2/3 */ |
574 | // if (enable) |
||
575 | // radeon_irq_kms_enable_afmt(rdev, dig->afmt->id); |
||
576 | // else |
||
577 | // radeon_irq_kms_disable_afmt(rdev, dig->afmt->id); |
||
2997 | Serge | 578 | } |
1963 | serge | 579 | |
3764 | Serge | 580 | dig->afmt->enabled = enable; |
2997 | Serge | 581 | |
3764 | Serge | 582 | DRM_DEBUG("%sabling HDMI interface @ 0x%04X for encoder 0x%x\n", |
583 | enable ? "En" : "Dis", dig->afmt->offset, radeon_encoder->encoder_id); |
||
1403 | serge | 584 | }>>>>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>><>>> |
585 |