path: root/tools/intel_bios_reader.c

/*
 * 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 <eric@anholt.net>
 *
 */

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>

#include "intel_bios.h"
#include "intel_io.h"
#include "intel_chipset.h"
#include "drmtest.h"

static uint32_t devid = -1;

/* no bother to include "edid.h" */
#define _H_ACTIVE(x) (x[2] + ((x[4] & 0xF0) << 4))
#define _H_SYNC_OFF(x) (x[8] + ((x[11] & 0xC0) << 2))
#define _H_SYNC_WIDTH(x) (x[9] + ((x[11] & 0x30) << 4))
#define _H_BLANK(x) (x[3] + ((x[4] & 0x0F) << 8))
#define _V_ACTIVE(x) (x[5] + ((x[7] & 0xF0) << 4))
#define _V_SYNC_OFF(x) ((x[10] >> 4) + ((x[11] & 0x0C) << 2))
#define _V_SYNC_WIDTH(x) ((x[10] & 0x0F) + ((x[11] & 0x03) << 4))
#define _V_BLANK(x) (x[6] + ((x[7] & 0x0F) << 8))
#define _PIXEL_CLOCK(x) (x[0] + (x[1] << 8)) * 10000

uint8_t *VBIOS;

#define INTEL_BIOS_8(_addr)	(VBIOS[_addr])
#define INTEL_BIOS_16(_addr)	(VBIOS[_addr] | \
				 (VBIOS[_addr + 1] << 8))
#define INTEL_BIOS_32(_addr)	(VBIOS[_addr] | \
				 (VBIOS[_addr + 1] << 8) | \
				 (VBIOS[_addr + 2] << 16) | \
				 (VBIOS[_addr + 3] << 24))

#define YESNO(val) ((val) ? "yes" : "no")

struct bdb_block {
	uint8_t id;
	uint16_t size;
	void *data;
};

static const char * const seq_name[] = {
	"UNDEFINED",
	"MIPI_SEQ_ASSERT_RESET",
	"MIPI_SEQ_INIT_OTP",
	"MIPI_SEQ_DISPLAY_ON",
	"MIPI_SEQ_DISPLAY_OFF",
	"MIPI_SEQ_DEASSERT_RESET",
};

struct bdb_header *bdb;
struct bdb_lvds_lfp_data_ptrs *lvds_lfp_data_ptrs;
static int tv_present;
static int lvds_present;
static int panel_type;

static struct bdb_block *find_section(int section_id, int length)
{
	struct bdb_block *block;
	unsigned char *base = (unsigned char *)bdb;
	int idx = 0;
	uint16_t total, current_size;
	unsigned char current_id;

	/* skip to first section */
	idx += bdb->header_size;
	total = bdb->bdb_size;
	if (total > length)
		total = length;

	block = malloc(sizeof(*block));
	if (!block) {
		fprintf(stderr, "out of memory\n");
		exit(-1);
	}

	/* walk the sections looking for section_id */
	while (idx + 3 < total) {
		current_id = *(base + idx);
		current_size = *(uint16_t *)(base + idx + 1);
		if (idx + current_size > total)
			return NULL;

		if (current_id == section_id) {
			block->id = current_id;
			block->size = current_size;
			block->data = base + idx + 3;
			return block;
		}

		idx += current_size + 3;
	}

	free(block);
	return NULL;
}

static void dump_general_features(const struct bdb_block *block)
{
	struct bdb_general_features *features = block->data;

	printf("\tPanel fitting: ");
	switch (features->panel_fitting) {
	case 0:
		printf("disabled\n");
		break;
	case 1:
		printf("text only\n");
		break;
	case 2:
		printf("graphics only\n");
		break;
	case 3:
		printf("text & graphics\n");
		break;
	}
	printf("\tFlexaim: %s\n", YESNO(features->flexaim));
	printf("\tMessage: %s\n", YESNO(features->msg_enable));
	printf("\tClear screen: %d\n", features->clear_screen);
	printf("\tDVO color flip required: %s\n", YESNO(features->color_flip));
	printf("\tExternal VBT: %s\n", YESNO(features->download_ext_vbt));
	printf("\tEnable SSC: %s\n", YESNO(features->enable_ssc));
	if (features->enable_ssc) {
		if (HAS_PCH_SPLIT(devid))
			printf("\tSSC frequency: %s\n", features->ssc_freq ?
			       "100 MHz" : "120 MHz");
		else
			printf("\tSSC frequency: %s\n", features->ssc_freq ?
			       "100 MHz (66 MHz on 855)" : "96 MHz (48 MHz on 855)");
	}
	printf("\tLFP on override: %s\n",
	       YESNO(features->enable_lfp_on_override));
	printf("\tDisable SSC on clone: %s\n",
	       YESNO(features->disable_ssc_ddt));
	printf("\tDisable smooth vision: %s\n",
	       YESNO(features->disable_smooth_vision));
	printf("\tSingle DVI for CRT/DVI: %s\n", YESNO(features->single_dvi));
	printf("\tLegacy monitor detect: %s\n",
	       YESNO(features->legacy_monitor_detect));
	printf("\tIntegrated CRT: %s\n", YESNO(features->int_crt_support));
	printf("\tIntegrated TV: %s\n", YESNO(features->int_tv_support));

	tv_present = 1;		/* should be based on whether TV DAC exists */
	lvds_present = 1;	/* should be based on IS_MOBILE() */
}

static void dump_backlight_info(const struct bdb_block *block)
{
	struct bdb_lvds_backlight *backlight = block->data;
	struct blc_struct *blc;

	if (sizeof(struct blc_struct) != backlight->blcstruct_size) {
		printf("\tBacklight struct sizes don't match (expected %zu, got %u), skipping\n",
		     sizeof(struct blc_struct), backlight->blcstruct_size);
		return;
	}

	blc = &backlight->panels[panel_type];

	printf("\tInverter type: %d\n", blc->inverter_type);
	printf("\t     polarity: %d\n", blc->inverter_polarity);
	printf("\t    GPIO pins: %d\n", blc->gpio_pins);
	printf("\t  GMBUS speed: %d\n", blc->gmbus_speed);
	printf("\t     PWM freq: %d\n", blc->pwm_freq);
	printf("\tMinimum brightness: %d\n", blc->min_brightness);
	printf("\tI2C slave addr: 0x%02x\n", blc->i2c_slave_addr);
	printf("\tI2C command: 0x%02x\n", blc->i2c_cmd);
}

