Subversion Repositories Kolibri OS

/*

 * Copyright © 2006 Intel Corporation

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the "Software"),

 * to deal in the Software without restriction, including without limitation

 * the rights to use, copy, modify, merge, publish, distribute, sublicense,

 * and/or sell copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice (including the next

 * paragraph) shall be included in all copies or substantial portions of the

 * Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

 * SOFTWARE.

 *

 * Authors:

 *    Eric Anholt 

 *

 */

#include 

#include 

#include 

#include "i915_drv.h"

#include "intel_bios.h"

#define	SLAVE_ADDR1	0x70

#define	SLAVE_ADDR2	0x72

static int panel_type;

static void *

find_section(struct bdb_header *bdb, int section_id)

{

	u8 *base = (u8 *)bdb;

	int index = 0;

	u16 total, current_size;

	u8 current_id;

	/* skip to first section */

	index += bdb->header_size;

	total = bdb->bdb_size;

	/* walk the sections looking for section_id */

	while (index < total) {

		current_id = *(base + index);

		index++;

		current_size = *((u16 *)(base + index));

		index += 2;

		if (current_id == section_id)

			return base + index;

		index += current_size;

	}

	return NULL;

}

static u16

get_blocksize(void *p)

{

	u16 *block_ptr, block_size;

	block_ptr = (u16 *)((char *)p - 2);

	block_size = *block_ptr;

	return block_size;

}

static void

fill_detail_timing_data(struct drm_display_mode *panel_fixed_mode,

			const struct lvds_dvo_timing *dvo_timing)

{

	panel_fixed_mode->hdisplay = (dvo_timing->hactive_hi << 8) |

		dvo_timing->hactive_lo;

	panel_fixed_mode->hsync_start = panel_fixed_mode->hdisplay +

		((dvo_timing->hsync_off_hi << 8) | dvo_timing->hsync_off_lo);

	panel_fixed_mode->hsync_end = panel_fixed_mode->hsync_start +

		dvo_timing->hsync_pulse_width;

	panel_fixed_mode->htotal = panel_fixed_mode->hdisplay +

		((dvo_timing->hblank_hi << 8) | dvo_timing->hblank_lo);

	panel_fixed_mode->vdisplay = (dvo_timing->vactive_hi << 8) |

		dvo_timing->vactive_lo;

	panel_fixed_mode->vsync_start = panel_fixed_mode->vdisplay +

		dvo_timing->vsync_off;

	panel_fixed_mode->vsync_end = panel_fixed_mode->vsync_start +

		dvo_timing->vsync_pulse_width;

	panel_fixed_mode->vtotal = panel_fixed_mode->vdisplay +

		((dvo_timing->vblank_hi << 8) | dvo_timing->vblank_lo);

	panel_fixed_mode->clock = dvo_timing->clock * 10;

	panel_fixed_mode->type = DRM_MODE_TYPE_PREFERRED;

	if (dvo_timing->hsync_positive)

		panel_fixed_mode->flags |= DRM_MODE_FLAG_PHSYNC;

	else

		panel_fixed_mode->flags |= DRM_MODE_FLAG_NHSYNC;

	if (dvo_timing->vsync_positive)

		panel_fixed_mode->flags |= DRM_MODE_FLAG_PVSYNC;

	else

		panel_fixed_mode->flags |= DRM_MODE_FLAG_NVSYNC;

	/* Some VBTs have bogus h/vtotal values */

	if (panel_fixed_mode->hsync_end > panel_fixed_mode->htotal)

		panel_fixed_mode->htotal = panel_fixed_mode->hsync_end + 1;

	if (panel_fixed_mode->vsync_end > panel_fixed_mode->vtotal)

		panel_fixed_mode->vtotal = panel_fixed_mode->vsync_end + 1;

	drm_mode_set_name(panel_fixed_mode);

}

static bool

lvds_dvo_timing_equal_size(const struct lvds_dvo_timing *a,

			   const struct lvds_dvo_timing *b)

{

	if (a->hactive_hi != b->hactive_hi ||

	    a->hactive_lo != b->hactive_lo)

		return false;

	if (a->hsync_off_hi != b->hsync_off_hi ||

	    a->hsync_off_lo != b->hsync_off_lo)

		return false;

	if (a->hsync_pulse_width != b->hsync_pulse_width)

		return false;

	if (a->hblank_hi != b->hblank_hi ||

	    a->hblank_lo != b->hblank_lo)

		return false;

	if (a->vactive_hi != b->vactive_hi ||

	    a->vactive_lo != b->vactive_lo)

		return false;

	if (a->vsync_off != b->vsync_off)

		return false;

	if (a->vsync_pulse_width != b->vsync_pulse_width)

		return false;

	if (a->vblank_hi != b->vblank_hi ||

	    a->vblank_lo != b->vblank_lo)

		return false;

	return true;

}

