413,25 → 413,36 |
static void intel_sdvo_debug_write(struct intel_sdvo *intel_sdvo, u8 cmd, |
const void *args, int args_len) |
{ |
int i; |
int i, pos = 0; |
#define BUF_LEN 256 |
char buffer[BUF_LEN]; |
|
DRM_DEBUG_KMS("%s: W: %02X ", |
SDVO_NAME(intel_sdvo), cmd); |
for (i = 0; i < args_len; i++) |
DRM_LOG_KMS("%02X ", ((u8 *)args)[i]); |
for (; i < 8; i++) |
DRM_LOG_KMS(" "); |
#define BUF_PRINT(args...) \ |
pos += snprintf(buffer + pos, max_t(int, BUF_LEN - pos, 0), args) |
|
|
for (i = 0; i < args_len; i++) { |
BUF_PRINT("%02X ", ((u8 *)args)[i]); |
} |
for (; i < 8; i++) { |
BUF_PRINT(" "); |
} |
for (i = 0; i < ARRAY_SIZE(sdvo_cmd_names); i++) { |
if (cmd == sdvo_cmd_names[i].cmd) { |
DRM_LOG_KMS("(%s)", sdvo_cmd_names[i].name); |
BUF_PRINT("(%s)", sdvo_cmd_names[i].name); |
break; |
} |
} |
if (i == ARRAY_SIZE(sdvo_cmd_names)) |
DRM_LOG_KMS("(%02X)", cmd); |
DRM_LOG_KMS("\n"); |
if (i == ARRAY_SIZE(sdvo_cmd_names)) { |
BUF_PRINT("(%02X)", cmd); |
} |
BUG_ON(pos >= BUF_LEN - 1); |
#undef BUF_PRINT |
#undef BUF_LEN |
|
DRM_DEBUG_KMS("%s: W: %02X %s\n", SDVO_NAME(intel_sdvo), cmd, buffer); |
} |
|
static const char *cmd_status_names[] = { |
"Power on", |
"Success", |
512,9 → 523,10 |
{ |
u8 retry = 15; /* 5 quick checks, followed by 10 long checks */ |
u8 status; |
int i; |
int i, pos = 0; |
#define BUF_LEN 256 |
char buffer[BUF_LEN]; |
|
DRM_DEBUG_KMS("%s: R: ", SDVO_NAME(intel_sdvo)); |
|
/* |
* The documentation states that all commands will be |
551,10 → 563,13 |
goto log_fail; |
} |
|
#define BUF_PRINT(args...) \ |
pos += snprintf(buffer + pos, max_t(int, BUF_LEN - pos, 0), args) |
|
if (status <= SDVO_CMD_STATUS_SCALING_NOT_SUPP) |
DRM_LOG_KMS("(%s)", cmd_status_names[status]); |
BUF_PRINT("(%s)", cmd_status_names[status]); |
else |
DRM_LOG_KMS("(??? %d)", status); |
BUF_PRINT("(??? %d)", status); |
|
if (status != SDVO_CMD_STATUS_SUCCESS) |
goto log_fail; |
565,13 → 580,17 |
SDVO_I2C_RETURN_0 + i, |
&((u8 *)response)[i])) |
goto log_fail; |
DRM_LOG_KMS(" %02X", ((u8 *)response)[i]); |
BUF_PRINT(" %02X", ((u8 *)response)[i]); |
} |
DRM_LOG_KMS("\n"); |
BUG_ON(pos >= BUF_LEN - 1); |
#undef BUF_PRINT |
#undef BUF_LEN |
|
DRM_DEBUG_KMS("%s: R: %s\n", SDVO_NAME(intel_sdvo), buffer); |
return true; |
|
log_fail: |
DRM_LOG_KMS("... failed\n"); |
DRM_DEBUG_KMS("%s: R: ... failed\n", SDVO_NAME(intel_sdvo)); |
return false; |
} |
|
933,7 → 952,7 |
|
static bool intel_sdvo_write_infoframe(struct intel_sdvo *intel_sdvo, |
unsigned if_index, uint8_t tx_rate, |
uint8_t *data, unsigned length) |
const uint8_t *data, unsigned length) |
{ |
uint8_t set_buf_index[2] = { if_index, 0 }; |
uint8_t hbuf_size, tmp[8]; |
1068,7 → 1087,7 |
|
static void i9xx_adjust_sdvo_tv_clock(struct intel_crtc_config *pipe_config) |
{ |
unsigned dotclock = pipe_config->adjusted_mode.clock; |
unsigned dotclock = pipe_config->port_clock; |
struct dpll *clock = &pipe_config->dpll; |
|
/* SDVO TV has fixed PLL values depend on its clock range, |
1133,7 → 1152,6 |
*/ |
pipe_config->pixel_multiplier = |
intel_sdvo_get_pixel_multiplier(adjusted_mode); |
adjusted_mode->clock *= pipe_config->pixel_multiplier; |
|
if (intel_sdvo->color_range_auto) { |
/* See CEA-861-E - 5.1 Default Encoding Parameters */ |
1217,11 → 1235,7 |
!intel_sdvo_set_tv_format(intel_sdvo)) |
return; |
|
/* We have tried to get input timing in mode_fixup, and filled into |
* adjusted_mode. |
*/ |
intel_sdvo_get_dtd_from_mode(&input_dtd, adjusted_mode); |
input_dtd.part1.clock /= crtc->config.pixel_multiplier; |
|
if (intel_sdvo->is_tv || intel_sdvo->is_lvds) |
input_dtd.part2.sdvo_flags = intel_sdvo->dtd_sdvo_flags; |
1330,6 → 1344,7 |
struct intel_sdvo *intel_sdvo = to_sdvo(encoder); |
struct intel_sdvo_dtd dtd; |
int encoder_pixel_multiplier = 0; |
int dotclock; |
u32 flags = 0, sdvox; |
u8 val; |
bool ret; |
1368,6 → 1383,13 |
>> SDVO_PORT_MULTIPLY_SHIFT) + 1; |
} |
|
dotclock = pipe_config->port_clock / pipe_config->pixel_multiplier; |
|
if (HAS_PCH_SPLIT(dev)) |
ironlake_check_encoder_dotclock(pipe_config, dotclock); |
|
pipe_config->adjusted_mode.crtc_clock = dotclock; |
|
/* Cross check the port pixel multiplier with the sdvo encoder state. */ |
if (intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_CLOCK_RATE_MULT, |
&val, 1)) { |
1514,7 → 1536,8 |
intel_modeset_check_state(connector->dev); |
} |
|
static int intel_sdvo_mode_valid(struct drm_connector *connector, |
static enum drm_mode_status |
intel_sdvo_mode_valid(struct drm_connector *connector, |
struct drm_display_mode *mode) |
{ |
struct intel_sdvo *intel_sdvo = intel_attached_sdvo(connector); |
1770,6 → 1793,9 |
{ |
struct edid *edid; |
|
DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", |
connector->base.id, drm_get_connector_name(connector)); |
|
/* set the bus switch and get the modes */ |
edid = intel_sdvo_get_edid(connector); |
|
1865,6 → 1891,9 |
uint32_t reply = 0, format_map = 0; |
int i; |
|
DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", |
connector->base.id, drm_get_connector_name(connector)); |
|
/* Read the list of supported input resolutions for the selected TV |
* format. |
*/ |
1899,6 → 1928,9 |
struct drm_i915_private *dev_priv = connector->dev->dev_private; |
struct drm_display_mode *newmode; |
|
DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", |
connector->base.id, drm_get_connector_name(connector)); |
|
/* |
* Fetch modes from VBT. For SDVO prefer the VBT mode since some |
* SDVO->LVDS transcoders can't cope with the EDID mode. |
1930,7 → 1962,6 |
break; |
} |
} |
|
} |
|
static int intel_sdvo_get_modes(struct drm_connector *connector) |
1998,7 → 2029,6 |
intel_sdvo_connector->tv_format); |
|
intel_sdvo_destroy_enhance_property(connector); |
drm_sysfs_connector_remove(connector); |
drm_connector_cleanup(connector); |
kfree(intel_sdvo_connector); |
} |
2394,7 → 2424,9 |
struct intel_connector *intel_connector; |
struct intel_sdvo_connector *intel_sdvo_connector; |
|
intel_sdvo_connector = kzalloc(sizeof(struct intel_sdvo_connector), GFP_KERNEL); |
DRM_DEBUG_KMS("initialising DVI device %d\n", device); |
|
intel_sdvo_connector = kzalloc(sizeof(*intel_sdvo_connector), GFP_KERNEL); |
if (!intel_sdvo_connector) |
return false; |
|
2442,7 → 2474,9 |
struct intel_connector *intel_connector; |
struct intel_sdvo_connector *intel_sdvo_connector; |
|
intel_sdvo_connector = kzalloc(sizeof(struct intel_sdvo_connector), GFP_KERNEL); |
DRM_DEBUG_KMS("initialising TV type %d\n", type); |
|
intel_sdvo_connector = kzalloc(sizeof(*intel_sdvo_connector), GFP_KERNEL); |
if (!intel_sdvo_connector) |
return false; |
|
2467,6 → 2501,7 |
return true; |
|
err: |
drm_sysfs_connector_remove(connector); |
intel_sdvo_destroy(connector); |
return false; |
} |
2479,7 → 2514,9 |
struct intel_connector *intel_connector; |
struct intel_sdvo_connector *intel_sdvo_connector; |
|
intel_sdvo_connector = kzalloc(sizeof(struct intel_sdvo_connector), GFP_KERNEL); |
DRM_DEBUG_KMS("initialising analog device %d\n", device); |
|
intel_sdvo_connector = kzalloc(sizeof(*intel_sdvo_connector), GFP_KERNEL); |
if (!intel_sdvo_connector) |
return false; |
|
2510,7 → 2547,9 |
struct intel_connector *intel_connector; |
struct intel_sdvo_connector *intel_sdvo_connector; |
|
intel_sdvo_connector = kzalloc(sizeof(struct intel_sdvo_connector), GFP_KERNEL); |
DRM_DEBUG_KMS("initialising LVDS device %d\n", device); |
|
intel_sdvo_connector = kzalloc(sizeof(*intel_sdvo_connector), GFP_KERNEL); |
if (!intel_sdvo_connector) |
return false; |
|
2534,6 → 2573,7 |
return true; |
|
err: |
drm_sysfs_connector_remove(connector); |
intel_sdvo_destroy(connector); |
return false; |
} |
2605,10 → 2645,12 |
|
list_for_each_entry_safe(connector, tmp, |
&dev->mode_config.connector_list, head) { |
if (intel_attached_encoder(connector) == &intel_sdvo->base) |
if (intel_attached_encoder(connector) == &intel_sdvo->base) { |
drm_sysfs_connector_remove(connector); |
intel_sdvo_destroy(connector); |
} |
} |
} |
|
static bool intel_sdvo_tv_create_property(struct intel_sdvo *intel_sdvo, |
struct intel_sdvo_connector *intel_sdvo_connector, |
2876,7 → 2918,7 |
struct intel_encoder *intel_encoder; |
struct intel_sdvo *intel_sdvo; |
int i; |
intel_sdvo = kzalloc(sizeof(struct intel_sdvo), GFP_KERNEL); |
intel_sdvo = kzalloc(sizeof(*intel_sdvo), GFP_KERNEL); |
if (!intel_sdvo) |
return false; |
|