static const struct {
	unsigned short type;
	const char *name;
} child_device_types[] = {
	{ DEVICE_TYPE_NONE, "none" },
	{ DEVICE_TYPE_CRT, "CRT" },
	{ DEVICE_TYPE_TV, "TV" },
	{ DEVICE_TYPE_EFP, "EFP" },
	{ DEVICE_TYPE_LFP, "LFP" },
	{ DEVICE_TYPE_CRT_DPMS, "CRT" },
	{ DEVICE_TYPE_CRT_DPMS_HOTPLUG, "CRT" },
	{ DEVICE_TYPE_TV_COMPOSITE, "TV composite" },
	{ DEVICE_TYPE_TV_MACROVISION, "TV" },
	{ DEVICE_TYPE_TV_RF_COMPOSITE, "TV" },
	{ DEVICE_TYPE_TV_SVIDEO_COMPOSITE, "TV S-Video" },
	{ DEVICE_TYPE_TV_SCART, "TV SCART" },
	{ DEVICE_TYPE_TV_CODEC_HOTPLUG_PWR, "TV" },
	{ DEVICE_TYPE_EFP_HOTPLUG_PWR, "EFP" },
	{ DEVICE_TYPE_EFP_DVI_HOTPLUG_PWR, "DVI" },
	{ DEVICE_TYPE_EFP_DVI_I, "DVI-I" },
	{ DEVICE_TYPE_EFP_DVI_D_DUAL, "DL-DVI-D" },
	{ DEVICE_TYPE_EFP_DVI_D_HDCP, "DVI-D" },
	{ DEVICE_TYPE_OPENLDI_HOTPLUG_PWR, "OpenLDI" },
	{ DEVICE_TYPE_OPENLDI_DUALPIX, "OpenLDI" },
	{ DEVICE_TYPE_LFP_PANELLINK, "PanelLink" },
	{ DEVICE_TYPE_LFP_CMOS_PWR, "CMOS LFP" },
	{ DEVICE_TYPE_LFP_LVDS_PWR, "LVDS" },
	{ DEVICE_TYPE_LFP_LVDS_DUAL, "LVDS" },
	{ DEVICE_TYPE_LFP_LVDS_DUAL_HDCP, "LVDS" },
	{ DEVICE_TYPE_INT_LFP, "LFP" },
	{ DEVICE_TYPE_INT_TV, "TV" },
	{ DEVICE_TYPE_DP, "DisplayPort" },
	{ DEVICE_TYPE_DP_HDMI_DVI, "DisplayPort/HDMI/DVI" },
	{ DEVICE_TYPE_DP_DVI, "DisplayPort/DVI" },
	{ DEVICE_TYPE_HDMI_DVI, "HDMI/DVI" },
	{ DEVICE_TYPE_DVI, "DVI" },
	{ DEVICE_TYPE_eDP, "eDP" },
};
static const int num_child_device_types =
	sizeof(child_device_types) / sizeof(child_device_types[0]);

static const char *child_device_type(unsigned short type)
{
	int i;

	for (i = 0; i < num_child_device_types; i++)
		if (child_device_types[i].type == type)
			return child_device_types[i].name;

	return "unknown";
}

static const struct {
	unsigned short type;
	const char *name;
} efp_ports[] = {
	{ DEVICE_PORT_NONE, "N/A" },
	{ DEVICE_PORT_HDMIB, "HDMI-B" },
	{ DEVICE_PORT_HDMIC, "HDMI-C" },
	{ DEVICE_PORT_HDMID, "HDMI-D" },
	{ DEVICE_PORT_DPB, "DP-B" },
	{ DEVICE_PORT_DPC, "DP-C" },
	{ DEVICE_PORT_DPD, "DP-D" },
};
static const int num_efp_ports = sizeof(efp_ports) / sizeof(efp_ports[0]);

static const char *efp_port(uint8_t type)
{
	int i;

	for (i = 0; i < num_efp_ports; i++)
		if (efp_ports[i].type == type)
			return efp_ports[i].name;

	return "unknown";
}

static const struct {
	unsigned short type;
	const char *name;
} efp_conn_info[] = {
	{ DEVICE_INFO_NONE, "N/A" },
	{ DEVICE_INFO_HDMI_CERT, "HDMI certified" },
	{ DEVICE_INFO_DP, "DisplayPort" },
	{ DEVICE_INFO_DVI, "DVI" },
};
static const int num_efp_conn_info = sizeof(efp_conn_info) / sizeof(efp_conn_info[0]);

static const char *efp_conn(uint8_t type)
{
	int i;

	for (i = 0; i < num_efp_conn_info; i++)
		if (efp_conn_info[i].type == type)
			return efp_conn_info[i].name;

	return "unknown";
}



