Loading...
1/*
2 * Copyright 2007-8 Advanced Micro Devices, Inc.
3 * Copyright 2008 Red Hat Inc.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the 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 COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
19 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21 * OTHER DEALINGS IN THE SOFTWARE.
22 *
23 * Authors: Dave Airlie
24 * Alex Deucher
25 */
26#include "drmP.h"
27#include "radeon_drm.h"
28#include "radeon.h"
29
30#include "atom.h"
31#include "atom-bits.h"
32
33/* from radeon_encoder.c */
34extern uint32_t
35radeon_get_encoder_enum(struct drm_device *dev, uint32_t supported_device,
36 uint8_t dac);
37extern void radeon_link_encoder_connector(struct drm_device *dev);
38extern void
39radeon_add_atom_encoder(struct drm_device *dev, uint32_t encoder_enum,
40 uint32_t supported_device, u16 caps);
41
42/* from radeon_connector.c */
43extern void
44radeon_add_atom_connector(struct drm_device *dev,
45 uint32_t connector_id,
46 uint32_t supported_device,
47 int connector_type,
48 struct radeon_i2c_bus_rec *i2c_bus,
49 uint32_t igp_lane_info,
50 uint16_t connector_object_id,
51 struct radeon_hpd *hpd,
52 struct radeon_router *router);
53
54/* from radeon_legacy_encoder.c */
55extern void
56radeon_add_legacy_encoder(struct drm_device *dev, uint32_t encoder_enum,
57 uint32_t supported_device);
58
59union atom_supported_devices {
60 struct _ATOM_SUPPORTED_DEVICES_INFO info;
61 struct _ATOM_SUPPORTED_DEVICES_INFO_2 info_2;
62 struct _ATOM_SUPPORTED_DEVICES_INFO_2d1 info_2d1;
63};
64
65static inline struct radeon_i2c_bus_rec radeon_lookup_i2c_gpio(struct radeon_device *rdev,
66 uint8_t id)
67{
68 struct atom_context *ctx = rdev->mode_info.atom_context;
69 ATOM_GPIO_I2C_ASSIGMENT *gpio;
70 struct radeon_i2c_bus_rec i2c;
71 int index = GetIndexIntoMasterTable(DATA, GPIO_I2C_Info);
72 struct _ATOM_GPIO_I2C_INFO *i2c_info;
73 uint16_t data_offset, size;
74 int i, num_indices;
75
76 memset(&i2c, 0, sizeof(struct radeon_i2c_bus_rec));
77 i2c.valid = false;
78
79 if (atom_parse_data_header(ctx, index, &size, NULL, NULL, &data_offset)) {
80 i2c_info = (struct _ATOM_GPIO_I2C_INFO *)(ctx->bios + data_offset);
81
82 num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
83 sizeof(ATOM_GPIO_I2C_ASSIGMENT);
84
85 for (i = 0; i < num_indices; i++) {
86 gpio = &i2c_info->asGPIO_Info[i];
87
88 /* some evergreen boards have bad data for this entry */
89 if (ASIC_IS_DCE4(rdev)) {
90 if ((i == 7) &&
91 (le16_to_cpu(gpio->usClkMaskRegisterIndex) == 0x1936) &&
92 (gpio->sucI2cId.ucAccess == 0)) {
93 gpio->sucI2cId.ucAccess = 0x97;
94 gpio->ucDataMaskShift = 8;
95 gpio->ucDataEnShift = 8;
96 gpio->ucDataY_Shift = 8;
97 gpio->ucDataA_Shift = 8;
98 }
99 }
100
101 /* some DCE3 boards have bad data for this entry */
102 if (ASIC_IS_DCE3(rdev)) {
103 if ((i == 4) &&
104 (le16_to_cpu(gpio->usClkMaskRegisterIndex) == 0x1fda) &&
105 (gpio->sucI2cId.ucAccess == 0x94))
106 gpio->sucI2cId.ucAccess = 0x14;
107 }
108
109 if (gpio->sucI2cId.ucAccess == id) {
110 i2c.mask_clk_reg = le16_to_cpu(gpio->usClkMaskRegisterIndex) * 4;
111 i2c.mask_data_reg = le16_to_cpu(gpio->usDataMaskRegisterIndex) * 4;
112 i2c.en_clk_reg = le16_to_cpu(gpio->usClkEnRegisterIndex) * 4;
113 i2c.en_data_reg = le16_to_cpu(gpio->usDataEnRegisterIndex) * 4;
114 i2c.y_clk_reg = le16_to_cpu(gpio->usClkY_RegisterIndex) * 4;
115 i2c.y_data_reg = le16_to_cpu(gpio->usDataY_RegisterIndex) * 4;
116 i2c.a_clk_reg = le16_to_cpu(gpio->usClkA_RegisterIndex) * 4;
117 i2c.a_data_reg = le16_to_cpu(gpio->usDataA_RegisterIndex) * 4;
118 i2c.mask_clk_mask = (1 << gpio->ucClkMaskShift);
119 i2c.mask_data_mask = (1 << gpio->ucDataMaskShift);
120 i2c.en_clk_mask = (1 << gpio->ucClkEnShift);
121 i2c.en_data_mask = (1 << gpio->ucDataEnShift);
122 i2c.y_clk_mask = (1 << gpio->ucClkY_Shift);
123 i2c.y_data_mask = (1 << gpio->ucDataY_Shift);
124 i2c.a_clk_mask = (1 << gpio->ucClkA_Shift);
125 i2c.a_data_mask = (1 << gpio->ucDataA_Shift);
126
127 if (gpio->sucI2cId.sbfAccess.bfHW_Capable)
128 i2c.hw_capable = true;
129 else
130 i2c.hw_capable = false;
131
132 if (gpio->sucI2cId.ucAccess == 0xa0)
133 i2c.mm_i2c = true;
134 else
135 i2c.mm_i2c = false;
136
137 i2c.i2c_id = gpio->sucI2cId.ucAccess;
138
139 if (i2c.mask_clk_reg)
140 i2c.valid = true;
141 break;
142 }
143 }
144 }
145
146 return i2c;
147}
148
149void radeon_atombios_i2c_init(struct radeon_device *rdev)
150{
151 struct atom_context *ctx = rdev->mode_info.atom_context;
152 ATOM_GPIO_I2C_ASSIGMENT *gpio;
153 struct radeon_i2c_bus_rec i2c;
154 int index = GetIndexIntoMasterTable(DATA, GPIO_I2C_Info);
155 struct _ATOM_GPIO_I2C_INFO *i2c_info;
156 uint16_t data_offset, size;
157 int i, num_indices;
158 char stmp[32];
159
160 memset(&i2c, 0, sizeof(struct radeon_i2c_bus_rec));
161
162 if (atom_parse_data_header(ctx, index, &size, NULL, NULL, &data_offset)) {
163 i2c_info = (struct _ATOM_GPIO_I2C_INFO *)(ctx->bios + data_offset);
164
165 num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
166 sizeof(ATOM_GPIO_I2C_ASSIGMENT);
167
168 for (i = 0; i < num_indices; i++) {
169 gpio = &i2c_info->asGPIO_Info[i];
170 i2c.valid = false;
171
172 /* some evergreen boards have bad data for this entry */
173 if (ASIC_IS_DCE4(rdev)) {
174 if ((i == 7) &&
175 (le16_to_cpu(gpio->usClkMaskRegisterIndex) == 0x1936) &&
176 (gpio->sucI2cId.ucAccess == 0)) {
177 gpio->sucI2cId.ucAccess = 0x97;
178 gpio->ucDataMaskShift = 8;
179 gpio->ucDataEnShift = 8;
180 gpio->ucDataY_Shift = 8;
181 gpio->ucDataA_Shift = 8;
182 }
183 }
184
185 /* some DCE3 boards have bad data for this entry */
186 if (ASIC_IS_DCE3(rdev)) {
187 if ((i == 4) &&
188 (le16_to_cpu(gpio->usClkMaskRegisterIndex) == 0x1fda) &&
189 (gpio->sucI2cId.ucAccess == 0x94))
190 gpio->sucI2cId.ucAccess = 0x14;
191 }
192
193 i2c.mask_clk_reg = le16_to_cpu(gpio->usClkMaskRegisterIndex) * 4;
194 i2c.mask_data_reg = le16_to_cpu(gpio->usDataMaskRegisterIndex) * 4;
195 i2c.en_clk_reg = le16_to_cpu(gpio->usClkEnRegisterIndex) * 4;
196 i2c.en_data_reg = le16_to_cpu(gpio->usDataEnRegisterIndex) * 4;
197 i2c.y_clk_reg = le16_to_cpu(gpio->usClkY_RegisterIndex) * 4;
198 i2c.y_data_reg = le16_to_cpu(gpio->usDataY_RegisterIndex) * 4;
199 i2c.a_clk_reg = le16_to_cpu(gpio->usClkA_RegisterIndex) * 4;
200 i2c.a_data_reg = le16_to_cpu(gpio->usDataA_RegisterIndex) * 4;
201 i2c.mask_clk_mask = (1 << gpio->ucClkMaskShift);
202 i2c.mask_data_mask = (1 << gpio->ucDataMaskShift);
203 i2c.en_clk_mask = (1 << gpio->ucClkEnShift);
204 i2c.en_data_mask = (1 << gpio->ucDataEnShift);
205 i2c.y_clk_mask = (1 << gpio->ucClkY_Shift);
206 i2c.y_data_mask = (1 << gpio->ucDataY_Shift);
207 i2c.a_clk_mask = (1 << gpio->ucClkA_Shift);
208 i2c.a_data_mask = (1 << gpio->ucDataA_Shift);
209
210 if (gpio->sucI2cId.sbfAccess.bfHW_Capable)
211 i2c.hw_capable = true;
212 else
213 i2c.hw_capable = false;
214
215 if (gpio->sucI2cId.ucAccess == 0xa0)
216 i2c.mm_i2c = true;
217 else
218 i2c.mm_i2c = false;
219
220 i2c.i2c_id = gpio->sucI2cId.ucAccess;
221
222 if (i2c.mask_clk_reg) {
223 i2c.valid = true;
224 sprintf(stmp, "0x%x", i2c.i2c_id);
225 rdev->i2c_bus[i] = radeon_i2c_create(rdev->ddev, &i2c, stmp);
226 }
227 }
228 }
229}
230
231static inline struct radeon_gpio_rec radeon_lookup_gpio(struct radeon_device *rdev,
232 u8 id)
233{
234 struct atom_context *ctx = rdev->mode_info.atom_context;
235 struct radeon_gpio_rec gpio;
236 int index = GetIndexIntoMasterTable(DATA, GPIO_Pin_LUT);
237 struct _ATOM_GPIO_PIN_LUT *gpio_info;
238 ATOM_GPIO_PIN_ASSIGNMENT *pin;
239 u16 data_offset, size;
240 int i, num_indices;
241
242 memset(&gpio, 0, sizeof(struct radeon_gpio_rec));
243 gpio.valid = false;
244
245 if (atom_parse_data_header(ctx, index, &size, NULL, NULL, &data_offset)) {
246 gpio_info = (struct _ATOM_GPIO_PIN_LUT *)(ctx->bios + data_offset);
247
248 num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
249 sizeof(ATOM_GPIO_PIN_ASSIGNMENT);
250
251 for (i = 0; i < num_indices; i++) {
252 pin = &gpio_info->asGPIO_Pin[i];
253 if (id == pin->ucGPIO_ID) {
254 gpio.id = pin->ucGPIO_ID;
255 gpio.reg = le16_to_cpu(pin->usGpioPin_AIndex) * 4;
256 gpio.mask = (1 << pin->ucGpioPinBitShift);
257 gpio.valid = true;
258 break;
259 }
260 }
261 }
262
263 return gpio;
264}
265
266static struct radeon_hpd radeon_atom_get_hpd_info_from_gpio(struct radeon_device *rdev,
267 struct radeon_gpio_rec *gpio)
268{
269 struct radeon_hpd hpd;
270 u32 reg;
271
272 memset(&hpd, 0, sizeof(struct radeon_hpd));
273
274 if (ASIC_IS_DCE4(rdev))
275 reg = EVERGREEN_DC_GPIO_HPD_A;
276 else
277 reg = AVIVO_DC_GPIO_HPD_A;
278
279 hpd.gpio = *gpio;
280 if (gpio->reg == reg) {
281 switch(gpio->mask) {
282 case (1 << 0):
283 hpd.hpd = RADEON_HPD_1;
284 break;
285 case (1 << 8):
286 hpd.hpd = RADEON_HPD_2;
287 break;
288 case (1 << 16):
289 hpd.hpd = RADEON_HPD_3;
290 break;
291 case (1 << 24):
292 hpd.hpd = RADEON_HPD_4;
293 break;
294 case (1 << 26):
295 hpd.hpd = RADEON_HPD_5;
296 break;
297 case (1 << 28):
298 hpd.hpd = RADEON_HPD_6;
299 break;
300 default:
301 hpd.hpd = RADEON_HPD_NONE;
302 break;
303 }
304 } else
305 hpd.hpd = RADEON_HPD_NONE;
306 return hpd;
307}
308
309static bool radeon_atom_apply_quirks(struct drm_device *dev,
310 uint32_t supported_device,
311 int *connector_type,
312 struct radeon_i2c_bus_rec *i2c_bus,
313 uint16_t *line_mux,
314 struct radeon_hpd *hpd)
315{
316
317 /* Asus M2A-VM HDMI board lists the DVI port as HDMI */
318 if ((dev->pdev->device == 0x791e) &&
319 (dev->pdev->subsystem_vendor == 0x1043) &&
320 (dev->pdev->subsystem_device == 0x826d)) {
321 if ((*connector_type == DRM_MODE_CONNECTOR_HDMIA) &&
322 (supported_device == ATOM_DEVICE_DFP3_SUPPORT))
323 *connector_type = DRM_MODE_CONNECTOR_DVID;
324 }
325
326 /* Asrock RS600 board lists the DVI port as HDMI */
327 if ((dev->pdev->device == 0x7941) &&
328 (dev->pdev->subsystem_vendor == 0x1849) &&
329 (dev->pdev->subsystem_device == 0x7941)) {
330 if ((*connector_type == DRM_MODE_CONNECTOR_HDMIA) &&
331 (supported_device == ATOM_DEVICE_DFP3_SUPPORT))
332 *connector_type = DRM_MODE_CONNECTOR_DVID;
333 }
334
335 /* MSI K9A2GM V2/V3 board has no HDMI or DVI */
336 if ((dev->pdev->device == 0x796e) &&
337 (dev->pdev->subsystem_vendor == 0x1462) &&
338 (dev->pdev->subsystem_device == 0x7302)) {
339 if ((supported_device == ATOM_DEVICE_DFP2_SUPPORT) ||
340 (supported_device == ATOM_DEVICE_DFP3_SUPPORT))
341 return false;
342 }
343
344 /* a-bit f-i90hd - ciaranm on #radeonhd - this board has no DVI */
345 if ((dev->pdev->device == 0x7941) &&
346 (dev->pdev->subsystem_vendor == 0x147b) &&
347 (dev->pdev->subsystem_device == 0x2412)) {
348 if (*connector_type == DRM_MODE_CONNECTOR_DVII)
349 return false;
350 }
351
352 /* Falcon NW laptop lists vga ddc line for LVDS */
353 if ((dev->pdev->device == 0x5653) &&
354 (dev->pdev->subsystem_vendor == 0x1462) &&
355 (dev->pdev->subsystem_device == 0x0291)) {
356 if (*connector_type == DRM_MODE_CONNECTOR_LVDS) {
357 i2c_bus->valid = false;
358 *line_mux = 53;
359 }
360 }
361
362 /* HIS X1300 is DVI+VGA, not DVI+DVI */
363 if ((dev->pdev->device == 0x7146) &&
364 (dev->pdev->subsystem_vendor == 0x17af) &&
365 (dev->pdev->subsystem_device == 0x2058)) {
366 if (supported_device == ATOM_DEVICE_DFP1_SUPPORT)
367 return false;
368 }
369
370 /* Gigabyte X1300 is DVI+VGA, not DVI+DVI */
371 if ((dev->pdev->device == 0x7142) &&
372 (dev->pdev->subsystem_vendor == 0x1458) &&
373 (dev->pdev->subsystem_device == 0x2134)) {
374 if (supported_device == ATOM_DEVICE_DFP1_SUPPORT)
375 return false;
376 }
377
378
379 /* Funky macbooks */
380 if ((dev->pdev->device == 0x71C5) &&
381 (dev->pdev->subsystem_vendor == 0x106b) &&
382 (dev->pdev->subsystem_device == 0x0080)) {
383 if ((supported_device == ATOM_DEVICE_CRT1_SUPPORT) ||
384 (supported_device == ATOM_DEVICE_DFP2_SUPPORT))
385 return false;
386 if (supported_device == ATOM_DEVICE_CRT2_SUPPORT)
387 *line_mux = 0x90;
388 }
389
390 /* mac rv630, rv730, others */
391 if ((supported_device == ATOM_DEVICE_TV1_SUPPORT) &&
392 (*connector_type == DRM_MODE_CONNECTOR_DVII)) {
393 *connector_type = DRM_MODE_CONNECTOR_9PinDIN;
394 *line_mux = CONNECTOR_7PIN_DIN_ENUM_ID1;
395 }
396
397 /* ASUS HD 3600 XT board lists the DVI port as HDMI */
398 if ((dev->pdev->device == 0x9598) &&
399 (dev->pdev->subsystem_vendor == 0x1043) &&
400 (dev->pdev->subsystem_device == 0x01da)) {
401 if (*connector_type == DRM_MODE_CONNECTOR_HDMIA) {
402 *connector_type = DRM_MODE_CONNECTOR_DVII;
403 }
404 }
405
406 /* ASUS HD 3600 board lists the DVI port as HDMI */
407 if ((dev->pdev->device == 0x9598) &&
408 (dev->pdev->subsystem_vendor == 0x1043) &&
409 (dev->pdev->subsystem_device == 0x01e4)) {
410 if (*connector_type == DRM_MODE_CONNECTOR_HDMIA) {
411 *connector_type = DRM_MODE_CONNECTOR_DVII;
412 }
413 }
414
415 /* ASUS HD 3450 board lists the DVI port as HDMI */
416 if ((dev->pdev->device == 0x95C5) &&
417 (dev->pdev->subsystem_vendor == 0x1043) &&
418 (dev->pdev->subsystem_device == 0x01e2)) {
419 if (*connector_type == DRM_MODE_CONNECTOR_HDMIA) {
420 *connector_type = DRM_MODE_CONNECTOR_DVII;
421 }
422 }
423
424 /* some BIOSes seem to report DAC on HDMI - usually this is a board with
425 * HDMI + VGA reporting as HDMI
426 */
427 if (*connector_type == DRM_MODE_CONNECTOR_HDMIA) {
428 if (supported_device & (ATOM_DEVICE_CRT_SUPPORT)) {
429 *connector_type = DRM_MODE_CONNECTOR_VGA;
430 *line_mux = 0;
431 }
432 }
433
434 /* Acer laptop (Acer TravelMate 5730/5730G) has an HDMI port
435 * on the laptop and a DVI port on the docking station and
436 * both share the same encoder, hpd pin, and ddc line.
437 * So while the bios table is technically correct,
438 * we drop the DVI port here since xrandr has no concept of
439 * encoders and will try and drive both connectors
440 * with different crtcs which isn't possible on the hardware
441 * side and leaves no crtcs for LVDS or VGA.
442 */
443 if (((dev->pdev->device == 0x95c4) || (dev->pdev->device == 0x9591)) &&
444 (dev->pdev->subsystem_vendor == 0x1025) &&
445 (dev->pdev->subsystem_device == 0x013c)) {
446 if ((*connector_type == DRM_MODE_CONNECTOR_DVII) &&
447 (supported_device == ATOM_DEVICE_DFP1_SUPPORT)) {
448 /* actually it's a DVI-D port not DVI-I */
449 *connector_type = DRM_MODE_CONNECTOR_DVID;
450 return false;
451 }
452 }
453
454 /* XFX Pine Group device rv730 reports no VGA DDC lines
455 * even though they are wired up to record 0x93
456 */
457 if ((dev->pdev->device == 0x9498) &&
458 (dev->pdev->subsystem_vendor == 0x1682) &&
459 (dev->pdev->subsystem_device == 0x2452)) {
460 struct radeon_device *rdev = dev->dev_private;
461 *i2c_bus = radeon_lookup_i2c_gpio(rdev, 0x93);
462 }
463 return true;
464}
465
466const int supported_devices_connector_convert[] = {
467 DRM_MODE_CONNECTOR_Unknown,
468 DRM_MODE_CONNECTOR_VGA,
469 DRM_MODE_CONNECTOR_DVII,
470 DRM_MODE_CONNECTOR_DVID,
471 DRM_MODE_CONNECTOR_DVIA,
472 DRM_MODE_CONNECTOR_SVIDEO,
473 DRM_MODE_CONNECTOR_Composite,
474 DRM_MODE_CONNECTOR_LVDS,
475 DRM_MODE_CONNECTOR_Unknown,
476 DRM_MODE_CONNECTOR_Unknown,
477 DRM_MODE_CONNECTOR_HDMIA,
478 DRM_MODE_CONNECTOR_HDMIB,
479 DRM_MODE_CONNECTOR_Unknown,
480 DRM_MODE_CONNECTOR_Unknown,
481 DRM_MODE_CONNECTOR_9PinDIN,
482 DRM_MODE_CONNECTOR_DisplayPort
483};
484
485const uint16_t supported_devices_connector_object_id_convert[] = {
486 CONNECTOR_OBJECT_ID_NONE,
487 CONNECTOR_OBJECT_ID_VGA,
488 CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I, /* not all boards support DL */
489 CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D, /* not all boards support DL */
490 CONNECTOR_OBJECT_ID_VGA, /* technically DVI-A */
491 CONNECTOR_OBJECT_ID_COMPOSITE,
492 CONNECTOR_OBJECT_ID_SVIDEO,
493 CONNECTOR_OBJECT_ID_LVDS,
494 CONNECTOR_OBJECT_ID_9PIN_DIN,
495 CONNECTOR_OBJECT_ID_9PIN_DIN,
496 CONNECTOR_OBJECT_ID_DISPLAYPORT,
497 CONNECTOR_OBJECT_ID_HDMI_TYPE_A,
498 CONNECTOR_OBJECT_ID_HDMI_TYPE_B,
499 CONNECTOR_OBJECT_ID_SVIDEO
500};
501
502const int object_connector_convert[] = {
503 DRM_MODE_CONNECTOR_Unknown,
504 DRM_MODE_CONNECTOR_DVII,
505 DRM_MODE_CONNECTOR_DVII,
506 DRM_MODE_CONNECTOR_DVID,
507 DRM_MODE_CONNECTOR_DVID,
508 DRM_MODE_CONNECTOR_VGA,
509 DRM_MODE_CONNECTOR_Composite,
510 DRM_MODE_CONNECTOR_SVIDEO,
511 DRM_MODE_CONNECTOR_Unknown,
512 DRM_MODE_CONNECTOR_Unknown,
513 DRM_MODE_CONNECTOR_9PinDIN,
514 DRM_MODE_CONNECTOR_Unknown,
515 DRM_MODE_CONNECTOR_HDMIA,
516 DRM_MODE_CONNECTOR_HDMIB,
517 DRM_MODE_CONNECTOR_LVDS,
518 DRM_MODE_CONNECTOR_9PinDIN,
519 DRM_MODE_CONNECTOR_Unknown,
520 DRM_MODE_CONNECTOR_Unknown,
521 DRM_MODE_CONNECTOR_Unknown,
522 DRM_MODE_CONNECTOR_DisplayPort,
523 DRM_MODE_CONNECTOR_eDP,
524 DRM_MODE_CONNECTOR_Unknown
525};
526
527bool radeon_get_atom_connector_info_from_object_table(struct drm_device *dev)
528{
529 struct radeon_device *rdev = dev->dev_private;
530 struct radeon_mode_info *mode_info = &rdev->mode_info;
531 struct atom_context *ctx = mode_info->atom_context;
532 int index = GetIndexIntoMasterTable(DATA, Object_Header);
533 u16 size, data_offset;
534 u8 frev, crev;
535 ATOM_CONNECTOR_OBJECT_TABLE *con_obj;
536 ATOM_ENCODER_OBJECT_TABLE *enc_obj;
537 ATOM_OBJECT_TABLE *router_obj;
538 ATOM_DISPLAY_OBJECT_PATH_TABLE *path_obj;
539 ATOM_OBJECT_HEADER *obj_header;
540 int i, j, k, path_size, device_support;
541 int connector_type;
542 u16 igp_lane_info, conn_id, connector_object_id;
543 struct radeon_i2c_bus_rec ddc_bus;
544 struct radeon_router router;
545 struct radeon_gpio_rec gpio;
546 struct radeon_hpd hpd;
547
548 if (!atom_parse_data_header(ctx, index, &size, &frev, &crev, &data_offset))
549 return false;
550
551 if (crev < 2)
552 return false;
553
554 obj_header = (ATOM_OBJECT_HEADER *) (ctx->bios + data_offset);
555 path_obj = (ATOM_DISPLAY_OBJECT_PATH_TABLE *)
556 (ctx->bios + data_offset +
557 le16_to_cpu(obj_header->usDisplayPathTableOffset));
558 con_obj = (ATOM_CONNECTOR_OBJECT_TABLE *)
559 (ctx->bios + data_offset +
560 le16_to_cpu(obj_header->usConnectorObjectTableOffset));
561 enc_obj = (ATOM_ENCODER_OBJECT_TABLE *)
562 (ctx->bios + data_offset +
563 le16_to_cpu(obj_header->usEncoderObjectTableOffset));
564 router_obj = (ATOM_OBJECT_TABLE *)
565 (ctx->bios + data_offset +
566 le16_to_cpu(obj_header->usRouterObjectTableOffset));
567 device_support = le16_to_cpu(obj_header->usDeviceSupport);
568
569 path_size = 0;
570 for (i = 0; i < path_obj->ucNumOfDispPath; i++) {
571 uint8_t *addr = (uint8_t *) path_obj->asDispPath;
572 ATOM_DISPLAY_OBJECT_PATH *path;
573 addr += path_size;
574 path = (ATOM_DISPLAY_OBJECT_PATH *) addr;
575 path_size += le16_to_cpu(path->usSize);
576
577 if (device_support & le16_to_cpu(path->usDeviceTag)) {
578 uint8_t con_obj_id, con_obj_num, con_obj_type;
579
580 con_obj_id =
581 (le16_to_cpu(path->usConnObjectId) & OBJECT_ID_MASK)
582 >> OBJECT_ID_SHIFT;
583 con_obj_num =
584 (le16_to_cpu(path->usConnObjectId) & ENUM_ID_MASK)
585 >> ENUM_ID_SHIFT;
586 con_obj_type =
587 (le16_to_cpu(path->usConnObjectId) &
588 OBJECT_TYPE_MASK) >> OBJECT_TYPE_SHIFT;
589
590 /* TODO CV support */
591 if (le16_to_cpu(path->usDeviceTag) ==
592 ATOM_DEVICE_CV_SUPPORT)
593 continue;
594
595 /* IGP chips */
596 if ((rdev->flags & RADEON_IS_IGP) &&
597 (con_obj_id ==
598 CONNECTOR_OBJECT_ID_PCIE_CONNECTOR)) {
599 uint16_t igp_offset = 0;
600 ATOM_INTEGRATED_SYSTEM_INFO_V2 *igp_obj;
601
602 index =
603 GetIndexIntoMasterTable(DATA,
604 IntegratedSystemInfo);
605
606 if (atom_parse_data_header(ctx, index, &size, &frev,
607 &crev, &igp_offset)) {
608
609 if (crev >= 2) {
610 igp_obj =
611 (ATOM_INTEGRATED_SYSTEM_INFO_V2
612 *) (ctx->bios + igp_offset);
613
614 if (igp_obj) {
615 uint32_t slot_config, ct;
616
617 if (con_obj_num == 1)
618 slot_config =
619 igp_obj->
620 ulDDISlot1Config;
621 else
622 slot_config =
623 igp_obj->
624 ulDDISlot2Config;
625
626 ct = (slot_config >> 16) & 0xff;
627 connector_type =
628 object_connector_convert
629 [ct];
630 connector_object_id = ct;
631 igp_lane_info =
632 slot_config & 0xffff;
633 } else
634 continue;
635 } else
636 continue;
637 } else {
638 igp_lane_info = 0;
639 connector_type =
640 object_connector_convert[con_obj_id];
641 connector_object_id = con_obj_id;
642 }
643 } else {
644 igp_lane_info = 0;
645 connector_type =
646 object_connector_convert[con_obj_id];
647 connector_object_id = con_obj_id;
648 }
649
650 if (connector_type == DRM_MODE_CONNECTOR_Unknown)
651 continue;
652
653 router.ddc_valid = false;
654 router.cd_valid = false;
655 for (j = 0; j < ((le16_to_cpu(path->usSize) - 8) / 2); j++) {
656 uint8_t grph_obj_id, grph_obj_num, grph_obj_type;
657
658 grph_obj_id =
659 (le16_to_cpu(path->usGraphicObjIds[j]) &
660 OBJECT_ID_MASK) >> OBJECT_ID_SHIFT;
661 grph_obj_num =
662 (le16_to_cpu(path->usGraphicObjIds[j]) &
663 ENUM_ID_MASK) >> ENUM_ID_SHIFT;
664 grph_obj_type =
665 (le16_to_cpu(path->usGraphicObjIds[j]) &
666 OBJECT_TYPE_MASK) >> OBJECT_TYPE_SHIFT;
667
668 if (grph_obj_type == GRAPH_OBJECT_TYPE_ENCODER) {
669 for (k = 0; k < enc_obj->ucNumberOfObjects; k++) {
670 u16 encoder_obj = le16_to_cpu(enc_obj->asObjects[k].usObjectID);
671 if (le16_to_cpu(path->usGraphicObjIds[j]) == encoder_obj) {
672 ATOM_COMMON_RECORD_HEADER *record = (ATOM_COMMON_RECORD_HEADER *)
673 (ctx->bios + data_offset +
674 le16_to_cpu(enc_obj->asObjects[k].usRecordOffset));
675 ATOM_ENCODER_CAP_RECORD *cap_record;
676 u16 caps = 0;
677
678 while (record->ucRecordSize > 0 &&
679 record->ucRecordType > 0 &&
680 record->ucRecordType <= ATOM_MAX_OBJECT_RECORD_NUMBER) {
681 switch (record->ucRecordType) {
682 case ATOM_ENCODER_CAP_RECORD_TYPE:
683 cap_record =(ATOM_ENCODER_CAP_RECORD *)
684 record;
685 caps = le16_to_cpu(cap_record->usEncoderCap);
686 break;
687 }
688 record = (ATOM_COMMON_RECORD_HEADER *)
689 ((char *)record + record->ucRecordSize);
690 }
691 radeon_add_atom_encoder(dev,
692 encoder_obj,
693 le16_to_cpu
694 (path->
695 usDeviceTag),
696 caps);
697 }
698 }
699 } else if (grph_obj_type == GRAPH_OBJECT_TYPE_ROUTER) {
700 for (k = 0; k < router_obj->ucNumberOfObjects; k++) {
701 u16 router_obj_id = le16_to_cpu(router_obj->asObjects[k].usObjectID);
702 if (le16_to_cpu(path->usGraphicObjIds[j]) == router_obj_id) {
703 ATOM_COMMON_RECORD_HEADER *record = (ATOM_COMMON_RECORD_HEADER *)
704 (ctx->bios + data_offset +
705 le16_to_cpu(router_obj->asObjects[k].usRecordOffset));
706 ATOM_I2C_RECORD *i2c_record;
707 ATOM_I2C_ID_CONFIG_ACCESS *i2c_config;
708 ATOM_ROUTER_DDC_PATH_SELECT_RECORD *ddc_path;
709 ATOM_ROUTER_DATA_CLOCK_PATH_SELECT_RECORD *cd_path;
710 ATOM_SRC_DST_TABLE_FOR_ONE_OBJECT *router_src_dst_table =
711 (ATOM_SRC_DST_TABLE_FOR_ONE_OBJECT *)
712 (ctx->bios + data_offset +
713 le16_to_cpu(router_obj->asObjects[k].usSrcDstTableOffset));
714 int enum_id;
715
716 router.router_id = router_obj_id;
717 for (enum_id = 0; enum_id < router_src_dst_table->ucNumberOfDst;
718 enum_id++) {
719 if (le16_to_cpu(path->usConnObjectId) ==
720 le16_to_cpu(router_src_dst_table->usDstObjectID[enum_id]))
721 break;
722 }
723
724 while (record->ucRecordSize > 0 &&
725 record->ucRecordType > 0 &&
726 record->ucRecordType <= ATOM_MAX_OBJECT_RECORD_NUMBER) {
727 switch (record->ucRecordType) {
728 case ATOM_I2C_RECORD_TYPE:
729 i2c_record =
730 (ATOM_I2C_RECORD *)
731 record;
732 i2c_config =
733 (ATOM_I2C_ID_CONFIG_ACCESS *)
734 &i2c_record->sucI2cId;
735 router.i2c_info =
736 radeon_lookup_i2c_gpio(rdev,
737 i2c_config->
738 ucAccess);
739 router.i2c_addr = i2c_record->ucI2CAddr >> 1;
740 break;
741 case ATOM_ROUTER_DDC_PATH_SELECT_RECORD_TYPE:
742 ddc_path = (ATOM_ROUTER_DDC_PATH_SELECT_RECORD *)
743 record;
744 router.ddc_valid = true;
745 router.ddc_mux_type = ddc_path->ucMuxType;
746 router.ddc_mux_control_pin = ddc_path->ucMuxControlPin;
747 router.ddc_mux_state = ddc_path->ucMuxState[enum_id];
748 break;
749 case ATOM_ROUTER_DATA_CLOCK_PATH_SELECT_RECORD_TYPE:
750 cd_path = (ATOM_ROUTER_DATA_CLOCK_PATH_SELECT_RECORD *)
751 record;
752 router.cd_valid = true;
753 router.cd_mux_type = cd_path->ucMuxType;
754 router.cd_mux_control_pin = cd_path->ucMuxControlPin;
755 router.cd_mux_state = cd_path->ucMuxState[enum_id];
756 break;
757 }
758 record = (ATOM_COMMON_RECORD_HEADER *)
759 ((char *)record + record->ucRecordSize);
760 }
761 }
762 }
763 }
764 }
765
766 /* look up gpio for ddc, hpd */
767 ddc_bus.valid = false;
768 hpd.hpd = RADEON_HPD_NONE;
769 if ((le16_to_cpu(path->usDeviceTag) &
770 (ATOM_DEVICE_TV_SUPPORT | ATOM_DEVICE_CV_SUPPORT)) == 0) {
771 for (j = 0; j < con_obj->ucNumberOfObjects; j++) {
772 if (le16_to_cpu(path->usConnObjectId) ==
773 le16_to_cpu(con_obj->asObjects[j].
774 usObjectID)) {
775 ATOM_COMMON_RECORD_HEADER
776 *record =
777 (ATOM_COMMON_RECORD_HEADER
778 *)
779 (ctx->bios + data_offset +
780 le16_to_cpu(con_obj->
781 asObjects[j].
782 usRecordOffset));
783 ATOM_I2C_RECORD *i2c_record;
784 ATOM_HPD_INT_RECORD *hpd_record;
785 ATOM_I2C_ID_CONFIG_ACCESS *i2c_config;
786
787 while (record->ucRecordSize > 0 &&
788 record->ucRecordType > 0 &&
789 record->ucRecordType <= ATOM_MAX_OBJECT_RECORD_NUMBER) {
790 switch (record->ucRecordType) {
791 case ATOM_I2C_RECORD_TYPE:
792 i2c_record =
793 (ATOM_I2C_RECORD *)
794 record;
795 i2c_config =
796 (ATOM_I2C_ID_CONFIG_ACCESS *)
797 &i2c_record->sucI2cId;
798 ddc_bus = radeon_lookup_i2c_gpio(rdev,
799 i2c_config->
800 ucAccess);
801 break;
802 case ATOM_HPD_INT_RECORD_TYPE:
803 hpd_record =
804 (ATOM_HPD_INT_RECORD *)
805 record;
806 gpio = radeon_lookup_gpio(rdev,
807 hpd_record->ucHPDIntGPIOID);
808 hpd = radeon_atom_get_hpd_info_from_gpio(rdev, &gpio);
809 hpd.plugged_state = hpd_record->ucPlugged_PinState;
810 break;
811 }
812 record =
813 (ATOM_COMMON_RECORD_HEADER
814 *) ((char *)record
815 +
816 record->
817 ucRecordSize);
818 }
819 break;
820 }
821 }
822 }
823
824 /* needed for aux chan transactions */
825 ddc_bus.hpd = hpd.hpd;
826
827 conn_id = le16_to_cpu(path->usConnObjectId);
828
829 if (!radeon_atom_apply_quirks
830 (dev, le16_to_cpu(path->usDeviceTag), &connector_type,
831 &ddc_bus, &conn_id, &hpd))
832 continue;
833
834 radeon_add_atom_connector(dev,
835 conn_id,
836 le16_to_cpu(path->
837 usDeviceTag),
838 connector_type, &ddc_bus,
839 igp_lane_info,
840 connector_object_id,
841 &hpd,
842 &router);
843
844 }
845 }
846
847 radeon_link_encoder_connector(dev);
848
849 return true;
850}
851
852static uint16_t atombios_get_connector_object_id(struct drm_device *dev,
853 int connector_type,
854 uint16_t devices)
855{
856 struct radeon_device *rdev = dev->dev_private;
857
858 if (rdev->flags & RADEON_IS_IGP) {
859 return supported_devices_connector_object_id_convert
860 [connector_type];
861 } else if (((connector_type == DRM_MODE_CONNECTOR_DVII) ||
862 (connector_type == DRM_MODE_CONNECTOR_DVID)) &&
863 (devices & ATOM_DEVICE_DFP2_SUPPORT)) {
864 struct radeon_mode_info *mode_info = &rdev->mode_info;
865 struct atom_context *ctx = mode_info->atom_context;
866 int index = GetIndexIntoMasterTable(DATA, XTMDS_Info);
867 uint16_t size, data_offset;
868 uint8_t frev, crev;
869 ATOM_XTMDS_INFO *xtmds;
870
871 if (atom_parse_data_header(ctx, index, &size, &frev, &crev, &data_offset)) {
872 xtmds = (ATOM_XTMDS_INFO *)(ctx->bios + data_offset);
873
874 if (xtmds->ucSupportedLink & ATOM_XTMDS_SUPPORTED_DUALLINK) {
875 if (connector_type == DRM_MODE_CONNECTOR_DVII)
876 return CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I;
877 else
878 return CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D;
879 } else {
880 if (connector_type == DRM_MODE_CONNECTOR_DVII)
881 return CONNECTOR_OBJECT_ID_SINGLE_LINK_DVI_I;
882 else
883 return CONNECTOR_OBJECT_ID_SINGLE_LINK_DVI_D;
884 }
885 } else
886 return supported_devices_connector_object_id_convert
887 [connector_type];
888 } else {
889 return supported_devices_connector_object_id_convert
890 [connector_type];
891 }
892}
893
894struct bios_connector {
895 bool valid;
896 uint16_t line_mux;
897 uint16_t devices;
898 int connector_type;
899 struct radeon_i2c_bus_rec ddc_bus;
900 struct radeon_hpd hpd;
901};
902
903bool radeon_get_atom_connector_info_from_supported_devices_table(struct
904 drm_device
905 *dev)
906{
907 struct radeon_device *rdev = dev->dev_private;
908 struct radeon_mode_info *mode_info = &rdev->mode_info;
909 struct atom_context *ctx = mode_info->atom_context;
910 int index = GetIndexIntoMasterTable(DATA, SupportedDevicesInfo);
911 uint16_t size, data_offset;
912 uint8_t frev, crev;
913 uint16_t device_support;
914 uint8_t dac;
915 union atom_supported_devices *supported_devices;
916 int i, j, max_device;
917 struct bios_connector *bios_connectors;
918 size_t bc_size = sizeof(*bios_connectors) * ATOM_MAX_SUPPORTED_DEVICE;
919 struct radeon_router router;
920
921 router.ddc_valid = false;
922 router.cd_valid = false;
923
924 bios_connectors = kzalloc(bc_size, GFP_KERNEL);
925 if (!bios_connectors)
926 return false;
927
928 if (!atom_parse_data_header(ctx, index, &size, &frev, &crev,
929 &data_offset)) {
930 kfree(bios_connectors);
931 return false;
932 }
933
934 supported_devices =
935 (union atom_supported_devices *)(ctx->bios + data_offset);
936
937 device_support = le16_to_cpu(supported_devices->info.usDeviceSupport);
938
939 if (frev > 1)
940 max_device = ATOM_MAX_SUPPORTED_DEVICE;
941 else
942 max_device = ATOM_MAX_SUPPORTED_DEVICE_INFO;
943
944 for (i = 0; i < max_device; i++) {
945 ATOM_CONNECTOR_INFO_I2C ci =
946 supported_devices->info.asConnInfo[i];
947
948 bios_connectors[i].valid = false;
949
950 if (!(device_support & (1 << i))) {
951 continue;
952 }
953
954 if (i == ATOM_DEVICE_CV_INDEX) {
955 DRM_DEBUG_KMS("Skipping Component Video\n");
956 continue;
957 }
958
959 bios_connectors[i].connector_type =
960 supported_devices_connector_convert[ci.sucConnectorInfo.
961 sbfAccess.
962 bfConnectorType];
963
964 if (bios_connectors[i].connector_type ==
965 DRM_MODE_CONNECTOR_Unknown)
966 continue;
967
968 dac = ci.sucConnectorInfo.sbfAccess.bfAssociatedDAC;
969
970 bios_connectors[i].line_mux =
971 ci.sucI2cId.ucAccess;
972
973 /* give tv unique connector ids */
974 if (i == ATOM_DEVICE_TV1_INDEX) {
975 bios_connectors[i].ddc_bus.valid = false;
976 bios_connectors[i].line_mux = 50;
977 } else if (i == ATOM_DEVICE_TV2_INDEX) {
978 bios_connectors[i].ddc_bus.valid = false;
979 bios_connectors[i].line_mux = 51;
980 } else if (i == ATOM_DEVICE_CV_INDEX) {
981 bios_connectors[i].ddc_bus.valid = false;
982 bios_connectors[i].line_mux = 52;
983 } else
984 bios_connectors[i].ddc_bus =
985 radeon_lookup_i2c_gpio(rdev,
986 bios_connectors[i].line_mux);
987
988 if ((crev > 1) && (frev > 1)) {
989 u8 isb = supported_devices->info_2d1.asIntSrcInfo[i].ucIntSrcBitmap;
990 switch (isb) {
991 case 0x4:
992 bios_connectors[i].hpd.hpd = RADEON_HPD_1;
993 break;
994 case 0xa:
995 bios_connectors[i].hpd.hpd = RADEON_HPD_2;
996 break;
997 default:
998 bios_connectors[i].hpd.hpd = RADEON_HPD_NONE;
999 break;
1000 }
1001 } else {
1002 if (i == ATOM_DEVICE_DFP1_INDEX)
1003 bios_connectors[i].hpd.hpd = RADEON_HPD_1;
1004 else if (i == ATOM_DEVICE_DFP2_INDEX)
1005 bios_connectors[i].hpd.hpd = RADEON_HPD_2;
1006 else
1007 bios_connectors[i].hpd.hpd = RADEON_HPD_NONE;
1008 }
1009
1010 /* Always set the connector type to VGA for CRT1/CRT2. if they are
1011 * shared with a DVI port, we'll pick up the DVI connector when we
1012 * merge the outputs. Some bioses incorrectly list VGA ports as DVI.
1013 */
1014 if (i == ATOM_DEVICE_CRT1_INDEX || i == ATOM_DEVICE_CRT2_INDEX)
1015 bios_connectors[i].connector_type =
1016 DRM_MODE_CONNECTOR_VGA;
1017
1018 if (!radeon_atom_apply_quirks
1019 (dev, (1 << i), &bios_connectors[i].connector_type,
1020 &bios_connectors[i].ddc_bus, &bios_connectors[i].line_mux,
1021 &bios_connectors[i].hpd))
1022 continue;
1023
1024 bios_connectors[i].valid = true;
1025 bios_connectors[i].devices = (1 << i);
1026
1027 if (ASIC_IS_AVIVO(rdev) || radeon_r4xx_atom)
1028 radeon_add_atom_encoder(dev,
1029 radeon_get_encoder_enum(dev,
1030 (1 << i),
1031 dac),
1032 (1 << i),
1033 0);
1034 else
1035 radeon_add_legacy_encoder(dev,
1036 radeon_get_encoder_enum(dev,
1037 (1 << i),
1038 dac),
1039 (1 << i));
1040 }
1041
1042 /* combine shared connectors */
1043 for (i = 0; i < max_device; i++) {
1044 if (bios_connectors[i].valid) {
1045 for (j = 0; j < max_device; j++) {
1046 if (bios_connectors[j].valid && (i != j)) {
1047 if (bios_connectors[i].line_mux ==
1048 bios_connectors[j].line_mux) {
1049 /* make sure not to combine LVDS */
1050 if (bios_connectors[i].devices & (ATOM_DEVICE_LCD_SUPPORT)) {
1051 bios_connectors[i].line_mux = 53;
1052 bios_connectors[i].ddc_bus.valid = false;
1053 continue;
1054 }
1055 if (bios_connectors[j].devices & (ATOM_DEVICE_LCD_SUPPORT)) {
1056 bios_connectors[j].line_mux = 53;
1057 bios_connectors[j].ddc_bus.valid = false;
1058 continue;
1059 }
1060 /* combine analog and digital for DVI-I */
1061 if (((bios_connectors[i].devices & (ATOM_DEVICE_DFP_SUPPORT)) &&
1062 (bios_connectors[j].devices & (ATOM_DEVICE_CRT_SUPPORT))) ||
1063 ((bios_connectors[j].devices & (ATOM_DEVICE_DFP_SUPPORT)) &&
1064 (bios_connectors[i].devices & (ATOM_DEVICE_CRT_SUPPORT)))) {
1065 bios_connectors[i].devices |=
1066 bios_connectors[j].devices;
1067 bios_connectors[i].connector_type =
1068 DRM_MODE_CONNECTOR_DVII;
1069 if (bios_connectors[j].devices & (ATOM_DEVICE_DFP_SUPPORT))
1070 bios_connectors[i].hpd =
1071 bios_connectors[j].hpd;
1072 bios_connectors[j].valid = false;
1073 }
1074 }
1075 }
1076 }
1077 }
1078 }
1079
1080 /* add the connectors */
1081 for (i = 0; i < max_device; i++) {
1082 if (bios_connectors[i].valid) {
1083 uint16_t connector_object_id =
1084 atombios_get_connector_object_id(dev,
1085 bios_connectors[i].connector_type,
1086 bios_connectors[i].devices);
1087 radeon_add_atom_connector(dev,
1088 bios_connectors[i].line_mux,
1089 bios_connectors[i].devices,
1090 bios_connectors[i].
1091 connector_type,
1092 &bios_connectors[i].ddc_bus,
1093 0,
1094 connector_object_id,
1095 &bios_connectors[i].hpd,
1096 &router);
1097 }
1098 }
1099
1100 radeon_link_encoder_connector(dev);
1101
1102 kfree(bios_connectors);
1103 return true;
1104}
1105
1106union firmware_info {
1107 ATOM_FIRMWARE_INFO info;
1108 ATOM_FIRMWARE_INFO_V1_2 info_12;
1109 ATOM_FIRMWARE_INFO_V1_3 info_13;
1110 ATOM_FIRMWARE_INFO_V1_4 info_14;
1111 ATOM_FIRMWARE_INFO_V2_1 info_21;
1112 ATOM_FIRMWARE_INFO_V2_2 info_22;
1113};
1114
1115bool radeon_atom_get_clock_info(struct drm_device *dev)
1116{
1117 struct radeon_device *rdev = dev->dev_private;
1118 struct radeon_mode_info *mode_info = &rdev->mode_info;
1119 int index = GetIndexIntoMasterTable(DATA, FirmwareInfo);
1120 union firmware_info *firmware_info;
1121 uint8_t frev, crev;
1122 struct radeon_pll *p1pll = &rdev->clock.p1pll;
1123 struct radeon_pll *p2pll = &rdev->clock.p2pll;
1124 struct radeon_pll *dcpll = &rdev->clock.dcpll;
1125 struct radeon_pll *spll = &rdev->clock.spll;
1126 struct radeon_pll *mpll = &rdev->clock.mpll;
1127 uint16_t data_offset;
1128
1129 if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1130 &frev, &crev, &data_offset)) {
1131 firmware_info =
1132 (union firmware_info *)(mode_info->atom_context->bios +
1133 data_offset);
1134 /* pixel clocks */
1135 p1pll->reference_freq =
1136 le16_to_cpu(firmware_info->info.usReferenceClock);
1137 p1pll->reference_div = 0;
1138
1139 if (crev < 2)
1140 p1pll->pll_out_min =
1141 le16_to_cpu(firmware_info->info.usMinPixelClockPLL_Output);
1142 else
1143 p1pll->pll_out_min =
1144 le32_to_cpu(firmware_info->info_12.ulMinPixelClockPLL_Output);
1145 p1pll->pll_out_max =
1146 le32_to_cpu(firmware_info->info.ulMaxPixelClockPLL_Output);
1147
1148 if (crev >= 4) {
1149 p1pll->lcd_pll_out_min =
1150 le16_to_cpu(firmware_info->info_14.usLcdMinPixelClockPLL_Output) * 100;
1151 if (p1pll->lcd_pll_out_min == 0)
1152 p1pll->lcd_pll_out_min = p1pll->pll_out_min;
1153 p1pll->lcd_pll_out_max =
1154 le16_to_cpu(firmware_info->info_14.usLcdMaxPixelClockPLL_Output) * 100;
1155 if (p1pll->lcd_pll_out_max == 0)
1156 p1pll->lcd_pll_out_max = p1pll->pll_out_max;
1157 } else {
1158 p1pll->lcd_pll_out_min = p1pll->pll_out_min;
1159 p1pll->lcd_pll_out_max = p1pll->pll_out_max;
1160 }
1161
1162 if (p1pll->pll_out_min == 0) {
1163 if (ASIC_IS_AVIVO(rdev))
1164 p1pll->pll_out_min = 64800;
1165 else
1166 p1pll->pll_out_min = 20000;
1167 }
1168
1169 p1pll->pll_in_min =
1170 le16_to_cpu(firmware_info->info.usMinPixelClockPLL_Input);
1171 p1pll->pll_in_max =
1172 le16_to_cpu(firmware_info->info.usMaxPixelClockPLL_Input);
1173
1174 *p2pll = *p1pll;
1175
1176 /* system clock */
1177 if (ASIC_IS_DCE4(rdev))
1178 spll->reference_freq =
1179 le16_to_cpu(firmware_info->info_21.usCoreReferenceClock);
1180 else
1181 spll->reference_freq =
1182 le16_to_cpu(firmware_info->info.usReferenceClock);
1183 spll->reference_div = 0;
1184
1185 spll->pll_out_min =
1186 le16_to_cpu(firmware_info->info.usMinEngineClockPLL_Output);
1187 spll->pll_out_max =
1188 le32_to_cpu(firmware_info->info.ulMaxEngineClockPLL_Output);
1189
1190 /* ??? */
1191 if (spll->pll_out_min == 0) {
1192 if (ASIC_IS_AVIVO(rdev))
1193 spll->pll_out_min = 64800;
1194 else
1195 spll->pll_out_min = 20000;
1196 }
1197
1198 spll->pll_in_min =
1199 le16_to_cpu(firmware_info->info.usMinEngineClockPLL_Input);
1200 spll->pll_in_max =
1201 le16_to_cpu(firmware_info->info.usMaxEngineClockPLL_Input);
1202
1203 /* memory clock */
1204 if (ASIC_IS_DCE4(rdev))
1205 mpll->reference_freq =
1206 le16_to_cpu(firmware_info->info_21.usMemoryReferenceClock);
1207 else
1208 mpll->reference_freq =
1209 le16_to_cpu(firmware_info->info.usReferenceClock);
1210 mpll->reference_div = 0;
1211
1212 mpll->pll_out_min =
1213 le16_to_cpu(firmware_info->info.usMinMemoryClockPLL_Output);
1214 mpll->pll_out_max =
1215 le32_to_cpu(firmware_info->info.ulMaxMemoryClockPLL_Output);
1216
1217 /* ??? */
1218 if (mpll->pll_out_min == 0) {
1219 if (ASIC_IS_AVIVO(rdev))
1220 mpll->pll_out_min = 64800;
1221 else
1222 mpll->pll_out_min = 20000;
1223 }
1224
1225 mpll->pll_in_min =
1226 le16_to_cpu(firmware_info->info.usMinMemoryClockPLL_Input);
1227 mpll->pll_in_max =
1228 le16_to_cpu(firmware_info->info.usMaxMemoryClockPLL_Input);
1229
1230 rdev->clock.default_sclk =
1231 le32_to_cpu(firmware_info->info.ulDefaultEngineClock);
1232 rdev->clock.default_mclk =
1233 le32_to_cpu(firmware_info->info.ulDefaultMemoryClock);
1234
1235 if (ASIC_IS_DCE4(rdev)) {
1236 rdev->clock.default_dispclk =
1237 le32_to_cpu(firmware_info->info_21.ulDefaultDispEngineClkFreq);
1238 if (rdev->clock.default_dispclk == 0) {
1239 if (ASIC_IS_DCE5(rdev))
1240 rdev->clock.default_dispclk = 54000; /* 540 Mhz */
1241 else
1242 rdev->clock.default_dispclk = 60000; /* 600 Mhz */
1243 }
1244 rdev->clock.dp_extclk =
1245 le16_to_cpu(firmware_info->info_21.usUniphyDPModeExtClkFreq);
1246 }
1247 *dcpll = *p1pll;
1248
1249 rdev->clock.max_pixel_clock = le16_to_cpu(firmware_info->info.usMaxPixelClock);
1250 if (rdev->clock.max_pixel_clock == 0)
1251 rdev->clock.max_pixel_clock = 40000;
1252
1253 return true;
1254 }
1255
1256 return false;
1257}
1258
1259union igp_info {
1260 struct _ATOM_INTEGRATED_SYSTEM_INFO info;
1261 struct _ATOM_INTEGRATED_SYSTEM_INFO_V2 info_2;
1262};
1263
1264bool radeon_atombios_sideport_present(struct radeon_device *rdev)
1265{
1266 struct radeon_mode_info *mode_info = &rdev->mode_info;
1267 int index = GetIndexIntoMasterTable(DATA, IntegratedSystemInfo);
1268 union igp_info *igp_info;
1269 u8 frev, crev;
1270 u16 data_offset;
1271
1272 /* sideport is AMD only */
1273 if (rdev->family == CHIP_RS600)
1274 return false;
1275
1276 if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1277 &frev, &crev, &data_offset)) {
1278 igp_info = (union igp_info *)(mode_info->atom_context->bios +
1279 data_offset);
1280 switch (crev) {
1281 case 1:
1282 if (le32_to_cpu(igp_info->info.ulBootUpMemoryClock))
1283 return true;
1284 break;
1285 case 2:
1286 if (le32_to_cpu(igp_info->info_2.ulBootUpSidePortClock))
1287 return true;
1288 break;
1289 default:
1290 DRM_ERROR("Unsupported IGP table: %d %d\n", frev, crev);
1291 break;
1292 }
1293 }
1294 return false;
1295}
1296
1297bool radeon_atombios_get_tmds_info(struct radeon_encoder *encoder,
1298 struct radeon_encoder_int_tmds *tmds)
1299{
1300 struct drm_device *dev = encoder->base.dev;
1301 struct radeon_device *rdev = dev->dev_private;
1302 struct radeon_mode_info *mode_info = &rdev->mode_info;
1303 int index = GetIndexIntoMasterTable(DATA, TMDS_Info);
1304 uint16_t data_offset;
1305 struct _ATOM_TMDS_INFO *tmds_info;
1306 uint8_t frev, crev;
1307 uint16_t maxfreq;
1308 int i;
1309
1310 if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1311 &frev, &crev, &data_offset)) {
1312 tmds_info =
1313 (struct _ATOM_TMDS_INFO *)(mode_info->atom_context->bios +
1314 data_offset);
1315
1316 maxfreq = le16_to_cpu(tmds_info->usMaxFrequency);
1317 for (i = 0; i < 4; i++) {
1318 tmds->tmds_pll[i].freq =
1319 le16_to_cpu(tmds_info->asMiscInfo[i].usFrequency);
1320 tmds->tmds_pll[i].value =
1321 tmds_info->asMiscInfo[i].ucPLL_ChargePump & 0x3f;
1322 tmds->tmds_pll[i].value |=
1323 (tmds_info->asMiscInfo[i].
1324 ucPLL_VCO_Gain & 0x3f) << 6;
1325 tmds->tmds_pll[i].value |=
1326 (tmds_info->asMiscInfo[i].
1327 ucPLL_DutyCycle & 0xf) << 12;
1328 tmds->tmds_pll[i].value |=
1329 (tmds_info->asMiscInfo[i].
1330 ucPLL_VoltageSwing & 0xf) << 16;
1331
1332 DRM_DEBUG_KMS("TMDS PLL From ATOMBIOS %u %x\n",
1333 tmds->tmds_pll[i].freq,
1334 tmds->tmds_pll[i].value);
1335
1336 if (maxfreq == tmds->tmds_pll[i].freq) {
1337 tmds->tmds_pll[i].freq = 0xffffffff;
1338 break;
1339 }
1340 }
1341 return true;
1342 }
1343 return false;
1344}
1345
1346bool radeon_atombios_get_ppll_ss_info(struct radeon_device *rdev,
1347 struct radeon_atom_ss *ss,
1348 int id)
1349{
1350 struct radeon_mode_info *mode_info = &rdev->mode_info;
1351 int index = GetIndexIntoMasterTable(DATA, PPLL_SS_Info);
1352 uint16_t data_offset, size;
1353 struct _ATOM_SPREAD_SPECTRUM_INFO *ss_info;
1354 uint8_t frev, crev;
1355 int i, num_indices;
1356
1357 memset(ss, 0, sizeof(struct radeon_atom_ss));
1358 if (atom_parse_data_header(mode_info->atom_context, index, &size,
1359 &frev, &crev, &data_offset)) {
1360 ss_info =
1361 (struct _ATOM_SPREAD_SPECTRUM_INFO *)(mode_info->atom_context->bios + data_offset);
1362
1363 num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
1364 sizeof(ATOM_SPREAD_SPECTRUM_ASSIGNMENT);
1365
1366 for (i = 0; i < num_indices; i++) {
1367 if (ss_info->asSS_Info[i].ucSS_Id == id) {
1368 ss->percentage =
1369 le16_to_cpu(ss_info->asSS_Info[i].usSpreadSpectrumPercentage);
1370 ss->type = ss_info->asSS_Info[i].ucSpreadSpectrumType;
1371 ss->step = ss_info->asSS_Info[i].ucSS_Step;
1372 ss->delay = ss_info->asSS_Info[i].ucSS_Delay;
1373 ss->range = ss_info->asSS_Info[i].ucSS_Range;
1374 ss->refdiv = ss_info->asSS_Info[i].ucRecommendedRef_Div;
1375 return true;
1376 }
1377 }
1378 }
1379 return false;
1380}
1381
1382static void radeon_atombios_get_igp_ss_overrides(struct radeon_device *rdev,
1383 struct radeon_atom_ss *ss,
1384 int id)
1385{
1386 struct radeon_mode_info *mode_info = &rdev->mode_info;
1387 int index = GetIndexIntoMasterTable(DATA, IntegratedSystemInfo);
1388 u16 data_offset, size;
1389 struct _ATOM_INTEGRATED_SYSTEM_INFO_V6 *igp_info;
1390 u8 frev, crev;
1391 u16 percentage = 0, rate = 0;
1392
1393 /* get any igp specific overrides */
1394 if (atom_parse_data_header(mode_info->atom_context, index, &size,
1395 &frev, &crev, &data_offset)) {
1396 igp_info = (struct _ATOM_INTEGRATED_SYSTEM_INFO_V6 *)
1397 (mode_info->atom_context->bios + data_offset);
1398 switch (id) {
1399 case ASIC_INTERNAL_SS_ON_TMDS:
1400 percentage = le16_to_cpu(igp_info->usDVISSPercentage);
1401 rate = le16_to_cpu(igp_info->usDVISSpreadRateIn10Hz);
1402 break;
1403 case ASIC_INTERNAL_SS_ON_HDMI:
1404 percentage = le16_to_cpu(igp_info->usHDMISSPercentage);
1405 rate = le16_to_cpu(igp_info->usHDMISSpreadRateIn10Hz);
1406 break;
1407 case ASIC_INTERNAL_SS_ON_LVDS:
1408 percentage = le16_to_cpu(igp_info->usLvdsSSPercentage);
1409 rate = le16_to_cpu(igp_info->usLvdsSSpreadRateIn10Hz);
1410 break;
1411 }
1412 if (percentage)
1413 ss->percentage = percentage;
1414 if (rate)
1415 ss->rate = rate;
1416 }
1417}
1418
1419union asic_ss_info {
1420 struct _ATOM_ASIC_INTERNAL_SS_INFO info;
1421 struct _ATOM_ASIC_INTERNAL_SS_INFO_V2 info_2;
1422 struct _ATOM_ASIC_INTERNAL_SS_INFO_V3 info_3;
1423};
1424
1425bool radeon_atombios_get_asic_ss_info(struct radeon_device *rdev,
1426 struct radeon_atom_ss *ss,
1427 int id, u32 clock)
1428{
1429 struct radeon_mode_info *mode_info = &rdev->mode_info;
1430 int index = GetIndexIntoMasterTable(DATA, ASIC_InternalSS_Info);
1431 uint16_t data_offset, size;
1432 union asic_ss_info *ss_info;
1433 uint8_t frev, crev;
1434 int i, num_indices;
1435
1436 memset(ss, 0, sizeof(struct radeon_atom_ss));
1437 if (atom_parse_data_header(mode_info->atom_context, index, &size,
1438 &frev, &crev, &data_offset)) {
1439
1440 ss_info =
1441 (union asic_ss_info *)(mode_info->atom_context->bios + data_offset);
1442
1443 switch (frev) {
1444 case 1:
1445 num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
1446 sizeof(ATOM_ASIC_SS_ASSIGNMENT);
1447
1448 for (i = 0; i < num_indices; i++) {
1449 if ((ss_info->info.asSpreadSpectrum[i].ucClockIndication == id) &&
1450 (clock <= le32_to_cpu(ss_info->info.asSpreadSpectrum[i].ulTargetClockRange))) {
1451 ss->percentage =
1452 le16_to_cpu(ss_info->info.asSpreadSpectrum[i].usSpreadSpectrumPercentage);
1453 ss->type = ss_info->info.asSpreadSpectrum[i].ucSpreadSpectrumMode;
1454 ss->rate = le16_to_cpu(ss_info->info.asSpreadSpectrum[i].usSpreadRateInKhz);
1455 return true;
1456 }
1457 }
1458 break;
1459 case 2:
1460 num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
1461 sizeof(ATOM_ASIC_SS_ASSIGNMENT_V2);
1462 for (i = 0; i < num_indices; i++) {
1463 if ((ss_info->info_2.asSpreadSpectrum[i].ucClockIndication == id) &&
1464 (clock <= le32_to_cpu(ss_info->info_2.asSpreadSpectrum[i].ulTargetClockRange))) {
1465 ss->percentage =
1466 le16_to_cpu(ss_info->info_2.asSpreadSpectrum[i].usSpreadSpectrumPercentage);
1467 ss->type = ss_info->info_2.asSpreadSpectrum[i].ucSpreadSpectrumMode;
1468 ss->rate = le16_to_cpu(ss_info->info_2.asSpreadSpectrum[i].usSpreadRateIn10Hz);
1469 return true;
1470 }
1471 }
1472 break;
1473 case 3:
1474 num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
1475 sizeof(ATOM_ASIC_SS_ASSIGNMENT_V3);
1476 for (i = 0; i < num_indices; i++) {
1477 if ((ss_info->info_3.asSpreadSpectrum[i].ucClockIndication == id) &&
1478 (clock <= le32_to_cpu(ss_info->info_3.asSpreadSpectrum[i].ulTargetClockRange))) {
1479 ss->percentage =
1480 le16_to_cpu(ss_info->info_3.asSpreadSpectrum[i].usSpreadSpectrumPercentage);
1481 ss->type = ss_info->info_3.asSpreadSpectrum[i].ucSpreadSpectrumMode;
1482 ss->rate = le16_to_cpu(ss_info->info_3.asSpreadSpectrum[i].usSpreadRateIn10Hz);
1483 if (rdev->flags & RADEON_IS_IGP)
1484 radeon_atombios_get_igp_ss_overrides(rdev, ss, id);
1485 return true;
1486 }
1487 }
1488 break;
1489 default:
1490 DRM_ERROR("Unsupported ASIC_InternalSS_Info table: %d %d\n", frev, crev);
1491 break;
1492 }
1493
1494 }
1495 return false;
1496}
1497
1498union lvds_info {
1499 struct _ATOM_LVDS_INFO info;
1500 struct _ATOM_LVDS_INFO_V12 info_12;
1501};
1502
1503struct radeon_encoder_atom_dig *radeon_atombios_get_lvds_info(struct
1504 radeon_encoder
1505 *encoder)
1506{
1507 struct drm_device *dev = encoder->base.dev;
1508 struct radeon_device *rdev = dev->dev_private;
1509 struct radeon_mode_info *mode_info = &rdev->mode_info;
1510 int index = GetIndexIntoMasterTable(DATA, LVDS_Info);
1511 uint16_t data_offset, misc;
1512 union lvds_info *lvds_info;
1513 uint8_t frev, crev;
1514 struct radeon_encoder_atom_dig *lvds = NULL;
1515 int encoder_enum = (encoder->encoder_enum & ENUM_ID_MASK) >> ENUM_ID_SHIFT;
1516
1517 if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1518 &frev, &crev, &data_offset)) {
1519 lvds_info =
1520 (union lvds_info *)(mode_info->atom_context->bios + data_offset);
1521 lvds =
1522 kzalloc(sizeof(struct radeon_encoder_atom_dig), GFP_KERNEL);
1523
1524 if (!lvds)
1525 return NULL;
1526
1527 lvds->native_mode.clock =
1528 le16_to_cpu(lvds_info->info.sLCDTiming.usPixClk) * 10;
1529 lvds->native_mode.hdisplay =
1530 le16_to_cpu(lvds_info->info.sLCDTiming.usHActive);
1531 lvds->native_mode.vdisplay =
1532 le16_to_cpu(lvds_info->info.sLCDTiming.usVActive);
1533 lvds->native_mode.htotal = lvds->native_mode.hdisplay +
1534 le16_to_cpu(lvds_info->info.sLCDTiming.usHBlanking_Time);
1535 lvds->native_mode.hsync_start = lvds->native_mode.hdisplay +
1536 le16_to_cpu(lvds_info->info.sLCDTiming.usHSyncOffset);
1537 lvds->native_mode.hsync_end = lvds->native_mode.hsync_start +
1538 le16_to_cpu(lvds_info->info.sLCDTiming.usHSyncWidth);
1539 lvds->native_mode.vtotal = lvds->native_mode.vdisplay +
1540 le16_to_cpu(lvds_info->info.sLCDTiming.usVBlanking_Time);
1541 lvds->native_mode.vsync_start = lvds->native_mode.vdisplay +
1542 le16_to_cpu(lvds_info->info.sLCDTiming.usVSyncOffset);
1543 lvds->native_mode.vsync_end = lvds->native_mode.vsync_start +
1544 le16_to_cpu(lvds_info->info.sLCDTiming.usVSyncWidth);
1545 lvds->panel_pwr_delay =
1546 le16_to_cpu(lvds_info->info.usOffDelayInMs);
1547 lvds->lcd_misc = lvds_info->info.ucLVDS_Misc;
1548
1549 misc = le16_to_cpu(lvds_info->info.sLCDTiming.susModeMiscInfo.usAccess);
1550 if (misc & ATOM_VSYNC_POLARITY)
1551 lvds->native_mode.flags |= DRM_MODE_FLAG_NVSYNC;
1552 if (misc & ATOM_HSYNC_POLARITY)
1553 lvds->native_mode.flags |= DRM_MODE_FLAG_NHSYNC;
1554 if (misc & ATOM_COMPOSITESYNC)
1555 lvds->native_mode.flags |= DRM_MODE_FLAG_CSYNC;
1556 if (misc & ATOM_INTERLACE)
1557 lvds->native_mode.flags |= DRM_MODE_FLAG_INTERLACE;
1558 if (misc & ATOM_DOUBLE_CLOCK_MODE)
1559 lvds->native_mode.flags |= DRM_MODE_FLAG_DBLSCAN;
1560
1561 lvds->native_mode.width_mm = le16_to_cpu(lvds_info->info.sLCDTiming.usImageHSize);
1562 lvds->native_mode.height_mm = le16_to_cpu(lvds_info->info.sLCDTiming.usImageVSize);
1563
1564 /* set crtc values */
1565 drm_mode_set_crtcinfo(&lvds->native_mode, CRTC_INTERLACE_HALVE_V);
1566
1567 lvds->lcd_ss_id = lvds_info->info.ucSS_Id;
1568
1569 encoder->native_mode = lvds->native_mode;
1570
1571 if (encoder_enum == 2)
1572 lvds->linkb = true;
1573 else
1574 lvds->linkb = false;
1575
1576 /* parse the lcd record table */
1577 if (le16_to_cpu(lvds_info->info.usModePatchTableOffset)) {
1578 ATOM_FAKE_EDID_PATCH_RECORD *fake_edid_record;
1579 ATOM_PANEL_RESOLUTION_PATCH_RECORD *panel_res_record;
1580 bool bad_record = false;
1581 u8 *record;
1582
1583 if ((frev == 1) && (crev < 2))
1584 /* absolute */
1585 record = (u8 *)(mode_info->atom_context->bios +
1586 le16_to_cpu(lvds_info->info.usModePatchTableOffset));
1587 else
1588 /* relative */
1589 record = (u8 *)(mode_info->atom_context->bios +
1590 data_offset +
1591 le16_to_cpu(lvds_info->info.usModePatchTableOffset));
1592 while (*record != ATOM_RECORD_END_TYPE) {
1593 switch (*record) {
1594 case LCD_MODE_PATCH_RECORD_MODE_TYPE:
1595 record += sizeof(ATOM_PATCH_RECORD_MODE);
1596 break;
1597 case LCD_RTS_RECORD_TYPE:
1598 record += sizeof(ATOM_LCD_RTS_RECORD);
1599 break;
1600 case LCD_CAP_RECORD_TYPE:
1601 record += sizeof(ATOM_LCD_MODE_CONTROL_CAP);
1602 break;
1603 case LCD_FAKE_EDID_PATCH_RECORD_TYPE:
1604 fake_edid_record = (ATOM_FAKE_EDID_PATCH_RECORD *)record;
1605 if (fake_edid_record->ucFakeEDIDLength) {
1606 struct edid *edid;
1607 int edid_size =
1608 max((int)EDID_LENGTH, (int)fake_edid_record->ucFakeEDIDLength);
1609 edid = kmalloc(edid_size, GFP_KERNEL);
1610 if (edid) {
1611 memcpy((u8 *)edid, (u8 *)&fake_edid_record->ucFakeEDIDString[0],
1612 fake_edid_record->ucFakeEDIDLength);
1613
1614 if (drm_edid_is_valid(edid)) {
1615 rdev->mode_info.bios_hardcoded_edid = edid;
1616 rdev->mode_info.bios_hardcoded_edid_size = edid_size;
1617 } else
1618 kfree(edid);
1619 }
1620 }
1621 record += sizeof(ATOM_FAKE_EDID_PATCH_RECORD);
1622 break;
1623 case LCD_PANEL_RESOLUTION_RECORD_TYPE:
1624 panel_res_record = (ATOM_PANEL_RESOLUTION_PATCH_RECORD *)record;
1625 lvds->native_mode.width_mm = panel_res_record->usHSize;
1626 lvds->native_mode.height_mm = panel_res_record->usVSize;
1627 record += sizeof(ATOM_PANEL_RESOLUTION_PATCH_RECORD);
1628 break;
1629 default:
1630 DRM_ERROR("Bad LCD record %d\n", *record);
1631 bad_record = true;
1632 break;
1633 }
1634 if (bad_record)
1635 break;
1636 }
1637 }
1638 }
1639 return lvds;
1640}
1641
1642struct radeon_encoder_primary_dac *
1643radeon_atombios_get_primary_dac_info(struct radeon_encoder *encoder)
1644{
1645 struct drm_device *dev = encoder->base.dev;
1646 struct radeon_device *rdev = dev->dev_private;
1647 struct radeon_mode_info *mode_info = &rdev->mode_info;
1648 int index = GetIndexIntoMasterTable(DATA, CompassionateData);
1649 uint16_t data_offset;
1650 struct _COMPASSIONATE_DATA *dac_info;
1651 uint8_t frev, crev;
1652 uint8_t bg, dac;
1653 struct radeon_encoder_primary_dac *p_dac = NULL;
1654
1655 if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1656 &frev, &crev, &data_offset)) {
1657 dac_info = (struct _COMPASSIONATE_DATA *)
1658 (mode_info->atom_context->bios + data_offset);
1659
1660 p_dac = kzalloc(sizeof(struct radeon_encoder_primary_dac), GFP_KERNEL);
1661
1662 if (!p_dac)
1663 return NULL;
1664
1665 bg = dac_info->ucDAC1_BG_Adjustment;
1666 dac = dac_info->ucDAC1_DAC_Adjustment;
1667 p_dac->ps2_pdac_adj = (bg << 8) | (dac);
1668
1669 }
1670 return p_dac;
1671}
1672
1673bool radeon_atom_get_tv_timings(struct radeon_device *rdev, int index,
1674 struct drm_display_mode *mode)
1675{
1676 struct radeon_mode_info *mode_info = &rdev->mode_info;
1677 ATOM_ANALOG_TV_INFO *tv_info;
1678 ATOM_ANALOG_TV_INFO_V1_2 *tv_info_v1_2;
1679 ATOM_DTD_FORMAT *dtd_timings;
1680 int data_index = GetIndexIntoMasterTable(DATA, AnalogTV_Info);
1681 u8 frev, crev;
1682 u16 data_offset, misc;
1683
1684 if (!atom_parse_data_header(mode_info->atom_context, data_index, NULL,
1685 &frev, &crev, &data_offset))
1686 return false;
1687
1688 switch (crev) {
1689 case 1:
1690 tv_info = (ATOM_ANALOG_TV_INFO *)(mode_info->atom_context->bios + data_offset);
1691 if (index >= MAX_SUPPORTED_TV_TIMING)
1692 return false;
1693
1694 mode->crtc_htotal = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_H_Total);
1695 mode->crtc_hdisplay = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_H_Disp);
1696 mode->crtc_hsync_start = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_H_SyncStart);
1697 mode->crtc_hsync_end = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_H_SyncStart) +
1698 le16_to_cpu(tv_info->aModeTimings[index].usCRTC_H_SyncWidth);
1699
1700 mode->crtc_vtotal = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_V_Total);
1701 mode->crtc_vdisplay = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_V_Disp);
1702 mode->crtc_vsync_start = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_V_SyncStart);
1703 mode->crtc_vsync_end = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_V_SyncStart) +
1704 le16_to_cpu(tv_info->aModeTimings[index].usCRTC_V_SyncWidth);
1705
1706 mode->flags = 0;
1707 misc = le16_to_cpu(tv_info->aModeTimings[index].susModeMiscInfo.usAccess);
1708 if (misc & ATOM_VSYNC_POLARITY)
1709 mode->flags |= DRM_MODE_FLAG_NVSYNC;
1710 if (misc & ATOM_HSYNC_POLARITY)
1711 mode->flags |= DRM_MODE_FLAG_NHSYNC;
1712 if (misc & ATOM_COMPOSITESYNC)
1713 mode->flags |= DRM_MODE_FLAG_CSYNC;
1714 if (misc & ATOM_INTERLACE)
1715 mode->flags |= DRM_MODE_FLAG_INTERLACE;
1716 if (misc & ATOM_DOUBLE_CLOCK_MODE)
1717 mode->flags |= DRM_MODE_FLAG_DBLSCAN;
1718
1719 mode->clock = le16_to_cpu(tv_info->aModeTimings[index].usPixelClock) * 10;
1720
1721 if (index == 1) {
1722 /* PAL timings appear to have wrong values for totals */
1723 mode->crtc_htotal -= 1;
1724 mode->crtc_vtotal -= 1;
1725 }
1726 break;
1727 case 2:
1728 tv_info_v1_2 = (ATOM_ANALOG_TV_INFO_V1_2 *)(mode_info->atom_context->bios + data_offset);
1729 if (index >= MAX_SUPPORTED_TV_TIMING_V1_2)
1730 return false;
1731
1732 dtd_timings = &tv_info_v1_2->aModeTimings[index];
1733 mode->crtc_htotal = le16_to_cpu(dtd_timings->usHActive) +
1734 le16_to_cpu(dtd_timings->usHBlanking_Time);
1735 mode->crtc_hdisplay = le16_to_cpu(dtd_timings->usHActive);
1736 mode->crtc_hsync_start = le16_to_cpu(dtd_timings->usHActive) +
1737 le16_to_cpu(dtd_timings->usHSyncOffset);
1738 mode->crtc_hsync_end = mode->crtc_hsync_start +
1739 le16_to_cpu(dtd_timings->usHSyncWidth);
1740
1741 mode->crtc_vtotal = le16_to_cpu(dtd_timings->usVActive) +
1742 le16_to_cpu(dtd_timings->usVBlanking_Time);
1743 mode->crtc_vdisplay = le16_to_cpu(dtd_timings->usVActive);
1744 mode->crtc_vsync_start = le16_to_cpu(dtd_timings->usVActive) +
1745 le16_to_cpu(dtd_timings->usVSyncOffset);
1746 mode->crtc_vsync_end = mode->crtc_vsync_start +
1747 le16_to_cpu(dtd_timings->usVSyncWidth);
1748
1749 mode->flags = 0;
1750 misc = le16_to_cpu(dtd_timings->susModeMiscInfo.usAccess);
1751 if (misc & ATOM_VSYNC_POLARITY)
1752 mode->flags |= DRM_MODE_FLAG_NVSYNC;
1753 if (misc & ATOM_HSYNC_POLARITY)
1754 mode->flags |= DRM_MODE_FLAG_NHSYNC;
1755 if (misc & ATOM_COMPOSITESYNC)
1756 mode->flags |= DRM_MODE_FLAG_CSYNC;
1757 if (misc & ATOM_INTERLACE)
1758 mode->flags |= DRM_MODE_FLAG_INTERLACE;
1759 if (misc & ATOM_DOUBLE_CLOCK_MODE)
1760 mode->flags |= DRM_MODE_FLAG_DBLSCAN;
1761
1762 mode->clock = le16_to_cpu(dtd_timings->usPixClk) * 10;
1763 break;
1764 }
1765 return true;
1766}
1767
1768enum radeon_tv_std
1769radeon_atombios_get_tv_info(struct radeon_device *rdev)
1770{
1771 struct radeon_mode_info *mode_info = &rdev->mode_info;
1772 int index = GetIndexIntoMasterTable(DATA, AnalogTV_Info);
1773 uint16_t data_offset;
1774 uint8_t frev, crev;
1775 struct _ATOM_ANALOG_TV_INFO *tv_info;
1776 enum radeon_tv_std tv_std = TV_STD_NTSC;
1777
1778 if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1779 &frev, &crev, &data_offset)) {
1780
1781 tv_info = (struct _ATOM_ANALOG_TV_INFO *)
1782 (mode_info->atom_context->bios + data_offset);
1783
1784 switch (tv_info->ucTV_BootUpDefaultStandard) {
1785 case ATOM_TV_NTSC:
1786 tv_std = TV_STD_NTSC;
1787 DRM_DEBUG_KMS("Default TV standard: NTSC\n");
1788 break;
1789 case ATOM_TV_NTSCJ:
1790 tv_std = TV_STD_NTSC_J;
1791 DRM_DEBUG_KMS("Default TV standard: NTSC-J\n");
1792 break;
1793 case ATOM_TV_PAL:
1794 tv_std = TV_STD_PAL;
1795 DRM_DEBUG_KMS("Default TV standard: PAL\n");
1796 break;
1797 case ATOM_TV_PALM:
1798 tv_std = TV_STD_PAL_M;
1799 DRM_DEBUG_KMS("Default TV standard: PAL-M\n");
1800 break;
1801 case ATOM_TV_PALN:
1802 tv_std = TV_STD_PAL_N;
1803 DRM_DEBUG_KMS("Default TV standard: PAL-N\n");
1804 break;
1805 case ATOM_TV_PALCN:
1806 tv_std = TV_STD_PAL_CN;
1807 DRM_DEBUG_KMS("Default TV standard: PAL-CN\n");
1808 break;
1809 case ATOM_TV_PAL60:
1810 tv_std = TV_STD_PAL_60;
1811 DRM_DEBUG_KMS("Default TV standard: PAL-60\n");
1812 break;
1813 case ATOM_TV_SECAM:
1814 tv_std = TV_STD_SECAM;
1815 DRM_DEBUG_KMS("Default TV standard: SECAM\n");
1816 break;
1817 default:
1818 tv_std = TV_STD_NTSC;
1819 DRM_DEBUG_KMS("Unknown TV standard; defaulting to NTSC\n");
1820 break;
1821 }
1822 }
1823 return tv_std;
1824}
1825
1826struct radeon_encoder_tv_dac *
1827radeon_atombios_get_tv_dac_info(struct radeon_encoder *encoder)
1828{
1829 struct drm_device *dev = encoder->base.dev;
1830 struct radeon_device *rdev = dev->dev_private;
1831 struct radeon_mode_info *mode_info = &rdev->mode_info;
1832 int index = GetIndexIntoMasterTable(DATA, CompassionateData);
1833 uint16_t data_offset;
1834 struct _COMPASSIONATE_DATA *dac_info;
1835 uint8_t frev, crev;
1836 uint8_t bg, dac;
1837 struct radeon_encoder_tv_dac *tv_dac = NULL;
1838
1839 if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1840 &frev, &crev, &data_offset)) {
1841
1842 dac_info = (struct _COMPASSIONATE_DATA *)
1843 (mode_info->atom_context->bios + data_offset);
1844
1845 tv_dac = kzalloc(sizeof(struct radeon_encoder_tv_dac), GFP_KERNEL);
1846
1847 if (!tv_dac)
1848 return NULL;
1849
1850 bg = dac_info->ucDAC2_CRT2_BG_Adjustment;
1851 dac = dac_info->ucDAC2_CRT2_DAC_Adjustment;
1852 tv_dac->ps2_tvdac_adj = (bg << 16) | (dac << 20);
1853
1854 bg = dac_info->ucDAC2_PAL_BG_Adjustment;
1855 dac = dac_info->ucDAC2_PAL_DAC_Adjustment;
1856 tv_dac->pal_tvdac_adj = (bg << 16) | (dac << 20);
1857
1858 bg = dac_info->ucDAC2_NTSC_BG_Adjustment;
1859 dac = dac_info->ucDAC2_NTSC_DAC_Adjustment;
1860 tv_dac->ntsc_tvdac_adj = (bg << 16) | (dac << 20);
1861
1862 tv_dac->tv_std = radeon_atombios_get_tv_info(rdev);
1863 }
1864 return tv_dac;
1865}
1866
1867static const char *thermal_controller_names[] = {
1868 "NONE",
1869 "lm63",
1870 "adm1032",
1871 "adm1030",
1872 "max6649",
1873 "lm64",
1874 "f75375",
1875 "asc7xxx",
1876};
1877
1878static const char *pp_lib_thermal_controller_names[] = {
1879 "NONE",
1880 "lm63",
1881 "adm1032",
1882 "adm1030",
1883 "max6649",
1884 "lm64",
1885 "f75375",
1886 "RV6xx",
1887 "RV770",
1888 "adt7473",
1889 "NONE",
1890 "External GPIO",
1891 "Evergreen",
1892 "emc2103",
1893 "Sumo",
1894 "Northern Islands",
1895};
1896
1897union power_info {
1898 struct _ATOM_POWERPLAY_INFO info;
1899 struct _ATOM_POWERPLAY_INFO_V2 info_2;
1900 struct _ATOM_POWERPLAY_INFO_V3 info_3;
1901 struct _ATOM_PPLIB_POWERPLAYTABLE pplib;
1902 struct _ATOM_PPLIB_POWERPLAYTABLE2 pplib2;
1903 struct _ATOM_PPLIB_POWERPLAYTABLE3 pplib3;
1904};
1905
1906union pplib_clock_info {
1907 struct _ATOM_PPLIB_R600_CLOCK_INFO r600;
1908 struct _ATOM_PPLIB_RS780_CLOCK_INFO rs780;
1909 struct _ATOM_PPLIB_EVERGREEN_CLOCK_INFO evergreen;
1910 struct _ATOM_PPLIB_SUMO_CLOCK_INFO sumo;
1911};
1912
1913union pplib_power_state {
1914 struct _ATOM_PPLIB_STATE v1;
1915 struct _ATOM_PPLIB_STATE_V2 v2;
1916};
1917
1918static void radeon_atombios_parse_misc_flags_1_3(struct radeon_device *rdev,
1919 int state_index,
1920 u32 misc, u32 misc2)
1921{
1922 rdev->pm.power_state[state_index].misc = misc;
1923 rdev->pm.power_state[state_index].misc2 = misc2;
1924 /* order matters! */
1925 if (misc & ATOM_PM_MISCINFO_POWER_SAVING_MODE)
1926 rdev->pm.power_state[state_index].type =
1927 POWER_STATE_TYPE_POWERSAVE;
1928 if (misc & ATOM_PM_MISCINFO_DEFAULT_DC_STATE_ENTRY_TRUE)
1929 rdev->pm.power_state[state_index].type =
1930 POWER_STATE_TYPE_BATTERY;
1931 if (misc & ATOM_PM_MISCINFO_DEFAULT_LOW_DC_STATE_ENTRY_TRUE)
1932 rdev->pm.power_state[state_index].type =
1933 POWER_STATE_TYPE_BATTERY;
1934 if (misc & ATOM_PM_MISCINFO_LOAD_BALANCE_EN)
1935 rdev->pm.power_state[state_index].type =
1936 POWER_STATE_TYPE_BALANCED;
1937 if (misc & ATOM_PM_MISCINFO_3D_ACCELERATION_EN) {
1938 rdev->pm.power_state[state_index].type =
1939 POWER_STATE_TYPE_PERFORMANCE;
1940 rdev->pm.power_state[state_index].flags &=
1941 ~RADEON_PM_STATE_SINGLE_DISPLAY_ONLY;
1942 }
1943 if (misc2 & ATOM_PM_MISCINFO2_SYSTEM_AC_LITE_MODE)
1944 rdev->pm.power_state[state_index].type =
1945 POWER_STATE_TYPE_BALANCED;
1946 if (misc & ATOM_PM_MISCINFO_DRIVER_DEFAULT_MODE) {
1947 rdev->pm.power_state[state_index].type =
1948 POWER_STATE_TYPE_DEFAULT;
1949 rdev->pm.default_power_state_index = state_index;
1950 rdev->pm.power_state[state_index].default_clock_mode =
1951 &rdev->pm.power_state[state_index].clock_info[0];
1952 } else if (state_index == 0) {
1953 rdev->pm.power_state[state_index].clock_info[0].flags |=
1954 RADEON_PM_MODE_NO_DISPLAY;
1955 }
1956}
1957
1958static int radeon_atombios_parse_power_table_1_3(struct radeon_device *rdev)
1959{
1960 struct radeon_mode_info *mode_info = &rdev->mode_info;
1961 u32 misc, misc2 = 0;
1962 int num_modes = 0, i;
1963 int state_index = 0;
1964 struct radeon_i2c_bus_rec i2c_bus;
1965 union power_info *power_info;
1966 int index = GetIndexIntoMasterTable(DATA, PowerPlayInfo);
1967 u16 data_offset;
1968 u8 frev, crev;
1969
1970 if (!atom_parse_data_header(mode_info->atom_context, index, NULL,
1971 &frev, &crev, &data_offset))
1972 return state_index;
1973 power_info = (union power_info *)(mode_info->atom_context->bios + data_offset);
1974
1975 /* add the i2c bus for thermal/fan chip */
1976 if (power_info->info.ucOverdriveThermalController > 0) {
1977 DRM_INFO("Possible %s thermal controller at 0x%02x\n",
1978 thermal_controller_names[power_info->info.ucOverdriveThermalController],
1979 power_info->info.ucOverdriveControllerAddress >> 1);
1980 i2c_bus = radeon_lookup_i2c_gpio(rdev, power_info->info.ucOverdriveI2cLine);
1981 rdev->pm.i2c_bus = radeon_i2c_lookup(rdev, &i2c_bus);
1982 if (rdev->pm.i2c_bus) {
1983 struct i2c_board_info info = { };
1984 const char *name = thermal_controller_names[power_info->info.
1985 ucOverdriveThermalController];
1986 info.addr = power_info->info.ucOverdriveControllerAddress >> 1;
1987 strlcpy(info.type, name, sizeof(info.type));
1988 i2c_new_device(&rdev->pm.i2c_bus->adapter, &info);
1989 }
1990 }
1991 num_modes = power_info->info.ucNumOfPowerModeEntries;
1992 if (num_modes > ATOM_MAX_NUMBEROF_POWER_BLOCK)
1993 num_modes = ATOM_MAX_NUMBEROF_POWER_BLOCK;
1994 rdev->pm.power_state = kzalloc(sizeof(struct radeon_power_state) * num_modes, GFP_KERNEL);
1995 if (!rdev->pm.power_state)
1996 return state_index;
1997 /* last mode is usually default, array is low to high */
1998 for (i = 0; i < num_modes; i++) {
1999 rdev->pm.power_state[state_index].clock_info[0].voltage.type = VOLTAGE_NONE;
2000 switch (frev) {
2001 case 1:
2002 rdev->pm.power_state[state_index].num_clock_modes = 1;
2003 rdev->pm.power_state[state_index].clock_info[0].mclk =
2004 le16_to_cpu(power_info->info.asPowerPlayInfo[i].usMemoryClock);
2005 rdev->pm.power_state[state_index].clock_info[0].sclk =
2006 le16_to_cpu(power_info->info.asPowerPlayInfo[i].usEngineClock);
2007 /* skip invalid modes */
2008 if ((rdev->pm.power_state[state_index].clock_info[0].mclk == 0) ||
2009 (rdev->pm.power_state[state_index].clock_info[0].sclk == 0))
2010 continue;
2011 rdev->pm.power_state[state_index].pcie_lanes =
2012 power_info->info.asPowerPlayInfo[i].ucNumPciELanes;
2013 misc = le32_to_cpu(power_info->info.asPowerPlayInfo[i].ulMiscInfo);
2014 if ((misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_SUPPORT) ||
2015 (misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_ACTIVE_HIGH)) {
2016 rdev->pm.power_state[state_index].clock_info[0].voltage.type =
2017 VOLTAGE_GPIO;
2018 rdev->pm.power_state[state_index].clock_info[0].voltage.gpio =
2019 radeon_lookup_gpio(rdev,
2020 power_info->info.asPowerPlayInfo[i].ucVoltageDropIndex);
2021 if (misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_ACTIVE_HIGH)
2022 rdev->pm.power_state[state_index].clock_info[0].voltage.active_high =
2023 true;
2024 else
2025 rdev->pm.power_state[state_index].clock_info[0].voltage.active_high =
2026 false;
2027 } else if (misc & ATOM_PM_MISCINFO_PROGRAM_VOLTAGE) {
2028 rdev->pm.power_state[state_index].clock_info[0].voltage.type =
2029 VOLTAGE_VDDC;
2030 rdev->pm.power_state[state_index].clock_info[0].voltage.vddc_id =
2031 power_info->info.asPowerPlayInfo[i].ucVoltageDropIndex;
2032 }
2033 rdev->pm.power_state[state_index].flags = RADEON_PM_STATE_SINGLE_DISPLAY_ONLY;
2034 radeon_atombios_parse_misc_flags_1_3(rdev, state_index, misc, 0);
2035 state_index++;
2036 break;
2037 case 2:
2038 rdev->pm.power_state[state_index].num_clock_modes = 1;
2039 rdev->pm.power_state[state_index].clock_info[0].mclk =
2040 le32_to_cpu(power_info->info_2.asPowerPlayInfo[i].ulMemoryClock);
2041 rdev->pm.power_state[state_index].clock_info[0].sclk =
2042 le32_to_cpu(power_info->info_2.asPowerPlayInfo[i].ulEngineClock);
2043 /* skip invalid modes */
2044 if ((rdev->pm.power_state[state_index].clock_info[0].mclk == 0) ||
2045 (rdev->pm.power_state[state_index].clock_info[0].sclk == 0))
2046 continue;
2047 rdev->pm.power_state[state_index].pcie_lanes =
2048 power_info->info_2.asPowerPlayInfo[i].ucNumPciELanes;
2049 misc = le32_to_cpu(power_info->info_2.asPowerPlayInfo[i].ulMiscInfo);
2050 misc2 = le32_to_cpu(power_info->info_2.asPowerPlayInfo[i].ulMiscInfo2);
2051 if ((misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_SUPPORT) ||
2052 (misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_ACTIVE_HIGH)) {
2053 rdev->pm.power_state[state_index].clock_info[0].voltage.type =
2054 VOLTAGE_GPIO;
2055 rdev->pm.power_state[state_index].clock_info[0].voltage.gpio =
2056 radeon_lookup_gpio(rdev,
2057 power_info->info_2.asPowerPlayInfo[i].ucVoltageDropIndex);
2058 if (misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_ACTIVE_HIGH)
2059 rdev->pm.power_state[state_index].clock_info[0].voltage.active_high =
2060 true;
2061 else
2062 rdev->pm.power_state[state_index].clock_info[0].voltage.active_high =
2063 false;
2064 } else if (misc & ATOM_PM_MISCINFO_PROGRAM_VOLTAGE) {
2065 rdev->pm.power_state[state_index].clock_info[0].voltage.type =
2066 VOLTAGE_VDDC;
2067 rdev->pm.power_state[state_index].clock_info[0].voltage.vddc_id =
2068 power_info->info_2.asPowerPlayInfo[i].ucVoltageDropIndex;
2069 }
2070 rdev->pm.power_state[state_index].flags = RADEON_PM_STATE_SINGLE_DISPLAY_ONLY;
2071 radeon_atombios_parse_misc_flags_1_3(rdev, state_index, misc, misc2);
2072 state_index++;
2073 break;
2074 case 3:
2075 rdev->pm.power_state[state_index].num_clock_modes = 1;
2076 rdev->pm.power_state[state_index].clock_info[0].mclk =
2077 le32_to_cpu(power_info->info_3.asPowerPlayInfo[i].ulMemoryClock);
2078 rdev->pm.power_state[state_index].clock_info[0].sclk =
2079 le32_to_cpu(power_info->info_3.asPowerPlayInfo[i].ulEngineClock);
2080 /* skip invalid modes */
2081 if ((rdev->pm.power_state[state_index].clock_info[0].mclk == 0) ||
2082 (rdev->pm.power_state[state_index].clock_info[0].sclk == 0))
2083 continue;
2084 rdev->pm.power_state[state_index].pcie_lanes =
2085 power_info->info_3.asPowerPlayInfo[i].ucNumPciELanes;
2086 misc = le32_to_cpu(power_info->info_3.asPowerPlayInfo[i].ulMiscInfo);
2087 misc2 = le32_to_cpu(power_info->info_3.asPowerPlayInfo[i].ulMiscInfo2);
2088 if ((misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_SUPPORT) ||
2089 (misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_ACTIVE_HIGH)) {
2090 rdev->pm.power_state[state_index].clock_info[0].voltage.type =
2091 VOLTAGE_GPIO;
2092 rdev->pm.power_state[state_index].clock_info[0].voltage.gpio =
2093 radeon_lookup_gpio(rdev,
2094 power_info->info_3.asPowerPlayInfo[i].ucVoltageDropIndex);
2095 if (misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_ACTIVE_HIGH)
2096 rdev->pm.power_state[state_index].clock_info[0].voltage.active_high =
2097 true;
2098 else
2099 rdev->pm.power_state[state_index].clock_info[0].voltage.active_high =
2100 false;
2101 } else if (misc & ATOM_PM_MISCINFO_PROGRAM_VOLTAGE) {
2102 rdev->pm.power_state[state_index].clock_info[0].voltage.type =
2103 VOLTAGE_VDDC;
2104 rdev->pm.power_state[state_index].clock_info[0].voltage.vddc_id =
2105 power_info->info_3.asPowerPlayInfo[i].ucVoltageDropIndex;
2106 if (misc2 & ATOM_PM_MISCINFO2_VDDCI_DYNAMIC_VOLTAGE_EN) {
2107 rdev->pm.power_state[state_index].clock_info[0].voltage.vddci_enabled =
2108 true;
2109 rdev->pm.power_state[state_index].clock_info[0].voltage.vddci_id =
2110 power_info->info_3.asPowerPlayInfo[i].ucVDDCI_VoltageDropIndex;
2111 }
2112 }
2113 rdev->pm.power_state[state_index].flags = RADEON_PM_STATE_SINGLE_DISPLAY_ONLY;
2114 radeon_atombios_parse_misc_flags_1_3(rdev, state_index, misc, misc2);
2115 state_index++;
2116 break;
2117 }
2118 }
2119 /* last mode is usually default */
2120 if (rdev->pm.default_power_state_index == -1) {
2121 rdev->pm.power_state[state_index - 1].type =
2122 POWER_STATE_TYPE_DEFAULT;
2123 rdev->pm.default_power_state_index = state_index - 1;
2124 rdev->pm.power_state[state_index - 1].default_clock_mode =
2125 &rdev->pm.power_state[state_index - 1].clock_info[0];
2126 rdev->pm.power_state[state_index].flags &=
2127 ~RADEON_PM_STATE_SINGLE_DISPLAY_ONLY;
2128 rdev->pm.power_state[state_index].misc = 0;
2129 rdev->pm.power_state[state_index].misc2 = 0;
2130 }
2131 return state_index;
2132}
2133
2134static void radeon_atombios_add_pplib_thermal_controller(struct radeon_device *rdev,
2135 ATOM_PPLIB_THERMALCONTROLLER *controller)
2136{
2137 struct radeon_i2c_bus_rec i2c_bus;
2138
2139 /* add the i2c bus for thermal/fan chip */
2140 if (controller->ucType > 0) {
2141 if (controller->ucType == ATOM_PP_THERMALCONTROLLER_RV6xx) {
2142 DRM_INFO("Internal thermal controller %s fan control\n",
2143 (controller->ucFanParameters &
2144 ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2145 rdev->pm.int_thermal_type = THERMAL_TYPE_RV6XX;
2146 } else if (controller->ucType == ATOM_PP_THERMALCONTROLLER_RV770) {
2147 DRM_INFO("Internal thermal controller %s fan control\n",
2148 (controller->ucFanParameters &
2149 ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2150 rdev->pm.int_thermal_type = THERMAL_TYPE_RV770;
2151 } else if (controller->ucType == ATOM_PP_THERMALCONTROLLER_EVERGREEN) {
2152 DRM_INFO("Internal thermal controller %s fan control\n",
2153 (controller->ucFanParameters &
2154 ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2155 rdev->pm.int_thermal_type = THERMAL_TYPE_EVERGREEN;
2156 } else if (controller->ucType == ATOM_PP_THERMALCONTROLLER_SUMO) {
2157 DRM_INFO("Internal thermal controller %s fan control\n",
2158 (controller->ucFanParameters &
2159 ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2160 rdev->pm.int_thermal_type = THERMAL_TYPE_SUMO;
2161 } else if (controller->ucType == ATOM_PP_THERMALCONTROLLER_NISLANDS) {
2162 DRM_INFO("Internal thermal controller %s fan control\n",
2163 (controller->ucFanParameters &
2164 ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2165 rdev->pm.int_thermal_type = THERMAL_TYPE_NI;
2166 } else if ((controller->ucType ==
2167 ATOM_PP_THERMALCONTROLLER_EXTERNAL_GPIO) ||
2168 (controller->ucType ==
2169 ATOM_PP_THERMALCONTROLLER_ADT7473_WITH_INTERNAL) ||
2170 (controller->ucType ==
2171 ATOM_PP_THERMALCONTROLLER_EMC2103_WITH_INTERNAL)) {
2172 DRM_INFO("Special thermal controller config\n");
2173 } else {
2174 DRM_INFO("Possible %s thermal controller at 0x%02x %s fan control\n",
2175 pp_lib_thermal_controller_names[controller->ucType],
2176 controller->ucI2cAddress >> 1,
2177 (controller->ucFanParameters &
2178 ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2179 i2c_bus = radeon_lookup_i2c_gpio(rdev, controller->ucI2cLine);
2180 rdev->pm.i2c_bus = radeon_i2c_lookup(rdev, &i2c_bus);
2181 if (rdev->pm.i2c_bus) {
2182 struct i2c_board_info info = { };
2183 const char *name = pp_lib_thermal_controller_names[controller->ucType];
2184 info.addr = controller->ucI2cAddress >> 1;
2185 strlcpy(info.type, name, sizeof(info.type));
2186 i2c_new_device(&rdev->pm.i2c_bus->adapter, &info);
2187 }
2188 }
2189 }
2190}
2191
2192static void radeon_atombios_get_default_voltages(struct radeon_device *rdev,
2193 u16 *vddc, u16 *vddci)
2194{
2195 struct radeon_mode_info *mode_info = &rdev->mode_info;
2196 int index = GetIndexIntoMasterTable(DATA, FirmwareInfo);
2197 u8 frev, crev;
2198 u16 data_offset;
2199 union firmware_info *firmware_info;
2200
2201 *vddc = 0;
2202 *vddci = 0;
2203
2204 if (atom_parse_data_header(mode_info->atom_context, index, NULL,
2205 &frev, &crev, &data_offset)) {
2206 firmware_info =
2207 (union firmware_info *)(mode_info->atom_context->bios +
2208 data_offset);
2209 *vddc = le16_to_cpu(firmware_info->info_14.usBootUpVDDCVoltage);
2210 if ((frev == 2) && (crev >= 2))
2211 *vddci = le16_to_cpu(firmware_info->info_22.usBootUpVDDCIVoltage);
2212 }
2213}
2214
2215static void radeon_atombios_parse_pplib_non_clock_info(struct radeon_device *rdev,
2216 int state_index, int mode_index,
2217 struct _ATOM_PPLIB_NONCLOCK_INFO *non_clock_info)
2218{
2219 int j;
2220 u32 misc = le32_to_cpu(non_clock_info->ulCapsAndSettings);
2221 u32 misc2 = le16_to_cpu(non_clock_info->usClassification);
2222 u16 vddc, vddci;
2223
2224 radeon_atombios_get_default_voltages(rdev, &vddc, &vddci);
2225
2226 rdev->pm.power_state[state_index].misc = misc;
2227 rdev->pm.power_state[state_index].misc2 = misc2;
2228 rdev->pm.power_state[state_index].pcie_lanes =
2229 ((misc & ATOM_PPLIB_PCIE_LINK_WIDTH_MASK) >>
2230 ATOM_PPLIB_PCIE_LINK_WIDTH_SHIFT) + 1;
2231 switch (misc2 & ATOM_PPLIB_CLASSIFICATION_UI_MASK) {
2232 case ATOM_PPLIB_CLASSIFICATION_UI_BATTERY:
2233 rdev->pm.power_state[state_index].type =
2234 POWER_STATE_TYPE_BATTERY;
2235 break;
2236 case ATOM_PPLIB_CLASSIFICATION_UI_BALANCED:
2237 rdev->pm.power_state[state_index].type =
2238 POWER_STATE_TYPE_BALANCED;
2239 break;
2240 case ATOM_PPLIB_CLASSIFICATION_UI_PERFORMANCE:
2241 rdev->pm.power_state[state_index].type =
2242 POWER_STATE_TYPE_PERFORMANCE;
2243 break;
2244 case ATOM_PPLIB_CLASSIFICATION_UI_NONE:
2245 if (misc2 & ATOM_PPLIB_CLASSIFICATION_3DPERFORMANCE)
2246 rdev->pm.power_state[state_index].type =
2247 POWER_STATE_TYPE_PERFORMANCE;
2248 break;
2249 }
2250 rdev->pm.power_state[state_index].flags = 0;
2251 if (misc & ATOM_PPLIB_SINGLE_DISPLAY_ONLY)
2252 rdev->pm.power_state[state_index].flags |=
2253 RADEON_PM_STATE_SINGLE_DISPLAY_ONLY;
2254 if (misc2 & ATOM_PPLIB_CLASSIFICATION_BOOT) {
2255 rdev->pm.power_state[state_index].type =
2256 POWER_STATE_TYPE_DEFAULT;
2257 rdev->pm.default_power_state_index = state_index;
2258 rdev->pm.power_state[state_index].default_clock_mode =
2259 &rdev->pm.power_state[state_index].clock_info[mode_index - 1];
2260 if (ASIC_IS_DCE5(rdev)) {
2261 /* NI chips post without MC ucode, so default clocks are strobe mode only */
2262 rdev->pm.default_sclk = rdev->pm.power_state[state_index].clock_info[0].sclk;
2263 rdev->pm.default_mclk = rdev->pm.power_state[state_index].clock_info[0].mclk;
2264 rdev->pm.default_vddc = rdev->pm.power_state[state_index].clock_info[0].voltage.voltage;
2265 rdev->pm.default_vddci = rdev->pm.power_state[state_index].clock_info[0].voltage.vddci;
2266 } else {
2267 /* patch the table values with the default slck/mclk from firmware info */
2268 for (j = 0; j < mode_index; j++) {
2269 rdev->pm.power_state[state_index].clock_info[j].mclk =
2270 rdev->clock.default_mclk;
2271 rdev->pm.power_state[state_index].clock_info[j].sclk =
2272 rdev->clock.default_sclk;
2273 if (vddc)
2274 rdev->pm.power_state[state_index].clock_info[j].voltage.voltage =
2275 vddc;
2276 }
2277 }
2278 }
2279}
2280
2281static bool radeon_atombios_parse_pplib_clock_info(struct radeon_device *rdev,
2282 int state_index, int mode_index,
2283 union pplib_clock_info *clock_info)
2284{
2285 u32 sclk, mclk;
2286
2287 if (rdev->flags & RADEON_IS_IGP) {
2288 if (rdev->family >= CHIP_PALM) {
2289 sclk = le16_to_cpu(clock_info->sumo.usEngineClockLow);
2290 sclk |= clock_info->sumo.ucEngineClockHigh << 16;
2291 rdev->pm.power_state[state_index].clock_info[mode_index].sclk = sclk;
2292 } else {
2293 sclk = le16_to_cpu(clock_info->rs780.usLowEngineClockLow);
2294 sclk |= clock_info->rs780.ucLowEngineClockHigh << 16;
2295 rdev->pm.power_state[state_index].clock_info[mode_index].sclk = sclk;
2296 }
2297 } else if (ASIC_IS_DCE4(rdev)) {
2298 sclk = le16_to_cpu(clock_info->evergreen.usEngineClockLow);
2299 sclk |= clock_info->evergreen.ucEngineClockHigh << 16;
2300 mclk = le16_to_cpu(clock_info->evergreen.usMemoryClockLow);
2301 mclk |= clock_info->evergreen.ucMemoryClockHigh << 16;
2302 rdev->pm.power_state[state_index].clock_info[mode_index].mclk = mclk;
2303 rdev->pm.power_state[state_index].clock_info[mode_index].sclk = sclk;
2304 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.type =
2305 VOLTAGE_SW;
2306 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.voltage =
2307 le16_to_cpu(clock_info->evergreen.usVDDC);
2308 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.vddci =
2309 le16_to_cpu(clock_info->evergreen.usVDDCI);
2310 } else {
2311 sclk = le16_to_cpu(clock_info->r600.usEngineClockLow);
2312 sclk |= clock_info->r600.ucEngineClockHigh << 16;
2313 mclk = le16_to_cpu(clock_info->r600.usMemoryClockLow);
2314 mclk |= clock_info->r600.ucMemoryClockHigh << 16;
2315 rdev->pm.power_state[state_index].clock_info[mode_index].mclk = mclk;
2316 rdev->pm.power_state[state_index].clock_info[mode_index].sclk = sclk;
2317 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.type =
2318 VOLTAGE_SW;
2319 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.voltage =
2320 le16_to_cpu(clock_info->r600.usVDDC);
2321 }
2322
2323 /* patch up vddc if necessary */
2324 if (rdev->pm.power_state[state_index].clock_info[mode_index].voltage.voltage == 0xff01) {
2325 u16 vddc;
2326
2327 if (radeon_atom_get_max_vddc(rdev, &vddc) == 0)
2328 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.voltage = vddc;
2329 }
2330
2331 if (rdev->flags & RADEON_IS_IGP) {
2332 /* skip invalid modes */
2333 if (rdev->pm.power_state[state_index].clock_info[mode_index].sclk == 0)
2334 return false;
2335 } else {
2336 /* skip invalid modes */
2337 if ((rdev->pm.power_state[state_index].clock_info[mode_index].mclk == 0) ||
2338 (rdev->pm.power_state[state_index].clock_info[mode_index].sclk == 0))
2339 return false;
2340 }
2341 return true;
2342}
2343
2344static int radeon_atombios_parse_power_table_4_5(struct radeon_device *rdev)
2345{
2346 struct radeon_mode_info *mode_info = &rdev->mode_info;
2347 struct _ATOM_PPLIB_NONCLOCK_INFO *non_clock_info;
2348 union pplib_power_state *power_state;
2349 int i, j;
2350 int state_index = 0, mode_index = 0;
2351 union pplib_clock_info *clock_info;
2352 bool valid;
2353 union power_info *power_info;
2354 int index = GetIndexIntoMasterTable(DATA, PowerPlayInfo);
2355 u16 data_offset;
2356 u8 frev, crev;
2357
2358 if (!atom_parse_data_header(mode_info->atom_context, index, NULL,
2359 &frev, &crev, &data_offset))
2360 return state_index;
2361 power_info = (union power_info *)(mode_info->atom_context->bios + data_offset);
2362
2363 radeon_atombios_add_pplib_thermal_controller(rdev, &power_info->pplib.sThermalController);
2364 rdev->pm.power_state = kzalloc(sizeof(struct radeon_power_state) *
2365 power_info->pplib.ucNumStates, GFP_KERNEL);
2366 if (!rdev->pm.power_state)
2367 return state_index;
2368 /* first mode is usually default, followed by low to high */
2369 for (i = 0; i < power_info->pplib.ucNumStates; i++) {
2370 mode_index = 0;
2371 power_state = (union pplib_power_state *)
2372 (mode_info->atom_context->bios + data_offset +
2373 le16_to_cpu(power_info->pplib.usStateArrayOffset) +
2374 i * power_info->pplib.ucStateEntrySize);
2375 non_clock_info = (struct _ATOM_PPLIB_NONCLOCK_INFO *)
2376 (mode_info->atom_context->bios + data_offset +
2377 le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset) +
2378 (power_state->v1.ucNonClockStateIndex *
2379 power_info->pplib.ucNonClockSize));
2380 for (j = 0; j < (power_info->pplib.ucStateEntrySize - 1); j++) {
2381 clock_info = (union pplib_clock_info *)
2382 (mode_info->atom_context->bios + data_offset +
2383 le16_to_cpu(power_info->pplib.usClockInfoArrayOffset) +
2384 (power_state->v1.ucClockStateIndices[j] *
2385 power_info->pplib.ucClockInfoSize));
2386 valid = radeon_atombios_parse_pplib_clock_info(rdev,
2387 state_index, mode_index,
2388 clock_info);
2389 if (valid)
2390 mode_index++;
2391 }
2392 rdev->pm.power_state[state_index].num_clock_modes = mode_index;
2393 if (mode_index) {
2394 radeon_atombios_parse_pplib_non_clock_info(rdev, state_index, mode_index,
2395 non_clock_info);
2396 state_index++;
2397 }
2398 }
2399 /* if multiple clock modes, mark the lowest as no display */
2400 for (i = 0; i < state_index; i++) {
2401 if (rdev->pm.power_state[i].num_clock_modes > 1)
2402 rdev->pm.power_state[i].clock_info[0].flags |=
2403 RADEON_PM_MODE_NO_DISPLAY;
2404 }
2405 /* first mode is usually default */
2406 if (rdev->pm.default_power_state_index == -1) {
2407 rdev->pm.power_state[0].type =
2408 POWER_STATE_TYPE_DEFAULT;
2409 rdev->pm.default_power_state_index = 0;
2410 rdev->pm.power_state[0].default_clock_mode =
2411 &rdev->pm.power_state[0].clock_info[0];
2412 }
2413 return state_index;
2414}
2415
2416static int radeon_atombios_parse_power_table_6(struct radeon_device *rdev)
2417{
2418 struct radeon_mode_info *mode_info = &rdev->mode_info;
2419 struct _ATOM_PPLIB_NONCLOCK_INFO *non_clock_info;
2420 union pplib_power_state *power_state;
2421 int i, j, non_clock_array_index, clock_array_index;
2422 int state_index = 0, mode_index = 0;
2423 union pplib_clock_info *clock_info;
2424 struct StateArray *state_array;
2425 struct ClockInfoArray *clock_info_array;
2426 struct NonClockInfoArray *non_clock_info_array;
2427 bool valid;
2428 union power_info *power_info;
2429 int index = GetIndexIntoMasterTable(DATA, PowerPlayInfo);
2430 u16 data_offset;
2431 u8 frev, crev;
2432
2433 if (!atom_parse_data_header(mode_info->atom_context, index, NULL,
2434 &frev, &crev, &data_offset))
2435 return state_index;
2436 power_info = (union power_info *)(mode_info->atom_context->bios + data_offset);
2437
2438 radeon_atombios_add_pplib_thermal_controller(rdev, &power_info->pplib.sThermalController);
2439 state_array = (struct StateArray *)
2440 (mode_info->atom_context->bios + data_offset +
2441 le16_to_cpu(power_info->pplib.usStateArrayOffset));
2442 clock_info_array = (struct ClockInfoArray *)
2443 (mode_info->atom_context->bios + data_offset +
2444 le16_to_cpu(power_info->pplib.usClockInfoArrayOffset));
2445 non_clock_info_array = (struct NonClockInfoArray *)
2446 (mode_info->atom_context->bios + data_offset +
2447 le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset));
2448 rdev->pm.power_state = kzalloc(sizeof(struct radeon_power_state) *
2449 state_array->ucNumEntries, GFP_KERNEL);
2450 if (!rdev->pm.power_state)
2451 return state_index;
2452 for (i = 0; i < state_array->ucNumEntries; i++) {
2453 mode_index = 0;
2454 power_state = (union pplib_power_state *)&state_array->states[i];
2455 /* XXX this might be an inagua bug... */
2456 non_clock_array_index = i; /* power_state->v2.nonClockInfoIndex */
2457 non_clock_info = (struct _ATOM_PPLIB_NONCLOCK_INFO *)
2458 &non_clock_info_array->nonClockInfo[non_clock_array_index];
2459 for (j = 0; j < power_state->v2.ucNumDPMLevels; j++) {
2460 clock_array_index = power_state->v2.clockInfoIndex[j];
2461 /* XXX this might be an inagua bug... */
2462 if (clock_array_index >= clock_info_array->ucNumEntries)
2463 continue;
2464 clock_info = (union pplib_clock_info *)
2465 &clock_info_array->clockInfo[clock_array_index];
2466 valid = radeon_atombios_parse_pplib_clock_info(rdev,
2467 state_index, mode_index,
2468 clock_info);
2469 if (valid)
2470 mode_index++;
2471 }
2472 rdev->pm.power_state[state_index].num_clock_modes = mode_index;
2473 if (mode_index) {
2474 radeon_atombios_parse_pplib_non_clock_info(rdev, state_index, mode_index,
2475 non_clock_info);
2476 state_index++;
2477 }
2478 }
2479 /* if multiple clock modes, mark the lowest as no display */
2480 for (i = 0; i < state_index; i++) {
2481 if (rdev->pm.power_state[i].num_clock_modes > 1)
2482 rdev->pm.power_state[i].clock_info[0].flags |=
2483 RADEON_PM_MODE_NO_DISPLAY;
2484 }
2485 /* first mode is usually default */
2486 if (rdev->pm.default_power_state_index == -1) {
2487 rdev->pm.power_state[0].type =
2488 POWER_STATE_TYPE_DEFAULT;
2489 rdev->pm.default_power_state_index = 0;
2490 rdev->pm.power_state[0].default_clock_mode =
2491 &rdev->pm.power_state[0].clock_info[0];
2492 }
2493 return state_index;
2494}
2495
2496void radeon_atombios_get_power_modes(struct radeon_device *rdev)
2497{
2498 struct radeon_mode_info *mode_info = &rdev->mode_info;
2499 int index = GetIndexIntoMasterTable(DATA, PowerPlayInfo);
2500 u16 data_offset;
2501 u8 frev, crev;
2502 int state_index = 0;
2503
2504 rdev->pm.default_power_state_index = -1;
2505
2506 if (atom_parse_data_header(mode_info->atom_context, index, NULL,
2507 &frev, &crev, &data_offset)) {
2508 switch (frev) {
2509 case 1:
2510 case 2:
2511 case 3:
2512 state_index = radeon_atombios_parse_power_table_1_3(rdev);
2513 break;
2514 case 4:
2515 case 5:
2516 state_index = radeon_atombios_parse_power_table_4_5(rdev);
2517 break;
2518 case 6:
2519 state_index = radeon_atombios_parse_power_table_6(rdev);
2520 break;
2521 default:
2522 break;
2523 }
2524 } else {
2525 rdev->pm.power_state = kzalloc(sizeof(struct radeon_power_state), GFP_KERNEL);
2526 if (rdev->pm.power_state) {
2527 /* add the default mode */
2528 rdev->pm.power_state[state_index].type =
2529 POWER_STATE_TYPE_DEFAULT;
2530 rdev->pm.power_state[state_index].num_clock_modes = 1;
2531 rdev->pm.power_state[state_index].clock_info[0].mclk = rdev->clock.default_mclk;
2532 rdev->pm.power_state[state_index].clock_info[0].sclk = rdev->clock.default_sclk;
2533 rdev->pm.power_state[state_index].default_clock_mode =
2534 &rdev->pm.power_state[state_index].clock_info[0];
2535 rdev->pm.power_state[state_index].clock_info[0].voltage.type = VOLTAGE_NONE;
2536 rdev->pm.power_state[state_index].pcie_lanes = 16;
2537 rdev->pm.default_power_state_index = state_index;
2538 rdev->pm.power_state[state_index].flags = 0;
2539 state_index++;
2540 }
2541 }
2542
2543 rdev->pm.num_power_states = state_index;
2544
2545 rdev->pm.current_power_state_index = rdev->pm.default_power_state_index;
2546 rdev->pm.current_clock_mode_index = 0;
2547 rdev->pm.current_vddc = rdev->pm.power_state[rdev->pm.default_power_state_index].clock_info[0].voltage.voltage;
2548}
2549
2550void radeon_atom_set_clock_gating(struct radeon_device *rdev, int enable)
2551{
2552 DYNAMIC_CLOCK_GATING_PS_ALLOCATION args;
2553 int index = GetIndexIntoMasterTable(COMMAND, DynamicClockGating);
2554
2555 args.ucEnable = enable;
2556
2557 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2558}
2559
2560uint32_t radeon_atom_get_engine_clock(struct radeon_device *rdev)
2561{
2562 GET_ENGINE_CLOCK_PS_ALLOCATION args;
2563 int index = GetIndexIntoMasterTable(COMMAND, GetEngineClock);
2564
2565 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2566 return le32_to_cpu(args.ulReturnEngineClock);
2567}
2568
2569uint32_t radeon_atom_get_memory_clock(struct radeon_device *rdev)
2570{
2571 GET_MEMORY_CLOCK_PS_ALLOCATION args;
2572 int index = GetIndexIntoMasterTable(COMMAND, GetMemoryClock);
2573
2574 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2575 return le32_to_cpu(args.ulReturnMemoryClock);
2576}
2577
2578void radeon_atom_set_engine_clock(struct radeon_device *rdev,
2579 uint32_t eng_clock)
2580{
2581 SET_ENGINE_CLOCK_PS_ALLOCATION args;
2582 int index = GetIndexIntoMasterTable(COMMAND, SetEngineClock);
2583
2584 args.ulTargetEngineClock = cpu_to_le32(eng_clock); /* 10 khz */
2585
2586 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2587}
2588
2589void radeon_atom_set_memory_clock(struct radeon_device *rdev,
2590 uint32_t mem_clock)
2591{
2592 SET_MEMORY_CLOCK_PS_ALLOCATION args;
2593 int index = GetIndexIntoMasterTable(COMMAND, SetMemoryClock);
2594
2595 if (rdev->flags & RADEON_IS_IGP)
2596 return;
2597
2598 args.ulTargetMemoryClock = cpu_to_le32(mem_clock); /* 10 khz */
2599
2600 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2601}
2602
2603union set_voltage {
2604 struct _SET_VOLTAGE_PS_ALLOCATION alloc;
2605 struct _SET_VOLTAGE_PARAMETERS v1;
2606 struct _SET_VOLTAGE_PARAMETERS_V2 v2;
2607};
2608
2609void radeon_atom_set_voltage(struct radeon_device *rdev, u16 voltage_level, u8 voltage_type)
2610{
2611 union set_voltage args;
2612 int index = GetIndexIntoMasterTable(COMMAND, SetVoltage);
2613 u8 frev, crev, volt_index = voltage_level;
2614
2615 if (!atom_parse_cmd_header(rdev->mode_info.atom_context, index, &frev, &crev))
2616 return;
2617
2618 /* 0xff01 is a flag rather then an actual voltage */
2619 if (voltage_level == 0xff01)
2620 return;
2621
2622 switch (crev) {
2623 case 1:
2624 args.v1.ucVoltageType = voltage_type;
2625 args.v1.ucVoltageMode = SET_ASIC_VOLTAGE_MODE_ALL_SOURCE;
2626 args.v1.ucVoltageIndex = volt_index;
2627 break;
2628 case 2:
2629 args.v2.ucVoltageType = voltage_type;
2630 args.v2.ucVoltageMode = SET_ASIC_VOLTAGE_MODE_SET_VOLTAGE;
2631 args.v2.usVoltageLevel = cpu_to_le16(voltage_level);
2632 break;
2633 default:
2634 DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
2635 return;
2636 }
2637
2638 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2639}
2640
2641int radeon_atom_get_max_vddc(struct radeon_device *rdev,
2642 u16 *voltage)
2643{
2644 union set_voltage args;
2645 int index = GetIndexIntoMasterTable(COMMAND, SetVoltage);
2646 u8 frev, crev;
2647
2648 if (!atom_parse_cmd_header(rdev->mode_info.atom_context, index, &frev, &crev))
2649 return -EINVAL;
2650
2651 switch (crev) {
2652 case 1:
2653 return -EINVAL;
2654 case 2:
2655 args.v2.ucVoltageType = SET_VOLTAGE_GET_MAX_VOLTAGE;
2656 args.v2.ucVoltageMode = 0;
2657 args.v2.usVoltageLevel = 0;
2658
2659 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2660
2661 *voltage = le16_to_cpu(args.v2.usVoltageLevel);
2662 break;
2663 default:
2664 DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
2665 return -EINVAL;
2666 }
2667
2668 return 0;
2669}
2670
2671void radeon_atom_initialize_bios_scratch_regs(struct drm_device *dev)
2672{
2673 struct radeon_device *rdev = dev->dev_private;
2674 uint32_t bios_2_scratch, bios_6_scratch;
2675
2676 if (rdev->family >= CHIP_R600) {
2677 bios_2_scratch = RREG32(R600_BIOS_2_SCRATCH);
2678 bios_6_scratch = RREG32(R600_BIOS_6_SCRATCH);
2679 } else {
2680 bios_2_scratch = RREG32(RADEON_BIOS_2_SCRATCH);
2681 bios_6_scratch = RREG32(RADEON_BIOS_6_SCRATCH);
2682 }
2683
2684 /* let the bios control the backlight */
2685 bios_2_scratch &= ~ATOM_S2_VRI_BRIGHT_ENABLE;
2686
2687 /* tell the bios not to handle mode switching */
2688 bios_6_scratch |= ATOM_S6_ACC_BLOCK_DISPLAY_SWITCH;
2689
2690 if (rdev->family >= CHIP_R600) {
2691 WREG32(R600_BIOS_2_SCRATCH, bios_2_scratch);
2692 WREG32(R600_BIOS_6_SCRATCH, bios_6_scratch);
2693 } else {
2694 WREG32(RADEON_BIOS_2_SCRATCH, bios_2_scratch);
2695 WREG32(RADEON_BIOS_6_SCRATCH, bios_6_scratch);
2696 }
2697
2698}
2699
2700void radeon_save_bios_scratch_regs(struct radeon_device *rdev)
2701{
2702 uint32_t scratch_reg;
2703 int i;
2704
2705 if (rdev->family >= CHIP_R600)
2706 scratch_reg = R600_BIOS_0_SCRATCH;
2707 else
2708 scratch_reg = RADEON_BIOS_0_SCRATCH;
2709
2710 for (i = 0; i < RADEON_BIOS_NUM_SCRATCH; i++)
2711 rdev->bios_scratch[i] = RREG32(scratch_reg + (i * 4));
2712}
2713
2714void radeon_restore_bios_scratch_regs(struct radeon_device *rdev)
2715{
2716 uint32_t scratch_reg;
2717 int i;
2718
2719 if (rdev->family >= CHIP_R600)
2720 scratch_reg = R600_BIOS_0_SCRATCH;
2721 else
2722 scratch_reg = RADEON_BIOS_0_SCRATCH;
2723
2724 for (i = 0; i < RADEON_BIOS_NUM_SCRATCH; i++)
2725 WREG32(scratch_reg + (i * 4), rdev->bios_scratch[i]);
2726}
2727
2728void radeon_atom_output_lock(struct drm_encoder *encoder, bool lock)
2729{
2730 struct drm_device *dev = encoder->dev;
2731 struct radeon_device *rdev = dev->dev_private;
2732 uint32_t bios_6_scratch;
2733
2734 if (rdev->family >= CHIP_R600)
2735 bios_6_scratch = RREG32(R600_BIOS_6_SCRATCH);
2736 else
2737 bios_6_scratch = RREG32(RADEON_BIOS_6_SCRATCH);
2738
2739 if (lock) {
2740 bios_6_scratch |= ATOM_S6_CRITICAL_STATE;
2741 bios_6_scratch &= ~ATOM_S6_ACC_MODE;
2742 } else {
2743 bios_6_scratch &= ~ATOM_S6_CRITICAL_STATE;
2744 bios_6_scratch |= ATOM_S6_ACC_MODE;
2745 }
2746
2747 if (rdev->family >= CHIP_R600)
2748 WREG32(R600_BIOS_6_SCRATCH, bios_6_scratch);
2749 else
2750 WREG32(RADEON_BIOS_6_SCRATCH, bios_6_scratch);
2751}
2752
2753/* at some point we may want to break this out into individual functions */
2754void
2755radeon_atombios_connected_scratch_regs(struct drm_connector *connector,
2756 struct drm_encoder *encoder,
2757 bool connected)
2758{
2759 struct drm_device *dev = connector->dev;
2760 struct radeon_device *rdev = dev->dev_private;
2761 struct radeon_connector *radeon_connector =
2762 to_radeon_connector(connector);
2763 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
2764 uint32_t bios_0_scratch, bios_3_scratch, bios_6_scratch;
2765
2766 if (rdev->family >= CHIP_R600) {
2767 bios_0_scratch = RREG32(R600_BIOS_0_SCRATCH);
2768 bios_3_scratch = RREG32(R600_BIOS_3_SCRATCH);
2769 bios_6_scratch = RREG32(R600_BIOS_6_SCRATCH);
2770 } else {
2771 bios_0_scratch = RREG32(RADEON_BIOS_0_SCRATCH);
2772 bios_3_scratch = RREG32(RADEON_BIOS_3_SCRATCH);
2773 bios_6_scratch = RREG32(RADEON_BIOS_6_SCRATCH);
2774 }
2775
2776 if ((radeon_encoder->devices & ATOM_DEVICE_TV1_SUPPORT) &&
2777 (radeon_connector->devices & ATOM_DEVICE_TV1_SUPPORT)) {
2778 if (connected) {
2779 DRM_DEBUG_KMS("TV1 connected\n");
2780 bios_3_scratch |= ATOM_S3_TV1_ACTIVE;
2781 bios_6_scratch |= ATOM_S6_ACC_REQ_TV1;
2782 } else {
2783 DRM_DEBUG_KMS("TV1 disconnected\n");
2784 bios_0_scratch &= ~ATOM_S0_TV1_MASK;
2785 bios_3_scratch &= ~ATOM_S3_TV1_ACTIVE;
2786 bios_6_scratch &= ~ATOM_S6_ACC_REQ_TV1;
2787 }
2788 }
2789 if ((radeon_encoder->devices & ATOM_DEVICE_CV_SUPPORT) &&
2790 (radeon_connector->devices & ATOM_DEVICE_CV_SUPPORT)) {
2791 if (connected) {
2792 DRM_DEBUG_KMS("CV connected\n");
2793 bios_3_scratch |= ATOM_S3_CV_ACTIVE;
2794 bios_6_scratch |= ATOM_S6_ACC_REQ_CV;
2795 } else {
2796 DRM_DEBUG_KMS("CV disconnected\n");
2797 bios_0_scratch &= ~ATOM_S0_CV_MASK;
2798 bios_3_scratch &= ~ATOM_S3_CV_ACTIVE;
2799 bios_6_scratch &= ~ATOM_S6_ACC_REQ_CV;
2800 }
2801 }
2802 if ((radeon_encoder->devices & ATOM_DEVICE_LCD1_SUPPORT) &&
2803 (radeon_connector->devices & ATOM_DEVICE_LCD1_SUPPORT)) {
2804 if (connected) {
2805 DRM_DEBUG_KMS("LCD1 connected\n");
2806 bios_0_scratch |= ATOM_S0_LCD1;
2807 bios_3_scratch |= ATOM_S3_LCD1_ACTIVE;
2808 bios_6_scratch |= ATOM_S6_ACC_REQ_LCD1;
2809 } else {
2810 DRM_DEBUG_KMS("LCD1 disconnected\n");
2811 bios_0_scratch &= ~ATOM_S0_LCD1;
2812 bios_3_scratch &= ~ATOM_S3_LCD1_ACTIVE;
2813 bios_6_scratch &= ~ATOM_S6_ACC_REQ_LCD1;
2814 }
2815 }
2816 if ((radeon_encoder->devices & ATOM_DEVICE_CRT1_SUPPORT) &&
2817 (radeon_connector->devices & ATOM_DEVICE_CRT1_SUPPORT)) {
2818 if (connected) {
2819 DRM_DEBUG_KMS("CRT1 connected\n");
2820 bios_0_scratch |= ATOM_S0_CRT1_COLOR;
2821 bios_3_scratch |= ATOM_S3_CRT1_ACTIVE;
2822 bios_6_scratch |= ATOM_S6_ACC_REQ_CRT1;
2823 } else {
2824 DRM_DEBUG_KMS("CRT1 disconnected\n");
2825 bios_0_scratch &= ~ATOM_S0_CRT1_MASK;
2826 bios_3_scratch &= ~ATOM_S3_CRT1_ACTIVE;
2827 bios_6_scratch &= ~ATOM_S6_ACC_REQ_CRT1;
2828 }
2829 }
2830 if ((radeon_encoder->devices & ATOM_DEVICE_CRT2_SUPPORT) &&
2831 (radeon_connector->devices & ATOM_DEVICE_CRT2_SUPPORT)) {
2832 if (connected) {
2833 DRM_DEBUG_KMS("CRT2 connected\n");
2834 bios_0_scratch |= ATOM_S0_CRT2_COLOR;
2835 bios_3_scratch |= ATOM_S3_CRT2_ACTIVE;
2836 bios_6_scratch |= ATOM_S6_ACC_REQ_CRT2;
2837 } else {
2838 DRM_DEBUG_KMS("CRT2 disconnected\n");
2839 bios_0_scratch &= ~ATOM_S0_CRT2_MASK;
2840 bios_3_scratch &= ~ATOM_S3_CRT2_ACTIVE;
2841 bios_6_scratch &= ~ATOM_S6_ACC_REQ_CRT2;
2842 }
2843 }
2844 if ((radeon_encoder->devices & ATOM_DEVICE_DFP1_SUPPORT) &&
2845 (radeon_connector->devices & ATOM_DEVICE_DFP1_SUPPORT)) {
2846 if (connected) {
2847 DRM_DEBUG_KMS("DFP1 connected\n");
2848 bios_0_scratch |= ATOM_S0_DFP1;
2849 bios_3_scratch |= ATOM_S3_DFP1_ACTIVE;
2850 bios_6_scratch |= ATOM_S6_ACC_REQ_DFP1;
2851 } else {
2852 DRM_DEBUG_KMS("DFP1 disconnected\n");
2853 bios_0_scratch &= ~ATOM_S0_DFP1;
2854 bios_3_scratch &= ~ATOM_S3_DFP1_ACTIVE;
2855 bios_6_scratch &= ~ATOM_S6_ACC_REQ_DFP1;
2856 }
2857 }
2858 if ((radeon_encoder->devices & ATOM_DEVICE_DFP2_SUPPORT) &&
2859 (radeon_connector->devices & ATOM_DEVICE_DFP2_SUPPORT)) {
2860 if (connected) {
2861 DRM_DEBUG_KMS("DFP2 connected\n");
2862 bios_0_scratch |= ATOM_S0_DFP2;
2863 bios_3_scratch |= ATOM_S3_DFP2_ACTIVE;
2864 bios_6_scratch |= ATOM_S6_ACC_REQ_DFP2;
2865 } else {
2866 DRM_DEBUG_KMS("DFP2 disconnected\n");
2867 bios_0_scratch &= ~ATOM_S0_DFP2;
2868 bios_3_scratch &= ~ATOM_S3_DFP2_ACTIVE;
2869 bios_6_scratch &= ~ATOM_S6_ACC_REQ_DFP2;
2870 }
2871 }
2872 if ((radeon_encoder->devices & ATOM_DEVICE_DFP3_SUPPORT) &&
2873 (radeon_connector->devices & ATOM_DEVICE_DFP3_SUPPORT)) {
2874 if (connected) {
2875 DRM_DEBUG_KMS("DFP3 connected\n");
2876 bios_0_scratch |= ATOM_S0_DFP3;
2877 bios_3_scratch |= ATOM_S3_DFP3_ACTIVE;
2878 bios_6_scratch |= ATOM_S6_ACC_REQ_DFP3;
2879 } else {
2880 DRM_DEBUG_KMS("DFP3 disconnected\n");
2881 bios_0_scratch &= ~ATOM_S0_DFP3;
2882 bios_3_scratch &= ~ATOM_S3_DFP3_ACTIVE;
2883 bios_6_scratch &= ~ATOM_S6_ACC_REQ_DFP3;
2884 }
2885 }
2886 if ((radeon_encoder->devices & ATOM_DEVICE_DFP4_SUPPORT) &&
2887 (radeon_connector->devices & ATOM_DEVICE_DFP4_SUPPORT)) {
2888 if (connected) {
2889 DRM_DEBUG_KMS("DFP4 connected\n");
2890 bios_0_scratch |= ATOM_S0_DFP4;
2891 bios_3_scratch |= ATOM_S3_DFP4_ACTIVE;
2892 bios_6_scratch |= ATOM_S6_ACC_REQ_DFP4;
2893 } else {
2894 DRM_DEBUG_KMS("DFP4 disconnected\n");
2895 bios_0_scratch &= ~ATOM_S0_DFP4;
2896 bios_3_scratch &= ~ATOM_S3_DFP4_ACTIVE;
2897 bios_6_scratch &= ~ATOM_S6_ACC_REQ_DFP4;
2898 }
2899 }
2900 if ((radeon_encoder->devices & ATOM_DEVICE_DFP5_SUPPORT) &&
2901 (radeon_connector->devices & ATOM_DEVICE_DFP5_SUPPORT)) {
2902 if (connected) {
2903 DRM_DEBUG_KMS("DFP5 connected\n");
2904 bios_0_scratch |= ATOM_S0_DFP5;
2905 bios_3_scratch |= ATOM_S3_DFP5_ACTIVE;
2906 bios_6_scratch |= ATOM_S6_ACC_REQ_DFP5;
2907 } else {
2908 DRM_DEBUG_KMS("DFP5 disconnected\n");
2909 bios_0_scratch &= ~ATOM_S0_DFP5;
2910 bios_3_scratch &= ~ATOM_S3_DFP5_ACTIVE;
2911 bios_6_scratch &= ~ATOM_S6_ACC_REQ_DFP5;
2912 }
2913 }
2914
2915 if (rdev->family >= CHIP_R600) {
2916 WREG32(R600_BIOS_0_SCRATCH, bios_0_scratch);
2917 WREG32(R600_BIOS_3_SCRATCH, bios_3_scratch);
2918 WREG32(R600_BIOS_6_SCRATCH, bios_6_scratch);
2919 } else {
2920 WREG32(RADEON_BIOS_0_SCRATCH, bios_0_scratch);
2921 WREG32(RADEON_BIOS_3_SCRATCH, bios_3_scratch);
2922 WREG32(RADEON_BIOS_6_SCRATCH, bios_6_scratch);
2923 }
2924}
2925
2926void
2927radeon_atombios_encoder_crtc_scratch_regs(struct drm_encoder *encoder, int crtc)
2928{
2929 struct drm_device *dev = encoder->dev;
2930 struct radeon_device *rdev = dev->dev_private;
2931 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
2932 uint32_t bios_3_scratch;
2933
2934 if (rdev->family >= CHIP_R600)
2935 bios_3_scratch = RREG32(R600_BIOS_3_SCRATCH);
2936 else
2937 bios_3_scratch = RREG32(RADEON_BIOS_3_SCRATCH);
2938
2939 if (radeon_encoder->devices & ATOM_DEVICE_TV1_SUPPORT) {
2940 bios_3_scratch &= ~ATOM_S3_TV1_CRTC_ACTIVE;
2941 bios_3_scratch |= (crtc << 18);
2942 }
2943 if (radeon_encoder->devices & ATOM_DEVICE_CV_SUPPORT) {
2944 bios_3_scratch &= ~ATOM_S3_CV_CRTC_ACTIVE;
2945 bios_3_scratch |= (crtc << 24);
2946 }
2947 if (radeon_encoder->devices & ATOM_DEVICE_CRT1_SUPPORT) {
2948 bios_3_scratch &= ~ATOM_S3_CRT1_CRTC_ACTIVE;
2949 bios_3_scratch |= (crtc << 16);
2950 }
2951 if (radeon_encoder->devices & ATOM_DEVICE_CRT2_SUPPORT) {
2952 bios_3_scratch &= ~ATOM_S3_CRT2_CRTC_ACTIVE;
2953 bios_3_scratch |= (crtc << 20);
2954 }
2955 if (radeon_encoder->devices & ATOM_DEVICE_LCD1_SUPPORT) {
2956 bios_3_scratch &= ~ATOM_S3_LCD1_CRTC_ACTIVE;
2957 bios_3_scratch |= (crtc << 17);
2958 }
2959 if (radeon_encoder->devices & ATOM_DEVICE_DFP1_SUPPORT) {
2960 bios_3_scratch &= ~ATOM_S3_DFP1_CRTC_ACTIVE;
2961 bios_3_scratch |= (crtc << 19);
2962 }
2963 if (radeon_encoder->devices & ATOM_DEVICE_DFP2_SUPPORT) {
2964 bios_3_scratch &= ~ATOM_S3_DFP2_CRTC_ACTIVE;
2965 bios_3_scratch |= (crtc << 23);
2966 }
2967 if (radeon_encoder->devices & ATOM_DEVICE_DFP3_SUPPORT) {
2968 bios_3_scratch &= ~ATOM_S3_DFP3_CRTC_ACTIVE;
2969 bios_3_scratch |= (crtc << 25);
2970 }
2971
2972 if (rdev->family >= CHIP_R600)
2973 WREG32(R600_BIOS_3_SCRATCH, bios_3_scratch);
2974 else
2975 WREG32(RADEON_BIOS_3_SCRATCH, bios_3_scratch);
2976}
2977
2978void
2979radeon_atombios_encoder_dpms_scratch_regs(struct drm_encoder *encoder, bool on)
2980{
2981 struct drm_device *dev = encoder->dev;
2982 struct radeon_device *rdev = dev->dev_private;
2983 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
2984 uint32_t bios_2_scratch;
2985
2986 if (rdev->family >= CHIP_R600)
2987 bios_2_scratch = RREG32(R600_BIOS_2_SCRATCH);
2988 else
2989 bios_2_scratch = RREG32(RADEON_BIOS_2_SCRATCH);
2990
2991 if (radeon_encoder->devices & ATOM_DEVICE_TV1_SUPPORT) {
2992 if (on)
2993 bios_2_scratch &= ~ATOM_S2_TV1_DPMS_STATE;
2994 else
2995 bios_2_scratch |= ATOM_S2_TV1_DPMS_STATE;
2996 }
2997 if (radeon_encoder->devices & ATOM_DEVICE_CV_SUPPORT) {
2998 if (on)
2999 bios_2_scratch &= ~ATOM_S2_CV_DPMS_STATE;
3000 else
3001 bios_2_scratch |= ATOM_S2_CV_DPMS_STATE;
3002 }
3003 if (radeon_encoder->devices & ATOM_DEVICE_CRT1_SUPPORT) {
3004 if (on)
3005 bios_2_scratch &= ~ATOM_S2_CRT1_DPMS_STATE;
3006 else
3007 bios_2_scratch |= ATOM_S2_CRT1_DPMS_STATE;
3008 }
3009 if (radeon_encoder->devices & ATOM_DEVICE_CRT2_SUPPORT) {
3010 if (on)
3011 bios_2_scratch &= ~ATOM_S2_CRT2_DPMS_STATE;
3012 else
3013 bios_2_scratch |= ATOM_S2_CRT2_DPMS_STATE;
3014 }
3015 if (radeon_encoder->devices & ATOM_DEVICE_LCD1_SUPPORT) {
3016 if (on)
3017 bios_2_scratch &= ~ATOM_S2_LCD1_DPMS_STATE;
3018 else
3019 bios_2_scratch |= ATOM_S2_LCD1_DPMS_STATE;
3020 }
3021 if (radeon_encoder->devices & ATOM_DEVICE_DFP1_SUPPORT) {
3022 if (on)
3023 bios_2_scratch &= ~ATOM_S2_DFP1_DPMS_STATE;
3024 else
3025 bios_2_scratch |= ATOM_S2_DFP1_DPMS_STATE;
3026 }
3027 if (radeon_encoder->devices & ATOM_DEVICE_DFP2_SUPPORT) {
3028 if (on)
3029 bios_2_scratch &= ~ATOM_S2_DFP2_DPMS_STATE;
3030 else
3031 bios_2_scratch |= ATOM_S2_DFP2_DPMS_STATE;
3032 }
3033 if (radeon_encoder->devices & ATOM_DEVICE_DFP3_SUPPORT) {
3034 if (on)
3035 bios_2_scratch &= ~ATOM_S2_DFP3_DPMS_STATE;
3036 else
3037 bios_2_scratch |= ATOM_S2_DFP3_DPMS_STATE;
3038 }
3039 if (radeon_encoder->devices & ATOM_DEVICE_DFP4_SUPPORT) {
3040 if (on)
3041 bios_2_scratch &= ~ATOM_S2_DFP4_DPMS_STATE;
3042 else
3043 bios_2_scratch |= ATOM_S2_DFP4_DPMS_STATE;
3044 }
3045 if (radeon_encoder->devices & ATOM_DEVICE_DFP5_SUPPORT) {
3046 if (on)
3047 bios_2_scratch &= ~ATOM_S2_DFP5_DPMS_STATE;
3048 else
3049 bios_2_scratch |= ATOM_S2_DFP5_DPMS_STATE;
3050 }
3051
3052 if (rdev->family >= CHIP_R600)
3053 WREG32(R600_BIOS_2_SCRATCH, bios_2_scratch);
3054 else
3055 WREG32(RADEON_BIOS_2_SCRATCH, bios_2_scratch);
3056}
1/*
2 * Copyright 2007-8 Advanced Micro Devices, Inc.
3 * Copyright 2008 Red Hat Inc.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the 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 COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
19 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21 * OTHER DEALINGS IN THE SOFTWARE.
22 *
23 * Authors: Dave Airlie
24 * Alex Deucher
25 */
26
27#include <linux/pci.h>
28
29#include <drm/drm_device.h>
30#include <drm/radeon_drm.h>
31
32#include "radeon.h"
33
34#include "atom.h"
35#include "atom-bits.h"
36#include "radeon_asic.h"
37
38extern void
39radeon_add_atom_encoder(struct drm_device *dev, uint32_t encoder_enum,
40 uint32_t supported_device, u16 caps);
41
42/* from radeon_legacy_encoder.c */
43extern void
44radeon_add_legacy_encoder(struct drm_device *dev, uint32_t encoder_enum,
45 uint32_t supported_device);
46
47union atom_supported_devices {
48 struct _ATOM_SUPPORTED_DEVICES_INFO info;
49 struct _ATOM_SUPPORTED_DEVICES_INFO_2 info_2;
50 struct _ATOM_SUPPORTED_DEVICES_INFO_2d1 info_2d1;
51};
52
53static void radeon_lookup_i2c_gpio_quirks(struct radeon_device *rdev,
54 ATOM_GPIO_I2C_ASSIGMENT *gpio,
55 u8 index)
56{
57 /* r4xx mask is technically not used by the hw, so patch in the legacy mask bits */
58 if ((rdev->family == CHIP_R420) ||
59 (rdev->family == CHIP_R423) ||
60 (rdev->family == CHIP_RV410)) {
61 if ((le16_to_cpu(gpio->usClkMaskRegisterIndex) == 0x0018) ||
62 (le16_to_cpu(gpio->usClkMaskRegisterIndex) == 0x0019) ||
63 (le16_to_cpu(gpio->usClkMaskRegisterIndex) == 0x001a)) {
64 gpio->ucClkMaskShift = 0x19;
65 gpio->ucDataMaskShift = 0x18;
66 }
67 }
68
69 /* some evergreen boards have bad data for this entry */
70 if (ASIC_IS_DCE4(rdev)) {
71 if ((index == 7) &&
72 (le16_to_cpu(gpio->usClkMaskRegisterIndex) == 0x1936) &&
73 (gpio->sucI2cId.ucAccess == 0)) {
74 gpio->sucI2cId.ucAccess = 0x97;
75 gpio->ucDataMaskShift = 8;
76 gpio->ucDataEnShift = 8;
77 gpio->ucDataY_Shift = 8;
78 gpio->ucDataA_Shift = 8;
79 }
80 }
81
82 /* some DCE3 boards have bad data for this entry */
83 if (ASIC_IS_DCE3(rdev)) {
84 if ((index == 4) &&
85 (le16_to_cpu(gpio->usClkMaskRegisterIndex) == 0x1fda) &&
86 (gpio->sucI2cId.ucAccess == 0x94))
87 gpio->sucI2cId.ucAccess = 0x14;
88 }
89}
90
91static struct radeon_i2c_bus_rec radeon_get_bus_rec_for_i2c_gpio(ATOM_GPIO_I2C_ASSIGMENT *gpio)
92{
93 struct radeon_i2c_bus_rec i2c;
94
95 memset(&i2c, 0, sizeof(struct radeon_i2c_bus_rec));
96
97 i2c.mask_clk_reg = le16_to_cpu(gpio->usClkMaskRegisterIndex) * 4;
98 i2c.mask_data_reg = le16_to_cpu(gpio->usDataMaskRegisterIndex) * 4;
99 i2c.en_clk_reg = le16_to_cpu(gpio->usClkEnRegisterIndex) * 4;
100 i2c.en_data_reg = le16_to_cpu(gpio->usDataEnRegisterIndex) * 4;
101 i2c.y_clk_reg = le16_to_cpu(gpio->usClkY_RegisterIndex) * 4;
102 i2c.y_data_reg = le16_to_cpu(gpio->usDataY_RegisterIndex) * 4;
103 i2c.a_clk_reg = le16_to_cpu(gpio->usClkA_RegisterIndex) * 4;
104 i2c.a_data_reg = le16_to_cpu(gpio->usDataA_RegisterIndex) * 4;
105 i2c.mask_clk_mask = (1 << gpio->ucClkMaskShift);
106 i2c.mask_data_mask = (1 << gpio->ucDataMaskShift);
107 i2c.en_clk_mask = (1 << gpio->ucClkEnShift);
108 i2c.en_data_mask = (1 << gpio->ucDataEnShift);
109 i2c.y_clk_mask = (1 << gpio->ucClkY_Shift);
110 i2c.y_data_mask = (1 << gpio->ucDataY_Shift);
111 i2c.a_clk_mask = (1 << gpio->ucClkA_Shift);
112 i2c.a_data_mask = (1 << gpio->ucDataA_Shift);
113
114 if (gpio->sucI2cId.sbfAccess.bfHW_Capable)
115 i2c.hw_capable = true;
116 else
117 i2c.hw_capable = false;
118
119 if (gpio->sucI2cId.ucAccess == 0xa0)
120 i2c.mm_i2c = true;
121 else
122 i2c.mm_i2c = false;
123
124 i2c.i2c_id = gpio->sucI2cId.ucAccess;
125
126 if (i2c.mask_clk_reg)
127 i2c.valid = true;
128 else
129 i2c.valid = false;
130
131 return i2c;
132}
133
134static struct radeon_i2c_bus_rec radeon_lookup_i2c_gpio(struct radeon_device *rdev,
135 uint8_t id)
136{
137 struct atom_context *ctx = rdev->mode_info.atom_context;
138 ATOM_GPIO_I2C_ASSIGMENT *gpio;
139 struct radeon_i2c_bus_rec i2c;
140 int index = GetIndexIntoMasterTable(DATA, GPIO_I2C_Info);
141 struct _ATOM_GPIO_I2C_INFO *i2c_info;
142 uint16_t data_offset, size;
143 int i, num_indices;
144
145 memset(&i2c, 0, sizeof(struct radeon_i2c_bus_rec));
146 i2c.valid = false;
147
148 if (atom_parse_data_header(ctx, index, &size, NULL, NULL, &data_offset)) {
149 i2c_info = (struct _ATOM_GPIO_I2C_INFO *)(ctx->bios + data_offset);
150
151 num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
152 sizeof(ATOM_GPIO_I2C_ASSIGMENT);
153
154 gpio = &i2c_info->asGPIO_Info[0];
155 for (i = 0; i < num_indices; i++) {
156
157 radeon_lookup_i2c_gpio_quirks(rdev, gpio, i);
158
159 if (gpio->sucI2cId.ucAccess == id) {
160 i2c = radeon_get_bus_rec_for_i2c_gpio(gpio);
161 break;
162 }
163 gpio = (ATOM_GPIO_I2C_ASSIGMENT *)
164 ((u8 *)gpio + sizeof(ATOM_GPIO_I2C_ASSIGMENT));
165 }
166 }
167
168 return i2c;
169}
170
171void radeon_atombios_i2c_init(struct radeon_device *rdev)
172{
173 struct atom_context *ctx = rdev->mode_info.atom_context;
174 ATOM_GPIO_I2C_ASSIGMENT *gpio;
175 struct radeon_i2c_bus_rec i2c;
176 int index = GetIndexIntoMasterTable(DATA, GPIO_I2C_Info);
177 struct _ATOM_GPIO_I2C_INFO *i2c_info;
178 uint16_t data_offset, size;
179 int i, num_indices;
180 char stmp[32];
181
182 if (atom_parse_data_header(ctx, index, &size, NULL, NULL, &data_offset)) {
183 i2c_info = (struct _ATOM_GPIO_I2C_INFO *)(ctx->bios + data_offset);
184
185 num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
186 sizeof(ATOM_GPIO_I2C_ASSIGMENT);
187
188 gpio = &i2c_info->asGPIO_Info[0];
189 for (i = 0; i < num_indices; i++) {
190 radeon_lookup_i2c_gpio_quirks(rdev, gpio, i);
191
192 i2c = radeon_get_bus_rec_for_i2c_gpio(gpio);
193
194 if (i2c.valid) {
195 sprintf(stmp, "0x%x", i2c.i2c_id);
196 rdev->i2c_bus[i] = radeon_i2c_create(rdev->ddev, &i2c, stmp);
197 }
198 gpio = (ATOM_GPIO_I2C_ASSIGMENT *)
199 ((u8 *)gpio + sizeof(ATOM_GPIO_I2C_ASSIGMENT));
200 }
201 }
202}
203
204struct radeon_gpio_rec radeon_atombios_lookup_gpio(struct radeon_device *rdev,
205 u8 id)
206{
207 struct atom_context *ctx = rdev->mode_info.atom_context;
208 struct radeon_gpio_rec gpio;
209 int index = GetIndexIntoMasterTable(DATA, GPIO_Pin_LUT);
210 struct _ATOM_GPIO_PIN_LUT *gpio_info;
211 ATOM_GPIO_PIN_ASSIGNMENT *pin;
212 u16 data_offset, size;
213 int i, num_indices;
214
215 memset(&gpio, 0, sizeof(struct radeon_gpio_rec));
216 gpio.valid = false;
217
218 if (atom_parse_data_header(ctx, index, &size, NULL, NULL, &data_offset)) {
219 gpio_info = (struct _ATOM_GPIO_PIN_LUT *)(ctx->bios + data_offset);
220
221 num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
222 sizeof(ATOM_GPIO_PIN_ASSIGNMENT);
223
224 pin = gpio_info->asGPIO_Pin;
225 for (i = 0; i < num_indices; i++) {
226 if (id == pin->ucGPIO_ID) {
227 gpio.id = pin->ucGPIO_ID;
228 gpio.reg = le16_to_cpu(pin->usGpioPin_AIndex) * 4;
229 gpio.shift = pin->ucGpioPinBitShift;
230 gpio.mask = (1 << pin->ucGpioPinBitShift);
231 gpio.valid = true;
232 break;
233 }
234 pin = (ATOM_GPIO_PIN_ASSIGNMENT *)
235 ((u8 *)pin + sizeof(ATOM_GPIO_PIN_ASSIGNMENT));
236 }
237 }
238
239 return gpio;
240}
241
242static struct radeon_hpd radeon_atom_get_hpd_info_from_gpio(struct radeon_device *rdev,
243 struct radeon_gpio_rec *gpio)
244{
245 struct radeon_hpd hpd;
246 u32 reg;
247
248 memset(&hpd, 0, sizeof(struct radeon_hpd));
249
250 if (ASIC_IS_DCE6(rdev))
251 reg = SI_DC_GPIO_HPD_A;
252 else if (ASIC_IS_DCE4(rdev))
253 reg = EVERGREEN_DC_GPIO_HPD_A;
254 else
255 reg = AVIVO_DC_GPIO_HPD_A;
256
257 hpd.gpio = *gpio;
258 if (gpio->reg == reg) {
259 switch(gpio->mask) {
260 case (1 << 0):
261 hpd.hpd = RADEON_HPD_1;
262 break;
263 case (1 << 8):
264 hpd.hpd = RADEON_HPD_2;
265 break;
266 case (1 << 16):
267 hpd.hpd = RADEON_HPD_3;
268 break;
269 case (1 << 24):
270 hpd.hpd = RADEON_HPD_4;
271 break;
272 case (1 << 26):
273 hpd.hpd = RADEON_HPD_5;
274 break;
275 case (1 << 28):
276 hpd.hpd = RADEON_HPD_6;
277 break;
278 default:
279 hpd.hpd = RADEON_HPD_NONE;
280 break;
281 }
282 } else
283 hpd.hpd = RADEON_HPD_NONE;
284 return hpd;
285}
286
287static bool radeon_atom_apply_quirks(struct drm_device *dev,
288 uint32_t supported_device,
289 int *connector_type,
290 struct radeon_i2c_bus_rec *i2c_bus,
291 uint16_t *line_mux,
292 struct radeon_hpd *hpd)
293{
294
295 /* Asus M2A-VM HDMI board lists the DVI port as HDMI */
296 if ((dev->pdev->device == 0x791e) &&
297 (dev->pdev->subsystem_vendor == 0x1043) &&
298 (dev->pdev->subsystem_device == 0x826d)) {
299 if ((*connector_type == DRM_MODE_CONNECTOR_HDMIA) &&
300 (supported_device == ATOM_DEVICE_DFP3_SUPPORT))
301 *connector_type = DRM_MODE_CONNECTOR_DVID;
302 }
303
304 /* Asrock RS600 board lists the DVI port as HDMI */
305 if ((dev->pdev->device == 0x7941) &&
306 (dev->pdev->subsystem_vendor == 0x1849) &&
307 (dev->pdev->subsystem_device == 0x7941)) {
308 if ((*connector_type == DRM_MODE_CONNECTOR_HDMIA) &&
309 (supported_device == ATOM_DEVICE_DFP3_SUPPORT))
310 *connector_type = DRM_MODE_CONNECTOR_DVID;
311 }
312
313 /* MSI K9A2GM V2/V3 board has no HDMI or DVI */
314 if ((dev->pdev->device == 0x796e) &&
315 (dev->pdev->subsystem_vendor == 0x1462) &&
316 (dev->pdev->subsystem_device == 0x7302)) {
317 if ((supported_device == ATOM_DEVICE_DFP2_SUPPORT) ||
318 (supported_device == ATOM_DEVICE_DFP3_SUPPORT))
319 return false;
320 }
321
322 /* a-bit f-i90hd - ciaranm on #radeonhd - this board has no DVI */
323 if ((dev->pdev->device == 0x7941) &&
324 (dev->pdev->subsystem_vendor == 0x147b) &&
325 (dev->pdev->subsystem_device == 0x2412)) {
326 if (*connector_type == DRM_MODE_CONNECTOR_DVII)
327 return false;
328 }
329
330 /* Falcon NW laptop lists vga ddc line for LVDS */
331 if ((dev->pdev->device == 0x5653) &&
332 (dev->pdev->subsystem_vendor == 0x1462) &&
333 (dev->pdev->subsystem_device == 0x0291)) {
334 if (*connector_type == DRM_MODE_CONNECTOR_LVDS) {
335 i2c_bus->valid = false;
336 *line_mux = 53;
337 }
338 }
339
340 /* HIS X1300 is DVI+VGA, not DVI+DVI */
341 if ((dev->pdev->device == 0x7146) &&
342 (dev->pdev->subsystem_vendor == 0x17af) &&
343 (dev->pdev->subsystem_device == 0x2058)) {
344 if (supported_device == ATOM_DEVICE_DFP1_SUPPORT)
345 return false;
346 }
347
348 /* Gigabyte X1300 is DVI+VGA, not DVI+DVI */
349 if ((dev->pdev->device == 0x7142) &&
350 (dev->pdev->subsystem_vendor == 0x1458) &&
351 (dev->pdev->subsystem_device == 0x2134)) {
352 if (supported_device == ATOM_DEVICE_DFP1_SUPPORT)
353 return false;
354 }
355
356
357 /* Funky macbooks */
358 if ((dev->pdev->device == 0x71C5) &&
359 (dev->pdev->subsystem_vendor == 0x106b) &&
360 (dev->pdev->subsystem_device == 0x0080)) {
361 if ((supported_device == ATOM_DEVICE_CRT1_SUPPORT) ||
362 (supported_device == ATOM_DEVICE_DFP2_SUPPORT))
363 return false;
364 if (supported_device == ATOM_DEVICE_CRT2_SUPPORT)
365 *line_mux = 0x90;
366 }
367
368 /* mac rv630, rv730, others */
369 if ((supported_device == ATOM_DEVICE_TV1_SUPPORT) &&
370 (*connector_type == DRM_MODE_CONNECTOR_DVII)) {
371 *connector_type = DRM_MODE_CONNECTOR_9PinDIN;
372 *line_mux = CONNECTOR_7PIN_DIN_ENUM_ID1;
373 }
374
375 /* ASUS HD 3600 XT board lists the DVI port as HDMI */
376 if ((dev->pdev->device == 0x9598) &&
377 (dev->pdev->subsystem_vendor == 0x1043) &&
378 (dev->pdev->subsystem_device == 0x01da)) {
379 if (*connector_type == DRM_MODE_CONNECTOR_HDMIA) {
380 *connector_type = DRM_MODE_CONNECTOR_DVII;
381 }
382 }
383
384 /* ASUS HD 3600 board lists the DVI port as HDMI */
385 if ((dev->pdev->device == 0x9598) &&
386 (dev->pdev->subsystem_vendor == 0x1043) &&
387 (dev->pdev->subsystem_device == 0x01e4)) {
388 if (*connector_type == DRM_MODE_CONNECTOR_HDMIA) {
389 *connector_type = DRM_MODE_CONNECTOR_DVII;
390 }
391 }
392
393 /* ASUS HD 3450 board lists the DVI port as HDMI */
394 if ((dev->pdev->device == 0x95C5) &&
395 (dev->pdev->subsystem_vendor == 0x1043) &&
396 (dev->pdev->subsystem_device == 0x01e2)) {
397 if (*connector_type == DRM_MODE_CONNECTOR_HDMIA) {
398 *connector_type = DRM_MODE_CONNECTOR_DVII;
399 }
400 }
401
402 /* some BIOSes seem to report DAC on HDMI - usually this is a board with
403 * HDMI + VGA reporting as HDMI
404 */
405 if (*connector_type == DRM_MODE_CONNECTOR_HDMIA) {
406 if (supported_device & (ATOM_DEVICE_CRT_SUPPORT)) {
407 *connector_type = DRM_MODE_CONNECTOR_VGA;
408 *line_mux = 0;
409 }
410 }
411
412 /* Acer laptop (Acer TravelMate 5730/5730G) has an HDMI port
413 * on the laptop and a DVI port on the docking station and
414 * both share the same encoder, hpd pin, and ddc line.
415 * So while the bios table is technically correct,
416 * we drop the DVI port here since xrandr has no concept of
417 * encoders and will try and drive both connectors
418 * with different crtcs which isn't possible on the hardware
419 * side and leaves no crtcs for LVDS or VGA.
420 */
421 if (((dev->pdev->device == 0x95c4) || (dev->pdev->device == 0x9591)) &&
422 (dev->pdev->subsystem_vendor == 0x1025) &&
423 (dev->pdev->subsystem_device == 0x013c)) {
424 if ((*connector_type == DRM_MODE_CONNECTOR_DVII) &&
425 (supported_device == ATOM_DEVICE_DFP1_SUPPORT)) {
426 /* actually it's a DVI-D port not DVI-I */
427 *connector_type = DRM_MODE_CONNECTOR_DVID;
428 return false;
429 }
430 }
431
432 /* XFX Pine Group device rv730 reports no VGA DDC lines
433 * even though they are wired up to record 0x93
434 */
435 if ((dev->pdev->device == 0x9498) &&
436 (dev->pdev->subsystem_vendor == 0x1682) &&
437 (dev->pdev->subsystem_device == 0x2452) &&
438 (i2c_bus->valid == false) &&
439 !(supported_device & (ATOM_DEVICE_TV_SUPPORT | ATOM_DEVICE_CV_SUPPORT))) {
440 struct radeon_device *rdev = dev->dev_private;
441 *i2c_bus = radeon_lookup_i2c_gpio(rdev, 0x93);
442 }
443
444 /* Fujitsu D3003-S2 board lists DVI-I as DVI-D and VGA */
445 if (((dev->pdev->device == 0x9802) ||
446 (dev->pdev->device == 0x9805) ||
447 (dev->pdev->device == 0x9806)) &&
448 (dev->pdev->subsystem_vendor == 0x1734) &&
449 (dev->pdev->subsystem_device == 0x11bd)) {
450 if (*connector_type == DRM_MODE_CONNECTOR_VGA) {
451 *connector_type = DRM_MODE_CONNECTOR_DVII;
452 *line_mux = 0x3103;
453 } else if (*connector_type == DRM_MODE_CONNECTOR_DVID) {
454 *connector_type = DRM_MODE_CONNECTOR_DVII;
455 }
456 }
457
458 return true;
459}
460
461static const int supported_devices_connector_convert[] = {
462 DRM_MODE_CONNECTOR_Unknown,
463 DRM_MODE_CONNECTOR_VGA,
464 DRM_MODE_CONNECTOR_DVII,
465 DRM_MODE_CONNECTOR_DVID,
466 DRM_MODE_CONNECTOR_DVIA,
467 DRM_MODE_CONNECTOR_SVIDEO,
468 DRM_MODE_CONNECTOR_Composite,
469 DRM_MODE_CONNECTOR_LVDS,
470 DRM_MODE_CONNECTOR_Unknown,
471 DRM_MODE_CONNECTOR_Unknown,
472 DRM_MODE_CONNECTOR_HDMIA,
473 DRM_MODE_CONNECTOR_HDMIB,
474 DRM_MODE_CONNECTOR_Unknown,
475 DRM_MODE_CONNECTOR_Unknown,
476 DRM_MODE_CONNECTOR_9PinDIN,
477 DRM_MODE_CONNECTOR_DisplayPort
478};
479
480static const uint16_t supported_devices_connector_object_id_convert[] = {
481 CONNECTOR_OBJECT_ID_NONE,
482 CONNECTOR_OBJECT_ID_VGA,
483 CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I, /* not all boards support DL */
484 CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D, /* not all boards support DL */
485 CONNECTOR_OBJECT_ID_VGA, /* technically DVI-A */
486 CONNECTOR_OBJECT_ID_COMPOSITE,
487 CONNECTOR_OBJECT_ID_SVIDEO,
488 CONNECTOR_OBJECT_ID_LVDS,
489 CONNECTOR_OBJECT_ID_9PIN_DIN,
490 CONNECTOR_OBJECT_ID_9PIN_DIN,
491 CONNECTOR_OBJECT_ID_DISPLAYPORT,
492 CONNECTOR_OBJECT_ID_HDMI_TYPE_A,
493 CONNECTOR_OBJECT_ID_HDMI_TYPE_B,
494 CONNECTOR_OBJECT_ID_SVIDEO
495};
496
497static const int object_connector_convert[] = {
498 DRM_MODE_CONNECTOR_Unknown,
499 DRM_MODE_CONNECTOR_DVII,
500 DRM_MODE_CONNECTOR_DVII,
501 DRM_MODE_CONNECTOR_DVID,
502 DRM_MODE_CONNECTOR_DVID,
503 DRM_MODE_CONNECTOR_VGA,
504 DRM_MODE_CONNECTOR_Composite,
505 DRM_MODE_CONNECTOR_SVIDEO,
506 DRM_MODE_CONNECTOR_Unknown,
507 DRM_MODE_CONNECTOR_Unknown,
508 DRM_MODE_CONNECTOR_9PinDIN,
509 DRM_MODE_CONNECTOR_Unknown,
510 DRM_MODE_CONNECTOR_HDMIA,
511 DRM_MODE_CONNECTOR_HDMIB,
512 DRM_MODE_CONNECTOR_LVDS,
513 DRM_MODE_CONNECTOR_9PinDIN,
514 DRM_MODE_CONNECTOR_Unknown,
515 DRM_MODE_CONNECTOR_Unknown,
516 DRM_MODE_CONNECTOR_Unknown,
517 DRM_MODE_CONNECTOR_DisplayPort,
518 DRM_MODE_CONNECTOR_eDP,
519 DRM_MODE_CONNECTOR_Unknown
520};
521
522bool radeon_get_atom_connector_info_from_object_table(struct drm_device *dev)
523{
524 struct radeon_device *rdev = dev->dev_private;
525 struct radeon_mode_info *mode_info = &rdev->mode_info;
526 struct atom_context *ctx = mode_info->atom_context;
527 int index = GetIndexIntoMasterTable(DATA, Object_Header);
528 u16 size, data_offset;
529 u8 frev, crev;
530 ATOM_CONNECTOR_OBJECT_TABLE *con_obj;
531 ATOM_ENCODER_OBJECT_TABLE *enc_obj;
532 ATOM_OBJECT_TABLE *router_obj;
533 ATOM_DISPLAY_OBJECT_PATH_TABLE *path_obj;
534 ATOM_OBJECT_HEADER *obj_header;
535 int i, j, k, path_size, device_support;
536 int connector_type;
537 u16 igp_lane_info, conn_id, connector_object_id;
538 struct radeon_i2c_bus_rec ddc_bus;
539 struct radeon_router router;
540 struct radeon_gpio_rec gpio;
541 struct radeon_hpd hpd;
542
543 if (!atom_parse_data_header(ctx, index, &size, &frev, &crev, &data_offset))
544 return false;
545
546 if (crev < 2)
547 return false;
548
549 obj_header = (ATOM_OBJECT_HEADER *) (ctx->bios + data_offset);
550 path_obj = (ATOM_DISPLAY_OBJECT_PATH_TABLE *)
551 (ctx->bios + data_offset +
552 le16_to_cpu(obj_header->usDisplayPathTableOffset));
553 con_obj = (ATOM_CONNECTOR_OBJECT_TABLE *)
554 (ctx->bios + data_offset +
555 le16_to_cpu(obj_header->usConnectorObjectTableOffset));
556 enc_obj = (ATOM_ENCODER_OBJECT_TABLE *)
557 (ctx->bios + data_offset +
558 le16_to_cpu(obj_header->usEncoderObjectTableOffset));
559 router_obj = (ATOM_OBJECT_TABLE *)
560 (ctx->bios + data_offset +
561 le16_to_cpu(obj_header->usRouterObjectTableOffset));
562 device_support = le16_to_cpu(obj_header->usDeviceSupport);
563
564 path_size = 0;
565 for (i = 0; i < path_obj->ucNumOfDispPath; i++) {
566 uint8_t *addr = (uint8_t *) path_obj->asDispPath;
567 ATOM_DISPLAY_OBJECT_PATH *path;
568 addr += path_size;
569 path = (ATOM_DISPLAY_OBJECT_PATH *) addr;
570 path_size += le16_to_cpu(path->usSize);
571
572 if (device_support & le16_to_cpu(path->usDeviceTag)) {
573 uint8_t con_obj_id, con_obj_num;
574
575 con_obj_id =
576 (le16_to_cpu(path->usConnObjectId) & OBJECT_ID_MASK)
577 >> OBJECT_ID_SHIFT;
578 con_obj_num =
579 (le16_to_cpu(path->usConnObjectId) & ENUM_ID_MASK)
580 >> ENUM_ID_SHIFT;
581
582 /* TODO CV support */
583 if (le16_to_cpu(path->usDeviceTag) ==
584 ATOM_DEVICE_CV_SUPPORT)
585 continue;
586
587 /* IGP chips */
588 if ((rdev->flags & RADEON_IS_IGP) &&
589 (con_obj_id ==
590 CONNECTOR_OBJECT_ID_PCIE_CONNECTOR)) {
591 uint16_t igp_offset = 0;
592 ATOM_INTEGRATED_SYSTEM_INFO_V2 *igp_obj;
593
594 index =
595 GetIndexIntoMasterTable(DATA,
596 IntegratedSystemInfo);
597
598 if (atom_parse_data_header(ctx, index, &size, &frev,
599 &crev, &igp_offset)) {
600
601 if (crev >= 2) {
602 igp_obj =
603 (ATOM_INTEGRATED_SYSTEM_INFO_V2
604 *) (ctx->bios + igp_offset);
605
606 if (igp_obj) {
607 uint32_t slot_config, ct;
608
609 if (con_obj_num == 1)
610 slot_config =
611 igp_obj->
612 ulDDISlot1Config;
613 else
614 slot_config =
615 igp_obj->
616 ulDDISlot2Config;
617
618 ct = (slot_config >> 16) & 0xff;
619 connector_type =
620 object_connector_convert
621 [ct];
622 connector_object_id = ct;
623 igp_lane_info =
624 slot_config & 0xffff;
625 } else
626 continue;
627 } else
628 continue;
629 } else {
630 igp_lane_info = 0;
631 connector_type =
632 object_connector_convert[con_obj_id];
633 connector_object_id = con_obj_id;
634 }
635 } else {
636 igp_lane_info = 0;
637 connector_type =
638 object_connector_convert[con_obj_id];
639 connector_object_id = con_obj_id;
640 }
641
642 if (connector_type == DRM_MODE_CONNECTOR_Unknown)
643 continue;
644
645 router.ddc_valid = false;
646 router.cd_valid = false;
647 for (j = 0; j < ((le16_to_cpu(path->usSize) - 8) / 2); j++) {
648 uint8_t grph_obj_type =
649 (le16_to_cpu(path->usGraphicObjIds[j]) &
650 OBJECT_TYPE_MASK) >> OBJECT_TYPE_SHIFT;
651
652 if (grph_obj_type == GRAPH_OBJECT_TYPE_ENCODER) {
653 for (k = 0; k < enc_obj->ucNumberOfObjects; k++) {
654 u16 encoder_obj = le16_to_cpu(enc_obj->asObjects[k].usObjectID);
655 if (le16_to_cpu(path->usGraphicObjIds[j]) == encoder_obj) {
656 ATOM_COMMON_RECORD_HEADER *record = (ATOM_COMMON_RECORD_HEADER *)
657 (ctx->bios + data_offset +
658 le16_to_cpu(enc_obj->asObjects[k].usRecordOffset));
659 ATOM_ENCODER_CAP_RECORD *cap_record;
660 u16 caps = 0;
661
662 while (record->ucRecordSize > 0 &&
663 record->ucRecordType > 0 &&
664 record->ucRecordType <= ATOM_MAX_OBJECT_RECORD_NUMBER) {
665 switch (record->ucRecordType) {
666 case ATOM_ENCODER_CAP_RECORD_TYPE:
667 cap_record =(ATOM_ENCODER_CAP_RECORD *)
668 record;
669 caps = le16_to_cpu(cap_record->usEncoderCap);
670 break;
671 }
672 record = (ATOM_COMMON_RECORD_HEADER *)
673 ((char *)record + record->ucRecordSize);
674 }
675 radeon_add_atom_encoder(dev,
676 encoder_obj,
677 le16_to_cpu
678 (path->
679 usDeviceTag),
680 caps);
681 }
682 }
683 } else if (grph_obj_type == GRAPH_OBJECT_TYPE_ROUTER) {
684 for (k = 0; k < router_obj->ucNumberOfObjects; k++) {
685 u16 router_obj_id = le16_to_cpu(router_obj->asObjects[k].usObjectID);
686 if (le16_to_cpu(path->usGraphicObjIds[j]) == router_obj_id) {
687 ATOM_COMMON_RECORD_HEADER *record = (ATOM_COMMON_RECORD_HEADER *)
688 (ctx->bios + data_offset +
689 le16_to_cpu(router_obj->asObjects[k].usRecordOffset));
690 ATOM_I2C_RECORD *i2c_record;
691 ATOM_I2C_ID_CONFIG_ACCESS *i2c_config;
692 ATOM_ROUTER_DDC_PATH_SELECT_RECORD *ddc_path;
693 ATOM_ROUTER_DATA_CLOCK_PATH_SELECT_RECORD *cd_path;
694 ATOM_SRC_DST_TABLE_FOR_ONE_OBJECT *router_src_dst_table =
695 (ATOM_SRC_DST_TABLE_FOR_ONE_OBJECT *)
696 (ctx->bios + data_offset +
697 le16_to_cpu(router_obj->asObjects[k].usSrcDstTableOffset));
698 u8 *num_dst_objs = (u8 *)
699 ((u8 *)router_src_dst_table + 1 +
700 (router_src_dst_table->ucNumberOfSrc * 2));
701 u16 *dst_objs = (u16 *)(num_dst_objs + 1);
702 int enum_id;
703
704 router.router_id = router_obj_id;
705 for (enum_id = 0; enum_id < (*num_dst_objs); enum_id++) {
706 if (le16_to_cpu(path->usConnObjectId) ==
707 le16_to_cpu(dst_objs[enum_id]))
708 break;
709 }
710
711 while (record->ucRecordSize > 0 &&
712 record->ucRecordType > 0 &&
713 record->ucRecordType <= ATOM_MAX_OBJECT_RECORD_NUMBER) {
714 switch (record->ucRecordType) {
715 case ATOM_I2C_RECORD_TYPE:
716 i2c_record =
717 (ATOM_I2C_RECORD *)
718 record;
719 i2c_config =
720 (ATOM_I2C_ID_CONFIG_ACCESS *)
721 &i2c_record->sucI2cId;
722 router.i2c_info =
723 radeon_lookup_i2c_gpio(rdev,
724 i2c_config->
725 ucAccess);
726 router.i2c_addr = i2c_record->ucI2CAddr >> 1;
727 break;
728 case ATOM_ROUTER_DDC_PATH_SELECT_RECORD_TYPE:
729 ddc_path = (ATOM_ROUTER_DDC_PATH_SELECT_RECORD *)
730 record;
731 router.ddc_valid = true;
732 router.ddc_mux_type = ddc_path->ucMuxType;
733 router.ddc_mux_control_pin = ddc_path->ucMuxControlPin;
734 router.ddc_mux_state = ddc_path->ucMuxState[enum_id];
735 break;
736 case ATOM_ROUTER_DATA_CLOCK_PATH_SELECT_RECORD_TYPE:
737 cd_path = (ATOM_ROUTER_DATA_CLOCK_PATH_SELECT_RECORD *)
738 record;
739 router.cd_valid = true;
740 router.cd_mux_type = cd_path->ucMuxType;
741 router.cd_mux_control_pin = cd_path->ucMuxControlPin;
742 router.cd_mux_state = cd_path->ucMuxState[enum_id];
743 break;
744 }
745 record = (ATOM_COMMON_RECORD_HEADER *)
746 ((char *)record + record->ucRecordSize);
747 }
748 }
749 }
750 }
751 }
752
753 /* look up gpio for ddc, hpd */
754 ddc_bus.valid = false;
755 hpd.hpd = RADEON_HPD_NONE;
756 if ((le16_to_cpu(path->usDeviceTag) &
757 (ATOM_DEVICE_TV_SUPPORT | ATOM_DEVICE_CV_SUPPORT)) == 0) {
758 for (j = 0; j < con_obj->ucNumberOfObjects; j++) {
759 if (le16_to_cpu(path->usConnObjectId) ==
760 le16_to_cpu(con_obj->asObjects[j].
761 usObjectID)) {
762 ATOM_COMMON_RECORD_HEADER
763 *record =
764 (ATOM_COMMON_RECORD_HEADER
765 *)
766 (ctx->bios + data_offset +
767 le16_to_cpu(con_obj->
768 asObjects[j].
769 usRecordOffset));
770 ATOM_I2C_RECORD *i2c_record;
771 ATOM_HPD_INT_RECORD *hpd_record;
772 ATOM_I2C_ID_CONFIG_ACCESS *i2c_config;
773
774 while (record->ucRecordSize > 0 &&
775 record->ucRecordType > 0 &&
776 record->ucRecordType <= ATOM_MAX_OBJECT_RECORD_NUMBER) {
777 switch (record->ucRecordType) {
778 case ATOM_I2C_RECORD_TYPE:
779 i2c_record =
780 (ATOM_I2C_RECORD *)
781 record;
782 i2c_config =
783 (ATOM_I2C_ID_CONFIG_ACCESS *)
784 &i2c_record->sucI2cId;
785 ddc_bus = radeon_lookup_i2c_gpio(rdev,
786 i2c_config->
787 ucAccess);
788 break;
789 case ATOM_HPD_INT_RECORD_TYPE:
790 hpd_record =
791 (ATOM_HPD_INT_RECORD *)
792 record;
793 gpio = radeon_atombios_lookup_gpio(rdev,
794 hpd_record->ucHPDIntGPIOID);
795 hpd = radeon_atom_get_hpd_info_from_gpio(rdev, &gpio);
796 hpd.plugged_state = hpd_record->ucPlugged_PinState;
797 break;
798 }
799 record =
800 (ATOM_COMMON_RECORD_HEADER
801 *) ((char *)record
802 +
803 record->
804 ucRecordSize);
805 }
806 break;
807 }
808 }
809 }
810
811 /* needed for aux chan transactions */
812 ddc_bus.hpd = hpd.hpd;
813
814 conn_id = le16_to_cpu(path->usConnObjectId);
815
816 if (!radeon_atom_apply_quirks
817 (dev, le16_to_cpu(path->usDeviceTag), &connector_type,
818 &ddc_bus, &conn_id, &hpd))
819 continue;
820
821 radeon_add_atom_connector(dev,
822 conn_id,
823 le16_to_cpu(path->
824 usDeviceTag),
825 connector_type, &ddc_bus,
826 igp_lane_info,
827 connector_object_id,
828 &hpd,
829 &router);
830
831 }
832 }
833
834 radeon_link_encoder_connector(dev);
835
836 radeon_setup_mst_connector(dev);
837 return true;
838}
839
840static uint16_t atombios_get_connector_object_id(struct drm_device *dev,
841 int connector_type,
842 uint16_t devices)
843{
844 struct radeon_device *rdev = dev->dev_private;
845
846 if (rdev->flags & RADEON_IS_IGP) {
847 return supported_devices_connector_object_id_convert
848 [connector_type];
849 } else if (((connector_type == DRM_MODE_CONNECTOR_DVII) ||
850 (connector_type == DRM_MODE_CONNECTOR_DVID)) &&
851 (devices & ATOM_DEVICE_DFP2_SUPPORT)) {
852 struct radeon_mode_info *mode_info = &rdev->mode_info;
853 struct atom_context *ctx = mode_info->atom_context;
854 int index = GetIndexIntoMasterTable(DATA, XTMDS_Info);
855 uint16_t size, data_offset;
856 uint8_t frev, crev;
857 ATOM_XTMDS_INFO *xtmds;
858
859 if (atom_parse_data_header(ctx, index, &size, &frev, &crev, &data_offset)) {
860 xtmds = (ATOM_XTMDS_INFO *)(ctx->bios + data_offset);
861
862 if (xtmds->ucSupportedLink & ATOM_XTMDS_SUPPORTED_DUALLINK) {
863 if (connector_type == DRM_MODE_CONNECTOR_DVII)
864 return CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_I;
865 else
866 return CONNECTOR_OBJECT_ID_DUAL_LINK_DVI_D;
867 } else {
868 if (connector_type == DRM_MODE_CONNECTOR_DVII)
869 return CONNECTOR_OBJECT_ID_SINGLE_LINK_DVI_I;
870 else
871 return CONNECTOR_OBJECT_ID_SINGLE_LINK_DVI_D;
872 }
873 } else
874 return supported_devices_connector_object_id_convert
875 [connector_type];
876 } else {
877 return supported_devices_connector_object_id_convert
878 [connector_type];
879 }
880}
881
882struct bios_connector {
883 bool valid;
884 uint16_t line_mux;
885 uint16_t devices;
886 int connector_type;
887 struct radeon_i2c_bus_rec ddc_bus;
888 struct radeon_hpd hpd;
889};
890
891bool radeon_get_atom_connector_info_from_supported_devices_table(struct
892 drm_device
893 *dev)
894{
895 struct radeon_device *rdev = dev->dev_private;
896 struct radeon_mode_info *mode_info = &rdev->mode_info;
897 struct atom_context *ctx = mode_info->atom_context;
898 int index = GetIndexIntoMasterTable(DATA, SupportedDevicesInfo);
899 uint16_t size, data_offset;
900 uint8_t frev, crev;
901 uint16_t device_support;
902 uint8_t dac;
903 union atom_supported_devices *supported_devices;
904 int i, j, max_device;
905 struct bios_connector *bios_connectors;
906 size_t bc_size = sizeof(*bios_connectors) * ATOM_MAX_SUPPORTED_DEVICE;
907 struct radeon_router router;
908
909 router.ddc_valid = false;
910 router.cd_valid = false;
911
912 bios_connectors = kzalloc(bc_size, GFP_KERNEL);
913 if (!bios_connectors)
914 return false;
915
916 if (!atom_parse_data_header(ctx, index, &size, &frev, &crev,
917 &data_offset)) {
918 kfree(bios_connectors);
919 return false;
920 }
921
922 supported_devices =
923 (union atom_supported_devices *)(ctx->bios + data_offset);
924
925 device_support = le16_to_cpu(supported_devices->info.usDeviceSupport);
926
927 if (frev > 1)
928 max_device = ATOM_MAX_SUPPORTED_DEVICE;
929 else
930 max_device = ATOM_MAX_SUPPORTED_DEVICE_INFO;
931
932 for (i = 0; i < max_device; i++) {
933 ATOM_CONNECTOR_INFO_I2C ci =
934 supported_devices->info.asConnInfo[i];
935
936 bios_connectors[i].valid = false;
937
938 if (!(device_support & (1 << i))) {
939 continue;
940 }
941
942 if (i == ATOM_DEVICE_CV_INDEX) {
943 DRM_DEBUG_KMS("Skipping Component Video\n");
944 continue;
945 }
946
947 bios_connectors[i].connector_type =
948 supported_devices_connector_convert[ci.sucConnectorInfo.
949 sbfAccess.
950 bfConnectorType];
951
952 if (bios_connectors[i].connector_type ==
953 DRM_MODE_CONNECTOR_Unknown)
954 continue;
955
956 dac = ci.sucConnectorInfo.sbfAccess.bfAssociatedDAC;
957
958 bios_connectors[i].line_mux =
959 ci.sucI2cId.ucAccess;
960
961 /* give tv unique connector ids */
962 if (i == ATOM_DEVICE_TV1_INDEX) {
963 bios_connectors[i].ddc_bus.valid = false;
964 bios_connectors[i].line_mux = 50;
965 } else if (i == ATOM_DEVICE_TV2_INDEX) {
966 bios_connectors[i].ddc_bus.valid = false;
967 bios_connectors[i].line_mux = 51;
968 } else if (i == ATOM_DEVICE_CV_INDEX) {
969 bios_connectors[i].ddc_bus.valid = false;
970 bios_connectors[i].line_mux = 52;
971 } else
972 bios_connectors[i].ddc_bus =
973 radeon_lookup_i2c_gpio(rdev,
974 bios_connectors[i].line_mux);
975
976 if ((crev > 1) && (frev > 1)) {
977 u8 isb = supported_devices->info_2d1.asIntSrcInfo[i].ucIntSrcBitmap;
978 switch (isb) {
979 case 0x4:
980 bios_connectors[i].hpd.hpd = RADEON_HPD_1;
981 break;
982 case 0xa:
983 bios_connectors[i].hpd.hpd = RADEON_HPD_2;
984 break;
985 default:
986 bios_connectors[i].hpd.hpd = RADEON_HPD_NONE;
987 break;
988 }
989 } else {
990 if (i == ATOM_DEVICE_DFP1_INDEX)
991 bios_connectors[i].hpd.hpd = RADEON_HPD_1;
992 else if (i == ATOM_DEVICE_DFP2_INDEX)
993 bios_connectors[i].hpd.hpd = RADEON_HPD_2;
994 else
995 bios_connectors[i].hpd.hpd = RADEON_HPD_NONE;
996 }
997
998 /* Always set the connector type to VGA for CRT1/CRT2. if they are
999 * shared with a DVI port, we'll pick up the DVI connector when we
1000 * merge the outputs. Some bioses incorrectly list VGA ports as DVI.
1001 */
1002 if (i == ATOM_DEVICE_CRT1_INDEX || i == ATOM_DEVICE_CRT2_INDEX)
1003 bios_connectors[i].connector_type =
1004 DRM_MODE_CONNECTOR_VGA;
1005
1006 if (!radeon_atom_apply_quirks
1007 (dev, (1 << i), &bios_connectors[i].connector_type,
1008 &bios_connectors[i].ddc_bus, &bios_connectors[i].line_mux,
1009 &bios_connectors[i].hpd))
1010 continue;
1011
1012 bios_connectors[i].valid = true;
1013 bios_connectors[i].devices = (1 << i);
1014
1015 if (ASIC_IS_AVIVO(rdev) || radeon_r4xx_atom)
1016 radeon_add_atom_encoder(dev,
1017 radeon_get_encoder_enum(dev,
1018 (1 << i),
1019 dac),
1020 (1 << i),
1021 0);
1022 else
1023 radeon_add_legacy_encoder(dev,
1024 radeon_get_encoder_enum(dev,
1025 (1 << i),
1026 dac),
1027 (1 << i));
1028 }
1029
1030 /* combine shared connectors */
1031 for (i = 0; i < max_device; i++) {
1032 if (bios_connectors[i].valid) {
1033 for (j = 0; j < max_device; j++) {
1034 if (bios_connectors[j].valid && (i != j)) {
1035 if (bios_connectors[i].line_mux ==
1036 bios_connectors[j].line_mux) {
1037 /* make sure not to combine LVDS */
1038 if (bios_connectors[i].devices & (ATOM_DEVICE_LCD_SUPPORT)) {
1039 bios_connectors[i].line_mux = 53;
1040 bios_connectors[i].ddc_bus.valid = false;
1041 continue;
1042 }
1043 if (bios_connectors[j].devices & (ATOM_DEVICE_LCD_SUPPORT)) {
1044 bios_connectors[j].line_mux = 53;
1045 bios_connectors[j].ddc_bus.valid = false;
1046 continue;
1047 }
1048 /* combine analog and digital for DVI-I */
1049 if (((bios_connectors[i].devices & (ATOM_DEVICE_DFP_SUPPORT)) &&
1050 (bios_connectors[j].devices & (ATOM_DEVICE_CRT_SUPPORT))) ||
1051 ((bios_connectors[j].devices & (ATOM_DEVICE_DFP_SUPPORT)) &&
1052 (bios_connectors[i].devices & (ATOM_DEVICE_CRT_SUPPORT)))) {
1053 bios_connectors[i].devices |=
1054 bios_connectors[j].devices;
1055 bios_connectors[i].connector_type =
1056 DRM_MODE_CONNECTOR_DVII;
1057 if (bios_connectors[j].devices & (ATOM_DEVICE_DFP_SUPPORT))
1058 bios_connectors[i].hpd =
1059 bios_connectors[j].hpd;
1060 bios_connectors[j].valid = false;
1061 }
1062 }
1063 }
1064 }
1065 }
1066 }
1067
1068 /* add the connectors */
1069 for (i = 0; i < max_device; i++) {
1070 if (bios_connectors[i].valid) {
1071 uint16_t connector_object_id =
1072 atombios_get_connector_object_id(dev,
1073 bios_connectors[i].connector_type,
1074 bios_connectors[i].devices);
1075 radeon_add_atom_connector(dev,
1076 bios_connectors[i].line_mux,
1077 bios_connectors[i].devices,
1078 bios_connectors[i].
1079 connector_type,
1080 &bios_connectors[i].ddc_bus,
1081 0,
1082 connector_object_id,
1083 &bios_connectors[i].hpd,
1084 &router);
1085 }
1086 }
1087
1088 radeon_link_encoder_connector(dev);
1089
1090 kfree(bios_connectors);
1091 return true;
1092}
1093
1094union firmware_info {
1095 ATOM_FIRMWARE_INFO info;
1096 ATOM_FIRMWARE_INFO_V1_2 info_12;
1097 ATOM_FIRMWARE_INFO_V1_3 info_13;
1098 ATOM_FIRMWARE_INFO_V1_4 info_14;
1099 ATOM_FIRMWARE_INFO_V2_1 info_21;
1100 ATOM_FIRMWARE_INFO_V2_2 info_22;
1101};
1102
1103union igp_info {
1104 struct _ATOM_INTEGRATED_SYSTEM_INFO info;
1105 struct _ATOM_INTEGRATED_SYSTEM_INFO_V2 info_2;
1106 struct _ATOM_INTEGRATED_SYSTEM_INFO_V6 info_6;
1107 struct _ATOM_INTEGRATED_SYSTEM_INFO_V1_7 info_7;
1108 struct _ATOM_INTEGRATED_SYSTEM_INFO_V1_8 info_8;
1109};
1110
1111static void radeon_atombios_get_dentist_vco_freq(struct radeon_device *rdev)
1112{
1113 struct radeon_mode_info *mode_info = &rdev->mode_info;
1114 int index = GetIndexIntoMasterTable(DATA, IntegratedSystemInfo);
1115 union igp_info *igp_info;
1116 u8 frev, crev;
1117 u16 data_offset;
1118
1119 if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1120 &frev, &crev, &data_offset)) {
1121 igp_info = (union igp_info *)(mode_info->atom_context->bios +
1122 data_offset);
1123 rdev->clock.vco_freq =
1124 le32_to_cpu(igp_info->info_6.ulDentistVCOFreq);
1125 }
1126}
1127
1128bool radeon_atom_get_clock_info(struct drm_device *dev)
1129{
1130 struct radeon_device *rdev = dev->dev_private;
1131 struct radeon_mode_info *mode_info = &rdev->mode_info;
1132 int index = GetIndexIntoMasterTable(DATA, FirmwareInfo);
1133 union firmware_info *firmware_info;
1134 uint8_t frev, crev;
1135 struct radeon_pll *p1pll = &rdev->clock.p1pll;
1136 struct radeon_pll *p2pll = &rdev->clock.p2pll;
1137 struct radeon_pll *dcpll = &rdev->clock.dcpll;
1138 struct radeon_pll *spll = &rdev->clock.spll;
1139 struct radeon_pll *mpll = &rdev->clock.mpll;
1140 uint16_t data_offset;
1141
1142 if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1143 &frev, &crev, &data_offset)) {
1144 firmware_info =
1145 (union firmware_info *)(mode_info->atom_context->bios +
1146 data_offset);
1147 /* pixel clocks */
1148 p1pll->reference_freq =
1149 le16_to_cpu(firmware_info->info.usReferenceClock);
1150 p1pll->reference_div = 0;
1151
1152 if ((frev < 2) && (crev < 2))
1153 p1pll->pll_out_min =
1154 le16_to_cpu(firmware_info->info.usMinPixelClockPLL_Output);
1155 else
1156 p1pll->pll_out_min =
1157 le32_to_cpu(firmware_info->info_12.ulMinPixelClockPLL_Output);
1158 p1pll->pll_out_max =
1159 le32_to_cpu(firmware_info->info.ulMaxPixelClockPLL_Output);
1160
1161 if (((frev < 2) && (crev >= 4)) || (frev >= 2)) {
1162 p1pll->lcd_pll_out_min =
1163 le16_to_cpu(firmware_info->info_14.usLcdMinPixelClockPLL_Output) * 100;
1164 if (p1pll->lcd_pll_out_min == 0)
1165 p1pll->lcd_pll_out_min = p1pll->pll_out_min;
1166 p1pll->lcd_pll_out_max =
1167 le16_to_cpu(firmware_info->info_14.usLcdMaxPixelClockPLL_Output) * 100;
1168 if (p1pll->lcd_pll_out_max == 0)
1169 p1pll->lcd_pll_out_max = p1pll->pll_out_max;
1170 } else {
1171 p1pll->lcd_pll_out_min = p1pll->pll_out_min;
1172 p1pll->lcd_pll_out_max = p1pll->pll_out_max;
1173 }
1174
1175 if (p1pll->pll_out_min == 0) {
1176 if (ASIC_IS_AVIVO(rdev))
1177 p1pll->pll_out_min = 64800;
1178 else
1179 p1pll->pll_out_min = 20000;
1180 }
1181
1182 p1pll->pll_in_min =
1183 le16_to_cpu(firmware_info->info.usMinPixelClockPLL_Input);
1184 p1pll->pll_in_max =
1185 le16_to_cpu(firmware_info->info.usMaxPixelClockPLL_Input);
1186
1187 *p2pll = *p1pll;
1188
1189 /* system clock */
1190 if (ASIC_IS_DCE4(rdev))
1191 spll->reference_freq =
1192 le16_to_cpu(firmware_info->info_21.usCoreReferenceClock);
1193 else
1194 spll->reference_freq =
1195 le16_to_cpu(firmware_info->info.usReferenceClock);
1196 spll->reference_div = 0;
1197
1198 spll->pll_out_min =
1199 le16_to_cpu(firmware_info->info.usMinEngineClockPLL_Output);
1200 spll->pll_out_max =
1201 le32_to_cpu(firmware_info->info.ulMaxEngineClockPLL_Output);
1202
1203 /* ??? */
1204 if (spll->pll_out_min == 0) {
1205 if (ASIC_IS_AVIVO(rdev))
1206 spll->pll_out_min = 64800;
1207 else
1208 spll->pll_out_min = 20000;
1209 }
1210
1211 spll->pll_in_min =
1212 le16_to_cpu(firmware_info->info.usMinEngineClockPLL_Input);
1213 spll->pll_in_max =
1214 le16_to_cpu(firmware_info->info.usMaxEngineClockPLL_Input);
1215
1216 /* memory clock */
1217 if (ASIC_IS_DCE4(rdev))
1218 mpll->reference_freq =
1219 le16_to_cpu(firmware_info->info_21.usMemoryReferenceClock);
1220 else
1221 mpll->reference_freq =
1222 le16_to_cpu(firmware_info->info.usReferenceClock);
1223 mpll->reference_div = 0;
1224
1225 mpll->pll_out_min =
1226 le16_to_cpu(firmware_info->info.usMinMemoryClockPLL_Output);
1227 mpll->pll_out_max =
1228 le32_to_cpu(firmware_info->info.ulMaxMemoryClockPLL_Output);
1229
1230 /* ??? */
1231 if (mpll->pll_out_min == 0) {
1232 if (ASIC_IS_AVIVO(rdev))
1233 mpll->pll_out_min = 64800;
1234 else
1235 mpll->pll_out_min = 20000;
1236 }
1237
1238 mpll->pll_in_min =
1239 le16_to_cpu(firmware_info->info.usMinMemoryClockPLL_Input);
1240 mpll->pll_in_max =
1241 le16_to_cpu(firmware_info->info.usMaxMemoryClockPLL_Input);
1242
1243 rdev->clock.default_sclk =
1244 le32_to_cpu(firmware_info->info.ulDefaultEngineClock);
1245 rdev->clock.default_mclk =
1246 le32_to_cpu(firmware_info->info.ulDefaultMemoryClock);
1247
1248 if (ASIC_IS_DCE4(rdev)) {
1249 rdev->clock.default_dispclk =
1250 le32_to_cpu(firmware_info->info_21.ulDefaultDispEngineClkFreq);
1251 if (rdev->clock.default_dispclk == 0) {
1252 if (ASIC_IS_DCE6(rdev))
1253 rdev->clock.default_dispclk = 60000; /* 600 Mhz */
1254 else if (ASIC_IS_DCE5(rdev))
1255 rdev->clock.default_dispclk = 54000; /* 540 Mhz */
1256 else
1257 rdev->clock.default_dispclk = 60000; /* 600 Mhz */
1258 }
1259 /* set a reasonable default for DP */
1260 if (ASIC_IS_DCE6(rdev) && (rdev->clock.default_dispclk < 53900)) {
1261 DRM_INFO("Changing default dispclk from %dMhz to 600Mhz\n",
1262 rdev->clock.default_dispclk / 100);
1263 rdev->clock.default_dispclk = 60000;
1264 }
1265 rdev->clock.dp_extclk =
1266 le16_to_cpu(firmware_info->info_21.usUniphyDPModeExtClkFreq);
1267 rdev->clock.current_dispclk = rdev->clock.default_dispclk;
1268 }
1269 *dcpll = *p1pll;
1270
1271 rdev->clock.max_pixel_clock = le16_to_cpu(firmware_info->info.usMaxPixelClock);
1272 if (rdev->clock.max_pixel_clock == 0)
1273 rdev->clock.max_pixel_clock = 40000;
1274
1275 /* not technically a clock, but... */
1276 rdev->mode_info.firmware_flags =
1277 le16_to_cpu(firmware_info->info.usFirmwareCapability.susAccess);
1278
1279 if (ASIC_IS_DCE8(rdev))
1280 rdev->clock.vco_freq =
1281 le32_to_cpu(firmware_info->info_22.ulGPUPLL_OutputFreq);
1282 else if (ASIC_IS_DCE5(rdev))
1283 rdev->clock.vco_freq = rdev->clock.current_dispclk;
1284 else if (ASIC_IS_DCE41(rdev))
1285 radeon_atombios_get_dentist_vco_freq(rdev);
1286 else
1287 rdev->clock.vco_freq = rdev->clock.current_dispclk;
1288
1289 if (rdev->clock.vco_freq == 0)
1290 rdev->clock.vco_freq = 360000; /* 3.6 GHz */
1291
1292 return true;
1293 }
1294
1295 return false;
1296}
1297
1298bool radeon_atombios_sideport_present(struct radeon_device *rdev)
1299{
1300 struct radeon_mode_info *mode_info = &rdev->mode_info;
1301 int index = GetIndexIntoMasterTable(DATA, IntegratedSystemInfo);
1302 union igp_info *igp_info;
1303 u8 frev, crev;
1304 u16 data_offset;
1305
1306 /* sideport is AMD only */
1307 if (rdev->family == CHIP_RS600)
1308 return false;
1309
1310 if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1311 &frev, &crev, &data_offset)) {
1312 igp_info = (union igp_info *)(mode_info->atom_context->bios +
1313 data_offset);
1314 switch (crev) {
1315 case 1:
1316 if (le32_to_cpu(igp_info->info.ulBootUpMemoryClock))
1317 return true;
1318 break;
1319 case 2:
1320 if (le32_to_cpu(igp_info->info_2.ulBootUpSidePortClock))
1321 return true;
1322 break;
1323 default:
1324 DRM_ERROR("Unsupported IGP table: %d %d\n", frev, crev);
1325 break;
1326 }
1327 }
1328 return false;
1329}
1330
1331bool radeon_atombios_get_tmds_info(struct radeon_encoder *encoder,
1332 struct radeon_encoder_int_tmds *tmds)
1333{
1334 struct drm_device *dev = encoder->base.dev;
1335 struct radeon_device *rdev = dev->dev_private;
1336 struct radeon_mode_info *mode_info = &rdev->mode_info;
1337 int index = GetIndexIntoMasterTable(DATA, TMDS_Info);
1338 uint16_t data_offset;
1339 struct _ATOM_TMDS_INFO *tmds_info;
1340 uint8_t frev, crev;
1341 uint16_t maxfreq;
1342 int i;
1343
1344 if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1345 &frev, &crev, &data_offset)) {
1346 tmds_info =
1347 (struct _ATOM_TMDS_INFO *)(mode_info->atom_context->bios +
1348 data_offset);
1349
1350 maxfreq = le16_to_cpu(tmds_info->usMaxFrequency);
1351 for (i = 0; i < 4; i++) {
1352 tmds->tmds_pll[i].freq =
1353 le16_to_cpu(tmds_info->asMiscInfo[i].usFrequency);
1354 tmds->tmds_pll[i].value =
1355 tmds_info->asMiscInfo[i].ucPLL_ChargePump & 0x3f;
1356 tmds->tmds_pll[i].value |=
1357 (tmds_info->asMiscInfo[i].
1358 ucPLL_VCO_Gain & 0x3f) << 6;
1359 tmds->tmds_pll[i].value |=
1360 (tmds_info->asMiscInfo[i].
1361 ucPLL_DutyCycle & 0xf) << 12;
1362 tmds->tmds_pll[i].value |=
1363 (tmds_info->asMiscInfo[i].
1364 ucPLL_VoltageSwing & 0xf) << 16;
1365
1366 DRM_DEBUG_KMS("TMDS PLL From ATOMBIOS %u %x\n",
1367 tmds->tmds_pll[i].freq,
1368 tmds->tmds_pll[i].value);
1369
1370 if (maxfreq == tmds->tmds_pll[i].freq) {
1371 tmds->tmds_pll[i].freq = 0xffffffff;
1372 break;
1373 }
1374 }
1375 return true;
1376 }
1377 return false;
1378}
1379
1380bool radeon_atombios_get_ppll_ss_info(struct radeon_device *rdev,
1381 struct radeon_atom_ss *ss,
1382 int id)
1383{
1384 struct radeon_mode_info *mode_info = &rdev->mode_info;
1385 int index = GetIndexIntoMasterTable(DATA, PPLL_SS_Info);
1386 uint16_t data_offset, size;
1387 struct _ATOM_SPREAD_SPECTRUM_INFO *ss_info;
1388 struct _ATOM_SPREAD_SPECTRUM_ASSIGNMENT *ss_assign;
1389 uint8_t frev, crev;
1390 int i, num_indices;
1391
1392 memset(ss, 0, sizeof(struct radeon_atom_ss));
1393 if (atom_parse_data_header(mode_info->atom_context, index, &size,
1394 &frev, &crev, &data_offset)) {
1395 ss_info =
1396 (struct _ATOM_SPREAD_SPECTRUM_INFO *)(mode_info->atom_context->bios + data_offset);
1397
1398 num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
1399 sizeof(ATOM_SPREAD_SPECTRUM_ASSIGNMENT);
1400 ss_assign = (struct _ATOM_SPREAD_SPECTRUM_ASSIGNMENT*)
1401 ((u8 *)&ss_info->asSS_Info[0]);
1402 for (i = 0; i < num_indices; i++) {
1403 if (ss_assign->ucSS_Id == id) {
1404 ss->percentage =
1405 le16_to_cpu(ss_assign->usSpreadSpectrumPercentage);
1406 ss->type = ss_assign->ucSpreadSpectrumType;
1407 ss->step = ss_assign->ucSS_Step;
1408 ss->delay = ss_assign->ucSS_Delay;
1409 ss->range = ss_assign->ucSS_Range;
1410 ss->refdiv = ss_assign->ucRecommendedRef_Div;
1411 return true;
1412 }
1413 ss_assign = (struct _ATOM_SPREAD_SPECTRUM_ASSIGNMENT*)
1414 ((u8 *)ss_assign + sizeof(struct _ATOM_SPREAD_SPECTRUM_ASSIGNMENT));
1415 }
1416 }
1417 return false;
1418}
1419
1420static void radeon_atombios_get_igp_ss_overrides(struct radeon_device *rdev,
1421 struct radeon_atom_ss *ss,
1422 int id)
1423{
1424 struct radeon_mode_info *mode_info = &rdev->mode_info;
1425 int index = GetIndexIntoMasterTable(DATA, IntegratedSystemInfo);
1426 u16 data_offset, size;
1427 union igp_info *igp_info;
1428 u8 frev, crev;
1429 u16 percentage = 0, rate = 0;
1430
1431 /* get any igp specific overrides */
1432 if (atom_parse_data_header(mode_info->atom_context, index, &size,
1433 &frev, &crev, &data_offset)) {
1434 igp_info = (union igp_info *)
1435 (mode_info->atom_context->bios + data_offset);
1436 switch (crev) {
1437 case 6:
1438 switch (id) {
1439 case ASIC_INTERNAL_SS_ON_TMDS:
1440 percentage = le16_to_cpu(igp_info->info_6.usDVISSPercentage);
1441 rate = le16_to_cpu(igp_info->info_6.usDVISSpreadRateIn10Hz);
1442 break;
1443 case ASIC_INTERNAL_SS_ON_HDMI:
1444 percentage = le16_to_cpu(igp_info->info_6.usHDMISSPercentage);
1445 rate = le16_to_cpu(igp_info->info_6.usHDMISSpreadRateIn10Hz);
1446 break;
1447 case ASIC_INTERNAL_SS_ON_LVDS:
1448 percentage = le16_to_cpu(igp_info->info_6.usLvdsSSPercentage);
1449 rate = le16_to_cpu(igp_info->info_6.usLvdsSSpreadRateIn10Hz);
1450 break;
1451 }
1452 break;
1453 case 7:
1454 switch (id) {
1455 case ASIC_INTERNAL_SS_ON_TMDS:
1456 percentage = le16_to_cpu(igp_info->info_7.usDVISSPercentage);
1457 rate = le16_to_cpu(igp_info->info_7.usDVISSpreadRateIn10Hz);
1458 break;
1459 case ASIC_INTERNAL_SS_ON_HDMI:
1460 percentage = le16_to_cpu(igp_info->info_7.usHDMISSPercentage);
1461 rate = le16_to_cpu(igp_info->info_7.usHDMISSpreadRateIn10Hz);
1462 break;
1463 case ASIC_INTERNAL_SS_ON_LVDS:
1464 percentage = le16_to_cpu(igp_info->info_7.usLvdsSSPercentage);
1465 rate = le16_to_cpu(igp_info->info_7.usLvdsSSpreadRateIn10Hz);
1466 break;
1467 }
1468 break;
1469 case 8:
1470 switch (id) {
1471 case ASIC_INTERNAL_SS_ON_TMDS:
1472 percentage = le16_to_cpu(igp_info->info_8.usDVISSPercentage);
1473 rate = le16_to_cpu(igp_info->info_8.usDVISSpreadRateIn10Hz);
1474 break;
1475 case ASIC_INTERNAL_SS_ON_HDMI:
1476 percentage = le16_to_cpu(igp_info->info_8.usHDMISSPercentage);
1477 rate = le16_to_cpu(igp_info->info_8.usHDMISSpreadRateIn10Hz);
1478 break;
1479 case ASIC_INTERNAL_SS_ON_LVDS:
1480 percentage = le16_to_cpu(igp_info->info_8.usLvdsSSPercentage);
1481 rate = le16_to_cpu(igp_info->info_8.usLvdsSSpreadRateIn10Hz);
1482 break;
1483 }
1484 break;
1485 default:
1486 DRM_ERROR("Unsupported IGP table: %d %d\n", frev, crev);
1487 break;
1488 }
1489 if (percentage)
1490 ss->percentage = percentage;
1491 if (rate)
1492 ss->rate = rate;
1493 }
1494}
1495
1496union asic_ss_info {
1497 struct _ATOM_ASIC_INTERNAL_SS_INFO info;
1498 struct _ATOM_ASIC_INTERNAL_SS_INFO_V2 info_2;
1499 struct _ATOM_ASIC_INTERNAL_SS_INFO_V3 info_3;
1500};
1501
1502union asic_ss_assignment {
1503 struct _ATOM_ASIC_SS_ASSIGNMENT v1;
1504 struct _ATOM_ASIC_SS_ASSIGNMENT_V2 v2;
1505 struct _ATOM_ASIC_SS_ASSIGNMENT_V3 v3;
1506};
1507
1508bool radeon_atombios_get_asic_ss_info(struct radeon_device *rdev,
1509 struct radeon_atom_ss *ss,
1510 int id, u32 clock)
1511{
1512 struct radeon_mode_info *mode_info = &rdev->mode_info;
1513 int index = GetIndexIntoMasterTable(DATA, ASIC_InternalSS_Info);
1514 uint16_t data_offset, size;
1515 union asic_ss_info *ss_info;
1516 union asic_ss_assignment *ss_assign;
1517 uint8_t frev, crev;
1518 int i, num_indices;
1519
1520 if (id == ASIC_INTERNAL_MEMORY_SS) {
1521 if (!(rdev->mode_info.firmware_flags & ATOM_BIOS_INFO_MEMORY_CLOCK_SS_SUPPORT))
1522 return false;
1523 }
1524 if (id == ASIC_INTERNAL_ENGINE_SS) {
1525 if (!(rdev->mode_info.firmware_flags & ATOM_BIOS_INFO_ENGINE_CLOCK_SS_SUPPORT))
1526 return false;
1527 }
1528
1529 memset(ss, 0, sizeof(struct radeon_atom_ss));
1530 if (atom_parse_data_header(mode_info->atom_context, index, &size,
1531 &frev, &crev, &data_offset)) {
1532
1533 ss_info =
1534 (union asic_ss_info *)(mode_info->atom_context->bios + data_offset);
1535
1536 switch (frev) {
1537 case 1:
1538 num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
1539 sizeof(ATOM_ASIC_SS_ASSIGNMENT);
1540
1541 ss_assign = (union asic_ss_assignment *)((u8 *)&ss_info->info.asSpreadSpectrum[0]);
1542 for (i = 0; i < num_indices; i++) {
1543 if ((ss_assign->v1.ucClockIndication == id) &&
1544 (clock <= le32_to_cpu(ss_assign->v1.ulTargetClockRange))) {
1545 ss->percentage =
1546 le16_to_cpu(ss_assign->v1.usSpreadSpectrumPercentage);
1547 ss->type = ss_assign->v1.ucSpreadSpectrumMode;
1548 ss->rate = le16_to_cpu(ss_assign->v1.usSpreadRateInKhz);
1549 ss->percentage_divider = 100;
1550 return true;
1551 }
1552 ss_assign = (union asic_ss_assignment *)
1553 ((u8 *)ss_assign + sizeof(ATOM_ASIC_SS_ASSIGNMENT));
1554 }
1555 break;
1556 case 2:
1557 num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
1558 sizeof(ATOM_ASIC_SS_ASSIGNMENT_V2);
1559 ss_assign = (union asic_ss_assignment *)((u8 *)&ss_info->info_2.asSpreadSpectrum[0]);
1560 for (i = 0; i < num_indices; i++) {
1561 if ((ss_assign->v2.ucClockIndication == id) &&
1562 (clock <= le32_to_cpu(ss_assign->v2.ulTargetClockRange))) {
1563 ss->percentage =
1564 le16_to_cpu(ss_assign->v2.usSpreadSpectrumPercentage);
1565 ss->type = ss_assign->v2.ucSpreadSpectrumMode;
1566 ss->rate = le16_to_cpu(ss_assign->v2.usSpreadRateIn10Hz);
1567 ss->percentage_divider = 100;
1568 if ((crev == 2) &&
1569 ((id == ASIC_INTERNAL_ENGINE_SS) ||
1570 (id == ASIC_INTERNAL_MEMORY_SS)))
1571 ss->rate /= 100;
1572 return true;
1573 }
1574 ss_assign = (union asic_ss_assignment *)
1575 ((u8 *)ss_assign + sizeof(ATOM_ASIC_SS_ASSIGNMENT_V2));
1576 }
1577 break;
1578 case 3:
1579 num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) /
1580 sizeof(ATOM_ASIC_SS_ASSIGNMENT_V3);
1581 ss_assign = (union asic_ss_assignment *)((u8 *)&ss_info->info_3.asSpreadSpectrum[0]);
1582 for (i = 0; i < num_indices; i++) {
1583 if ((ss_assign->v3.ucClockIndication == id) &&
1584 (clock <= le32_to_cpu(ss_assign->v3.ulTargetClockRange))) {
1585 ss->percentage =
1586 le16_to_cpu(ss_assign->v3.usSpreadSpectrumPercentage);
1587 ss->type = ss_assign->v3.ucSpreadSpectrumMode;
1588 ss->rate = le16_to_cpu(ss_assign->v3.usSpreadRateIn10Hz);
1589 if (ss_assign->v3.ucSpreadSpectrumMode &
1590 SS_MODE_V3_PERCENTAGE_DIV_BY_1000_MASK)
1591 ss->percentage_divider = 1000;
1592 else
1593 ss->percentage_divider = 100;
1594 if ((id == ASIC_INTERNAL_ENGINE_SS) ||
1595 (id == ASIC_INTERNAL_MEMORY_SS))
1596 ss->rate /= 100;
1597 if (rdev->flags & RADEON_IS_IGP)
1598 radeon_atombios_get_igp_ss_overrides(rdev, ss, id);
1599 return true;
1600 }
1601 ss_assign = (union asic_ss_assignment *)
1602 ((u8 *)ss_assign + sizeof(ATOM_ASIC_SS_ASSIGNMENT_V3));
1603 }
1604 break;
1605 default:
1606 DRM_ERROR("Unsupported ASIC_InternalSS_Info table: %d %d\n", frev, crev);
1607 break;
1608 }
1609
1610 }
1611 return false;
1612}
1613
1614union lvds_info {
1615 struct _ATOM_LVDS_INFO info;
1616 struct _ATOM_LVDS_INFO_V12 info_12;
1617};
1618
1619struct radeon_encoder_atom_dig *radeon_atombios_get_lvds_info(struct
1620 radeon_encoder
1621 *encoder)
1622{
1623 struct drm_device *dev = encoder->base.dev;
1624 struct radeon_device *rdev = dev->dev_private;
1625 struct radeon_mode_info *mode_info = &rdev->mode_info;
1626 int index = GetIndexIntoMasterTable(DATA, LVDS_Info);
1627 uint16_t data_offset, misc;
1628 union lvds_info *lvds_info;
1629 uint8_t frev, crev;
1630 struct radeon_encoder_atom_dig *lvds = NULL;
1631 int encoder_enum = (encoder->encoder_enum & ENUM_ID_MASK) >> ENUM_ID_SHIFT;
1632
1633 if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1634 &frev, &crev, &data_offset)) {
1635 lvds_info =
1636 (union lvds_info *)(mode_info->atom_context->bios + data_offset);
1637 lvds =
1638 kzalloc(sizeof(struct radeon_encoder_atom_dig), GFP_KERNEL);
1639
1640 if (!lvds)
1641 return NULL;
1642
1643 lvds->native_mode.clock =
1644 le16_to_cpu(lvds_info->info.sLCDTiming.usPixClk) * 10;
1645 lvds->native_mode.hdisplay =
1646 le16_to_cpu(lvds_info->info.sLCDTiming.usHActive);
1647 lvds->native_mode.vdisplay =
1648 le16_to_cpu(lvds_info->info.sLCDTiming.usVActive);
1649 lvds->native_mode.htotal = lvds->native_mode.hdisplay +
1650 le16_to_cpu(lvds_info->info.sLCDTiming.usHBlanking_Time);
1651 lvds->native_mode.hsync_start = lvds->native_mode.hdisplay +
1652 le16_to_cpu(lvds_info->info.sLCDTiming.usHSyncOffset);
1653 lvds->native_mode.hsync_end = lvds->native_mode.hsync_start +
1654 le16_to_cpu(lvds_info->info.sLCDTiming.usHSyncWidth);
1655 lvds->native_mode.vtotal = lvds->native_mode.vdisplay +
1656 le16_to_cpu(lvds_info->info.sLCDTiming.usVBlanking_Time);
1657 lvds->native_mode.vsync_start = lvds->native_mode.vdisplay +
1658 le16_to_cpu(lvds_info->info.sLCDTiming.usVSyncOffset);
1659 lvds->native_mode.vsync_end = lvds->native_mode.vsync_start +
1660 le16_to_cpu(lvds_info->info.sLCDTiming.usVSyncWidth);
1661 lvds->panel_pwr_delay =
1662 le16_to_cpu(lvds_info->info.usOffDelayInMs);
1663 lvds->lcd_misc = lvds_info->info.ucLVDS_Misc;
1664
1665 misc = le16_to_cpu(lvds_info->info.sLCDTiming.susModeMiscInfo.usAccess);
1666 if (misc & ATOM_VSYNC_POLARITY)
1667 lvds->native_mode.flags |= DRM_MODE_FLAG_NVSYNC;
1668 if (misc & ATOM_HSYNC_POLARITY)
1669 lvds->native_mode.flags |= DRM_MODE_FLAG_NHSYNC;
1670 if (misc & ATOM_COMPOSITESYNC)
1671 lvds->native_mode.flags |= DRM_MODE_FLAG_CSYNC;
1672 if (misc & ATOM_INTERLACE)
1673 lvds->native_mode.flags |= DRM_MODE_FLAG_INTERLACE;
1674 if (misc & ATOM_DOUBLE_CLOCK_MODE)
1675 lvds->native_mode.flags |= DRM_MODE_FLAG_DBLSCAN;
1676
1677 lvds->native_mode.width_mm = le16_to_cpu(lvds_info->info.sLCDTiming.usImageHSize);
1678 lvds->native_mode.height_mm = le16_to_cpu(lvds_info->info.sLCDTiming.usImageVSize);
1679
1680 /* set crtc values */
1681 drm_mode_set_crtcinfo(&lvds->native_mode, CRTC_INTERLACE_HALVE_V);
1682
1683 lvds->lcd_ss_id = lvds_info->info.ucSS_Id;
1684
1685 encoder->native_mode = lvds->native_mode;
1686
1687 if (encoder_enum == 2)
1688 lvds->linkb = true;
1689 else
1690 lvds->linkb = false;
1691
1692 /* parse the lcd record table */
1693 if (le16_to_cpu(lvds_info->info.usModePatchTableOffset)) {
1694 ATOM_FAKE_EDID_PATCH_RECORD *fake_edid_record;
1695 ATOM_PANEL_RESOLUTION_PATCH_RECORD *panel_res_record;
1696 bool bad_record = false;
1697 u8 *record;
1698
1699 if ((frev == 1) && (crev < 2))
1700 /* absolute */
1701 record = (u8 *)(mode_info->atom_context->bios +
1702 le16_to_cpu(lvds_info->info.usModePatchTableOffset));
1703 else
1704 /* relative */
1705 record = (u8 *)(mode_info->atom_context->bios +
1706 data_offset +
1707 le16_to_cpu(lvds_info->info.usModePatchTableOffset));
1708 while (*record != ATOM_RECORD_END_TYPE) {
1709 switch (*record) {
1710 case LCD_MODE_PATCH_RECORD_MODE_TYPE:
1711 record += sizeof(ATOM_PATCH_RECORD_MODE);
1712 break;
1713 case LCD_RTS_RECORD_TYPE:
1714 record += sizeof(ATOM_LCD_RTS_RECORD);
1715 break;
1716 case LCD_CAP_RECORD_TYPE:
1717 record += sizeof(ATOM_LCD_MODE_CONTROL_CAP);
1718 break;
1719 case LCD_FAKE_EDID_PATCH_RECORD_TYPE:
1720 fake_edid_record = (ATOM_FAKE_EDID_PATCH_RECORD *)record;
1721 if (fake_edid_record->ucFakeEDIDLength) {
1722 struct edid *edid;
1723 int edid_size =
1724 max((int)EDID_LENGTH, (int)fake_edid_record->ucFakeEDIDLength);
1725 edid = kmalloc(edid_size, GFP_KERNEL);
1726 if (edid) {
1727 memcpy((u8 *)edid, (u8 *)&fake_edid_record->ucFakeEDIDString[0],
1728 fake_edid_record->ucFakeEDIDLength);
1729
1730 if (drm_edid_is_valid(edid)) {
1731 rdev->mode_info.bios_hardcoded_edid = edid;
1732 rdev->mode_info.bios_hardcoded_edid_size = edid_size;
1733 } else
1734 kfree(edid);
1735 }
1736 }
1737 record += fake_edid_record->ucFakeEDIDLength ?
1738 fake_edid_record->ucFakeEDIDLength + 2 :
1739 sizeof(ATOM_FAKE_EDID_PATCH_RECORD);
1740 break;
1741 case LCD_PANEL_RESOLUTION_RECORD_TYPE:
1742 panel_res_record = (ATOM_PANEL_RESOLUTION_PATCH_RECORD *)record;
1743 lvds->native_mode.width_mm = panel_res_record->usHSize;
1744 lvds->native_mode.height_mm = panel_res_record->usVSize;
1745 record += sizeof(ATOM_PANEL_RESOLUTION_PATCH_RECORD);
1746 break;
1747 default:
1748 DRM_ERROR("Bad LCD record %d\n", *record);
1749 bad_record = true;
1750 break;
1751 }
1752 if (bad_record)
1753 break;
1754 }
1755 }
1756 }
1757 return lvds;
1758}
1759
1760struct radeon_encoder_primary_dac *
1761radeon_atombios_get_primary_dac_info(struct radeon_encoder *encoder)
1762{
1763 struct drm_device *dev = encoder->base.dev;
1764 struct radeon_device *rdev = dev->dev_private;
1765 struct radeon_mode_info *mode_info = &rdev->mode_info;
1766 int index = GetIndexIntoMasterTable(DATA, CompassionateData);
1767 uint16_t data_offset;
1768 struct _COMPASSIONATE_DATA *dac_info;
1769 uint8_t frev, crev;
1770 uint8_t bg, dac;
1771 struct radeon_encoder_primary_dac *p_dac = NULL;
1772
1773 if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1774 &frev, &crev, &data_offset)) {
1775 dac_info = (struct _COMPASSIONATE_DATA *)
1776 (mode_info->atom_context->bios + data_offset);
1777
1778 p_dac = kzalloc(sizeof(struct radeon_encoder_primary_dac), GFP_KERNEL);
1779
1780 if (!p_dac)
1781 return NULL;
1782
1783 bg = dac_info->ucDAC1_BG_Adjustment;
1784 dac = dac_info->ucDAC1_DAC_Adjustment;
1785 p_dac->ps2_pdac_adj = (bg << 8) | (dac);
1786
1787 }
1788 return p_dac;
1789}
1790
1791bool radeon_atom_get_tv_timings(struct radeon_device *rdev, int index,
1792 struct drm_display_mode *mode)
1793{
1794 struct radeon_mode_info *mode_info = &rdev->mode_info;
1795 ATOM_ANALOG_TV_INFO *tv_info;
1796 ATOM_ANALOG_TV_INFO_V1_2 *tv_info_v1_2;
1797 ATOM_DTD_FORMAT *dtd_timings;
1798 int data_index = GetIndexIntoMasterTable(DATA, AnalogTV_Info);
1799 u8 frev, crev;
1800 u16 data_offset, misc;
1801
1802 if (!atom_parse_data_header(mode_info->atom_context, data_index, NULL,
1803 &frev, &crev, &data_offset))
1804 return false;
1805
1806 switch (crev) {
1807 case 1:
1808 tv_info = (ATOM_ANALOG_TV_INFO *)(mode_info->atom_context->bios + data_offset);
1809 if (index >= MAX_SUPPORTED_TV_TIMING)
1810 return false;
1811
1812 mode->crtc_htotal = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_H_Total);
1813 mode->crtc_hdisplay = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_H_Disp);
1814 mode->crtc_hsync_start = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_H_SyncStart);
1815 mode->crtc_hsync_end = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_H_SyncStart) +
1816 le16_to_cpu(tv_info->aModeTimings[index].usCRTC_H_SyncWidth);
1817
1818 mode->crtc_vtotal = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_V_Total);
1819 mode->crtc_vdisplay = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_V_Disp);
1820 mode->crtc_vsync_start = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_V_SyncStart);
1821 mode->crtc_vsync_end = le16_to_cpu(tv_info->aModeTimings[index].usCRTC_V_SyncStart) +
1822 le16_to_cpu(tv_info->aModeTimings[index].usCRTC_V_SyncWidth);
1823
1824 mode->flags = 0;
1825 misc = le16_to_cpu(tv_info->aModeTimings[index].susModeMiscInfo.usAccess);
1826 if (misc & ATOM_VSYNC_POLARITY)
1827 mode->flags |= DRM_MODE_FLAG_NVSYNC;
1828 if (misc & ATOM_HSYNC_POLARITY)
1829 mode->flags |= DRM_MODE_FLAG_NHSYNC;
1830 if (misc & ATOM_COMPOSITESYNC)
1831 mode->flags |= DRM_MODE_FLAG_CSYNC;
1832 if (misc & ATOM_INTERLACE)
1833 mode->flags |= DRM_MODE_FLAG_INTERLACE;
1834 if (misc & ATOM_DOUBLE_CLOCK_MODE)
1835 mode->flags |= DRM_MODE_FLAG_DBLSCAN;
1836
1837 mode->crtc_clock = mode->clock =
1838 le16_to_cpu(tv_info->aModeTimings[index].usPixelClock) * 10;
1839
1840 if (index == 1) {
1841 /* PAL timings appear to have wrong values for totals */
1842 mode->crtc_htotal -= 1;
1843 mode->crtc_vtotal -= 1;
1844 }
1845 break;
1846 case 2:
1847 tv_info_v1_2 = (ATOM_ANALOG_TV_INFO_V1_2 *)(mode_info->atom_context->bios + data_offset);
1848 if (index >= MAX_SUPPORTED_TV_TIMING_V1_2)
1849 return false;
1850
1851 dtd_timings = &tv_info_v1_2->aModeTimings[index];
1852 mode->crtc_htotal = le16_to_cpu(dtd_timings->usHActive) +
1853 le16_to_cpu(dtd_timings->usHBlanking_Time);
1854 mode->crtc_hdisplay = le16_to_cpu(dtd_timings->usHActive);
1855 mode->crtc_hsync_start = le16_to_cpu(dtd_timings->usHActive) +
1856 le16_to_cpu(dtd_timings->usHSyncOffset);
1857 mode->crtc_hsync_end = mode->crtc_hsync_start +
1858 le16_to_cpu(dtd_timings->usHSyncWidth);
1859
1860 mode->crtc_vtotal = le16_to_cpu(dtd_timings->usVActive) +
1861 le16_to_cpu(dtd_timings->usVBlanking_Time);
1862 mode->crtc_vdisplay = le16_to_cpu(dtd_timings->usVActive);
1863 mode->crtc_vsync_start = le16_to_cpu(dtd_timings->usVActive) +
1864 le16_to_cpu(dtd_timings->usVSyncOffset);
1865 mode->crtc_vsync_end = mode->crtc_vsync_start +
1866 le16_to_cpu(dtd_timings->usVSyncWidth);
1867
1868 mode->flags = 0;
1869 misc = le16_to_cpu(dtd_timings->susModeMiscInfo.usAccess);
1870 if (misc & ATOM_VSYNC_POLARITY)
1871 mode->flags |= DRM_MODE_FLAG_NVSYNC;
1872 if (misc & ATOM_HSYNC_POLARITY)
1873 mode->flags |= DRM_MODE_FLAG_NHSYNC;
1874 if (misc & ATOM_COMPOSITESYNC)
1875 mode->flags |= DRM_MODE_FLAG_CSYNC;
1876 if (misc & ATOM_INTERLACE)
1877 mode->flags |= DRM_MODE_FLAG_INTERLACE;
1878 if (misc & ATOM_DOUBLE_CLOCK_MODE)
1879 mode->flags |= DRM_MODE_FLAG_DBLSCAN;
1880
1881 mode->crtc_clock = mode->clock =
1882 le16_to_cpu(dtd_timings->usPixClk) * 10;
1883 break;
1884 }
1885 return true;
1886}
1887
1888enum radeon_tv_std
1889radeon_atombios_get_tv_info(struct radeon_device *rdev)
1890{
1891 struct radeon_mode_info *mode_info = &rdev->mode_info;
1892 int index = GetIndexIntoMasterTable(DATA, AnalogTV_Info);
1893 uint16_t data_offset;
1894 uint8_t frev, crev;
1895 struct _ATOM_ANALOG_TV_INFO *tv_info;
1896 enum radeon_tv_std tv_std = TV_STD_NTSC;
1897
1898 if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1899 &frev, &crev, &data_offset)) {
1900
1901 tv_info = (struct _ATOM_ANALOG_TV_INFO *)
1902 (mode_info->atom_context->bios + data_offset);
1903
1904 switch (tv_info->ucTV_BootUpDefaultStandard) {
1905 case ATOM_TV_NTSC:
1906 tv_std = TV_STD_NTSC;
1907 DRM_DEBUG_KMS("Default TV standard: NTSC\n");
1908 break;
1909 case ATOM_TV_NTSCJ:
1910 tv_std = TV_STD_NTSC_J;
1911 DRM_DEBUG_KMS("Default TV standard: NTSC-J\n");
1912 break;
1913 case ATOM_TV_PAL:
1914 tv_std = TV_STD_PAL;
1915 DRM_DEBUG_KMS("Default TV standard: PAL\n");
1916 break;
1917 case ATOM_TV_PALM:
1918 tv_std = TV_STD_PAL_M;
1919 DRM_DEBUG_KMS("Default TV standard: PAL-M\n");
1920 break;
1921 case ATOM_TV_PALN:
1922 tv_std = TV_STD_PAL_N;
1923 DRM_DEBUG_KMS("Default TV standard: PAL-N\n");
1924 break;
1925 case ATOM_TV_PALCN:
1926 tv_std = TV_STD_PAL_CN;
1927 DRM_DEBUG_KMS("Default TV standard: PAL-CN\n");
1928 break;
1929 case ATOM_TV_PAL60:
1930 tv_std = TV_STD_PAL_60;
1931 DRM_DEBUG_KMS("Default TV standard: PAL-60\n");
1932 break;
1933 case ATOM_TV_SECAM:
1934 tv_std = TV_STD_SECAM;
1935 DRM_DEBUG_KMS("Default TV standard: SECAM\n");
1936 break;
1937 default:
1938 tv_std = TV_STD_NTSC;
1939 DRM_DEBUG_KMS("Unknown TV standard; defaulting to NTSC\n");
1940 break;
1941 }
1942 }
1943 return tv_std;
1944}
1945
1946struct radeon_encoder_tv_dac *
1947radeon_atombios_get_tv_dac_info(struct radeon_encoder *encoder)
1948{
1949 struct drm_device *dev = encoder->base.dev;
1950 struct radeon_device *rdev = dev->dev_private;
1951 struct radeon_mode_info *mode_info = &rdev->mode_info;
1952 int index = GetIndexIntoMasterTable(DATA, CompassionateData);
1953 uint16_t data_offset;
1954 struct _COMPASSIONATE_DATA *dac_info;
1955 uint8_t frev, crev;
1956 uint8_t bg, dac;
1957 struct radeon_encoder_tv_dac *tv_dac = NULL;
1958
1959 if (atom_parse_data_header(mode_info->atom_context, index, NULL,
1960 &frev, &crev, &data_offset)) {
1961
1962 dac_info = (struct _COMPASSIONATE_DATA *)
1963 (mode_info->atom_context->bios + data_offset);
1964
1965 tv_dac = kzalloc(sizeof(struct radeon_encoder_tv_dac), GFP_KERNEL);
1966
1967 if (!tv_dac)
1968 return NULL;
1969
1970 bg = dac_info->ucDAC2_CRT2_BG_Adjustment;
1971 dac = dac_info->ucDAC2_CRT2_DAC_Adjustment;
1972 tv_dac->ps2_tvdac_adj = (bg << 16) | (dac << 20);
1973
1974 bg = dac_info->ucDAC2_PAL_BG_Adjustment;
1975 dac = dac_info->ucDAC2_PAL_DAC_Adjustment;
1976 tv_dac->pal_tvdac_adj = (bg << 16) | (dac << 20);
1977
1978 bg = dac_info->ucDAC2_NTSC_BG_Adjustment;
1979 dac = dac_info->ucDAC2_NTSC_DAC_Adjustment;
1980 tv_dac->ntsc_tvdac_adj = (bg << 16) | (dac << 20);
1981
1982 tv_dac->tv_std = radeon_atombios_get_tv_info(rdev);
1983 }
1984 return tv_dac;
1985}
1986
1987static const char *thermal_controller_names[] = {
1988 "NONE",
1989 "lm63",
1990 "adm1032",
1991 "adm1030",
1992 "max6649",
1993 "lm63", /* lm64 */
1994 "f75375",
1995 "asc7xxx",
1996};
1997
1998static const char *pp_lib_thermal_controller_names[] = {
1999 "NONE",
2000 "lm63",
2001 "adm1032",
2002 "adm1030",
2003 "max6649",
2004 "lm63", /* lm64 */
2005 "f75375",
2006 "RV6xx",
2007 "RV770",
2008 "adt7473",
2009 "NONE",
2010 "External GPIO",
2011 "Evergreen",
2012 "emc2103",
2013 "Sumo",
2014 "Northern Islands",
2015 "Southern Islands",
2016 "lm96163",
2017 "Sea Islands",
2018};
2019
2020union power_info {
2021 struct _ATOM_POWERPLAY_INFO info;
2022 struct _ATOM_POWERPLAY_INFO_V2 info_2;
2023 struct _ATOM_POWERPLAY_INFO_V3 info_3;
2024 struct _ATOM_PPLIB_POWERPLAYTABLE pplib;
2025 struct _ATOM_PPLIB_POWERPLAYTABLE2 pplib2;
2026 struct _ATOM_PPLIB_POWERPLAYTABLE3 pplib3;
2027};
2028
2029union pplib_clock_info {
2030 struct _ATOM_PPLIB_R600_CLOCK_INFO r600;
2031 struct _ATOM_PPLIB_RS780_CLOCK_INFO rs780;
2032 struct _ATOM_PPLIB_EVERGREEN_CLOCK_INFO evergreen;
2033 struct _ATOM_PPLIB_SUMO_CLOCK_INFO sumo;
2034 struct _ATOM_PPLIB_SI_CLOCK_INFO si;
2035 struct _ATOM_PPLIB_CI_CLOCK_INFO ci;
2036};
2037
2038union pplib_power_state {
2039 struct _ATOM_PPLIB_STATE v1;
2040 struct _ATOM_PPLIB_STATE_V2 v2;
2041};
2042
2043static void radeon_atombios_parse_misc_flags_1_3(struct radeon_device *rdev,
2044 int state_index,
2045 u32 misc, u32 misc2)
2046{
2047 rdev->pm.power_state[state_index].misc = misc;
2048 rdev->pm.power_state[state_index].misc2 = misc2;
2049 /* order matters! */
2050 if (misc & ATOM_PM_MISCINFO_POWER_SAVING_MODE)
2051 rdev->pm.power_state[state_index].type =
2052 POWER_STATE_TYPE_POWERSAVE;
2053 if (misc & ATOM_PM_MISCINFO_DEFAULT_DC_STATE_ENTRY_TRUE)
2054 rdev->pm.power_state[state_index].type =
2055 POWER_STATE_TYPE_BATTERY;
2056 if (misc & ATOM_PM_MISCINFO_DEFAULT_LOW_DC_STATE_ENTRY_TRUE)
2057 rdev->pm.power_state[state_index].type =
2058 POWER_STATE_TYPE_BATTERY;
2059 if (misc & ATOM_PM_MISCINFO_LOAD_BALANCE_EN)
2060 rdev->pm.power_state[state_index].type =
2061 POWER_STATE_TYPE_BALANCED;
2062 if (misc & ATOM_PM_MISCINFO_3D_ACCELERATION_EN) {
2063 rdev->pm.power_state[state_index].type =
2064 POWER_STATE_TYPE_PERFORMANCE;
2065 rdev->pm.power_state[state_index].flags &=
2066 ~RADEON_PM_STATE_SINGLE_DISPLAY_ONLY;
2067 }
2068 if (misc2 & ATOM_PM_MISCINFO2_SYSTEM_AC_LITE_MODE)
2069 rdev->pm.power_state[state_index].type =
2070 POWER_STATE_TYPE_BALANCED;
2071 if (misc & ATOM_PM_MISCINFO_DRIVER_DEFAULT_MODE) {
2072 rdev->pm.power_state[state_index].type =
2073 POWER_STATE_TYPE_DEFAULT;
2074 rdev->pm.default_power_state_index = state_index;
2075 rdev->pm.power_state[state_index].default_clock_mode =
2076 &rdev->pm.power_state[state_index].clock_info[0];
2077 } else if (state_index == 0) {
2078 rdev->pm.power_state[state_index].clock_info[0].flags |=
2079 RADEON_PM_MODE_NO_DISPLAY;
2080 }
2081}
2082
2083static int radeon_atombios_parse_power_table_1_3(struct radeon_device *rdev)
2084{
2085 struct radeon_mode_info *mode_info = &rdev->mode_info;
2086 u32 misc, misc2 = 0;
2087 int num_modes = 0, i;
2088 int state_index = 0;
2089 struct radeon_i2c_bus_rec i2c_bus;
2090 union power_info *power_info;
2091 int index = GetIndexIntoMasterTable(DATA, PowerPlayInfo);
2092 u16 data_offset;
2093 u8 frev, crev;
2094
2095 if (!atom_parse_data_header(mode_info->atom_context, index, NULL,
2096 &frev, &crev, &data_offset))
2097 return state_index;
2098 power_info = (union power_info *)(mode_info->atom_context->bios + data_offset);
2099
2100 /* add the i2c bus for thermal/fan chip */
2101 if ((power_info->info.ucOverdriveThermalController > 0) &&
2102 (power_info->info.ucOverdriveThermalController < ARRAY_SIZE(thermal_controller_names))) {
2103 DRM_INFO("Possible %s thermal controller at 0x%02x\n",
2104 thermal_controller_names[power_info->info.ucOverdriveThermalController],
2105 power_info->info.ucOverdriveControllerAddress >> 1);
2106 i2c_bus = radeon_lookup_i2c_gpio(rdev, power_info->info.ucOverdriveI2cLine);
2107 rdev->pm.i2c_bus = radeon_i2c_lookup(rdev, &i2c_bus);
2108 if (rdev->pm.i2c_bus) {
2109 struct i2c_board_info info = { };
2110 const char *name = thermal_controller_names[power_info->info.
2111 ucOverdriveThermalController];
2112 info.addr = power_info->info.ucOverdriveControllerAddress >> 1;
2113 strlcpy(info.type, name, sizeof(info.type));
2114 i2c_new_client_device(&rdev->pm.i2c_bus->adapter, &info);
2115 }
2116 }
2117 num_modes = power_info->info.ucNumOfPowerModeEntries;
2118 if (num_modes > ATOM_MAX_NUMBEROF_POWER_BLOCK)
2119 num_modes = ATOM_MAX_NUMBEROF_POWER_BLOCK;
2120 if (num_modes == 0)
2121 return state_index;
2122 rdev->pm.power_state = kcalloc(num_modes,
2123 sizeof(struct radeon_power_state),
2124 GFP_KERNEL);
2125 if (!rdev->pm.power_state)
2126 return state_index;
2127 /* last mode is usually default, array is low to high */
2128 for (i = 0; i < num_modes; i++) {
2129 rdev->pm.power_state[state_index].clock_info =
2130 kcalloc(1, sizeof(struct radeon_pm_clock_info),
2131 GFP_KERNEL);
2132 if (!rdev->pm.power_state[state_index].clock_info)
2133 return state_index;
2134 rdev->pm.power_state[state_index].num_clock_modes = 1;
2135 rdev->pm.power_state[state_index].clock_info[0].voltage.type = VOLTAGE_NONE;
2136 switch (frev) {
2137 case 1:
2138 rdev->pm.power_state[state_index].clock_info[0].mclk =
2139 le16_to_cpu(power_info->info.asPowerPlayInfo[i].usMemoryClock);
2140 rdev->pm.power_state[state_index].clock_info[0].sclk =
2141 le16_to_cpu(power_info->info.asPowerPlayInfo[i].usEngineClock);
2142 /* skip invalid modes */
2143 if ((rdev->pm.power_state[state_index].clock_info[0].mclk == 0) ||
2144 (rdev->pm.power_state[state_index].clock_info[0].sclk == 0))
2145 continue;
2146 rdev->pm.power_state[state_index].pcie_lanes =
2147 power_info->info.asPowerPlayInfo[i].ucNumPciELanes;
2148 misc = le32_to_cpu(power_info->info.asPowerPlayInfo[i].ulMiscInfo);
2149 if ((misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_SUPPORT) ||
2150 (misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_ACTIVE_HIGH)) {
2151 rdev->pm.power_state[state_index].clock_info[0].voltage.type =
2152 VOLTAGE_GPIO;
2153 rdev->pm.power_state[state_index].clock_info[0].voltage.gpio =
2154 radeon_atombios_lookup_gpio(rdev,
2155 power_info->info.asPowerPlayInfo[i].ucVoltageDropIndex);
2156 if (misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_ACTIVE_HIGH)
2157 rdev->pm.power_state[state_index].clock_info[0].voltage.active_high =
2158 true;
2159 else
2160 rdev->pm.power_state[state_index].clock_info[0].voltage.active_high =
2161 false;
2162 } else if (misc & ATOM_PM_MISCINFO_PROGRAM_VOLTAGE) {
2163 rdev->pm.power_state[state_index].clock_info[0].voltage.type =
2164 VOLTAGE_VDDC;
2165 rdev->pm.power_state[state_index].clock_info[0].voltage.vddc_id =
2166 power_info->info.asPowerPlayInfo[i].ucVoltageDropIndex;
2167 }
2168 rdev->pm.power_state[state_index].flags = RADEON_PM_STATE_SINGLE_DISPLAY_ONLY;
2169 radeon_atombios_parse_misc_flags_1_3(rdev, state_index, misc, 0);
2170 state_index++;
2171 break;
2172 case 2:
2173 rdev->pm.power_state[state_index].clock_info[0].mclk =
2174 le32_to_cpu(power_info->info_2.asPowerPlayInfo[i].ulMemoryClock);
2175 rdev->pm.power_state[state_index].clock_info[0].sclk =
2176 le32_to_cpu(power_info->info_2.asPowerPlayInfo[i].ulEngineClock);
2177 /* skip invalid modes */
2178 if ((rdev->pm.power_state[state_index].clock_info[0].mclk == 0) ||
2179 (rdev->pm.power_state[state_index].clock_info[0].sclk == 0))
2180 continue;
2181 rdev->pm.power_state[state_index].pcie_lanes =
2182 power_info->info_2.asPowerPlayInfo[i].ucNumPciELanes;
2183 misc = le32_to_cpu(power_info->info_2.asPowerPlayInfo[i].ulMiscInfo);
2184 misc2 = le32_to_cpu(power_info->info_2.asPowerPlayInfo[i].ulMiscInfo2);
2185 if ((misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_SUPPORT) ||
2186 (misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_ACTIVE_HIGH)) {
2187 rdev->pm.power_state[state_index].clock_info[0].voltage.type =
2188 VOLTAGE_GPIO;
2189 rdev->pm.power_state[state_index].clock_info[0].voltage.gpio =
2190 radeon_atombios_lookup_gpio(rdev,
2191 power_info->info_2.asPowerPlayInfo[i].ucVoltageDropIndex);
2192 if (misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_ACTIVE_HIGH)
2193 rdev->pm.power_state[state_index].clock_info[0].voltage.active_high =
2194 true;
2195 else
2196 rdev->pm.power_state[state_index].clock_info[0].voltage.active_high =
2197 false;
2198 } else if (misc & ATOM_PM_MISCINFO_PROGRAM_VOLTAGE) {
2199 rdev->pm.power_state[state_index].clock_info[0].voltage.type =
2200 VOLTAGE_VDDC;
2201 rdev->pm.power_state[state_index].clock_info[0].voltage.vddc_id =
2202 power_info->info_2.asPowerPlayInfo[i].ucVoltageDropIndex;
2203 }
2204 rdev->pm.power_state[state_index].flags = RADEON_PM_STATE_SINGLE_DISPLAY_ONLY;
2205 radeon_atombios_parse_misc_flags_1_3(rdev, state_index, misc, misc2);
2206 state_index++;
2207 break;
2208 case 3:
2209 rdev->pm.power_state[state_index].clock_info[0].mclk =
2210 le32_to_cpu(power_info->info_3.asPowerPlayInfo[i].ulMemoryClock);
2211 rdev->pm.power_state[state_index].clock_info[0].sclk =
2212 le32_to_cpu(power_info->info_3.asPowerPlayInfo[i].ulEngineClock);
2213 /* skip invalid modes */
2214 if ((rdev->pm.power_state[state_index].clock_info[0].mclk == 0) ||
2215 (rdev->pm.power_state[state_index].clock_info[0].sclk == 0))
2216 continue;
2217 rdev->pm.power_state[state_index].pcie_lanes =
2218 power_info->info_3.asPowerPlayInfo[i].ucNumPciELanes;
2219 misc = le32_to_cpu(power_info->info_3.asPowerPlayInfo[i].ulMiscInfo);
2220 misc2 = le32_to_cpu(power_info->info_3.asPowerPlayInfo[i].ulMiscInfo2);
2221 if ((misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_SUPPORT) ||
2222 (misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_ACTIVE_HIGH)) {
2223 rdev->pm.power_state[state_index].clock_info[0].voltage.type =
2224 VOLTAGE_GPIO;
2225 rdev->pm.power_state[state_index].clock_info[0].voltage.gpio =
2226 radeon_atombios_lookup_gpio(rdev,
2227 power_info->info_3.asPowerPlayInfo[i].ucVoltageDropIndex);
2228 if (misc & ATOM_PM_MISCINFO_VOLTAGE_DROP_ACTIVE_HIGH)
2229 rdev->pm.power_state[state_index].clock_info[0].voltage.active_high =
2230 true;
2231 else
2232 rdev->pm.power_state[state_index].clock_info[0].voltage.active_high =
2233 false;
2234 } else if (misc & ATOM_PM_MISCINFO_PROGRAM_VOLTAGE) {
2235 rdev->pm.power_state[state_index].clock_info[0].voltage.type =
2236 VOLTAGE_VDDC;
2237 rdev->pm.power_state[state_index].clock_info[0].voltage.vddc_id =
2238 power_info->info_3.asPowerPlayInfo[i].ucVoltageDropIndex;
2239 if (misc2 & ATOM_PM_MISCINFO2_VDDCI_DYNAMIC_VOLTAGE_EN) {
2240 rdev->pm.power_state[state_index].clock_info[0].voltage.vddci_enabled =
2241 true;
2242 rdev->pm.power_state[state_index].clock_info[0].voltage.vddci_id =
2243 power_info->info_3.asPowerPlayInfo[i].ucVDDCI_VoltageDropIndex;
2244 }
2245 }
2246 rdev->pm.power_state[state_index].flags = RADEON_PM_STATE_SINGLE_DISPLAY_ONLY;
2247 radeon_atombios_parse_misc_flags_1_3(rdev, state_index, misc, misc2);
2248 state_index++;
2249 break;
2250 }
2251 }
2252 /* last mode is usually default */
2253 if (rdev->pm.default_power_state_index == -1) {
2254 rdev->pm.power_state[state_index - 1].type =
2255 POWER_STATE_TYPE_DEFAULT;
2256 rdev->pm.default_power_state_index = state_index - 1;
2257 rdev->pm.power_state[state_index - 1].default_clock_mode =
2258 &rdev->pm.power_state[state_index - 1].clock_info[0];
2259 rdev->pm.power_state[state_index].flags &=
2260 ~RADEON_PM_STATE_SINGLE_DISPLAY_ONLY;
2261 rdev->pm.power_state[state_index].misc = 0;
2262 rdev->pm.power_state[state_index].misc2 = 0;
2263 }
2264 return state_index;
2265}
2266
2267static void radeon_atombios_add_pplib_thermal_controller(struct radeon_device *rdev,
2268 ATOM_PPLIB_THERMALCONTROLLER *controller)
2269{
2270 struct radeon_i2c_bus_rec i2c_bus;
2271
2272 /* add the i2c bus for thermal/fan chip */
2273 if (controller->ucType > 0) {
2274 if (controller->ucFanParameters & ATOM_PP_FANPARAMETERS_NOFAN)
2275 rdev->pm.no_fan = true;
2276 rdev->pm.fan_pulses_per_revolution =
2277 controller->ucFanParameters & ATOM_PP_FANPARAMETERS_TACHOMETER_PULSES_PER_REVOLUTION_MASK;
2278 if (rdev->pm.fan_pulses_per_revolution) {
2279 rdev->pm.fan_min_rpm = controller->ucFanMinRPM;
2280 rdev->pm.fan_max_rpm = controller->ucFanMaxRPM;
2281 }
2282 if (controller->ucType == ATOM_PP_THERMALCONTROLLER_RV6xx) {
2283 DRM_INFO("Internal thermal controller %s fan control\n",
2284 (controller->ucFanParameters &
2285 ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2286 rdev->pm.int_thermal_type = THERMAL_TYPE_RV6XX;
2287 } else if (controller->ucType == ATOM_PP_THERMALCONTROLLER_RV770) {
2288 DRM_INFO("Internal thermal controller %s fan control\n",
2289 (controller->ucFanParameters &
2290 ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2291 rdev->pm.int_thermal_type = THERMAL_TYPE_RV770;
2292 } else if (controller->ucType == ATOM_PP_THERMALCONTROLLER_EVERGREEN) {
2293 DRM_INFO("Internal thermal controller %s fan control\n",
2294 (controller->ucFanParameters &
2295 ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2296 rdev->pm.int_thermal_type = THERMAL_TYPE_EVERGREEN;
2297 } else if (controller->ucType == ATOM_PP_THERMALCONTROLLER_SUMO) {
2298 DRM_INFO("Internal thermal controller %s fan control\n",
2299 (controller->ucFanParameters &
2300 ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2301 rdev->pm.int_thermal_type = THERMAL_TYPE_SUMO;
2302 } else if (controller->ucType == ATOM_PP_THERMALCONTROLLER_NISLANDS) {
2303 DRM_INFO("Internal thermal controller %s fan control\n",
2304 (controller->ucFanParameters &
2305 ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2306 rdev->pm.int_thermal_type = THERMAL_TYPE_NI;
2307 } else if (controller->ucType == ATOM_PP_THERMALCONTROLLER_SISLANDS) {
2308 DRM_INFO("Internal thermal controller %s fan control\n",
2309 (controller->ucFanParameters &
2310 ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2311 rdev->pm.int_thermal_type = THERMAL_TYPE_SI;
2312 } else if (controller->ucType == ATOM_PP_THERMALCONTROLLER_CISLANDS) {
2313 DRM_INFO("Internal thermal controller %s fan control\n",
2314 (controller->ucFanParameters &
2315 ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2316 rdev->pm.int_thermal_type = THERMAL_TYPE_CI;
2317 } else if (controller->ucType == ATOM_PP_THERMALCONTROLLER_KAVERI) {
2318 DRM_INFO("Internal thermal controller %s fan control\n",
2319 (controller->ucFanParameters &
2320 ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2321 rdev->pm.int_thermal_type = THERMAL_TYPE_KV;
2322 } else if (controller->ucType ==
2323 ATOM_PP_THERMALCONTROLLER_EXTERNAL_GPIO) {
2324 DRM_INFO("External GPIO thermal controller %s fan control\n",
2325 (controller->ucFanParameters &
2326 ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2327 rdev->pm.int_thermal_type = THERMAL_TYPE_EXTERNAL_GPIO;
2328 } else if (controller->ucType ==
2329 ATOM_PP_THERMALCONTROLLER_ADT7473_WITH_INTERNAL) {
2330 DRM_INFO("ADT7473 with internal thermal controller %s fan control\n",
2331 (controller->ucFanParameters &
2332 ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2333 rdev->pm.int_thermal_type = THERMAL_TYPE_ADT7473_WITH_INTERNAL;
2334 } else if (controller->ucType ==
2335 ATOM_PP_THERMALCONTROLLER_EMC2103_WITH_INTERNAL) {
2336 DRM_INFO("EMC2103 with internal thermal controller %s fan control\n",
2337 (controller->ucFanParameters &
2338 ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2339 rdev->pm.int_thermal_type = THERMAL_TYPE_EMC2103_WITH_INTERNAL;
2340 } else if (controller->ucType < ARRAY_SIZE(pp_lib_thermal_controller_names)) {
2341 DRM_INFO("Possible %s thermal controller at 0x%02x %s fan control\n",
2342 pp_lib_thermal_controller_names[controller->ucType],
2343 controller->ucI2cAddress >> 1,
2344 (controller->ucFanParameters &
2345 ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2346 rdev->pm.int_thermal_type = THERMAL_TYPE_EXTERNAL;
2347 i2c_bus = radeon_lookup_i2c_gpio(rdev, controller->ucI2cLine);
2348 rdev->pm.i2c_bus = radeon_i2c_lookup(rdev, &i2c_bus);
2349 if (rdev->pm.i2c_bus) {
2350 struct i2c_board_info info = { };
2351 const char *name = pp_lib_thermal_controller_names[controller->ucType];
2352 info.addr = controller->ucI2cAddress >> 1;
2353 strlcpy(info.type, name, sizeof(info.type));
2354 i2c_new_client_device(&rdev->pm.i2c_bus->adapter, &info);
2355 }
2356 } else {
2357 DRM_INFO("Unknown thermal controller type %d at 0x%02x %s fan control\n",
2358 controller->ucType,
2359 controller->ucI2cAddress >> 1,
2360 (controller->ucFanParameters &
2361 ATOM_PP_FANPARAMETERS_NOFAN) ? "without" : "with");
2362 }
2363 }
2364}
2365
2366void radeon_atombios_get_default_voltages(struct radeon_device *rdev,
2367 u16 *vddc, u16 *vddci, u16 *mvdd)
2368{
2369 struct radeon_mode_info *mode_info = &rdev->mode_info;
2370 int index = GetIndexIntoMasterTable(DATA, FirmwareInfo);
2371 u8 frev, crev;
2372 u16 data_offset;
2373 union firmware_info *firmware_info;
2374
2375 *vddc = 0;
2376 *vddci = 0;
2377 *mvdd = 0;
2378
2379 if (atom_parse_data_header(mode_info->atom_context, index, NULL,
2380 &frev, &crev, &data_offset)) {
2381 firmware_info =
2382 (union firmware_info *)(mode_info->atom_context->bios +
2383 data_offset);
2384 *vddc = le16_to_cpu(firmware_info->info_14.usBootUpVDDCVoltage);
2385 if ((frev == 2) && (crev >= 2)) {
2386 *vddci = le16_to_cpu(firmware_info->info_22.usBootUpVDDCIVoltage);
2387 *mvdd = le16_to_cpu(firmware_info->info_22.usBootUpMVDDCVoltage);
2388 }
2389 }
2390}
2391
2392static void radeon_atombios_parse_pplib_non_clock_info(struct radeon_device *rdev,
2393 int state_index, int mode_index,
2394 struct _ATOM_PPLIB_NONCLOCK_INFO *non_clock_info)
2395{
2396 int j;
2397 u32 misc = le32_to_cpu(non_clock_info->ulCapsAndSettings);
2398 u32 misc2 = le16_to_cpu(non_clock_info->usClassification);
2399 u16 vddc, vddci, mvdd;
2400
2401 radeon_atombios_get_default_voltages(rdev, &vddc, &vddci, &mvdd);
2402
2403 rdev->pm.power_state[state_index].misc = misc;
2404 rdev->pm.power_state[state_index].misc2 = misc2;
2405 rdev->pm.power_state[state_index].pcie_lanes =
2406 ((misc & ATOM_PPLIB_PCIE_LINK_WIDTH_MASK) >>
2407 ATOM_PPLIB_PCIE_LINK_WIDTH_SHIFT) + 1;
2408 switch (misc2 & ATOM_PPLIB_CLASSIFICATION_UI_MASK) {
2409 case ATOM_PPLIB_CLASSIFICATION_UI_BATTERY:
2410 rdev->pm.power_state[state_index].type =
2411 POWER_STATE_TYPE_BATTERY;
2412 break;
2413 case ATOM_PPLIB_CLASSIFICATION_UI_BALANCED:
2414 rdev->pm.power_state[state_index].type =
2415 POWER_STATE_TYPE_BALANCED;
2416 break;
2417 case ATOM_PPLIB_CLASSIFICATION_UI_PERFORMANCE:
2418 rdev->pm.power_state[state_index].type =
2419 POWER_STATE_TYPE_PERFORMANCE;
2420 break;
2421 case ATOM_PPLIB_CLASSIFICATION_UI_NONE:
2422 if (misc2 & ATOM_PPLIB_CLASSIFICATION_3DPERFORMANCE)
2423 rdev->pm.power_state[state_index].type =
2424 POWER_STATE_TYPE_PERFORMANCE;
2425 break;
2426 }
2427 rdev->pm.power_state[state_index].flags = 0;
2428 if (misc & ATOM_PPLIB_SINGLE_DISPLAY_ONLY)
2429 rdev->pm.power_state[state_index].flags |=
2430 RADEON_PM_STATE_SINGLE_DISPLAY_ONLY;
2431 if (misc2 & ATOM_PPLIB_CLASSIFICATION_BOOT) {
2432 rdev->pm.power_state[state_index].type =
2433 POWER_STATE_TYPE_DEFAULT;
2434 rdev->pm.default_power_state_index = state_index;
2435 rdev->pm.power_state[state_index].default_clock_mode =
2436 &rdev->pm.power_state[state_index].clock_info[mode_index - 1];
2437 if ((rdev->family >= CHIP_BARTS) && !(rdev->flags & RADEON_IS_IGP)) {
2438 /* NI chips post without MC ucode, so default clocks are strobe mode only */
2439 rdev->pm.default_sclk = rdev->pm.power_state[state_index].clock_info[0].sclk;
2440 rdev->pm.default_mclk = rdev->pm.power_state[state_index].clock_info[0].mclk;
2441 rdev->pm.default_vddc = rdev->pm.power_state[state_index].clock_info[0].voltage.voltage;
2442 rdev->pm.default_vddci = rdev->pm.power_state[state_index].clock_info[0].voltage.vddci;
2443 } else {
2444 u16 max_vddci = 0;
2445
2446 if (ASIC_IS_DCE4(rdev))
2447 radeon_atom_get_max_voltage(rdev,
2448 SET_VOLTAGE_TYPE_ASIC_VDDCI,
2449 &max_vddci);
2450 /* patch the table values with the default sclk/mclk from firmware info */
2451 for (j = 0; j < mode_index; j++) {
2452 rdev->pm.power_state[state_index].clock_info[j].mclk =
2453 rdev->clock.default_mclk;
2454 rdev->pm.power_state[state_index].clock_info[j].sclk =
2455 rdev->clock.default_sclk;
2456 if (vddc)
2457 rdev->pm.power_state[state_index].clock_info[j].voltage.voltage =
2458 vddc;
2459 if (max_vddci)
2460 rdev->pm.power_state[state_index].clock_info[j].voltage.vddci =
2461 max_vddci;
2462 }
2463 }
2464 }
2465}
2466
2467static bool radeon_atombios_parse_pplib_clock_info(struct radeon_device *rdev,
2468 int state_index, int mode_index,
2469 union pplib_clock_info *clock_info)
2470{
2471 u32 sclk, mclk;
2472 u16 vddc;
2473
2474 if (rdev->flags & RADEON_IS_IGP) {
2475 if (rdev->family >= CHIP_PALM) {
2476 sclk = le16_to_cpu(clock_info->sumo.usEngineClockLow);
2477 sclk |= clock_info->sumo.ucEngineClockHigh << 16;
2478 rdev->pm.power_state[state_index].clock_info[mode_index].sclk = sclk;
2479 } else {
2480 sclk = le16_to_cpu(clock_info->rs780.usLowEngineClockLow);
2481 sclk |= clock_info->rs780.ucLowEngineClockHigh << 16;
2482 rdev->pm.power_state[state_index].clock_info[mode_index].sclk = sclk;
2483 }
2484 } else if (rdev->family >= CHIP_BONAIRE) {
2485 sclk = le16_to_cpu(clock_info->ci.usEngineClockLow);
2486 sclk |= clock_info->ci.ucEngineClockHigh << 16;
2487 mclk = le16_to_cpu(clock_info->ci.usMemoryClockLow);
2488 mclk |= clock_info->ci.ucMemoryClockHigh << 16;
2489 rdev->pm.power_state[state_index].clock_info[mode_index].mclk = mclk;
2490 rdev->pm.power_state[state_index].clock_info[mode_index].sclk = sclk;
2491 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.type =
2492 VOLTAGE_NONE;
2493 } else if (rdev->family >= CHIP_TAHITI) {
2494 sclk = le16_to_cpu(clock_info->si.usEngineClockLow);
2495 sclk |= clock_info->si.ucEngineClockHigh << 16;
2496 mclk = le16_to_cpu(clock_info->si.usMemoryClockLow);
2497 mclk |= clock_info->si.ucMemoryClockHigh << 16;
2498 rdev->pm.power_state[state_index].clock_info[mode_index].mclk = mclk;
2499 rdev->pm.power_state[state_index].clock_info[mode_index].sclk = sclk;
2500 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.type =
2501 VOLTAGE_SW;
2502 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.voltage =
2503 le16_to_cpu(clock_info->si.usVDDC);
2504 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.vddci =
2505 le16_to_cpu(clock_info->si.usVDDCI);
2506 } else if (rdev->family >= CHIP_CEDAR) {
2507 sclk = le16_to_cpu(clock_info->evergreen.usEngineClockLow);
2508 sclk |= clock_info->evergreen.ucEngineClockHigh << 16;
2509 mclk = le16_to_cpu(clock_info->evergreen.usMemoryClockLow);
2510 mclk |= clock_info->evergreen.ucMemoryClockHigh << 16;
2511 rdev->pm.power_state[state_index].clock_info[mode_index].mclk = mclk;
2512 rdev->pm.power_state[state_index].clock_info[mode_index].sclk = sclk;
2513 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.type =
2514 VOLTAGE_SW;
2515 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.voltage =
2516 le16_to_cpu(clock_info->evergreen.usVDDC);
2517 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.vddci =
2518 le16_to_cpu(clock_info->evergreen.usVDDCI);
2519 } else {
2520 sclk = le16_to_cpu(clock_info->r600.usEngineClockLow);
2521 sclk |= clock_info->r600.ucEngineClockHigh << 16;
2522 mclk = le16_to_cpu(clock_info->r600.usMemoryClockLow);
2523 mclk |= clock_info->r600.ucMemoryClockHigh << 16;
2524 rdev->pm.power_state[state_index].clock_info[mode_index].mclk = mclk;
2525 rdev->pm.power_state[state_index].clock_info[mode_index].sclk = sclk;
2526 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.type =
2527 VOLTAGE_SW;
2528 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.voltage =
2529 le16_to_cpu(clock_info->r600.usVDDC);
2530 }
2531
2532 /* patch up vddc if necessary */
2533 switch (rdev->pm.power_state[state_index].clock_info[mode_index].voltage.voltage) {
2534 case ATOM_VIRTUAL_VOLTAGE_ID0:
2535 case ATOM_VIRTUAL_VOLTAGE_ID1:
2536 case ATOM_VIRTUAL_VOLTAGE_ID2:
2537 case ATOM_VIRTUAL_VOLTAGE_ID3:
2538 case ATOM_VIRTUAL_VOLTAGE_ID4:
2539 case ATOM_VIRTUAL_VOLTAGE_ID5:
2540 case ATOM_VIRTUAL_VOLTAGE_ID6:
2541 case ATOM_VIRTUAL_VOLTAGE_ID7:
2542 if (radeon_atom_get_max_vddc(rdev, VOLTAGE_TYPE_VDDC,
2543 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.voltage,
2544 &vddc) == 0)
2545 rdev->pm.power_state[state_index].clock_info[mode_index].voltage.voltage = vddc;
2546 break;
2547 default:
2548 break;
2549 }
2550
2551 if (rdev->flags & RADEON_IS_IGP) {
2552 /* skip invalid modes */
2553 if (rdev->pm.power_state[state_index].clock_info[mode_index].sclk == 0)
2554 return false;
2555 } else {
2556 /* skip invalid modes */
2557 if ((rdev->pm.power_state[state_index].clock_info[mode_index].mclk == 0) ||
2558 (rdev->pm.power_state[state_index].clock_info[mode_index].sclk == 0))
2559 return false;
2560 }
2561 return true;
2562}
2563
2564static int radeon_atombios_parse_power_table_4_5(struct radeon_device *rdev)
2565{
2566 struct radeon_mode_info *mode_info = &rdev->mode_info;
2567 struct _ATOM_PPLIB_NONCLOCK_INFO *non_clock_info;
2568 union pplib_power_state *power_state;
2569 int i, j;
2570 int state_index = 0, mode_index = 0;
2571 union pplib_clock_info *clock_info;
2572 bool valid;
2573 union power_info *power_info;
2574 int index = GetIndexIntoMasterTable(DATA, PowerPlayInfo);
2575 u16 data_offset;
2576 u8 frev, crev;
2577
2578 if (!atom_parse_data_header(mode_info->atom_context, index, NULL,
2579 &frev, &crev, &data_offset))
2580 return state_index;
2581 power_info = (union power_info *)(mode_info->atom_context->bios + data_offset);
2582
2583 radeon_atombios_add_pplib_thermal_controller(rdev, &power_info->pplib.sThermalController);
2584 if (power_info->pplib.ucNumStates == 0)
2585 return state_index;
2586 rdev->pm.power_state = kcalloc(power_info->pplib.ucNumStates,
2587 sizeof(struct radeon_power_state),
2588 GFP_KERNEL);
2589 if (!rdev->pm.power_state)
2590 return state_index;
2591 /* first mode is usually default, followed by low to high */
2592 for (i = 0; i < power_info->pplib.ucNumStates; i++) {
2593 mode_index = 0;
2594 power_state = (union pplib_power_state *)
2595 (mode_info->atom_context->bios + data_offset +
2596 le16_to_cpu(power_info->pplib.usStateArrayOffset) +
2597 i * power_info->pplib.ucStateEntrySize);
2598 non_clock_info = (struct _ATOM_PPLIB_NONCLOCK_INFO *)
2599 (mode_info->atom_context->bios + data_offset +
2600 le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset) +
2601 (power_state->v1.ucNonClockStateIndex *
2602 power_info->pplib.ucNonClockSize));
2603 rdev->pm.power_state[i].clock_info =
2604 kcalloc((power_info->pplib.ucStateEntrySize - 1) ?
2605 (power_info->pplib.ucStateEntrySize - 1) : 1,
2606 sizeof(struct radeon_pm_clock_info),
2607 GFP_KERNEL);
2608 if (!rdev->pm.power_state[i].clock_info)
2609 return state_index;
2610 if (power_info->pplib.ucStateEntrySize - 1) {
2611 for (j = 0; j < (power_info->pplib.ucStateEntrySize - 1); j++) {
2612 clock_info = (union pplib_clock_info *)
2613 (mode_info->atom_context->bios + data_offset +
2614 le16_to_cpu(power_info->pplib.usClockInfoArrayOffset) +
2615 (power_state->v1.ucClockStateIndices[j] *
2616 power_info->pplib.ucClockInfoSize));
2617 valid = radeon_atombios_parse_pplib_clock_info(rdev,
2618 state_index, mode_index,
2619 clock_info);
2620 if (valid)
2621 mode_index++;
2622 }
2623 } else {
2624 rdev->pm.power_state[state_index].clock_info[0].mclk =
2625 rdev->clock.default_mclk;
2626 rdev->pm.power_state[state_index].clock_info[0].sclk =
2627 rdev->clock.default_sclk;
2628 mode_index++;
2629 }
2630 rdev->pm.power_state[state_index].num_clock_modes = mode_index;
2631 if (mode_index) {
2632 radeon_atombios_parse_pplib_non_clock_info(rdev, state_index, mode_index,
2633 non_clock_info);
2634 state_index++;
2635 }
2636 }
2637 /* if multiple clock modes, mark the lowest as no display */
2638 for (i = 0; i < state_index; i++) {
2639 if (rdev->pm.power_state[i].num_clock_modes > 1)
2640 rdev->pm.power_state[i].clock_info[0].flags |=
2641 RADEON_PM_MODE_NO_DISPLAY;
2642 }
2643 /* first mode is usually default */
2644 if (rdev->pm.default_power_state_index == -1) {
2645 rdev->pm.power_state[0].type =
2646 POWER_STATE_TYPE_DEFAULT;
2647 rdev->pm.default_power_state_index = 0;
2648 rdev->pm.power_state[0].default_clock_mode =
2649 &rdev->pm.power_state[0].clock_info[0];
2650 }
2651 return state_index;
2652}
2653
2654static int radeon_atombios_parse_power_table_6(struct radeon_device *rdev)
2655{
2656 struct radeon_mode_info *mode_info = &rdev->mode_info;
2657 struct _ATOM_PPLIB_NONCLOCK_INFO *non_clock_info;
2658 union pplib_power_state *power_state;
2659 int i, j, non_clock_array_index, clock_array_index;
2660 int state_index = 0, mode_index = 0;
2661 union pplib_clock_info *clock_info;
2662 struct _StateArray *state_array;
2663 struct _ClockInfoArray *clock_info_array;
2664 struct _NonClockInfoArray *non_clock_info_array;
2665 bool valid;
2666 union power_info *power_info;
2667 int index = GetIndexIntoMasterTable(DATA, PowerPlayInfo);
2668 u16 data_offset;
2669 u8 frev, crev;
2670 u8 *power_state_offset;
2671
2672 if (!atom_parse_data_header(mode_info->atom_context, index, NULL,
2673 &frev, &crev, &data_offset))
2674 return state_index;
2675 power_info = (union power_info *)(mode_info->atom_context->bios + data_offset);
2676
2677 radeon_atombios_add_pplib_thermal_controller(rdev, &power_info->pplib.sThermalController);
2678 state_array = (struct _StateArray *)
2679 (mode_info->atom_context->bios + data_offset +
2680 le16_to_cpu(power_info->pplib.usStateArrayOffset));
2681 clock_info_array = (struct _ClockInfoArray *)
2682 (mode_info->atom_context->bios + data_offset +
2683 le16_to_cpu(power_info->pplib.usClockInfoArrayOffset));
2684 non_clock_info_array = (struct _NonClockInfoArray *)
2685 (mode_info->atom_context->bios + data_offset +
2686 le16_to_cpu(power_info->pplib.usNonClockInfoArrayOffset));
2687 if (state_array->ucNumEntries == 0)
2688 return state_index;
2689 rdev->pm.power_state = kcalloc(state_array->ucNumEntries,
2690 sizeof(struct radeon_power_state),
2691 GFP_KERNEL);
2692 if (!rdev->pm.power_state)
2693 return state_index;
2694 power_state_offset = (u8 *)state_array->states;
2695 for (i = 0; i < state_array->ucNumEntries; i++) {
2696 mode_index = 0;
2697 power_state = (union pplib_power_state *)power_state_offset;
2698 non_clock_array_index = power_state->v2.nonClockInfoIndex;
2699 non_clock_info = (struct _ATOM_PPLIB_NONCLOCK_INFO *)
2700 &non_clock_info_array->nonClockInfo[non_clock_array_index];
2701 rdev->pm.power_state[i].clock_info =
2702 kcalloc(power_state->v2.ucNumDPMLevels ?
2703 power_state->v2.ucNumDPMLevels : 1,
2704 sizeof(struct radeon_pm_clock_info),
2705 GFP_KERNEL);
2706 if (!rdev->pm.power_state[i].clock_info)
2707 return state_index;
2708 if (power_state->v2.ucNumDPMLevels) {
2709 for (j = 0; j < power_state->v2.ucNumDPMLevels; j++) {
2710 clock_array_index = power_state->v2.clockInfoIndex[j];
2711 clock_info = (union pplib_clock_info *)
2712 &clock_info_array->clockInfo[clock_array_index * clock_info_array->ucEntrySize];
2713 valid = radeon_atombios_parse_pplib_clock_info(rdev,
2714 state_index, mode_index,
2715 clock_info);
2716 if (valid)
2717 mode_index++;
2718 }
2719 } else {
2720 rdev->pm.power_state[state_index].clock_info[0].mclk =
2721 rdev->clock.default_mclk;
2722 rdev->pm.power_state[state_index].clock_info[0].sclk =
2723 rdev->clock.default_sclk;
2724 mode_index++;
2725 }
2726 rdev->pm.power_state[state_index].num_clock_modes = mode_index;
2727 if (mode_index) {
2728 radeon_atombios_parse_pplib_non_clock_info(rdev, state_index, mode_index,
2729 non_clock_info);
2730 state_index++;
2731 }
2732 power_state_offset += 2 + power_state->v2.ucNumDPMLevels;
2733 }
2734 /* if multiple clock modes, mark the lowest as no display */
2735 for (i = 0; i < state_index; i++) {
2736 if (rdev->pm.power_state[i].num_clock_modes > 1)
2737 rdev->pm.power_state[i].clock_info[0].flags |=
2738 RADEON_PM_MODE_NO_DISPLAY;
2739 }
2740 /* first mode is usually default */
2741 if (rdev->pm.default_power_state_index == -1) {
2742 rdev->pm.power_state[0].type =
2743 POWER_STATE_TYPE_DEFAULT;
2744 rdev->pm.default_power_state_index = 0;
2745 rdev->pm.power_state[0].default_clock_mode =
2746 &rdev->pm.power_state[0].clock_info[0];
2747 }
2748 return state_index;
2749}
2750
2751void radeon_atombios_get_power_modes(struct radeon_device *rdev)
2752{
2753 struct radeon_mode_info *mode_info = &rdev->mode_info;
2754 int index = GetIndexIntoMasterTable(DATA, PowerPlayInfo);
2755 u16 data_offset;
2756 u8 frev, crev;
2757 int state_index = 0;
2758
2759 rdev->pm.default_power_state_index = -1;
2760
2761 if (atom_parse_data_header(mode_info->atom_context, index, NULL,
2762 &frev, &crev, &data_offset)) {
2763 switch (frev) {
2764 case 1:
2765 case 2:
2766 case 3:
2767 state_index = radeon_atombios_parse_power_table_1_3(rdev);
2768 break;
2769 case 4:
2770 case 5:
2771 state_index = radeon_atombios_parse_power_table_4_5(rdev);
2772 break;
2773 case 6:
2774 state_index = radeon_atombios_parse_power_table_6(rdev);
2775 break;
2776 default:
2777 break;
2778 }
2779 }
2780
2781 if (state_index == 0) {
2782 rdev->pm.power_state = kzalloc(sizeof(struct radeon_power_state), GFP_KERNEL);
2783 if (rdev->pm.power_state) {
2784 rdev->pm.power_state[0].clock_info =
2785 kcalloc(1,
2786 sizeof(struct radeon_pm_clock_info),
2787 GFP_KERNEL);
2788 if (rdev->pm.power_state[0].clock_info) {
2789 /* add the default mode */
2790 rdev->pm.power_state[state_index].type =
2791 POWER_STATE_TYPE_DEFAULT;
2792 rdev->pm.power_state[state_index].num_clock_modes = 1;
2793 rdev->pm.power_state[state_index].clock_info[0].mclk = rdev->clock.default_mclk;
2794 rdev->pm.power_state[state_index].clock_info[0].sclk = rdev->clock.default_sclk;
2795 rdev->pm.power_state[state_index].default_clock_mode =
2796 &rdev->pm.power_state[state_index].clock_info[0];
2797 rdev->pm.power_state[state_index].clock_info[0].voltage.type = VOLTAGE_NONE;
2798 rdev->pm.power_state[state_index].pcie_lanes = 16;
2799 rdev->pm.default_power_state_index = state_index;
2800 rdev->pm.power_state[state_index].flags = 0;
2801 state_index++;
2802 }
2803 }
2804 }
2805
2806 rdev->pm.num_power_states = state_index;
2807
2808 rdev->pm.current_power_state_index = rdev->pm.default_power_state_index;
2809 rdev->pm.current_clock_mode_index = 0;
2810 if (rdev->pm.default_power_state_index >= 0)
2811 rdev->pm.current_vddc =
2812 rdev->pm.power_state[rdev->pm.default_power_state_index].clock_info[0].voltage.voltage;
2813 else
2814 rdev->pm.current_vddc = 0;
2815}
2816
2817union get_clock_dividers {
2818 struct _COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS v1;
2819 struct _COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V2 v2;
2820 struct _COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V3 v3;
2821 struct _COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V4 v4;
2822 struct _COMPUTE_MEMORY_ENGINE_PLL_PARAMETERS_V5 v5;
2823 struct _COMPUTE_GPU_CLOCK_INPUT_PARAMETERS_V1_6 v6_in;
2824 struct _COMPUTE_GPU_CLOCK_OUTPUT_PARAMETERS_V1_6 v6_out;
2825};
2826
2827int radeon_atom_get_clock_dividers(struct radeon_device *rdev,
2828 u8 clock_type,
2829 u32 clock,
2830 bool strobe_mode,
2831 struct atom_clock_dividers *dividers)
2832{
2833 union get_clock_dividers args;
2834 int index = GetIndexIntoMasterTable(COMMAND, ComputeMemoryEnginePLL);
2835 u8 frev, crev;
2836
2837 memset(&args, 0, sizeof(args));
2838 memset(dividers, 0, sizeof(struct atom_clock_dividers));
2839
2840 if (!atom_parse_cmd_header(rdev->mode_info.atom_context, index, &frev, &crev))
2841 return -EINVAL;
2842
2843 switch (crev) {
2844 case 1:
2845 /* r4xx, r5xx */
2846 args.v1.ucAction = clock_type;
2847 args.v1.ulClock = cpu_to_le32(clock); /* 10 khz */
2848
2849 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2850
2851 dividers->post_div = args.v1.ucPostDiv;
2852 dividers->fb_div = args.v1.ucFbDiv;
2853 dividers->enable_post_div = true;
2854 break;
2855 case 2:
2856 case 3:
2857 case 5:
2858 /* r6xx, r7xx, evergreen, ni, si */
2859 if (rdev->family <= CHIP_RV770) {
2860 args.v2.ucAction = clock_type;
2861 args.v2.ulClock = cpu_to_le32(clock); /* 10 khz */
2862
2863 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2864
2865 dividers->post_div = args.v2.ucPostDiv;
2866 dividers->fb_div = le16_to_cpu(args.v2.usFbDiv);
2867 dividers->ref_div = args.v2.ucAction;
2868 if (rdev->family == CHIP_RV770) {
2869 dividers->enable_post_div = (le32_to_cpu(args.v2.ulClock) & (1 << 24)) ?
2870 true : false;
2871 dividers->vco_mode = (le32_to_cpu(args.v2.ulClock) & (1 << 25)) ? 1 : 0;
2872 } else
2873 dividers->enable_post_div = (dividers->fb_div & 1) ? true : false;
2874 } else {
2875 if (clock_type == COMPUTE_ENGINE_PLL_PARAM) {
2876 args.v3.ulClockParams = cpu_to_le32((clock_type << 24) | clock);
2877
2878 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2879
2880 dividers->post_div = args.v3.ucPostDiv;
2881 dividers->enable_post_div = (args.v3.ucCntlFlag &
2882 ATOM_PLL_CNTL_FLAG_PLL_POST_DIV_EN) ? true : false;
2883 dividers->enable_dithen = (args.v3.ucCntlFlag &
2884 ATOM_PLL_CNTL_FLAG_FRACTION_DISABLE) ? false : true;
2885 dividers->whole_fb_div = le16_to_cpu(args.v3.ulFbDiv.usFbDiv);
2886 dividers->frac_fb_div = le16_to_cpu(args.v3.ulFbDiv.usFbDivFrac);
2887 dividers->ref_div = args.v3.ucRefDiv;
2888 dividers->vco_mode = (args.v3.ucCntlFlag &
2889 ATOM_PLL_CNTL_FLAG_MPLL_VCO_MODE) ? 1 : 0;
2890 } else {
2891 /* for SI we use ComputeMemoryClockParam for memory plls */
2892 if (rdev->family >= CHIP_TAHITI)
2893 return -EINVAL;
2894 args.v5.ulClockParams = cpu_to_le32((clock_type << 24) | clock);
2895 if (strobe_mode)
2896 args.v5.ucInputFlag = ATOM_PLL_INPUT_FLAG_PLL_STROBE_MODE_EN;
2897
2898 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2899
2900 dividers->post_div = args.v5.ucPostDiv;
2901 dividers->enable_post_div = (args.v5.ucCntlFlag &
2902 ATOM_PLL_CNTL_FLAG_PLL_POST_DIV_EN) ? true : false;
2903 dividers->enable_dithen = (args.v5.ucCntlFlag &
2904 ATOM_PLL_CNTL_FLAG_FRACTION_DISABLE) ? false : true;
2905 dividers->whole_fb_div = le16_to_cpu(args.v5.ulFbDiv.usFbDiv);
2906 dividers->frac_fb_div = le16_to_cpu(args.v5.ulFbDiv.usFbDivFrac);
2907 dividers->ref_div = args.v5.ucRefDiv;
2908 dividers->vco_mode = (args.v5.ucCntlFlag &
2909 ATOM_PLL_CNTL_FLAG_MPLL_VCO_MODE) ? 1 : 0;
2910 }
2911 }
2912 break;
2913 case 4:
2914 /* fusion */
2915 args.v4.ulClock = cpu_to_le32(clock); /* 10 khz */
2916
2917 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2918
2919 dividers->post_divider = dividers->post_div = args.v4.ucPostDiv;
2920 dividers->real_clock = le32_to_cpu(args.v4.ulClock);
2921 break;
2922 case 6:
2923 /* CI */
2924 /* COMPUTE_GPUCLK_INPUT_FLAG_DEFAULT_GPUCLK, COMPUTE_GPUCLK_INPUT_FLAG_SCLK */
2925 args.v6_in.ulClock.ulComputeClockFlag = clock_type;
2926 args.v6_in.ulClock.ulClockFreq = cpu_to_le32(clock); /* 10 khz */
2927
2928 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2929
2930 dividers->whole_fb_div = le16_to_cpu(args.v6_out.ulFbDiv.usFbDiv);
2931 dividers->frac_fb_div = le16_to_cpu(args.v6_out.ulFbDiv.usFbDivFrac);
2932 dividers->ref_div = args.v6_out.ucPllRefDiv;
2933 dividers->post_div = args.v6_out.ucPllPostDiv;
2934 dividers->flags = args.v6_out.ucPllCntlFlag;
2935 dividers->real_clock = le32_to_cpu(args.v6_out.ulClock.ulClock);
2936 dividers->post_divider = args.v6_out.ulClock.ucPostDiv;
2937 break;
2938 default:
2939 return -EINVAL;
2940 }
2941 return 0;
2942}
2943
2944int radeon_atom_get_memory_pll_dividers(struct radeon_device *rdev,
2945 u32 clock,
2946 bool strobe_mode,
2947 struct atom_mpll_param *mpll_param)
2948{
2949 COMPUTE_MEMORY_CLOCK_PARAM_PARAMETERS_V2_1 args;
2950 int index = GetIndexIntoMasterTable(COMMAND, ComputeMemoryClockParam);
2951 u8 frev, crev;
2952
2953 memset(&args, 0, sizeof(args));
2954 memset(mpll_param, 0, sizeof(struct atom_mpll_param));
2955
2956 if (!atom_parse_cmd_header(rdev->mode_info.atom_context, index, &frev, &crev))
2957 return -EINVAL;
2958
2959 switch (frev) {
2960 case 2:
2961 switch (crev) {
2962 case 1:
2963 /* SI */
2964 args.ulClock = cpu_to_le32(clock); /* 10 khz */
2965 args.ucInputFlag = 0;
2966 if (strobe_mode)
2967 args.ucInputFlag |= MPLL_INPUT_FLAG_STROBE_MODE_EN;
2968
2969 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
2970
2971 mpll_param->clkfrac = le16_to_cpu(args.ulFbDiv.usFbDivFrac);
2972 mpll_param->clkf = le16_to_cpu(args.ulFbDiv.usFbDiv);
2973 mpll_param->post_div = args.ucPostDiv;
2974 mpll_param->dll_speed = args.ucDllSpeed;
2975 mpll_param->bwcntl = args.ucBWCntl;
2976 mpll_param->vco_mode =
2977 (args.ucPllCntlFlag & MPLL_CNTL_FLAG_VCO_MODE_MASK);
2978 mpll_param->yclk_sel =
2979 (args.ucPllCntlFlag & MPLL_CNTL_FLAG_BYPASS_DQ_PLL) ? 1 : 0;
2980 mpll_param->qdr =
2981 (args.ucPllCntlFlag & MPLL_CNTL_FLAG_QDR_ENABLE) ? 1 : 0;
2982 mpll_param->half_rate =
2983 (args.ucPllCntlFlag & MPLL_CNTL_FLAG_AD_HALF_RATE) ? 1 : 0;
2984 break;
2985 default:
2986 return -EINVAL;
2987 }
2988 break;
2989 default:
2990 return -EINVAL;
2991 }
2992 return 0;
2993}
2994
2995void radeon_atom_set_clock_gating(struct radeon_device *rdev, int enable)
2996{
2997 DYNAMIC_CLOCK_GATING_PS_ALLOCATION args;
2998 int index = GetIndexIntoMasterTable(COMMAND, DynamicClockGating);
2999
3000 args.ucEnable = enable;
3001
3002 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3003}
3004
3005uint32_t radeon_atom_get_engine_clock(struct radeon_device *rdev)
3006{
3007 GET_ENGINE_CLOCK_PS_ALLOCATION args;
3008 int index = GetIndexIntoMasterTable(COMMAND, GetEngineClock);
3009
3010 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3011 return le32_to_cpu(args.ulReturnEngineClock);
3012}
3013
3014uint32_t radeon_atom_get_memory_clock(struct radeon_device *rdev)
3015{
3016 GET_MEMORY_CLOCK_PS_ALLOCATION args;
3017 int index = GetIndexIntoMasterTable(COMMAND, GetMemoryClock);
3018
3019 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3020 return le32_to_cpu(args.ulReturnMemoryClock);
3021}
3022
3023void radeon_atom_set_engine_clock(struct radeon_device *rdev,
3024 uint32_t eng_clock)
3025{
3026 SET_ENGINE_CLOCK_PS_ALLOCATION args;
3027 int index = GetIndexIntoMasterTable(COMMAND, SetEngineClock);
3028
3029 args.ulTargetEngineClock = cpu_to_le32(eng_clock); /* 10 khz */
3030
3031 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3032}
3033
3034void radeon_atom_set_memory_clock(struct radeon_device *rdev,
3035 uint32_t mem_clock)
3036{
3037 SET_MEMORY_CLOCK_PS_ALLOCATION args;
3038 int index = GetIndexIntoMasterTable(COMMAND, SetMemoryClock);
3039
3040 if (rdev->flags & RADEON_IS_IGP)
3041 return;
3042
3043 args.ulTargetMemoryClock = cpu_to_le32(mem_clock); /* 10 khz */
3044
3045 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3046}
3047
3048void radeon_atom_set_engine_dram_timings(struct radeon_device *rdev,
3049 u32 eng_clock, u32 mem_clock)
3050{
3051 SET_ENGINE_CLOCK_PS_ALLOCATION args;
3052 int index = GetIndexIntoMasterTable(COMMAND, DynamicMemorySettings);
3053 u32 tmp;
3054
3055 memset(&args, 0, sizeof(args));
3056
3057 tmp = eng_clock & SET_CLOCK_FREQ_MASK;
3058 tmp |= (COMPUTE_ENGINE_PLL_PARAM << 24);
3059
3060 args.ulTargetEngineClock = cpu_to_le32(tmp);
3061 if (mem_clock)
3062 args.sReserved.ulClock = cpu_to_le32(mem_clock & SET_CLOCK_FREQ_MASK);
3063
3064 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3065}
3066
3067void radeon_atom_update_memory_dll(struct radeon_device *rdev,
3068 u32 mem_clock)
3069{
3070 u32 args;
3071 int index = GetIndexIntoMasterTable(COMMAND, DynamicMemorySettings);
3072
3073 args = cpu_to_le32(mem_clock); /* 10 khz */
3074
3075 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3076}
3077
3078void radeon_atom_set_ac_timing(struct radeon_device *rdev,
3079 u32 mem_clock)
3080{
3081 SET_MEMORY_CLOCK_PS_ALLOCATION args;
3082 int index = GetIndexIntoMasterTable(COMMAND, DynamicMemorySettings);
3083 u32 tmp = mem_clock | (COMPUTE_MEMORY_PLL_PARAM << 24);
3084
3085 args.ulTargetMemoryClock = cpu_to_le32(tmp); /* 10 khz */
3086
3087 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3088}
3089
3090union set_voltage {
3091 struct _SET_VOLTAGE_PS_ALLOCATION alloc;
3092 struct _SET_VOLTAGE_PARAMETERS v1;
3093 struct _SET_VOLTAGE_PARAMETERS_V2 v2;
3094 struct _SET_VOLTAGE_PARAMETERS_V1_3 v3;
3095};
3096
3097void radeon_atom_set_voltage(struct radeon_device *rdev, u16 voltage_level, u8 voltage_type)
3098{
3099 union set_voltage args;
3100 int index = GetIndexIntoMasterTable(COMMAND, SetVoltage);
3101 u8 frev, crev, volt_index = voltage_level;
3102
3103 if (!atom_parse_cmd_header(rdev->mode_info.atom_context, index, &frev, &crev))
3104 return;
3105
3106 /* 0xff01 is a flag rather then an actual voltage */
3107 if (voltage_level == 0xff01)
3108 return;
3109
3110 switch (crev) {
3111 case 1:
3112 args.v1.ucVoltageType = voltage_type;
3113 args.v1.ucVoltageMode = SET_ASIC_VOLTAGE_MODE_ALL_SOURCE;
3114 args.v1.ucVoltageIndex = volt_index;
3115 break;
3116 case 2:
3117 args.v2.ucVoltageType = voltage_type;
3118 args.v2.ucVoltageMode = SET_ASIC_VOLTAGE_MODE_SET_VOLTAGE;
3119 args.v2.usVoltageLevel = cpu_to_le16(voltage_level);
3120 break;
3121 case 3:
3122 args.v3.ucVoltageType = voltage_type;
3123 args.v3.ucVoltageMode = ATOM_SET_VOLTAGE;
3124 args.v3.usVoltageLevel = cpu_to_le16(voltage_level);
3125 break;
3126 default:
3127 DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
3128 return;
3129 }
3130
3131 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3132}
3133
3134int radeon_atom_get_max_vddc(struct radeon_device *rdev, u8 voltage_type,
3135 u16 voltage_id, u16 *voltage)
3136{
3137 union set_voltage args;
3138 int index = GetIndexIntoMasterTable(COMMAND, SetVoltage);
3139 u8 frev, crev;
3140
3141 if (!atom_parse_cmd_header(rdev->mode_info.atom_context, index, &frev, &crev))
3142 return -EINVAL;
3143
3144 switch (crev) {
3145 case 1:
3146 return -EINVAL;
3147 case 2:
3148 args.v2.ucVoltageType = SET_VOLTAGE_GET_MAX_VOLTAGE;
3149 args.v2.ucVoltageMode = 0;
3150 args.v2.usVoltageLevel = 0;
3151
3152 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3153
3154 *voltage = le16_to_cpu(args.v2.usVoltageLevel);
3155 break;
3156 case 3:
3157 args.v3.ucVoltageType = voltage_type;
3158 args.v3.ucVoltageMode = ATOM_GET_VOLTAGE_LEVEL;
3159 args.v3.usVoltageLevel = cpu_to_le16(voltage_id);
3160
3161 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3162
3163 *voltage = le16_to_cpu(args.v3.usVoltageLevel);
3164 break;
3165 default:
3166 DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
3167 return -EINVAL;
3168 }
3169
3170 return 0;
3171}
3172
3173int radeon_atom_get_leakage_vddc_based_on_leakage_idx(struct radeon_device *rdev,
3174 u16 *voltage,
3175 u16 leakage_idx)
3176{
3177 return radeon_atom_get_max_vddc(rdev, VOLTAGE_TYPE_VDDC, leakage_idx, voltage);
3178}
3179
3180int radeon_atom_get_leakage_id_from_vbios(struct radeon_device *rdev,
3181 u16 *leakage_id)
3182{
3183 union set_voltage args;
3184 int index = GetIndexIntoMasterTable(COMMAND, SetVoltage);
3185 u8 frev, crev;
3186
3187 if (!atom_parse_cmd_header(rdev->mode_info.atom_context, index, &frev, &crev))
3188 return -EINVAL;
3189
3190 switch (crev) {
3191 case 3:
3192 case 4:
3193 args.v3.ucVoltageType = 0;
3194 args.v3.ucVoltageMode = ATOM_GET_LEAKAGE_ID;
3195 args.v3.usVoltageLevel = 0;
3196
3197 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3198
3199 *leakage_id = le16_to_cpu(args.v3.usVoltageLevel);
3200 break;
3201 default:
3202 DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
3203 return -EINVAL;
3204 }
3205
3206 return 0;
3207}
3208
3209int radeon_atom_get_leakage_vddc_based_on_leakage_params(struct radeon_device *rdev,
3210 u16 *vddc, u16 *vddci,
3211 u16 virtual_voltage_id,
3212 u16 vbios_voltage_id)
3213{
3214 int index = GetIndexIntoMasterTable(DATA, ASIC_ProfilingInfo);
3215 u8 frev, crev;
3216 u16 data_offset, size;
3217 int i, j;
3218 ATOM_ASIC_PROFILING_INFO_V2_1 *profile;
3219 u16 *leakage_bin, *vddc_id_buf, *vddc_buf, *vddci_id_buf, *vddci_buf;
3220
3221 *vddc = 0;
3222 *vddci = 0;
3223
3224 if (!atom_parse_data_header(rdev->mode_info.atom_context, index, &size,
3225 &frev, &crev, &data_offset))
3226 return -EINVAL;
3227
3228 profile = (ATOM_ASIC_PROFILING_INFO_V2_1 *)
3229 (rdev->mode_info.atom_context->bios + data_offset);
3230
3231 switch (frev) {
3232 case 1:
3233 return -EINVAL;
3234 case 2:
3235 switch (crev) {
3236 case 1:
3237 if (size < sizeof(ATOM_ASIC_PROFILING_INFO_V2_1))
3238 return -EINVAL;
3239 leakage_bin = (u16 *)
3240 (rdev->mode_info.atom_context->bios + data_offset +
3241 le16_to_cpu(profile->usLeakageBinArrayOffset));
3242 vddc_id_buf = (u16 *)
3243 (rdev->mode_info.atom_context->bios + data_offset +
3244 le16_to_cpu(profile->usElbVDDC_IdArrayOffset));
3245 vddc_buf = (u16 *)
3246 (rdev->mode_info.atom_context->bios + data_offset +
3247 le16_to_cpu(profile->usElbVDDC_LevelArrayOffset));
3248 vddci_id_buf = (u16 *)
3249 (rdev->mode_info.atom_context->bios + data_offset +
3250 le16_to_cpu(profile->usElbVDDCI_IdArrayOffset));
3251 vddci_buf = (u16 *)
3252 (rdev->mode_info.atom_context->bios + data_offset +
3253 le16_to_cpu(profile->usElbVDDCI_LevelArrayOffset));
3254
3255 if (profile->ucElbVDDC_Num > 0) {
3256 for (i = 0; i < profile->ucElbVDDC_Num; i++) {
3257 if (vddc_id_buf[i] == virtual_voltage_id) {
3258 for (j = 0; j < profile->ucLeakageBinNum; j++) {
3259 if (vbios_voltage_id <= leakage_bin[j]) {
3260 *vddc = vddc_buf[j * profile->ucElbVDDC_Num + i];
3261 break;
3262 }
3263 }
3264 break;
3265 }
3266 }
3267 }
3268 if (profile->ucElbVDDCI_Num > 0) {
3269 for (i = 0; i < profile->ucElbVDDCI_Num; i++) {
3270 if (vddci_id_buf[i] == virtual_voltage_id) {
3271 for (j = 0; j < profile->ucLeakageBinNum; j++) {
3272 if (vbios_voltage_id <= leakage_bin[j]) {
3273 *vddci = vddci_buf[j * profile->ucElbVDDCI_Num + i];
3274 break;
3275 }
3276 }
3277 break;
3278 }
3279 }
3280 }
3281 break;
3282 default:
3283 DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
3284 return -EINVAL;
3285 }
3286 break;
3287 default:
3288 DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
3289 return -EINVAL;
3290 }
3291
3292 return 0;
3293}
3294
3295union get_voltage_info {
3296 struct _GET_VOLTAGE_INFO_INPUT_PARAMETER_V1_2 in;
3297 struct _GET_EVV_VOLTAGE_INFO_OUTPUT_PARAMETER_V1_2 evv_out;
3298};
3299
3300int radeon_atom_get_voltage_evv(struct radeon_device *rdev,
3301 u16 virtual_voltage_id,
3302 u16 *voltage)
3303{
3304 int index = GetIndexIntoMasterTable(COMMAND, GetVoltageInfo);
3305 u32 entry_id;
3306 u32 count = rdev->pm.dpm.dyn_state.vddc_dependency_on_sclk.count;
3307 union get_voltage_info args;
3308
3309 for (entry_id = 0; entry_id < count; entry_id++) {
3310 if (rdev->pm.dpm.dyn_state.vddc_dependency_on_sclk.entries[entry_id].v ==
3311 virtual_voltage_id)
3312 break;
3313 }
3314
3315 if (entry_id >= count)
3316 return -EINVAL;
3317
3318 args.in.ucVoltageType = VOLTAGE_TYPE_VDDC;
3319 args.in.ucVoltageMode = ATOM_GET_VOLTAGE_EVV_VOLTAGE;
3320 args.in.usVoltageLevel = cpu_to_le16(virtual_voltage_id);
3321 args.in.ulSCLKFreq =
3322 cpu_to_le32(rdev->pm.dpm.dyn_state.vddc_dependency_on_sclk.entries[entry_id].clk);
3323
3324 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3325
3326 *voltage = le16_to_cpu(args.evv_out.usVoltageLevel);
3327
3328 return 0;
3329}
3330
3331int radeon_atom_get_voltage_gpio_settings(struct radeon_device *rdev,
3332 u16 voltage_level, u8 voltage_type,
3333 u32 *gpio_value, u32 *gpio_mask)
3334{
3335 union set_voltage args;
3336 int index = GetIndexIntoMasterTable(COMMAND, SetVoltage);
3337 u8 frev, crev;
3338
3339 if (!atom_parse_cmd_header(rdev->mode_info.atom_context, index, &frev, &crev))
3340 return -EINVAL;
3341
3342 switch (crev) {
3343 case 1:
3344 return -EINVAL;
3345 case 2:
3346 args.v2.ucVoltageType = voltage_type;
3347 args.v2.ucVoltageMode = SET_ASIC_VOLTAGE_MODE_GET_GPIOMASK;
3348 args.v2.usVoltageLevel = cpu_to_le16(voltage_level);
3349
3350 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3351
3352 *gpio_mask = le32_to_cpu(*(u32 *)&args.v2);
3353
3354 args.v2.ucVoltageType = voltage_type;
3355 args.v2.ucVoltageMode = SET_ASIC_VOLTAGE_MODE_GET_GPIOVAL;
3356 args.v2.usVoltageLevel = cpu_to_le16(voltage_level);
3357
3358 atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
3359
3360 *gpio_value = le32_to_cpu(*(u32 *)&args.v2);
3361 break;
3362 default:
3363 DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
3364 return -EINVAL;
3365 }
3366
3367 return 0;
3368}
3369
3370union voltage_object_info {
3371 struct _ATOM_VOLTAGE_OBJECT_INFO v1;
3372 struct _ATOM_VOLTAGE_OBJECT_INFO_V2 v2;
3373 struct _ATOM_VOLTAGE_OBJECT_INFO_V3_1 v3;
3374};
3375
3376union voltage_object {
3377 struct _ATOM_VOLTAGE_OBJECT v1;
3378 struct _ATOM_VOLTAGE_OBJECT_V2 v2;
3379 union _ATOM_VOLTAGE_OBJECT_V3 v3;
3380};
3381
3382static ATOM_VOLTAGE_OBJECT *atom_lookup_voltage_object_v1(ATOM_VOLTAGE_OBJECT_INFO *v1,
3383 u8 voltage_type)
3384{
3385 u32 size = le16_to_cpu(v1->sHeader.usStructureSize);
3386 u32 offset = offsetof(ATOM_VOLTAGE_OBJECT_INFO, asVoltageObj[0]);
3387 u8 *start = (u8 *)v1;
3388
3389 while (offset < size) {
3390 ATOM_VOLTAGE_OBJECT *vo = (ATOM_VOLTAGE_OBJECT *)(start + offset);
3391 if (vo->ucVoltageType == voltage_type)
3392 return vo;
3393 offset += offsetof(ATOM_VOLTAGE_OBJECT, asFormula.ucVIDAdjustEntries) +
3394 vo->asFormula.ucNumOfVoltageEntries;
3395 }
3396 return NULL;
3397}
3398
3399static ATOM_VOLTAGE_OBJECT_V2 *atom_lookup_voltage_object_v2(ATOM_VOLTAGE_OBJECT_INFO_V2 *v2,
3400 u8 voltage_type)
3401{
3402 u32 size = le16_to_cpu(v2->sHeader.usStructureSize);
3403 u32 offset = offsetof(ATOM_VOLTAGE_OBJECT_INFO_V2, asVoltageObj[0]);
3404 u8 *start = (u8*)v2;
3405
3406 while (offset < size) {
3407 ATOM_VOLTAGE_OBJECT_V2 *vo = (ATOM_VOLTAGE_OBJECT_V2 *)(start + offset);
3408 if (vo->ucVoltageType == voltage_type)
3409 return vo;
3410 offset += offsetof(ATOM_VOLTAGE_OBJECT_V2, asFormula.asVIDAdjustEntries) +
3411 (vo->asFormula.ucNumOfVoltageEntries * sizeof(VOLTAGE_LUT_ENTRY));
3412 }
3413 return NULL;
3414}
3415
3416static ATOM_VOLTAGE_OBJECT_V3 *atom_lookup_voltage_object_v3(ATOM_VOLTAGE_OBJECT_INFO_V3_1 *v3,
3417 u8 voltage_type, u8 voltage_mode)
3418{
3419 u32 size = le16_to_cpu(v3->sHeader.usStructureSize);
3420 u32 offset = offsetof(ATOM_VOLTAGE_OBJECT_INFO_V3_1, asVoltageObj[0]);
3421 u8 *start = (u8*)v3;
3422
3423 while (offset < size) {
3424 ATOM_VOLTAGE_OBJECT_V3 *vo = (ATOM_VOLTAGE_OBJECT_V3 *)(start + offset);
3425 if ((vo->asGpioVoltageObj.sHeader.ucVoltageType == voltage_type) &&
3426 (vo->asGpioVoltageObj.sHeader.ucVoltageMode == voltage_mode))
3427 return vo;
3428 offset += le16_to_cpu(vo->asGpioVoltageObj.sHeader.usSize);
3429 }
3430 return NULL;
3431}
3432
3433bool
3434radeon_atom_is_voltage_gpio(struct radeon_device *rdev,
3435 u8 voltage_type, u8 voltage_mode)
3436{
3437 int index = GetIndexIntoMasterTable(DATA, VoltageObjectInfo);
3438 u8 frev, crev;
3439 u16 data_offset, size;
3440 union voltage_object_info *voltage_info;
3441 union voltage_object *voltage_object = NULL;
3442
3443 if (atom_parse_data_header(rdev->mode_info.atom_context, index, &size,
3444 &frev, &crev, &data_offset)) {
3445 voltage_info = (union voltage_object_info *)
3446 (rdev->mode_info.atom_context->bios + data_offset);
3447
3448 switch (frev) {
3449 case 1:
3450 case 2:
3451 switch (crev) {
3452 case 1:
3453 voltage_object = (union voltage_object *)
3454 atom_lookup_voltage_object_v1(&voltage_info->v1, voltage_type);
3455 if (voltage_object &&
3456 (voltage_object->v1.asControl.ucVoltageControlId == VOLTAGE_CONTROLLED_BY_GPIO))
3457 return true;
3458 break;
3459 case 2:
3460 voltage_object = (union voltage_object *)
3461 atom_lookup_voltage_object_v2(&voltage_info->v2, voltage_type);
3462 if (voltage_object &&
3463 (voltage_object->v2.asControl.ucVoltageControlId == VOLTAGE_CONTROLLED_BY_GPIO))
3464 return true;
3465 break;
3466 default:
3467 DRM_ERROR("unknown voltage object table\n");
3468 return false;
3469 }
3470 break;
3471 case 3:
3472 switch (crev) {
3473 case 1:
3474 if (atom_lookup_voltage_object_v3(&voltage_info->v3,
3475 voltage_type, voltage_mode))
3476 return true;
3477 break;
3478 default:
3479 DRM_ERROR("unknown voltage object table\n");
3480 return false;
3481 }
3482 break;
3483 default:
3484 DRM_ERROR("unknown voltage object table\n");
3485 return false;
3486 }
3487
3488 }
3489 return false;
3490}
3491
3492int radeon_atom_get_svi2_info(struct radeon_device *rdev,
3493 u8 voltage_type,
3494 u8 *svd_gpio_id, u8 *svc_gpio_id)
3495{
3496 int index = GetIndexIntoMasterTable(DATA, VoltageObjectInfo);
3497 u8 frev, crev;
3498 u16 data_offset, size;
3499 union voltage_object_info *voltage_info;
3500 union voltage_object *voltage_object = NULL;
3501
3502 if (atom_parse_data_header(rdev->mode_info.atom_context, index, &size,
3503 &frev, &crev, &data_offset)) {
3504 voltage_info = (union voltage_object_info *)
3505 (rdev->mode_info.atom_context->bios + data_offset);
3506
3507 switch (frev) {
3508 case 3:
3509 switch (crev) {
3510 case 1:
3511 voltage_object = (union voltage_object *)
3512 atom_lookup_voltage_object_v3(&voltage_info->v3,
3513 voltage_type,
3514 VOLTAGE_OBJ_SVID2);
3515 if (voltage_object) {
3516 *svd_gpio_id = voltage_object->v3.asSVID2Obj.ucSVDGpioId;
3517 *svc_gpio_id = voltage_object->v3.asSVID2Obj.ucSVCGpioId;
3518 } else {
3519 return -EINVAL;
3520 }
3521 break;
3522 default:
3523 DRM_ERROR("unknown voltage object table\n");
3524 return -EINVAL;
3525 }
3526 break;
3527 default:
3528 DRM_ERROR("unknown voltage object table\n");
3529 return -EINVAL;
3530 }
3531
3532 }
3533 return 0;
3534}
3535
3536int radeon_atom_get_max_voltage(struct radeon_device *rdev,
3537 u8 voltage_type, u16 *max_voltage)
3538{
3539 int index = GetIndexIntoMasterTable(DATA, VoltageObjectInfo);
3540 u8 frev, crev;
3541 u16 data_offset, size;
3542 union voltage_object_info *voltage_info;
3543 union voltage_object *voltage_object = NULL;
3544
3545 if (atom_parse_data_header(rdev->mode_info.atom_context, index, &size,
3546 &frev, &crev, &data_offset)) {
3547 voltage_info = (union voltage_object_info *)
3548 (rdev->mode_info.atom_context->bios + data_offset);
3549
3550 switch (crev) {
3551 case 1:
3552 voltage_object = (union voltage_object *)
3553 atom_lookup_voltage_object_v1(&voltage_info->v1, voltage_type);
3554 if (voltage_object) {
3555 ATOM_VOLTAGE_FORMULA *formula =
3556 &voltage_object->v1.asFormula;
3557 if (formula->ucFlag & 1)
3558 *max_voltage =
3559 le16_to_cpu(formula->usVoltageBaseLevel) +
3560 formula->ucNumOfVoltageEntries / 2 *
3561 le16_to_cpu(formula->usVoltageStep);
3562 else
3563 *max_voltage =
3564 le16_to_cpu(formula->usVoltageBaseLevel) +
3565 (formula->ucNumOfVoltageEntries - 1) *
3566 le16_to_cpu(formula->usVoltageStep);
3567 return 0;
3568 }
3569 break;
3570 case 2:
3571 voltage_object = (union voltage_object *)
3572 atom_lookup_voltage_object_v2(&voltage_info->v2, voltage_type);
3573 if (voltage_object) {
3574 ATOM_VOLTAGE_FORMULA_V2 *formula =
3575 &voltage_object->v2.asFormula;
3576 if (formula->ucNumOfVoltageEntries) {
3577 VOLTAGE_LUT_ENTRY *lut = (VOLTAGE_LUT_ENTRY *)
3578 ((u8 *)&formula->asVIDAdjustEntries[0] +
3579 (sizeof(VOLTAGE_LUT_ENTRY) * (formula->ucNumOfVoltageEntries - 1)));
3580 *max_voltage =
3581 le16_to_cpu(lut->usVoltageValue);
3582 return 0;
3583 }
3584 }
3585 break;
3586 default:
3587 DRM_ERROR("unknown voltage object table\n");
3588 return -EINVAL;
3589 }
3590
3591 }
3592 return -EINVAL;
3593}
3594
3595int radeon_atom_get_min_voltage(struct radeon_device *rdev,
3596 u8 voltage_type, u16 *min_voltage)
3597{
3598 int index = GetIndexIntoMasterTable(DATA, VoltageObjectInfo);
3599 u8 frev, crev;
3600 u16 data_offset, size;
3601 union voltage_object_info *voltage_info;
3602 union voltage_object *voltage_object = NULL;
3603
3604 if (atom_parse_data_header(rdev->mode_info.atom_context, index, &size,
3605 &frev, &crev, &data_offset)) {
3606 voltage_info = (union voltage_object_info *)
3607 (rdev->mode_info.atom_context->bios + data_offset);
3608
3609 switch (crev) {
3610 case 1:
3611 voltage_object = (union voltage_object *)
3612 atom_lookup_voltage_object_v1(&voltage_info->v1, voltage_type);
3613 if (voltage_object) {
3614 ATOM_VOLTAGE_FORMULA *formula =
3615 &voltage_object->v1.asFormula;
3616 *min_voltage =
3617 le16_to_cpu(formula->usVoltageBaseLevel);
3618 return 0;
3619 }
3620 break;
3621 case 2:
3622 voltage_object = (union voltage_object *)
3623 atom_lookup_voltage_object_v2(&voltage_info->v2, voltage_type);
3624 if (voltage_object) {
3625 ATOM_VOLTAGE_FORMULA_V2 *formula =
3626 &voltage_object->v2.asFormula;
3627 if (formula->ucNumOfVoltageEntries) {
3628 *min_voltage =
3629 le16_to_cpu(formula->asVIDAdjustEntries[
3630 0
3631 ].usVoltageValue);
3632 return 0;
3633 }
3634 }
3635 break;
3636 default:
3637 DRM_ERROR("unknown voltage object table\n");
3638 return -EINVAL;
3639 }
3640
3641 }
3642 return -EINVAL;
3643}
3644
3645int radeon_atom_get_voltage_step(struct radeon_device *rdev,
3646 u8 voltage_type, u16 *voltage_step)
3647{
3648 int index = GetIndexIntoMasterTable(DATA, VoltageObjectInfo);
3649 u8 frev, crev;
3650 u16 data_offset, size;
3651 union voltage_object_info *voltage_info;
3652 union voltage_object *voltage_object = NULL;
3653
3654 if (atom_parse_data_header(rdev->mode_info.atom_context, index, &size,
3655 &frev, &crev, &data_offset)) {
3656 voltage_info = (union voltage_object_info *)
3657 (rdev->mode_info.atom_context->bios + data_offset);
3658
3659 switch (crev) {
3660 case 1:
3661 voltage_object = (union voltage_object *)
3662 atom_lookup_voltage_object_v1(&voltage_info->v1, voltage_type);
3663 if (voltage_object) {
3664 ATOM_VOLTAGE_FORMULA *formula =
3665 &voltage_object->v1.asFormula;
3666 if (formula->ucFlag & 1)
3667 *voltage_step =
3668 (le16_to_cpu(formula->usVoltageStep) + 1) / 2;
3669 else
3670 *voltage_step =
3671 le16_to_cpu(formula->usVoltageStep);
3672 return 0;
3673 }
3674 break;
3675 case 2:
3676 return -EINVAL;
3677 default:
3678 DRM_ERROR("unknown voltage object table\n");
3679 return -EINVAL;
3680 }
3681
3682 }
3683 return -EINVAL;
3684}
3685
3686int radeon_atom_round_to_true_voltage(struct radeon_device *rdev,
3687 u8 voltage_type,
3688 u16 nominal_voltage,
3689 u16 *true_voltage)
3690{
3691 u16 min_voltage, max_voltage, voltage_step;
3692
3693 if (radeon_atom_get_max_voltage(rdev, voltage_type, &max_voltage))
3694 return -EINVAL;
3695 if (radeon_atom_get_min_voltage(rdev, voltage_type, &min_voltage))
3696 return -EINVAL;
3697 if (radeon_atom_get_voltage_step(rdev, voltage_type, &voltage_step))
3698 return -EINVAL;
3699
3700 if (nominal_voltage <= min_voltage)
3701 *true_voltage = min_voltage;
3702 else if (nominal_voltage >= max_voltage)
3703 *true_voltage = max_voltage;
3704 else
3705 *true_voltage = min_voltage +
3706 ((nominal_voltage - min_voltage) / voltage_step) *
3707 voltage_step;
3708
3709 return 0;
3710}
3711
3712int radeon_atom_get_voltage_table(struct radeon_device *rdev,
3713 u8 voltage_type, u8 voltage_mode,
3714 struct atom_voltage_table *voltage_table)
3715{
3716 int index = GetIndexIntoMasterTable(DATA, VoltageObjectInfo);
3717 u8 frev, crev;
3718 u16 data_offset, size;
3719 int i, ret;
3720 union voltage_object_info *voltage_info;
3721 union voltage_object *voltage_object = NULL;
3722
3723 if (atom_parse_data_header(rdev->mode_info.atom_context, index, &size,
3724 &frev, &crev, &data_offset)) {
3725 voltage_info = (union voltage_object_info *)
3726 (rdev->mode_info.atom_context->bios + data_offset);
3727
3728 switch (frev) {
3729 case 1:
3730 case 2:
3731 switch (crev) {
3732 case 1:
3733 DRM_ERROR("old table version %d, %d\n", frev, crev);
3734 return -EINVAL;
3735 case 2:
3736 voltage_object = (union voltage_object *)
3737 atom_lookup_voltage_object_v2(&voltage_info->v2, voltage_type);
3738 if (voltage_object) {
3739 ATOM_VOLTAGE_FORMULA_V2 *formula =
3740 &voltage_object->v2.asFormula;
3741 VOLTAGE_LUT_ENTRY *lut;
3742 if (formula->ucNumOfVoltageEntries > MAX_VOLTAGE_ENTRIES)
3743 return -EINVAL;
3744 lut = &formula->asVIDAdjustEntries[0];
3745 for (i = 0; i < formula->ucNumOfVoltageEntries; i++) {
3746 voltage_table->entries[i].value =
3747 le16_to_cpu(lut->usVoltageValue);
3748 ret = radeon_atom_get_voltage_gpio_settings(rdev,
3749 voltage_table->entries[i].value,
3750 voltage_type,
3751 &voltage_table->entries[i].smio_low,
3752 &voltage_table->mask_low);
3753 if (ret)
3754 return ret;
3755 lut = (VOLTAGE_LUT_ENTRY *)
3756 ((u8 *)lut + sizeof(VOLTAGE_LUT_ENTRY));
3757 }
3758 voltage_table->count = formula->ucNumOfVoltageEntries;
3759 return 0;
3760 }
3761 break;
3762 default:
3763 DRM_ERROR("unknown voltage object table\n");
3764 return -EINVAL;
3765 }
3766 break;
3767 case 3:
3768 switch (crev) {
3769 case 1:
3770 voltage_object = (union voltage_object *)
3771 atom_lookup_voltage_object_v3(&voltage_info->v3,
3772 voltage_type, voltage_mode);
3773 if (voltage_object) {
3774 ATOM_GPIO_VOLTAGE_OBJECT_V3 *gpio =
3775 &voltage_object->v3.asGpioVoltageObj;
3776 VOLTAGE_LUT_ENTRY_V2 *lut;
3777 if (gpio->ucGpioEntryNum > MAX_VOLTAGE_ENTRIES)
3778 return -EINVAL;
3779 lut = &gpio->asVolGpioLut[0];
3780 for (i = 0; i < gpio->ucGpioEntryNum; i++) {
3781 voltage_table->entries[i].value =
3782 le16_to_cpu(lut->usVoltageValue);
3783 voltage_table->entries[i].smio_low =
3784 le32_to_cpu(lut->ulVoltageId);
3785 lut = (VOLTAGE_LUT_ENTRY_V2 *)
3786 ((u8 *)lut + sizeof(VOLTAGE_LUT_ENTRY_V2));
3787 }
3788 voltage_table->mask_low = le32_to_cpu(gpio->ulGpioMaskVal);
3789 voltage_table->count = gpio->ucGpioEntryNum;
3790 voltage_table->phase_delay = gpio->ucPhaseDelay;
3791 return 0;
3792 }
3793 break;
3794 default:
3795 DRM_ERROR("unknown voltage object table\n");
3796 return -EINVAL;
3797 }
3798 break;
3799 default:
3800 DRM_ERROR("unknown voltage object table\n");
3801 return -EINVAL;
3802 }
3803 }
3804 return -EINVAL;
3805}
3806
3807union vram_info {
3808 struct _ATOM_VRAM_INFO_V3 v1_3;
3809 struct _ATOM_VRAM_INFO_V4 v1_4;
3810 struct _ATOM_VRAM_INFO_HEADER_V2_1 v2_1;
3811};
3812
3813int radeon_atom_get_memory_info(struct radeon_device *rdev,
3814 u8 module_index, struct atom_memory_info *mem_info)
3815{
3816 int index = GetIndexIntoMasterTable(DATA, VRAM_Info);
3817 u8 frev, crev, i;
3818 u16 data_offset, size;
3819 union vram_info *vram_info;
3820
3821 memset(mem_info, 0, sizeof(struct atom_memory_info));
3822
3823 if (atom_parse_data_header(rdev->mode_info.atom_context, index, &size,
3824 &frev, &crev, &data_offset)) {
3825 vram_info = (union vram_info *)
3826 (rdev->mode_info.atom_context->bios + data_offset);
3827 switch (frev) {
3828 case 1:
3829 switch (crev) {
3830 case 3:
3831 /* r6xx */
3832 if (module_index < vram_info->v1_3.ucNumOfVRAMModule) {
3833 ATOM_VRAM_MODULE_V3 *vram_module =
3834 (ATOM_VRAM_MODULE_V3 *)vram_info->v1_3.aVramInfo;
3835
3836 for (i = 0; i < module_index; i++) {
3837 if (le16_to_cpu(vram_module->usSize) == 0)
3838 return -EINVAL;
3839 vram_module = (ATOM_VRAM_MODULE_V3 *)
3840 ((u8 *)vram_module + le16_to_cpu(vram_module->usSize));
3841 }
3842 mem_info->mem_vendor = vram_module->asMemory.ucMemoryVenderID & 0xf;
3843 mem_info->mem_type = vram_module->asMemory.ucMemoryType & 0xf0;
3844 } else
3845 return -EINVAL;
3846 break;
3847 case 4:
3848 /* r7xx, evergreen */
3849 if (module_index < vram_info->v1_4.ucNumOfVRAMModule) {
3850 ATOM_VRAM_MODULE_V4 *vram_module =
3851 (ATOM_VRAM_MODULE_V4 *)vram_info->v1_4.aVramInfo;
3852
3853 for (i = 0; i < module_index; i++) {
3854 if (le16_to_cpu(vram_module->usModuleSize) == 0)
3855 return -EINVAL;
3856 vram_module = (ATOM_VRAM_MODULE_V4 *)
3857 ((u8 *)vram_module + le16_to_cpu(vram_module->usModuleSize));
3858 }
3859 mem_info->mem_vendor = vram_module->ucMemoryVenderID & 0xf;
3860 mem_info->mem_type = vram_module->ucMemoryType & 0xf0;
3861 } else
3862 return -EINVAL;
3863 break;
3864 default:
3865 DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
3866 return -EINVAL;
3867 }
3868 break;
3869 case 2:
3870 switch (crev) {
3871 case 1:
3872 /* ni */
3873 if (module_index < vram_info->v2_1.ucNumOfVRAMModule) {
3874 ATOM_VRAM_MODULE_V7 *vram_module =
3875 (ATOM_VRAM_MODULE_V7 *)vram_info->v2_1.aVramInfo;
3876
3877 for (i = 0; i < module_index; i++) {
3878 if (le16_to_cpu(vram_module->usModuleSize) == 0)
3879 return -EINVAL;
3880 vram_module = (ATOM_VRAM_MODULE_V7 *)
3881 ((u8 *)vram_module + le16_to_cpu(vram_module->usModuleSize));
3882 }
3883 mem_info->mem_vendor = vram_module->ucMemoryVenderID & 0xf;
3884 mem_info->mem_type = vram_module->ucMemoryType & 0xf0;
3885 } else
3886 return -EINVAL;
3887 break;
3888 default:
3889 DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
3890 return -EINVAL;
3891 }
3892 break;
3893 default:
3894 DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
3895 return -EINVAL;
3896 }
3897 return 0;
3898 }
3899 return -EINVAL;
3900}
3901
3902int radeon_atom_get_mclk_range_table(struct radeon_device *rdev,
3903 bool gddr5, u8 module_index,
3904 struct atom_memory_clock_range_table *mclk_range_table)
3905{
3906 int index = GetIndexIntoMasterTable(DATA, VRAM_Info);
3907 u8 frev, crev, i;
3908 u16 data_offset, size;
3909 union vram_info *vram_info;
3910 u32 mem_timing_size = gddr5 ?
3911 sizeof(ATOM_MEMORY_TIMING_FORMAT_V2) : sizeof(ATOM_MEMORY_TIMING_FORMAT);
3912
3913 memset(mclk_range_table, 0, sizeof(struct atom_memory_clock_range_table));
3914
3915 if (atom_parse_data_header(rdev->mode_info.atom_context, index, &size,
3916 &frev, &crev, &data_offset)) {
3917 vram_info = (union vram_info *)
3918 (rdev->mode_info.atom_context->bios + data_offset);
3919 switch (frev) {
3920 case 1:
3921 switch (crev) {
3922 case 3:
3923 DRM_ERROR("old table version %d, %d\n", frev, crev);
3924 return -EINVAL;
3925 case 4:
3926 /* r7xx, evergreen */
3927 if (module_index < vram_info->v1_4.ucNumOfVRAMModule) {
3928 ATOM_VRAM_MODULE_V4 *vram_module =
3929 (ATOM_VRAM_MODULE_V4 *)vram_info->v1_4.aVramInfo;
3930 ATOM_MEMORY_TIMING_FORMAT *format;
3931
3932 for (i = 0; i < module_index; i++) {
3933 if (le16_to_cpu(vram_module->usModuleSize) == 0)
3934 return -EINVAL;
3935 vram_module = (ATOM_VRAM_MODULE_V4 *)
3936 ((u8 *)vram_module + le16_to_cpu(vram_module->usModuleSize));
3937 }
3938 mclk_range_table->num_entries = (u8)
3939 ((le16_to_cpu(vram_module->usModuleSize) - offsetof(ATOM_VRAM_MODULE_V4, asMemTiming)) /
3940 mem_timing_size);
3941 format = &vram_module->asMemTiming[0];
3942 for (i = 0; i < mclk_range_table->num_entries; i++) {
3943 mclk_range_table->mclk[i] = le32_to_cpu(format->ulClkRange);
3944 format = (ATOM_MEMORY_TIMING_FORMAT *)
3945 ((u8 *)format + mem_timing_size);
3946 }
3947 } else
3948 return -EINVAL;
3949 break;
3950 default:
3951 DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
3952 return -EINVAL;
3953 }
3954 break;
3955 case 2:
3956 DRM_ERROR("new table version %d, %d\n", frev, crev);
3957 return -EINVAL;
3958 default:
3959 DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
3960 return -EINVAL;
3961 }
3962 return 0;
3963 }
3964 return -EINVAL;
3965}
3966
3967#define MEM_ID_MASK 0xff000000
3968#define MEM_ID_SHIFT 24
3969#define CLOCK_RANGE_MASK 0x00ffffff
3970#define CLOCK_RANGE_SHIFT 0
3971#define LOW_NIBBLE_MASK 0xf
3972#define DATA_EQU_PREV 0
3973#define DATA_FROM_TABLE 4
3974
3975int radeon_atom_init_mc_reg_table(struct radeon_device *rdev,
3976 u8 module_index,
3977 struct atom_mc_reg_table *reg_table)
3978{
3979 int index = GetIndexIntoMasterTable(DATA, VRAM_Info);
3980 u8 frev, crev, num_entries, t_mem_id, num_ranges = 0;
3981 u32 i = 0, j;
3982 u16 data_offset, size;
3983 union vram_info *vram_info;
3984
3985 memset(reg_table, 0, sizeof(struct atom_mc_reg_table));
3986
3987 if (atom_parse_data_header(rdev->mode_info.atom_context, index, &size,
3988 &frev, &crev, &data_offset)) {
3989 vram_info = (union vram_info *)
3990 (rdev->mode_info.atom_context->bios + data_offset);
3991 switch (frev) {
3992 case 1:
3993 DRM_ERROR("old table version %d, %d\n", frev, crev);
3994 return -EINVAL;
3995 case 2:
3996 switch (crev) {
3997 case 1:
3998 if (module_index < vram_info->v2_1.ucNumOfVRAMModule) {
3999 ATOM_INIT_REG_BLOCK *reg_block =
4000 (ATOM_INIT_REG_BLOCK *)
4001 ((u8 *)vram_info + le16_to_cpu(vram_info->v2_1.usMemClkPatchTblOffset));
4002 ATOM_MEMORY_SETTING_DATA_BLOCK *reg_data =
4003 (ATOM_MEMORY_SETTING_DATA_BLOCK *)
4004 ((u8 *)reg_block + (2 * sizeof(u16)) +
4005 le16_to_cpu(reg_block->usRegIndexTblSize));
4006 ATOM_INIT_REG_INDEX_FORMAT *format = ®_block->asRegIndexBuf[0];
4007 num_entries = (u8)((le16_to_cpu(reg_block->usRegIndexTblSize)) /
4008 sizeof(ATOM_INIT_REG_INDEX_FORMAT)) - 1;
4009 if (num_entries > VBIOS_MC_REGISTER_ARRAY_SIZE)
4010 return -EINVAL;
4011 while (i < num_entries) {
4012 if (format->ucPreRegDataLength & ACCESS_PLACEHOLDER)
4013 break;
4014 reg_table->mc_reg_address[i].s1 =
4015 (u16)(le16_to_cpu(format->usRegIndex));
4016 reg_table->mc_reg_address[i].pre_reg_data =
4017 (u8)(format->ucPreRegDataLength);
4018 i++;
4019 format = (ATOM_INIT_REG_INDEX_FORMAT *)
4020 ((u8 *)format + sizeof(ATOM_INIT_REG_INDEX_FORMAT));
4021 }
4022 reg_table->last = i;
4023 while ((le32_to_cpu(*(u32 *)reg_data) != END_OF_REG_DATA_BLOCK) &&
4024 (num_ranges < VBIOS_MAX_AC_TIMING_ENTRIES)) {
4025 t_mem_id = (u8)((le32_to_cpu(*(u32 *)reg_data) & MEM_ID_MASK)
4026 >> MEM_ID_SHIFT);
4027 if (module_index == t_mem_id) {
4028 reg_table->mc_reg_table_entry[num_ranges].mclk_max =
4029 (u32)((le32_to_cpu(*(u32 *)reg_data) & CLOCK_RANGE_MASK)
4030 >> CLOCK_RANGE_SHIFT);
4031 for (i = 0, j = 1; i < reg_table->last; i++) {
4032 if ((reg_table->mc_reg_address[i].pre_reg_data & LOW_NIBBLE_MASK) == DATA_FROM_TABLE) {
4033 reg_table->mc_reg_table_entry[num_ranges].mc_data[i] =
4034 (u32)le32_to_cpu(*((u32 *)reg_data + j));
4035 j++;
4036 } else if ((reg_table->mc_reg_address[i].pre_reg_data & LOW_NIBBLE_MASK) == DATA_EQU_PREV) {
4037 reg_table->mc_reg_table_entry[num_ranges].mc_data[i] =
4038 reg_table->mc_reg_table_entry[num_ranges].mc_data[i - 1];
4039 }
4040 }
4041 num_ranges++;
4042 }
4043 reg_data = (ATOM_MEMORY_SETTING_DATA_BLOCK *)
4044 ((u8 *)reg_data + le16_to_cpu(reg_block->usRegDataBlkSize));
4045 }
4046 if (le32_to_cpu(*(u32 *)reg_data) != END_OF_REG_DATA_BLOCK)
4047 return -EINVAL;
4048 reg_table->num_entries = num_ranges;
4049 } else
4050 return -EINVAL;
4051 break;
4052 default:
4053 DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
4054 return -EINVAL;
4055 }
4056 break;
4057 default:
4058 DRM_ERROR("Unknown table version %d, %d\n", frev, crev);
4059 return -EINVAL;
4060 }
4061 return 0;
4062 }
4063 return -EINVAL;
4064}
4065
4066void radeon_atom_initialize_bios_scratch_regs(struct drm_device *dev)
4067{
4068 struct radeon_device *rdev = dev->dev_private;
4069 uint32_t bios_2_scratch, bios_6_scratch;
4070
4071 if (rdev->family >= CHIP_R600) {
4072 bios_2_scratch = RREG32(R600_BIOS_2_SCRATCH);
4073 bios_6_scratch = RREG32(R600_BIOS_6_SCRATCH);
4074 } else {
4075 bios_2_scratch = RREG32(RADEON_BIOS_2_SCRATCH);
4076 bios_6_scratch = RREG32(RADEON_BIOS_6_SCRATCH);
4077 }
4078
4079 /* let the bios control the backlight */
4080 bios_2_scratch &= ~ATOM_S2_VRI_BRIGHT_ENABLE;
4081
4082 /* tell the bios not to handle mode switching */
4083 bios_6_scratch |= ATOM_S6_ACC_BLOCK_DISPLAY_SWITCH;
4084
4085 /* clear the vbios dpms state */
4086 if (ASIC_IS_DCE4(rdev))
4087 bios_2_scratch &= ~ATOM_S2_DEVICE_DPMS_STATE;
4088
4089 if (rdev->family >= CHIP_R600) {
4090 WREG32(R600_BIOS_2_SCRATCH, bios_2_scratch);
4091 WREG32(R600_BIOS_6_SCRATCH, bios_6_scratch);
4092 } else {
4093 WREG32(RADEON_BIOS_2_SCRATCH, bios_2_scratch);
4094 WREG32(RADEON_BIOS_6_SCRATCH, bios_6_scratch);
4095 }
4096
4097}
4098
4099void radeon_save_bios_scratch_regs(struct radeon_device *rdev)
4100{
4101 uint32_t scratch_reg;
4102 int i;
4103
4104 if (rdev->family >= CHIP_R600)
4105 scratch_reg = R600_BIOS_0_SCRATCH;
4106 else
4107 scratch_reg = RADEON_BIOS_0_SCRATCH;
4108
4109 for (i = 0; i < RADEON_BIOS_NUM_SCRATCH; i++)
4110 rdev->bios_scratch[i] = RREG32(scratch_reg + (i * 4));
4111}
4112
4113void radeon_restore_bios_scratch_regs(struct radeon_device *rdev)
4114{
4115 uint32_t scratch_reg;
4116 int i;
4117
4118 if (rdev->family >= CHIP_R600)
4119 scratch_reg = R600_BIOS_0_SCRATCH;
4120 else
4121 scratch_reg = RADEON_BIOS_0_SCRATCH;
4122
4123 for (i = 0; i < RADEON_BIOS_NUM_SCRATCH; i++)
4124 WREG32(scratch_reg + (i * 4), rdev->bios_scratch[i]);
4125}
4126
4127void radeon_atom_output_lock(struct drm_encoder *encoder, bool lock)
4128{
4129 struct drm_device *dev = encoder->dev;
4130 struct radeon_device *rdev = dev->dev_private;
4131 uint32_t bios_6_scratch;
4132
4133 if (rdev->family >= CHIP_R600)
4134 bios_6_scratch = RREG32(R600_BIOS_6_SCRATCH);
4135 else
4136 bios_6_scratch = RREG32(RADEON_BIOS_6_SCRATCH);
4137
4138 if (lock) {
4139 bios_6_scratch |= ATOM_S6_CRITICAL_STATE;
4140 bios_6_scratch &= ~ATOM_S6_ACC_MODE;
4141 } else {
4142 bios_6_scratch &= ~ATOM_S6_CRITICAL_STATE;
4143 bios_6_scratch |= ATOM_S6_ACC_MODE;
4144 }
4145
4146 if (rdev->family >= CHIP_R600)
4147 WREG32(R600_BIOS_6_SCRATCH, bios_6_scratch);
4148 else
4149 WREG32(RADEON_BIOS_6_SCRATCH, bios_6_scratch);
4150}
4151
4152/* at some point we may want to break this out into individual functions */
4153void
4154radeon_atombios_connected_scratch_regs(struct drm_connector *connector,
4155 struct drm_encoder *encoder,
4156 bool connected)
4157{
4158 struct drm_device *dev = connector->dev;
4159 struct radeon_device *rdev = dev->dev_private;
4160 struct radeon_connector *radeon_connector =
4161 to_radeon_connector(connector);
4162 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
4163 uint32_t bios_0_scratch, bios_3_scratch, bios_6_scratch;
4164
4165 if (rdev->family >= CHIP_R600) {
4166 bios_0_scratch = RREG32(R600_BIOS_0_SCRATCH);
4167 bios_3_scratch = RREG32(R600_BIOS_3_SCRATCH);
4168 bios_6_scratch = RREG32(R600_BIOS_6_SCRATCH);
4169 } else {
4170 bios_0_scratch = RREG32(RADEON_BIOS_0_SCRATCH);
4171 bios_3_scratch = RREG32(RADEON_BIOS_3_SCRATCH);
4172 bios_6_scratch = RREG32(RADEON_BIOS_6_SCRATCH);
4173 }
4174
4175 if ((radeon_encoder->devices & ATOM_DEVICE_TV1_SUPPORT) &&
4176 (radeon_connector->devices & ATOM_DEVICE_TV1_SUPPORT)) {
4177 if (connected) {
4178 DRM_DEBUG_KMS("TV1 connected\n");
4179 bios_3_scratch |= ATOM_S3_TV1_ACTIVE;
4180 bios_6_scratch |= ATOM_S6_ACC_REQ_TV1;
4181 } else {
4182 DRM_DEBUG_KMS("TV1 disconnected\n");
4183 bios_0_scratch &= ~ATOM_S0_TV1_MASK;
4184 bios_3_scratch &= ~ATOM_S3_TV1_ACTIVE;
4185 bios_6_scratch &= ~ATOM_S6_ACC_REQ_TV1;
4186 }
4187 }
4188 if ((radeon_encoder->devices & ATOM_DEVICE_CV_SUPPORT) &&
4189 (radeon_connector->devices & ATOM_DEVICE_CV_SUPPORT)) {
4190 if (connected) {
4191 DRM_DEBUG_KMS("CV connected\n");
4192 bios_3_scratch |= ATOM_S3_CV_ACTIVE;
4193 bios_6_scratch |= ATOM_S6_ACC_REQ_CV;
4194 } else {
4195 DRM_DEBUG_KMS("CV disconnected\n");
4196 bios_0_scratch &= ~ATOM_S0_CV_MASK;
4197 bios_3_scratch &= ~ATOM_S3_CV_ACTIVE;
4198 bios_6_scratch &= ~ATOM_S6_ACC_REQ_CV;
4199 }
4200 }
4201 if ((radeon_encoder->devices & ATOM_DEVICE_LCD1_SUPPORT) &&
4202 (radeon_connector->devices & ATOM_DEVICE_LCD1_SUPPORT)) {
4203 if (connected) {
4204 DRM_DEBUG_KMS("LCD1 connected\n");
4205 bios_0_scratch |= ATOM_S0_LCD1;
4206 bios_3_scratch |= ATOM_S3_LCD1_ACTIVE;
4207 bios_6_scratch |= ATOM_S6_ACC_REQ_LCD1;
4208 } else {
4209 DRM_DEBUG_KMS("LCD1 disconnected\n");
4210 bios_0_scratch &= ~ATOM_S0_LCD1;
4211 bios_3_scratch &= ~ATOM_S3_LCD1_ACTIVE;
4212 bios_6_scratch &= ~ATOM_S6_ACC_REQ_LCD1;
4213 }
4214 }
4215 if ((radeon_encoder->devices & ATOM_DEVICE_CRT1_SUPPORT) &&
4216 (radeon_connector->devices & ATOM_DEVICE_CRT1_SUPPORT)) {
4217 if (connected) {
4218 DRM_DEBUG_KMS("CRT1 connected\n");
4219 bios_0_scratch |= ATOM_S0_CRT1_COLOR;
4220 bios_3_scratch |= ATOM_S3_CRT1_ACTIVE;
4221 bios_6_scratch |= ATOM_S6_ACC_REQ_CRT1;
4222 } else {
4223 DRM_DEBUG_KMS("CRT1 disconnected\n");
4224 bios_0_scratch &= ~ATOM_S0_CRT1_MASK;
4225 bios_3_scratch &= ~ATOM_S3_CRT1_ACTIVE;
4226 bios_6_scratch &= ~ATOM_S6_ACC_REQ_CRT1;
4227 }
4228 }
4229 if ((radeon_encoder->devices & ATOM_DEVICE_CRT2_SUPPORT) &&
4230 (radeon_connector->devices & ATOM_DEVICE_CRT2_SUPPORT)) {
4231 if (connected) {
4232 DRM_DEBUG_KMS("CRT2 connected\n");
4233 bios_0_scratch |= ATOM_S0_CRT2_COLOR;
4234 bios_3_scratch |= ATOM_S3_CRT2_ACTIVE;
4235 bios_6_scratch |= ATOM_S6_ACC_REQ_CRT2;
4236 } else {
4237 DRM_DEBUG_KMS("CRT2 disconnected\n");
4238 bios_0_scratch &= ~ATOM_S0_CRT2_MASK;
4239 bios_3_scratch &= ~ATOM_S3_CRT2_ACTIVE;
4240 bios_6_scratch &= ~ATOM_S6_ACC_REQ_CRT2;
4241 }
4242 }
4243 if ((radeon_encoder->devices & ATOM_DEVICE_DFP1_SUPPORT) &&
4244 (radeon_connector->devices & ATOM_DEVICE_DFP1_SUPPORT)) {
4245 if (connected) {
4246 DRM_DEBUG_KMS("DFP1 connected\n");
4247 bios_0_scratch |= ATOM_S0_DFP1;
4248 bios_3_scratch |= ATOM_S3_DFP1_ACTIVE;
4249 bios_6_scratch |= ATOM_S6_ACC_REQ_DFP1;
4250 } else {
4251 DRM_DEBUG_KMS("DFP1 disconnected\n");
4252 bios_0_scratch &= ~ATOM_S0_DFP1;
4253 bios_3_scratch &= ~ATOM_S3_DFP1_ACTIVE;
4254 bios_6_scratch &= ~ATOM_S6_ACC_REQ_DFP1;
4255 }
4256 }
4257 if ((radeon_encoder->devices & ATOM_DEVICE_DFP2_SUPPORT) &&
4258 (radeon_connector->devices & ATOM_DEVICE_DFP2_SUPPORT)) {
4259 if (connected) {
4260 DRM_DEBUG_KMS("DFP2 connected\n");
4261 bios_0_scratch |= ATOM_S0_DFP2;
4262 bios_3_scratch |= ATOM_S3_DFP2_ACTIVE;
4263 bios_6_scratch |= ATOM_S6_ACC_REQ_DFP2;
4264 } else {
4265 DRM_DEBUG_KMS("DFP2 disconnected\n");
4266 bios_0_scratch &= ~ATOM_S0_DFP2;
4267 bios_3_scratch &= ~ATOM_S3_DFP2_ACTIVE;
4268 bios_6_scratch &= ~ATOM_S6_ACC_REQ_DFP2;
4269 }
4270 }
4271 if ((radeon_encoder->devices & ATOM_DEVICE_DFP3_SUPPORT) &&
4272 (radeon_connector->devices & ATOM_DEVICE_DFP3_SUPPORT)) {
4273 if (connected) {
4274 DRM_DEBUG_KMS("DFP3 connected\n");
4275 bios_0_scratch |= ATOM_S0_DFP3;
4276 bios_3_scratch |= ATOM_S3_DFP3_ACTIVE;
4277 bios_6_scratch |= ATOM_S6_ACC_REQ_DFP3;
4278 } else {
4279 DRM_DEBUG_KMS("DFP3 disconnected\n");
4280 bios_0_scratch &= ~ATOM_S0_DFP3;
4281 bios_3_scratch &= ~ATOM_S3_DFP3_ACTIVE;
4282 bios_6_scratch &= ~ATOM_S6_ACC_REQ_DFP3;
4283 }
4284 }
4285 if ((radeon_encoder->devices & ATOM_DEVICE_DFP4_SUPPORT) &&
4286 (radeon_connector->devices & ATOM_DEVICE_DFP4_SUPPORT)) {
4287 if (connected) {
4288 DRM_DEBUG_KMS("DFP4 connected\n");
4289 bios_0_scratch |= ATOM_S0_DFP4;
4290 bios_3_scratch |= ATOM_S3_DFP4_ACTIVE;
4291 bios_6_scratch |= ATOM_S6_ACC_REQ_DFP4;
4292 } else {
4293 DRM_DEBUG_KMS("DFP4 disconnected\n");
4294 bios_0_scratch &= ~ATOM_S0_DFP4;
4295 bios_3_scratch &= ~ATOM_S3_DFP4_ACTIVE;
4296 bios_6_scratch &= ~ATOM_S6_ACC_REQ_DFP4;
4297 }
4298 }
4299 if ((radeon_encoder->devices & ATOM_DEVICE_DFP5_SUPPORT) &&
4300 (radeon_connector->devices & ATOM_DEVICE_DFP5_SUPPORT)) {
4301 if (connected) {
4302 DRM_DEBUG_KMS("DFP5 connected\n");
4303 bios_0_scratch |= ATOM_S0_DFP5;
4304 bios_3_scratch |= ATOM_S3_DFP5_ACTIVE;
4305 bios_6_scratch |= ATOM_S6_ACC_REQ_DFP5;
4306 } else {
4307 DRM_DEBUG_KMS("DFP5 disconnected\n");
4308 bios_0_scratch &= ~ATOM_S0_DFP5;
4309 bios_3_scratch &= ~ATOM_S3_DFP5_ACTIVE;
4310 bios_6_scratch &= ~ATOM_S6_ACC_REQ_DFP5;
4311 }
4312 }
4313 if ((radeon_encoder->devices & ATOM_DEVICE_DFP6_SUPPORT) &&
4314 (radeon_connector->devices & ATOM_DEVICE_DFP6_SUPPORT)) {
4315 if (connected) {
4316 DRM_DEBUG_KMS("DFP6 connected\n");
4317 bios_0_scratch |= ATOM_S0_DFP6;
4318 bios_3_scratch |= ATOM_S3_DFP6_ACTIVE;
4319 bios_6_scratch |= ATOM_S6_ACC_REQ_DFP6;
4320 } else {
4321 DRM_DEBUG_KMS("DFP6 disconnected\n");
4322 bios_0_scratch &= ~ATOM_S0_DFP6;
4323 bios_3_scratch &= ~ATOM_S3_DFP6_ACTIVE;
4324 bios_6_scratch &= ~ATOM_S6_ACC_REQ_DFP6;
4325 }
4326 }
4327
4328 if (rdev->family >= CHIP_R600) {
4329 WREG32(R600_BIOS_0_SCRATCH, bios_0_scratch);
4330 WREG32(R600_BIOS_3_SCRATCH, bios_3_scratch);
4331 WREG32(R600_BIOS_6_SCRATCH, bios_6_scratch);
4332 } else {
4333 WREG32(RADEON_BIOS_0_SCRATCH, bios_0_scratch);
4334 WREG32(RADEON_BIOS_3_SCRATCH, bios_3_scratch);
4335 WREG32(RADEON_BIOS_6_SCRATCH, bios_6_scratch);
4336 }
4337}
4338
4339void
4340radeon_atombios_encoder_crtc_scratch_regs(struct drm_encoder *encoder, int crtc)
4341{
4342 struct drm_device *dev = encoder->dev;
4343 struct radeon_device *rdev = dev->dev_private;
4344 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
4345 uint32_t bios_3_scratch;
4346
4347 if (ASIC_IS_DCE4(rdev))
4348 return;
4349
4350 if (rdev->family >= CHIP_R600)
4351 bios_3_scratch = RREG32(R600_BIOS_3_SCRATCH);
4352 else
4353 bios_3_scratch = RREG32(RADEON_BIOS_3_SCRATCH);
4354
4355 if (radeon_encoder->devices & ATOM_DEVICE_TV1_SUPPORT) {
4356 bios_3_scratch &= ~ATOM_S3_TV1_CRTC_ACTIVE;
4357 bios_3_scratch |= (crtc << 18);
4358 }
4359 if (radeon_encoder->devices & ATOM_DEVICE_CV_SUPPORT) {
4360 bios_3_scratch &= ~ATOM_S3_CV_CRTC_ACTIVE;
4361 bios_3_scratch |= (crtc << 24);
4362 }
4363 if (radeon_encoder->devices & ATOM_DEVICE_CRT1_SUPPORT) {
4364 bios_3_scratch &= ~ATOM_S3_CRT1_CRTC_ACTIVE;
4365 bios_3_scratch |= (crtc << 16);
4366 }
4367 if (radeon_encoder->devices & ATOM_DEVICE_CRT2_SUPPORT) {
4368 bios_3_scratch &= ~ATOM_S3_CRT2_CRTC_ACTIVE;
4369 bios_3_scratch |= (crtc << 20);
4370 }
4371 if (radeon_encoder->devices & ATOM_DEVICE_LCD1_SUPPORT) {
4372 bios_3_scratch &= ~ATOM_S3_LCD1_CRTC_ACTIVE;
4373 bios_3_scratch |= (crtc << 17);
4374 }
4375 if (radeon_encoder->devices & ATOM_DEVICE_DFP1_SUPPORT) {
4376 bios_3_scratch &= ~ATOM_S3_DFP1_CRTC_ACTIVE;
4377 bios_3_scratch |= (crtc << 19);
4378 }
4379 if (radeon_encoder->devices & ATOM_DEVICE_DFP2_SUPPORT) {
4380 bios_3_scratch &= ~ATOM_S3_DFP2_CRTC_ACTIVE;
4381 bios_3_scratch |= (crtc << 23);
4382 }
4383 if (radeon_encoder->devices & ATOM_DEVICE_DFP3_SUPPORT) {
4384 bios_3_scratch &= ~ATOM_S3_DFP3_CRTC_ACTIVE;
4385 bios_3_scratch |= (crtc << 25);
4386 }
4387
4388 if (rdev->family >= CHIP_R600)
4389 WREG32(R600_BIOS_3_SCRATCH, bios_3_scratch);
4390 else
4391 WREG32(RADEON_BIOS_3_SCRATCH, bios_3_scratch);
4392}
4393
4394void
4395radeon_atombios_encoder_dpms_scratch_regs(struct drm_encoder *encoder, bool on)
4396{
4397 struct drm_device *dev = encoder->dev;
4398 struct radeon_device *rdev = dev->dev_private;
4399 struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
4400 uint32_t bios_2_scratch;
4401
4402 if (ASIC_IS_DCE4(rdev))
4403 return;
4404
4405 if (rdev->family >= CHIP_R600)
4406 bios_2_scratch = RREG32(R600_BIOS_2_SCRATCH);
4407 else
4408 bios_2_scratch = RREG32(RADEON_BIOS_2_SCRATCH);
4409
4410 if (radeon_encoder->devices & ATOM_DEVICE_TV1_SUPPORT) {
4411 if (on)
4412 bios_2_scratch &= ~ATOM_S2_TV1_DPMS_STATE;
4413 else
4414 bios_2_scratch |= ATOM_S2_TV1_DPMS_STATE;
4415 }
4416 if (radeon_encoder->devices & ATOM_DEVICE_CV_SUPPORT) {
4417 if (on)
4418 bios_2_scratch &= ~ATOM_S2_CV_DPMS_STATE;
4419 else
4420 bios_2_scratch |= ATOM_S2_CV_DPMS_STATE;
4421 }
4422 if (radeon_encoder->devices & ATOM_DEVICE_CRT1_SUPPORT) {
4423 if (on)
4424 bios_2_scratch &= ~ATOM_S2_CRT1_DPMS_STATE;
4425 else
4426 bios_2_scratch |= ATOM_S2_CRT1_DPMS_STATE;
4427 }
4428 if (radeon_encoder->devices & ATOM_DEVICE_CRT2_SUPPORT) {
4429 if (on)
4430 bios_2_scratch &= ~ATOM_S2_CRT2_DPMS_STATE;
4431 else
4432 bios_2_scratch |= ATOM_S2_CRT2_DPMS_STATE;
4433 }
4434 if (radeon_encoder->devices & ATOM_DEVICE_LCD1_SUPPORT) {
4435 if (on)
4436 bios_2_scratch &= ~ATOM_S2_LCD1_DPMS_STATE;
4437 else
4438 bios_2_scratch |= ATOM_S2_LCD1_DPMS_STATE;
4439 }
4440 if (radeon_encoder->devices & ATOM_DEVICE_DFP1_SUPPORT) {
4441 if (on)
4442 bios_2_scratch &= ~ATOM_S2_DFP1_DPMS_STATE;
4443 else
4444 bios_2_scratch |= ATOM_S2_DFP1_DPMS_STATE;
4445 }
4446 if (radeon_encoder->devices & ATOM_DEVICE_DFP2_SUPPORT) {
4447 if (on)
4448 bios_2_scratch &= ~ATOM_S2_DFP2_DPMS_STATE;
4449 else
4450 bios_2_scratch |= ATOM_S2_DFP2_DPMS_STATE;
4451 }
4452 if (radeon_encoder->devices & ATOM_DEVICE_DFP3_SUPPORT) {
4453 if (on)
4454 bios_2_scratch &= ~ATOM_S2_DFP3_DPMS_STATE;
4455 else
4456 bios_2_scratch |= ATOM_S2_DFP3_DPMS_STATE;
4457 }
4458 if (radeon_encoder->devices & ATOM_DEVICE_DFP4_SUPPORT) {
4459 if (on)
4460 bios_2_scratch &= ~ATOM_S2_DFP4_DPMS_STATE;
4461 else
4462 bios_2_scratch |= ATOM_S2_DFP4_DPMS_STATE;
4463 }
4464 if (radeon_encoder->devices & ATOM_DEVICE_DFP5_SUPPORT) {
4465 if (on)
4466 bios_2_scratch &= ~ATOM_S2_DFP5_DPMS_STATE;
4467 else
4468 bios_2_scratch |= ATOM_S2_DFP5_DPMS_STATE;
4469 }
4470
4471 if (rdev->family >= CHIP_R600)
4472 WREG32(R600_BIOS_2_SCRATCH, bios_2_scratch);
4473 else
4474 WREG32(RADEON_BIOS_2_SCRATCH, bios_2_scratch);
4475}