WebSVN – Kolibri OS – Diff – /drivers/video/drm/i915/intel_bios.c

 #include
 #include
 #include "i915_drv.h"
 #include "intel_bios.h"
+/**
+ * DOC: Video BIOS Table (VBT)
+ *
+ * The Video BIOS Table, or VBT, provides platform and board specific
+ * configuration information to the driver that is not discoverable or available
+ * through other means. The configuration is mostly related to display
+ * hardware. The VBT is available via the ACPI OpRegion or, on older systems, in
+ * the PCI ROM.
+ *
+ * The VBT consists of a VBT Header (defined as &struct vbt_header), a BDB
+ * Header (&struct bdb_header), and a number of BIOS Data Blocks (BDB) that
+ * contain the actual configuration information. The VBT Header, and thus the
+ * VBT, begins with "$VBT" signature. The VBT Header contains the offset of the
+ * BDB Header. The data blocks are concatenated after the BDB Header. The data
+ * blocks have a 1-byte Block ID, 2-byte Block Size, and Block Size bytes of
+ * data. (Block 53, the MIPI Sequence Block is an exception.)
+ *
+ * The driver parses the VBT during load. The relevant information is stored in
+ * driver private data for ease of use, and the actual VBT is not read after
+ * that.
+ */
 #define	SLAVE_ADDR1	0x70
 #define	SLAVE_ADDR2	0x72
+static int panel_type;
+/* Get BDB block size given a pointer to Block ID. */
+static u32 _get_blocksize(const u8 *block_base)
+{
+	/* The MIPI Sequence Block v3+ has a separate size field. */
+	if (*block_base == BDB_MIPI_SEQUENCE && *(block_base + 3) >= 3)
+		return *((const u32 *)(block_base + 4));
+	else
+		return *((const u16 *)(block_base + 1));
+}
+/* Get BDB block size give a pointer to data after Block ID and Block Size. */
+static u32 get_blocksize(const void *block_data)
+{
 	return _get_blocksize(block_data - 3);
 static int panel_type;
 static const void *
 find_section(const void *_bdb, int section_id)
 	total = bdb->bdb_size;
 	/* walk the sections looking for section_id */
 	while (index + 3 < total) {
-		current_id = *(base + index);
-		index++;
+		current_id = *(base + index);
-		current_size = *((const u16 *)(base + index));
+		current_size = _get_blocksize(base + index);
-		index += 2;
-		/* The MIPI Sequence Block v3+ has a separate size field. */
-		if (current_id == BDB_MIPI_SEQUENCE && *(base + index) >= 3)
-			current_size = *((const u32 *)(base + index + 1));
+		index += 3;
 		if (index + current_size > total)
+	}
 	return NULL;
-}
-static u16
-get_blocksize(const 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)
 	dev_priv->vbt.psr.tp1_wakeup_time = psr_table->tp1_wakeup_time;
 	dev_priv->vbt.psr.tp2_tp3_wakeup_time = psr_table->tp2_tp3_wakeup_time;