static void dump_child_device(struct child_device_config *child)
{
	char child_id[11];

	if (!child->device_type)
		return;

	if (bdb->version < 152) {
		strncpy(child_id, (char *)child->device_id, 10);
		child_id[10] = 0;

		printf("\tChild device info:\n");
		printf("\t\tDevice type: %04x (%s)\n", child->device_type,
		       child_device_type(child->device_type));
		printf("\t\tSignature: %s\n", child_id);
		printf("\t\tAIM offset: %d\n", child->addin_offset);
		printf("\t\tDVO port: 0x%02x\n", child->dvo_port);
	} else { /* 152+ have EFP blocks here */
		struct efp_child_device_config *efp =
			(struct efp_child_device_config *)child;
		printf("\tEFP device info:\n");
		printf("\t\tDevice type: 0x%04x (%s)\n", efp->device_type,
		       child_device_type(efp->device_type));
		printf("\t\tPort: 0x%02x (%s)\n", efp->port,
		       efp_port(efp->port));
		printf("\t\tDDC pin: 0x%02x\n", efp->ddc_pin);
		printf("\t\tDock port: 0x%02x (%s)\n", efp->docked_port,
		       efp_port(efp->docked_port));
		printf("\t\tHDMI compatible? %s\n", efp->hdmi_compat ? "Yes" : "No");
		printf("\t\tInfo: %s\n", efp_conn(efp->conn_info));
		printf("\t\tAux channel: 0x%02x\n", efp->aux_chan);
		printf("\t\tDongle detect: 0x%02x\n", efp->dongle_detect);
	}
}

static void dump_general_definitions(const struct bdb_block *block)
{
	struct bdb_general_definitions *defs = block->data;
	struct child_device_config *child;
	int i;
	int child_device_num;

	printf("\tCRT DDC GMBUS addr: 0x%02x\n", defs->crt_ddc_gmbus_pin);
	printf("\tUse ACPI DPMS CRT power states: %s\n",
	       YESNO(defs->dpms_acpi));
	printf("\tSkip CRT detect at boot: %s\n",
	       YESNO(defs->skip_boot_crt_detect));
	printf("\tUse DPMS on AIM devices: %s\n", YESNO(defs->dpms_aim));
	printf("\tBoot display type: 0x%02x%02x\n", defs->boot_display[1],
	       defs->boot_display[0]);
	printf("\tTV data block present: %s\n", YESNO(tv_present));
	child_device_num = (block->size - sizeof(*defs)) / sizeof(*child);
	for (i = 0; i < child_device_num; i++)
		dump_child_device(&defs->devices[i]);
}

static void dump_child_devices(const struct bdb_block *block)
{
	struct bdb_child_devices *child_devs = block->data;
	struct child_device_config *child;
	int i;

	for (i = 0; i < DEVICE_CHILD_SIZE; i++) {
		child = &child_devs->children[i];
		/* Skip nonexistent children */
		if (!child->device_type)
			continue;
		printf("\tChild device %d\n", i);
		printf("\t\tType: 0x%04x (%s)\n", child->device_type,
		       child_device_type(child->device_type));
		printf("\t\tDVO port: 0x%02x\n", child->dvo_port);
		printf("\t\tI2C pin: 0x%02x\n", child->i2c_pin);
		printf("\t\tSlave addr: 0x%02x\n", child->slave_addr);
		printf("\t\tDDC pin: 0x%02x\n", child->ddc_pin);
		printf("\t\tDVO config: 0x%02x\n", child->dvo_cfg);
		printf("\t\tDVO wiring: 0x%02x\n", child->dvo_wiring);
	}
}

static void dump_lvds_options(const struct bdb_block *block)
{
	struct bdb_lvds_options *options = block->data;

	panel_type = options->panel_type;
	printf("\tPanel type: %d\n", panel_type);
	printf("\tLVDS EDID available: %s\n", YESNO(options->lvds_edid));
	printf("\tPixel dither: %s\n", YESNO(options->pixel_dither));
	printf("\tPFIT auto ratio: %s\n", YESNO(options->pfit_ratio_auto));
	printf("\tPFIT enhanced graphics mode: %s\n",
	       YESNO(options->pfit_gfx_mode_enhanced));
	printf("\tPFIT enhanced text mode: %s\n",
	       YESNO(options->pfit_text_mode_enhanced));
	printf("\tPFIT mode: %d\n", options->pfit_mode);
}

static void dump_lvds_ptr_data(const struct bdb_block *block)
{
	struct bdb_lvds_lfp_data_ptrs *ptrs = block->data;

	printf("\tNumber of entries: %d\n", ptrs->lvds_entries);

	/* save for use by dump_lvds_data() */
	lvds_lfp_data_ptrs = ptrs;
}

static void dump_lvds_data(const struct bdb_block *block)
{
	struct bdb_lvds_lfp_data *lvds_data = block->data;
	struct bdb_lvds_lfp_data_ptrs *ptrs = lvds_lfp_data_ptrs;
	int num_entries;
	int i;
	int hdisplay, hsyncstart, hsyncend, htotal;
	int vdisplay, vsyncstart, vsyncend, vtotal;
	float clock;
	int lfp_data_size, dvo_offset;

	if (!ptrs) {
		printf("No LVDS ptr block\n");
		return;
	}

	lfp_data_size =
	    ptrs->ptr[1].fp_timing_offset - ptrs->ptr[0].fp_timing_offset;
	dvo_offset =
	    ptrs->ptr[0].dvo_timing_offset - ptrs->ptr[0].fp_timing_offset;

	num_entries = block->size / lfp_data_size;

	printf("  Number of entries: %d (preferred block marked with '*')\n",
	       num_entries);

	for (i = 0; i < num_entries; i++) {
		uint8_t *lfp_data_ptr =
		    (uint8_t *) lvds_data->data + lfp_data_size * i;
		uint8_t *timing_data = lfp_data_ptr + dvo_offset;
		struct bdb_lvds_lfp_data_entry *lfp_data =
		    (struct bdb_lvds_lfp_data_entry *)lfp_data_ptr;
		char marker;

		if (i == panel_type)
			marker = '*';
		else
			marker = ' ';

		hdisplay = _H_ACTIVE(timing_data);
		hsyncstart = hdisplay + _H_SYNC_OFF(timing_data);
		hsyncend = hsyncstart + _H_SYNC_WIDTH(timing_data);
		htotal = hdisplay + _H_BLANK(timing_data);

		vdisplay = _V_ACTIVE(timing_data);
		vsyncstart = vdisplay + _V_SYNC_OFF(timing_data);
		vsyncend = vsyncstart + _V_SYNC_WIDTH(timing_data);
		vtotal = vdisplay + _V_BLANK(timing_data);
		clock = _PIXEL_CLOCK(timing_data) / 1000;

		printf("%c\tpanel type %02i: %dx%d clock %d\n", marker,
		       i, lfp_data->fp_timing.x_res, lfp_data->fp_timing.y_res,
		       _PIXEL_CLOCK(timing_data));
		printf("\t\tinfo:\n");
		printf("\t\t  LVDS: 0x%08lx\n",
		       (unsigned long)lfp_data->fp_timing.lvds_reg_val);
		printf("\t\t  PP_ON_DELAYS: 0x%08lx\n",
		       (unsigned long)lfp_data->fp_timing.pp_on_reg_val);
		printf("\t\t  PP_OFF_DELAYS: 0x%08lx\n",
		       (unsigned long)lfp_data->fp_timing.pp_off_reg_val);
		printf("\t\t  PP_DIVISOR: 0x%08lx\n",
		       (unsigned long)lfp_data->fp_timing.pp_cycle_reg_val);
		printf("\t\t  PFIT: 0x%08lx\n",
		       (unsigned long)lfp_data->fp_timing.pfit_reg_val);
		printf("\t\ttimings: %d %d %d %d %d %d %d %d %.2f (%s)\n",
		       hdisplay, hsyncstart, hsyncend, htotal,
		       vdisplay, vsyncstart, vsyncend, vtotal, clock,
		       (hsyncend > htotal || vsyncend > vtotal) ?
		       "BAD!" : "good");
	}
}

