Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 4559 → Rev 4560

/drivers/video/drm/i915/intel_sdvo.c
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;