-}
-static u8 *goto_next_sequence(u8 *data, int *size)
-{
-	u16 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 = *((u16 *)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:
-			DRM_ERROR("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 void
-static void
+parse_mipi_config(struct drm_i915_private *dev_priv,
-parse_mipi(struct drm_i915_private *dev_priv, const struct bdb_header *bdb)
+		  const struct bdb_header *bdb)
-{
 	const struct bdb_mipi_config *start;
-	const struct bdb_mipi_sequence *sequence;
+	const struct bdb_mipi_config *start;
-	const struct mipi_config *config;
-	const struct mipi_pps_data *pps;
-	u8 *data;
-	const u8 *seq_data;
-	int i, panel_id, seq_size;
+	const struct mipi_config *config;
-	u16 block_size;
+	const struct mipi_pps_data *pps;
 		return;
+	}
 	/* We have mandatory mipi config blocks. Initialize as generic panel */
+	dev_priv->vbt.dsi.panel_id = MIPI_DSI_GENERIC_PANEL_ID;
-	dev_priv->vbt.dsi.panel_id = MIPI_DSI_GENERIC_PANEL_ID;
+}
+/* Find the sequence block and size for the given panel. */
+static const u8 *
+find_panel_sequence_block(const struct bdb_mipi_sequence *sequence,
+			  u16 panel_id, u32 *seq_size)
+{
+	u32 total = get_blocksize(sequence);
+	const u8 *data = &sequence->data[0];
+	u8 current_id;
+	u32 current_size;
+	int header_size = sequence->version >= 3 ? 5 : 3;
+	int index = 0;
+	int i;
-	/* Check if we have sequence block as well */
+	/* skip new block size */
+	if (sequence->version >= 3)
+		data += 4;
-	sequence = find_section(bdb, BDB_MIPI_SEQUENCE);
+	for (i = 0; i < MAX_MIPI_CONFIGURATIONS && index < total; i++) {
-	if (!sequence) {
+		if (index + header_size > total) {
-		DRM_DEBUG_KMS("No MIPI Sequence found, parsing complete\n");
+			DRM_ERROR("Invalid sequence block (header)\n");
-		return;
+			return NULL;
-	}
+		}
+		current_id = *(data + index);
+		if (sequence->version >= 3)
+			current_size = *((const u32 *)(data + index + 1));
+		else
+			current_size = *((const u16 *)(data + index + 1));
+		index += header_size;
-	/* Fail gracefully for forward incompatible sequence block. */
+		if (index + current_size > total) {
+			DRM_ERROR("Invalid sequence block\n");
+			return NULL;
+		}
-	if (sequence->version >= 3) {
+		if (current_id == panel_id) {
+			*seq_size = current_size;
+			return data + index;
+		}
-		DRM_ERROR("Unable to parse MIPI Sequence Block v3+\n");
+		index += current_size;
+	}
+	DRM_ERROR("Sequence block detected but no valid configuration\n");
+	return NULL;
+}
+static int goto_next_sequence(const u8 *data, int index, int total)
+{
+	u16 len;
+	/* Skip Sequence Byte. */
+	for (index = index + 1; index < total; index += len) {
+		u8 operation_byte = *(data + index);
+		index++;
+		switch (operation_byte) {
+		case MIPI_SEQ_ELEM_END:
+			return index;
+		case MIPI_SEQ_ELEM_SEND_PKT:
+			if (index + 4 > total)
+				return 0;
+			len = *((const u16 *)(data + index + 2)) + 4;
+			break;
+		case MIPI_SEQ_ELEM_DELAY:
+			len = 4;
+			break;
+		case MIPI_SEQ_ELEM_GPIO:
+			len = 2;
+			break;
+		case MIPI_SEQ_ELEM_I2C:
+			if (index + 7 > total)
+				return 0;
+			len = *(data + index + 6) + 7;
+			break;
+		default:
+			DRM_ERROR("Unknown operation byte\n");
+			return 0;
+		}
+	}
+	return 0;
+}
-		return;
 static int goto_next_sequence_v3(const u8 *data, int index, int total)
+{
+	int seq_end;
-	DRM_DEBUG_DRIVER("Found MIPI sequence block\n");
+	u16 len;
+	u32 size_of_sequence;
+	/*
+	 * Could skip sequence based on Size of Sequence alone, but also do some
-	block_size = get_blocksize(sequence);
+	 * checking on the structure.
+	 */
 	if (total < 5) {
-	/*
+		DRM_ERROR("Too small sequence size\n");
-	 * parse the sequence block for individual sequences
+		return 0;
+	}
 	 */
-	dev_priv->vbt.dsi.seq_version = sequence->version;
-	seq_data = &sequence->data[0];
+	/* Skip Sequence Byte. */
-	/*
+	index++;
-	 * 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++) {
+	 * Size of Sequence. Excludes the Sequence Byte and the size itself,
-		panel_id = *seq_data;
+	 * includes MIPI_SEQ_ELEM_END byte, excludes the final MIPI_SEQ_END
-		seq_size = *((u16 *) (seq_data + 1));
+	 * byte.
+	 */
+	size_of_sequence = *((const uint32_t *)(data + index));
+	index += 4;
+	seq_end = index + size_of_sequence;
+	if (seq_end > total) {
+		DRM_ERROR("Invalid sequence size\n");
+		return 0;
+	}
+	for (; index < total; index += len) {
-		if (panel_id == panel_type)
+		u8 operation_byte = *(data + index);
+		index++;
+		if (operation_byte == MIPI_SEQ_ELEM_END) {
+			if (index != seq_end) {
+				DRM_ERROR("Invalid element structure\n");
+				return 0;
+			}
+			return index;
+		}
-			break;
+		len = *(data + index);
+		index++;
+		/*
+		 * FIXME: Would be nice to check elements like for v1/v2 in
+		 * goto_next_sequence() above.
+		 */
+		switch (operation_byte) {
+		case MIPI_SEQ_ELEM_SEND_PKT:
+		case MIPI_SEQ_ELEM_DELAY:
+		case MIPI_SEQ_ELEM_GPIO:
+		case MIPI_SEQ_ELEM_I2C:
+		case MIPI_SEQ_ELEM_SPI:
+		case MIPI_SEQ_ELEM_PMIC:
+			break;
+		default:
+			DRM_ERROR("Unknown operation byte %u\n",
+				  operation_byte);
+			break;
+		}
+	}
+	return 0;
+}
+static void
+parse_mipi_sequence(struct drm_i915_private *dev_priv,
+		    const struct bdb_header *bdb)
+{
+	const struct bdb_mipi_sequence *sequence;
+	const u8 *seq_data;
+	u32 seq_size;
-		/* skip the sequence including seq header of 3 bytes */
+	u8 *data;
-		seq_data = seq_data + 3 + seq_size;
+	int index = 0;
-		if ((seq_data - &sequence->data[0]) > block_size) {
-			DRM_ERROR("Sequence start is beyond sequence block size, corrupted sequence block\n");
+	/* Only our generic panel driver uses the sequence block. */
-			return;
+	if (dev_priv->vbt.dsi.panel_id != MIPI_DSI_GENERIC_PANEL_ID)
-		}
+		return;
 	sequence = find_section(bdb, BDB_MIPI_SEQUENCE);
-	if (i == MAX_MIPI_CONFIGURATIONS) {
+	if (!sequence) {
+		DRM_DEBUG_KMS("No MIPI Sequence found, parsing complete\n");
-		DRM_ERROR("Sequence block detected but no valid configuration\n");
+		return;
-		return;
+	}
-	/* check if found sequence is completely within the sequence block
-	 * just being paranoid */
+	/* Fail gracefully for forward incompatible sequence block. */
-	if (seq_size > block_size) {
+	if (sequence->version >= 4) {
-		DRM_ERROR("Corrupted sequence/size, bailing out\n");
+		DRM_ERROR("Unable to parse MIPI Sequence Block v%u\n",
-		return;
-	}
+			  sequence->version);
+		return;
-	/* skip the panel id(1 byte) and seq size(2 bytes) */
+	}
-	dev_priv->vbt.dsi.data = kmemdup(seq_data + 3, seq_size, GFP_KERNEL);
-	if (!dev_priv->vbt.dsi.data)
-		return;
+	DRM_DEBUG_DRIVER("Found MIPI sequence block v%u\n", sequence->version);
+	seq_data = find_panel_sequence_block(sequence, panel_type, &seq_size);
-	/*
+	if (!seq_data)
-	 * loop into the sequence data and split into multiple sequneces
+		return;
 	 * There are only 5 types of sequences as of now
-	 */
-	data = dev_priv->vbt.dsi.data;
+	data = kmemdup(seq_data, seq_size, GFP_KERNEL);
+	if (!data)
+		return;
+	/* Parse the sequences, store pointers to each sequence. */
-	dev_priv->vbt.dsi.size = seq_size;
+	for (;;) {
+		u8 seq_id = *(data + index);
-	/* two consecutive 0x00 indicate end of all sequences */
+		if (seq_id == MIPI_SEQ_END)
-	while (1) {
+			break;
-		int seq_id = *data;
-		if (MIPI_SEQ_MAX > seq_id && seq_id > MIPI_SEQ_UNDEFINED) {
-			dev_priv->vbt.dsi.sequence[seq_id] = data;
 			DRM_DEBUG_DRIVER("Found mipi sequence - %d\n", seq_id);
+		if (seq_id >= MIPI_SEQ_MAX) {
+			DRM_ERROR("Unknown sequence %u\n", seq_id);
+			goto err;
+		}
-		} else {
-			DRM_ERROR("undefined sequence\n");
+		dev_priv->vbt.dsi.sequence[seq_id] = data + index;
-			goto err;
-		}
-		/* partial parsing to skip elements */
-		data = goto_next_sequence(data, &seq_size);
+		if (sequence->version >= 3)
 			index = goto_next_sequence_v3(data, index, seq_size);
-		if (data == NULL) {
+		else
-			DRM_ERROR("Sequence elements going beyond block itself. Sequence block parsing failed\n");
+			index = goto_next_sequence(data, index, seq_size);
-			goto err;
+		if (!index) {
 	p_defs = find_section(bdb, BDB_GENERAL_DEFINITIONS);
 	if (!p_defs) {
 		DRM_DEBUG_KMS("No general definition block is found, no devices defined.\n");
 		return;
+	}
-	if (bdb->version < 195) {
+	if (bdb->version < 106) {
+		expected_size = 22;
+	} else if (bdb->version < 109) {
+		expected_size = 27;
+	} else if (bdb->version < 195) {
+		BUILD_BUG_ON(sizeof(struct old_child_dev_config) != 33);
 		expected_size = sizeof(struct old_child_dev_config);
 	} else if (bdb->version == 195) {
 		expected_size = 37;
 	} else if (bdb->version <= 197) {
 		expected_size = 38;
 		BUILD_BUG_ON(sizeof(*p_child) < 38);
 		DRM_DEBUG_DRIVER("Expected child device config size for VBT version %u not known; assuming %u\n",
 				 bdb->version, expected_size);
+	}
+	/* Flag an error for unexpected size, but continue anyway. */
+	if (p_defs->child_dev_size != expected_size)
+		DRM_ERROR("Unexpected child device config size %u (expected %u for VBT version %u)\n",
+			  p_defs->child_dev_size, expected_size, bdb->version);
 	/* The legacy sized child device config is the minimum we need. */
 	if (p_defs->child_dev_size < sizeof(struct old_child_dev_config)) {
-		DRM_ERROR("Child device config size %u is too small.\n",
+		DRM_DEBUG_KMS("Child device config size %u is too small.\n",
-			  p_defs->child_dev_size);
+			      p_defs->child_dev_size);
 		return;
-	}
-	/* Flag an error for unexpected size, but continue anyway. */
-	if (p_defs->child_dev_size != expected_size)
-		DRM_ERROR("Unexpected child device config size %u (expected %u for VBT version %u)\n",
 			  p_defs->child_dev_size, expected_size, bdb->version);
 	/* get the block size of general definitions */
 	block_size = get_blocksize(p_defs);
 	/* get the number of child device */
 	return NULL;
+}
 /**
  * intel_bios_init - find VBT and initialize settings from the BIOS
- * @dev: DRM device
+ * @dev_priv: i915 device instance
+ *
  * Loads the Video BIOS and checks that the VBT exists.  Sets scratch registers
  * to appropriate values.
+ *
 	parse_sdvo_device_mapping(dev_priv, bdb);
 	parse_device_mapping(dev_priv, bdb);
 	parse_driver_features(dev_priv, bdb);
 	parse_edp(dev_priv, bdb);
 	parse_psr(dev_priv, bdb);
-	parse_mipi(dev_priv, bdb);
+	parse_mipi_config(dev_priv, bdb);
+	parse_mipi_sequence(dev_priv, bdb);
 	parse_ddi_ports(dev_priv, bdb);
 	if (bios)

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/intel_bios.c – Rev 6937 → 7144