static void dump_driver_feature(const struct bdb_block *block)
{
	struct bdb_driver_feature *feature = block->data;

	printf("\tBoot Device Algorithm: %s\n", feature->boot_dev_algorithm ?
	       "driver default" : "os default");
	printf("\tBlock display switching when DVD active: %s\n",
	       YESNO(feature->block_display_switch));
	printf("\tAllow display switching when in Full Screen DOS: %s\n",
	       YESNO(feature->allow_display_switch));
	printf("\tHot Plug DVO: %s\n", YESNO(feature->hotplug_dvo));
	printf("\tDual View Zoom: %s\n", YESNO(feature->dual_view_zoom));
	printf("\tDriver INT 15h hook: %s\n", YESNO(feature->int15h_hook));
	printf("\tEnable Sprite in Clone Mode: %s\n",
	       YESNO(feature->sprite_in_clone));
	printf("\tUse 00000110h ID for Primary LFP: %s\n",
	       YESNO(feature->primary_lfp_id));
	printf("\tBoot Mode X: %u\n", feature->boot_mode_x);
	printf("\tBoot Mode Y: %u\n", feature->boot_mode_y);
	printf("\tBoot Mode Bpp: %u\n", feature->boot_mode_bpp);
	printf("\tBoot Mode Refresh: %u\n", feature->boot_mode_refresh);
	printf("\tEnable LFP as primary: %s\n",
	       YESNO(feature->enable_lfp_primary));
	printf("\tSelective Mode Pruning: %s\n",
	       YESNO(feature->selective_mode_pruning));
	printf("\tDual-Frequency Graphics Technology: %s\n",
	       YESNO(feature->dual_frequency));
	printf("\tDefault Render Clock Frequency: %s\n",
	       feature->render_clock_freq ? "low" : "high");
	printf("\tNT 4.0 Dual Display Clone Support: %s\n",
	       YESNO(feature->nt_clone_support));
	printf("\tDefault Power Scheme user interface: %s\n",
	       feature->power_scheme_ui ? "3rd party" : "CUI");
	printf
	    ("\tSprite Display Assignment when Overlay is Active in Clone Mode: %s\n",
	     feature->sprite_display_assign ? "primary" : "secondary");
	printf("\tDisplay Maintain Aspect Scaling via CUI: %s\n",
	       YESNO(feature->cui_aspect_scaling));
	printf("\tPreserve Aspect Ratio: %s\n",
	       YESNO(feature->preserve_aspect_ratio));
	printf("\tEnable SDVO device power down: %s\n",
	       YESNO(feature->sdvo_device_power_down));
	printf("\tCRT hotplug: %s\n", YESNO(feature->crt_hotplug));
	printf("\tLVDS config: ");
	switch (feature->lvds_config) {
	case BDB_DRIVER_NO_LVDS:
		printf("No LVDS\n");
		break;
	case BDB_DRIVER_INT_LVDS:
		printf("Integrated LVDS\n");
		break;
	case BDB_DRIVER_SDVO_LVDS:
		printf("SDVO LVDS\n");
		break;
	case BDB_DRIVER_EDP:
		printf("Embedded DisplayPort\n");
		break;
	}
	printf("\tDefine Display statically: %s\n",
	       YESNO(feature->static_display));
	printf("\tLegacy CRT max X: %d\n", feature->legacy_crt_max_x);
	printf("\tLegacy CRT max Y: %d\n", feature->legacy_crt_max_y);
	printf("\tLegacy CRT max refresh: %d\n",
	       feature->legacy_crt_max_refresh);
}