static const struct lvds_dvo_timing *

get_lvds_dvo_timing(const struct bdb_lvds_lfp_data *lvds_lfp_data,

		    const struct bdb_lvds_lfp_data_ptrs *lvds_lfp_data_ptrs,

		    int index)

{

	/*

	 * the size of fp_timing varies on the different platform.

	 * So calculate the DVO timing relative offset in LVDS data

	 * entry to get the DVO timing entry

	 */

	int lfp_data_size =

		lvds_lfp_data_ptrs->ptr[1].dvo_timing_offset -

		lvds_lfp_data_ptrs->ptr[0].dvo_timing_offset;

	int dvo_timing_offset =

		lvds_lfp_data_ptrs->ptr[0].dvo_timing_offset -

		lvds_lfp_data_ptrs->ptr[0].fp_timing_offset;

	char *entry = (char *)lvds_lfp_data->data + lfp_data_size * index;

	return (struct lvds_dvo_timing *)(entry + dvo_timing_offset);

}

/* get lvds_fp_timing entry

 * this function may return NULL if the corresponding entry is invalid

 */

static const struct lvds_fp_timing *

get_lvds_fp_timing(const struct bdb_header *bdb,

		   const struct bdb_lvds_lfp_data *data,

		   const struct bdb_lvds_lfp_data_ptrs *ptrs,

		   int index)

{

	size_t data_ofs = (const u8 *)data - (const u8 *)bdb;

	u16 data_size = ((const u16 *)data)[-1]; /* stored in header */

	size_t ofs;

	if (index >= ARRAY_SIZE(ptrs->ptr))

		return NULL;

	ofs = ptrs->ptr[index].fp_timing_offset;

	if (ofs < data_ofs ||

	    ofs + sizeof(struct lvds_fp_timing) > data_ofs + data_size)

		return NULL;

	return (const struct lvds_fp_timing *)((const u8 *)bdb + ofs);

}

/* Try to find integrated panel data */

static void

parse_lfp_panel_data(struct drm_i915_private *dev_priv,

			    struct bdb_header *bdb)

{

	const struct bdb_lvds_options *lvds_options;

	const struct bdb_lvds_lfp_data *lvds_lfp_data;

	const struct bdb_lvds_lfp_data_ptrs *lvds_lfp_data_ptrs;

	const struct lvds_dvo_timing *panel_dvo_timing;

	const struct lvds_fp_timing *fp_timing;

	struct drm_display_mode *panel_fixed_mode;

	int i, downclock;

	lvds_options = find_section(bdb, BDB_LVDS_OPTIONS);

	if (!lvds_options)

		return;

	dev_priv->lvds_dither = lvds_options->pixel_dither;

	if (lvds_options->panel_type == 0xff)

		return;

	panel_type = lvds_options->panel_type;

	lvds_lfp_data = find_section(bdb, BDB_LVDS_LFP_DATA);

	if (!lvds_lfp_data)

		return;

	lvds_lfp_data_ptrs = find_section(bdb, BDB_LVDS_LFP_DATA_PTRS);

	if (!lvds_lfp_data_ptrs)

		return;

	dev_priv->lvds_vbt = 1;

	panel_dvo_timing = get_lvds_dvo_timing(lvds_lfp_data,

					       lvds_lfp_data_ptrs,

					       lvds_options->panel_type);

	panel_fixed_mode = kzalloc(sizeof(*panel_fixed_mode), GFP_KERNEL);

	if (!panel_fixed_mode)

		return;

	fill_detail_timing_data(panel_fixed_mode, panel_dvo_timing);

	dev_priv->lfp_lvds_vbt_mode = panel_fixed_mode;

	DRM_DEBUG_KMS("Found panel mode in BIOS VBT tables:\n");

	drm_mode_debug_printmodeline(panel_fixed_mode);

	/*

	 * Iterate over the LVDS panel timing info to find the lowest clock

	 * for the native resolution.

	 */

	downclock = panel_dvo_timing->clock;

	for (i = 0; i < 16; i++) {

		const struct lvds_dvo_timing *dvo_timing;

		dvo_timing = get_lvds_dvo_timing(lvds_lfp_data,

						 lvds_lfp_data_ptrs,

						 i);

		if (lvds_dvo_timing_equal_size(dvo_timing, panel_dvo_timing) &&

		    dvo_timing->clock < downclock)

			downclock = dvo_timing->clock;

	}

	if (downclock < panel_dvo_timing->clock && i915_lvds_downclock) {

		dev_priv->lvds_downclock_avail = 1;