static void dump_edp(const struct bdb_block *block)
{
	struct bdb_edp *edp = block->data;
	int bpp, msa;
	int i;

	for (i = 0; i < 16; i++) {
		printf("\tPanel %d%s\n", i, panel_type == i ? " *" : "");

		printf("\t\tPower Sequence: T3 %d T7 %d T9 %d T10 %d T12 %d\n",
		       edp->power_seqs[i].t3,
		       edp->power_seqs[i].t7,
		       edp->power_seqs[i].t9,
		       edp->power_seqs[i].t10,
		       edp->power_seqs[i].t12);

		bpp = (edp->color_depth >> (i * 2)) & 3;

		printf("\t\tPanel color depth: ");
		switch (bpp) {
		case EDP_18BPP:
			printf("18 bpp\n");
			break;
		case EDP_24BPP:
			printf("24 bpp\n");
			break;
		case EDP_30BPP:
			printf("30 bpp\n");
			break;
		default:
			printf("(unknown value %d)\n", bpp);
			break;
		}

		msa = (edp->sdrrs_msa_timing_delay >> (i * 2)) & 3;
		printf("\t\teDP sDRRS MSA Delay: Lane %d\n", msa + 1);

		printf("\t\tLink params:\n");
		printf("\t\t\trate: ");
		if (edp->link_params[i].rate == EDP_RATE_1_62)
			printf("1.62G\n");
		else if (edp->link_params[i].rate == EDP_RATE_2_7)
			printf("2.7G\n");
		printf("\t\t\tlanes: ");
		switch (edp->link_params[i].lanes) {
		case EDP_LANE_1:
			printf("x1 mode\n");
			break;
		case EDP_LANE_2:
			printf("x2 mode\n");
			break;
		case EDP_LANE_4:
			printf("x4 mode\n");
			break;
		default:
			printf("(unknown value %d)\n",
			       edp->link_params[i].lanes);
			break;
		}
		printf("\t\t\tpre-emphasis: ");
		switch (edp->link_params[i].preemphasis) {
		case EDP_PREEMPHASIS_NONE:
			printf("none\n");
			break;
		case EDP_PREEMPHASIS_3_5dB:
			printf("3.5dB\n");
			break;
		case EDP_PREEMPHASIS_6dB:
			printf("6dB\n");
			break;
		case EDP_PREEMPHASIS_9_5dB:
			printf("9.5dB\n");
			break;
		default:
			printf("(unknown value %d)\n",
			       edp->link_params[i].preemphasis);
			break;
		}
		printf("\t\t\tvswing: ");
		switch (edp->link_params[i].vswing) {
		case EDP_VSWING_0_4V:
			printf("0.4V\n");
			break;
		case EDP_VSWING_0_6V:
			printf("0.6V\n");
			break;
		case EDP_VSWING_0_8V:
			printf("0.8V\n");
			break;
		case EDP_VSWING_1_2V:
			printf("1.2V\n");
			break;
		default:
			printf("(unknown value %d)\n",
			       edp->link_params[i].vswing);
			break;
		}
	}
}

static void
print_detail_timing_data(struct lvds_dvo_timing2 *dvo_timing)
{
	int display, sync_start, sync_end, total;

	display = (dvo_timing->hactive_hi << 8) | dvo_timing->hactive_lo;
	sync_start = display +
		((dvo_timing->hsync_off_hi << 8) | dvo_timing->hsync_off_lo);
	sync_end = sync_start + dvo_timing->hsync_pulse_width;
	total = display +
		((dvo_timing->hblank_hi << 8) | dvo_timing->hblank_lo);
	printf("\thdisplay: %d\n", display);
	printf("\thsync [%d, %d] %s\n", sync_start, sync_end,
	       dvo_timing->hsync_positive ? "+sync" : "-sync");
	printf("\thtotal: %d\n", total);

	display = (dvo_timing->vactive_hi << 8) | dvo_timing->vactive_lo;
	sync_start = display + dvo_timing->vsync_off;
	sync_end = sync_start + dvo_timing->vsync_pulse_width;
	total = display +
		((dvo_timing->vblank_hi << 8) | dvo_timing->vblank_lo);
	printf("\tvdisplay: %d\n", display);
	printf("\tvsync [%d, %d] %s\n", sync_start, sync_end,
	       dvo_timing->vsync_positive ? "+sync" : "-sync");
	printf("\tvtotal: %d\n", total);

	printf("\tclock: %d\n", dvo_timing->clock * 10);
}

static void dump_sdvo_panel_dtds(const struct bdb_block *block)
{
	struct lvds_dvo_timing2 *dvo_timing = block->data;
	int n, count;

	count = block->size / sizeof(struct lvds_dvo_timing2);
	for (n = 0; n < count; n++) {
		printf("%d:\n", n);
		print_detail_timing_data(dvo_timing++);
	}
}

static void dump_sdvo_lvds_options(const struct bdb_block *block)
{
	struct bdb_sdvo_lvds_options *options = block->data;

	printf("\tbacklight: %d\n", options->panel_backlight);
	printf("\th40 type: %d\n", options->h40_set_panel_type);
	printf("\ttype: %d\n", options->panel_type);
	printf("\tssc_clk_freq: %d\n", options->ssc_clk_freq);
	printf("\tals_low_trip: %d\n", options->als_low_trip);
	printf("\tals_high_trip: %d\n", options->als_high_trip);
	/*
	u8 sclalarcoeff_tab_row_num;
	u8 sclalarcoeff_tab_row_size;
	u8 coefficient[8];
	*/
	printf("\tmisc[0]: %x\n", options->panel_misc_bits_1);
	printf("\tmisc[1]: %x\n", options->panel_misc_bits_2);
	printf("\tmisc[2]: %x\n", options->panel_misc_bits_3);
	printf("\tmisc[3]: %x\n", options->panel_misc_bits_4);
}

static void dump_mipi_config(const struct bdb_block *block)
{
	struct bdb_mipi_config *start = block->data;
	struct mipi_config *config;
	struct mipi_pps_data *pps;

	config = &start->config[panel_type];
	pps = &start->pps[panel_type];

	printf("\tGeneral Param\n");
	printf("\t\t BTA disable: %s\n", config->bta ? "Disabled" : "Enabled");

	printf("\t\t Video Mode Color Format: ");
	if (config->videomode_color_format == 0)
		printf("Not supported\n");
	else if (config->videomode_color_format == 1)
		printf("RGB565\n");
	else if (config->videomode_color_format == 2)
		printf("RGB666\n");
	else if (config->videomode_color_format == 3)
		printf("RGB666 Loosely Packed\n");
	else if (config->videomode_color_format == 4)
		printf("RGB888\n");
	printf("\t\t PPS GPIO Pins: %s \n", config->pwm_blc ? "Using SOC" : "Using PMIC");
	printf("\t\t CABC Support: %s\n", config->cabc ? "supported" : "not supported");
	//insert video mode type
	printf("\t\t Mode: %s\n", config->cmd_mode ? "COMMAND" : "VIDEO");
	printf("\t\t Dithering: %s\n", config->dithering ? "done in Display Controller" : "done in Panel Controller");

	printf("\tPort Desc\n");
	//insert pixel overlap count
	printf("\t\t Lane Count: %d\n", config->lane_cnt + 1);
	printf("\t\t Dual Link Support: ");
	if (config->dual_link == 0)
		printf("not supported\n");
	else if (config->dual_link == 1)
		printf("Front Back mode\n");
	else
		printf("Pixel Alternative Mode\n");

	printf("\tDphy Flags\n");
	printf("\t\t Clock Stop: %s\n", config->clk_stop ? "ENABLED" : "DISABLED");
	printf("\t\t EOT disabled: %s\n\n", config->eot_disabled ? "EOT not to be sent" : "EOT to be sent");

	printf("\tHSTxTimeOut: 0x%x\n", config->hs_tx_timeout);
	printf("\tLPRXTimeOut: 0x%x\n", config->lp_rx_timeout);
	printf("\tTurnAroundTimeOut: 0x%x\n", config->turn_around_timeout);
	printf("\tDeviceResetTimer: 0x%x\n", config->device_reset_timer);
	printf("\tMasterinitTimer: 0x%x\n", config->master_init_timer);
	printf("\tDBIBandwidthTimer: 0x%x\n", config->dbi_bw_timer);
	printf("\tLpByteClkValue: 0x%x\n\n", config->lp_byte_clk_val);

	printf("\tDphy Params\n");
	printf("\t\tExit to zero Count: 0x%x\n", config->exit_zero_cnt);
	printf("\t\tTrail Count: 0x%X\n", config->trail_cnt);
	printf("\t\tClk zero count: 0x%x\n", config->clk_zero_cnt);
	printf("\t\tPrepare count:0x%x\n\n", config->prepare_cnt);

	printf("\tClockLaneSwitchingCount: 0x%x\n", config->clk_lane_switch_cnt);
	printf("\tHighToLowSwitchingCount: 0x%x\n\n", config->hl_switch_cnt);

	printf("\tTimings based on Dphy spec\n");
	printf("\t\tTClkMiss: 0x%x\n", config->tclk_miss);
	printf("\t\tTClkPost: 0x%x\n", config->tclk_post);
	printf("\t\tTClkPre: 0x%x\n", config->tclk_pre);
	printf("\t\tTClkPrepare: 0x%x\n", config->tclk_prepare);
	printf("\t\tTClkSettle: 0x%x\n", config->tclk_settle);
	printf("\t\tTClkTermEnable: 0x%x\n\n", config->tclk_term_enable);

	printf("\tTClkTrail: 0x%x\n", config->tclk_trail);
	printf("\tTClkPrepareTClkZero: 0x%x\n", config->tclk_prepare_clkzero);
	printf("\tTHSExit: 0x%x\n", config->ths_exit);
	printf("\tTHsPrepare: 0x%x\n", config->ths_prepare);
	printf("\tTHsPrepareTHsZero: 0x%x\n", config->ths_prepare_hszero);
	printf("\tTHSSettle: 0x%x\n", config->ths_settle);
	printf("\tTHSSkip: 0x%x\n", config->ths_skip);
	printf("\tTHsTrail: 0x%x\n", config->ths_trail);
	printf("\tTInit: 0x%x\n", config->tinit);
	printf("\tTLPX: 0x%x\n", config->tlpx);

	printf("\tMIPI PPS\n");
	printf("\t\tPanel power ON delay: %d\n", pps->panel_on_delay);
	printf("\t\tPanel power on to Baklight enable delay: %d\n", pps->bl_enable_delay);
	printf("\t\tBacklight disable to Panel power OFF delay: %d\n", pps->bl_disable_delay);
	printf("\t\tPanel power OFF delay: %d\n", pps->panel_off_delay);
	printf("\t\tPanel power cycle delay: %d\n", pps->panel_power_cycle_delay);
}

static uint8_t *mipi_dump_send_packet(uint8_t *data)
{
	uint8_t type, byte, count;
	uint16_t len;

	byte = *data++;
	/* get packet type and increment the pointer */
	type = *data++;

	len = *((uint16_t *) data);
	data += 2;
	printf("\t\t SEND COMMAND: ");
	printf("0x%x 0x%x 0x%x", byte, type, len);
	for (count = 0; count < len; count++)
		printf(" 0x%x",*(data+count));
	printf("\n");
	data += len;
	return data;
}

static uint8_t *mipi_dump_delay(uint8_t *data)
{
	printf("\t\t Delay : 0x%x 0x%x 0x%x 0x%x\n", data[0], data[1], data[2], data[3]);
	data += 4;
	return data;
}

static uint8_t *mipi_dump_gpio(uint8_t *data)
{
	uint8_t gpio, action;

	printf("\t\t GPIO value:");
	gpio = *data++;

	/* pull up/down */
	action = *data++;
	printf(" 0x%x 0x%x\n", gpio, action);
	return data;
}

typedef uint8_t * (*fn_mipi_elem_dump)(uint8_t *data);

static const fn_mipi_elem_dump dump_elem[] = {
	NULL, /* reserved */
	mipi_dump_send_packet,
	mipi_dump_delay,
	mipi_dump_gpio,
	NULL, /* status read; later */
};

static void dump_sequence(uint8_t *sequence)
{
	uint8_t *data = sequence;
	fn_mipi_elem_dump mipi_elem_dump;
	int index_no;

	if (!sequence)
		return;

	printf("\tSequence Name: %s\n", seq_name[*data]);

	/* go to the first element of the sequence */
	data++;

	/* parse each byte till we reach end of sequence byte - 0x00 */
	while (1) {
		index_no = *data;
		mipi_elem_dump = dump_elem[index_no];
		if (!mipi_elem_dump) {
			printf("Error: Unsupported MIPI element, skipping sequence execution\n");
			return;
		}
		/* goto element payload */
		data++;

		/* execute the element specifc rotines */
		data = mipi_elem_dump(data);

		/*
		 * After processing the element, data should point to
		 * next element or end of sequence
		 * check if have we reached end of sequence
		 */

		if (*data == 0x00)
			break;
	}
}

static uint8_t *goto_next_sequence(uint8_t *data, int *size)
{
	uint16_t len;
	int tmp = *size;

	if (--tmp < 0)
		return NULL;

	/* goto first element */
	data++;
	while (1) {
		switch (*data) {
		case MIPI_SEQ_ELEM_SEND_PKT:
			/*
			 * skip by this element payload size
			 * skip elem id, command flag and data type
			 */
			tmp -= 5;
			if (tmp < 0)
				return NULL;

			data += 3;
			len = *((uint16_t *)data);

			tmp -= len;
			if (tmp < 0)
				return NULL;

			/* skip by len */
			data = data + 2 + len;
			break;
		case MIPI_SEQ_ELEM_DELAY:
			/* skip by elem id, and delay is 4 bytes */
			tmp -= 5;
			if (tmp < 0)
				return NULL;

			data += 5;
			break;
		case MIPI_SEQ_ELEM_GPIO:
			tmp -= 3;
			if (tmp < 0)
				return NULL;

			data += 3;
			break;
		default:
			printf("Unknown element\n");
			return NULL;
                }

		/* end of sequence ? */
		if (*data == 0)
			break;
        }

	/* goto next sequence or end of block byte */
	if (--tmp < 0)
		return NULL;

        data++;

	/* update amount of data left for the sequence block to be parsed */
	*size = tmp;
	return data;
}

static uint16_t get_blocksize(void *p)
{
	uint16_t *block_ptr, block_size;

	block_ptr = (uint16_t *)((char *)p - 2);
	block_size = *block_ptr;
	return block_size;
}

static void dump_mipi_sequence(const struct bdb_block *block)
{
	struct bdb_mipi_sequence *sequence = block->data;
	uint8_t *data, *seq_data;
	int i, panel_id, seq_size;
	uint16_t block_size;

	/* Check if we have sequence block as well */
	if (!sequence) {
		printf("No MIPI Sequence found\n");
		return;
	}

	block_size = get_blocksize(sequence);

	/*
	 * parse the sequence block for individual sequences
	 */
	seq_data = &sequence->data[0];

	/*
	 * sequence block is variable length and hence we need to parse and
	 * get the sequence data for specific panel id
	 */
	for (i = 0; i < MAX_MIPI_CONFIGURATIONS; i++) {
		panel_id = *seq_data;
		seq_size = *((uint16_t *) (seq_data + 1));
		if (panel_id == panel_type)
			break;

		/* skip the sequence including seq header of 3 bytes */
		seq_data = seq_data + 3 + seq_size;
		if ((seq_data - &sequence->data[0]) > block_size) {
			printf("Sequence start is beyond sequence block size, corrupted sequence block\n");
			return;
		}
	}

	if (i == MAX_MIPI_CONFIGURATIONS) {
		printf("Sequence block detected but no valid configuration\n");
		return;
	}

	/* check if found sequence is completely within the sequence block
	 * just being paranoid */
	if (seq_size > block_size) {
		printf("Corrupted sequence/size, bailing out\n");
		return;
        }

	/* skip the panel id(1 byte) and seq size(2 bytes) */
	data = (uint8_t *) calloc(1, seq_size);
	if (data)
		memmove(data, seq_data + 3, seq_size);
	else {
		printf("Memory not allocated for sequence data\n");
		return;
	}
	/*
	 * loop into the sequence data and split into multiple sequneces
	 * There are only 5 types of sequences as of now
	 */

	/* two consecutive 0x00 indicate end of all sequences */
        while (1) {
		int seq_id = *data;
		if (MIPI_SEQ_MAX > seq_id && seq_id > MIPI_SEQ_UNDEFINED)
			dump_sequence(data);
		 else {
			printf("Error:undefined sequence\n");
			goto err;
                }

		/* partial parsing to skip elements */
		data = goto_next_sequence(data, &seq_size);

		if (data == NULL) {
			printf("Sequence elements going beyond block itself. Sequence block parsing failed\n");
			goto err;
                }

		if (*data == 0)
			break; /* end of sequence reached */
	}
        return;

err:
	free(data);
	data = NULL;
}


static int
get_device_id(unsigned char *bios)
{
    int device;
    int offset = (bios[0x19] << 8) + bios[0x18];

    if (bios[offset] != 'P' ||
	bios[offset+1] != 'C' ||
	bios[offset+2] != 'I' ||
	bios[offset+3] != 'R')
	return -1;

    device = (bios[offset+7] << 8) + bios[offset+6];

    return device;
}

struct dumper {
	uint8_t id;
	const char *name;
	void (*dump)(const struct bdb_block *block);
};

struct dumper dumpers[] = {
	{
		.id = BDB_GENERAL_FEATURES,
		.name = "General features block",
		.dump = dump_general_features,
	},
	{
		.id = BDB_GENERAL_DEFINITIONS,
		.name = "General definitions block",
		.dump = dump_general_definitions,
	},
	{
		.id = BDB_CHILD_DEVICE_TABLE,
		.name = "Child devices block",
		.dump = dump_child_devices,
	},
	{
		.id = BDB_LVDS_OPTIONS,
		.name = "LVDS options block",
		.dump = dump_lvds_options,
	},
	{
		.id = BDB_LVDS_LFP_DATA_PTRS,
		.name = "LVDS timing pointer data",
		.dump = dump_lvds_ptr_data,
	},
	{
		.id = BDB_LVDS_LFP_DATA,
		.name = "LVDS panel data block",
		.dump = dump_lvds_data,
	},
	{
		.id = BDB_LVDS_BACKLIGHT,
		.name = "Backlight info block",
		.dump = dump_backlight_info,
	},
	{
		.id = BDB_SDVO_LVDS_OPTIONS,
		.name = "SDVO LVDS options block",
		.dump = dump_sdvo_lvds_options,
	},
	{
		.id = BDB_SDVO_PANEL_DTDS,
		.name = "SDVO panel dtds",
		.dump = dump_sdvo_panel_dtds,
	},
	{
		.id = BDB_DRIVER_FEATURES,
		.name = "Driver feature data block",
		.dump = dump_driver_feature,
	},
	{
		.id = BDB_EDP,
		.name = "eDP block",
		.dump = dump_edp,
	},
	{
		.id = BDB_MIPI_CONFIG,
		.name = "MIPI configuration block",
		.dump = dump_mipi_config,
	},
	{
		.id = BDB_MIPI_SEQUENCE,
		.name = "MIPI sequence block",
		.dump = dump_mipi_sequence,
	},
};

static void hex_dump(const struct bdb_block *block)
{
	int i;
	uint8_t *p = block->data;

	for (i = 0; i < block->size; i++) {
		if (i % 16 == 0)
			printf("\t%04x: ", i);
		printf("%02x", p[i]);
		if (i % 16 == 15) {
			if (i + 1 < block->size)
				printf("\n");
		} else if (i % 8 == 7) {
			printf("  ");
		} else {
			printf(" ");
		}
	}
	printf("\n\n");
}

static void dump_section(int section_id, int size)
{
	struct dumper *dumper = NULL;
	const struct bdb_block *block;
	static int done[256];
	int i;

	if (done[section_id])
		return;
	done[section_id] = 1;

	block = find_section(section_id, size);
	if (!block)
		return;

	for (i = 0; i < ARRAY_SIZE(dumpers); i++) {
		if (block->id == dumpers[i].id) {
			dumper = &dumpers[i];
			break;
		}
	}

	if (dumper && dumper->name)
		printf("BDB block %d - %s:\n", block->id, dumper->name);
	else
		printf("BDB block %d:\n", block->id);

	hex_dump(block);
	if (dumper && dumper->dump)
		dumper->dump(block);
	printf("\n");
}

int main(int argc, char **argv)
{
	int fd;
	struct vbt_header *vbt = NULL;
	int vbt_off, bdb_off, i;
	const char *filename = "bios";
	struct stat finfo;
	int size;
	struct bdb_block *block;
	char signature[17];
	char *devid_string;

	if (argc != 2) {
		printf("usage: %s <rom file>\n", argv[0]);
		return 1;
	}

	if ((devid_string = getenv("DEVICE")))
	    devid = strtoul(devid_string, NULL, 0);

	filename = argv[1];

	fd = open(filename, O_RDONLY);
	if (fd == -1) {
		printf("Couldn't open \"%s\": %s\n", filename, strerror(errno));
		return 1;
	}

	if (stat(filename, &finfo)) {
		printf("failed to stat \"%s\": %s\n", filename,
		       strerror(errno));
		return 1;
	}
	size = finfo.st_size;

	if (size == 0) {
		int len = 0, ret;
		size = 8192;
		VBIOS = malloc (size);
		while ((ret = read(fd, VBIOS + len, size - len))) {
			if (ret < 0) {
				printf("failed to read \"%s\": %s\n", filename,
				       strerror(errno));
				return 1;
			}

			len += ret;
			if (len == size) {
				size *= 2;
				VBIOS = realloc(VBIOS, size);
			}
		}
	} else {
		VBIOS = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
		if (VBIOS == MAP_FAILED) {
			printf("failed to map \"%s\": %s\n", filename, strerror(errno));
			return 1;
		}
	}

	/* Scour memory looking for the VBT signature */
	for (i = 0; i + 4 < size; i++) {
		if (!memcmp(VBIOS + i, "$VBT", 4)) {
			vbt_off = i;
			vbt = (struct vbt_header *)(VBIOS + i);
			break;
		}
	}

	if (!vbt) {
		printf("VBT signature missing\n");
		return 1;
	}

	printf("VBT vers: %d.%d\n", vbt->version / 100, vbt->version % 100);

	bdb_off = vbt_off + vbt->bdb_offset;
	if (bdb_off >= size - sizeof(struct bdb_header)) {
		printf("Invalid VBT found, BDB points beyond end of data block\n");
		return 1;
	}

	bdb = (struct bdb_header *)(VBIOS + bdb_off);
	strncpy(signature, (char *)bdb->signature, 16);
	signature[16] = 0;
	printf("BDB sig: %s\n", signature);
	printf("BDB vers: %d\n", bdb->version);

	printf("Available sections: ");

	for (i = 0; i < 256; i++) {
		block = find_section(i, size);
		if (!block)
			continue;
		printf("%d ", i);
		free(block);
	}
	printf("\n");

	if (devid == -1)
	    devid = get_device_id(VBIOS);
	if (devid == -1)
	    printf("Warning: could not find PCI device ID!\n");

	dump_section(BDB_GENERAL_FEATURES, size);
	dump_section(BDB_GENERAL_DEFINITIONS, size);
	dump_section(BDB_CHILD_DEVICE_TABLE, size);
	dump_section(BDB_LVDS_OPTIONS, size);
	dump_section(BDB_LVDS_LFP_DATA_PTRS, size);
	dump_section(BDB_LVDS_LFP_DATA, size);
	dump_section(BDB_LVDS_BACKLIGHT, size);

	dump_section(BDB_SDVO_LVDS_OPTIONS, size);
	dump_section(BDB_SDVO_PANEL_DTDS, size);

	dump_section(BDB_DRIVER_FEATURES, size);
	dump_section(BDB_EDP, size);
	dump_section(BDB_MIPI_CONFIG, size);
	dump_section(BDB_MIPI_SEQUENCE, size);

	for (i = 0; i < 256; i++)
		dump_section(i, size);

	return 0;
}