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

 	mutex_lock(&dev_priv->sb_lock);
 	if (!gtable[gpio].init) {
 		/* program the function */
 		/* FIXME: remove constant below */
+		vlv_iosf_sb_write(dev_priv, IOSF_PORT_GPIO_NC, function,
-		vlv_gpio_nc_write(dev_priv, function, 0x2000CC00);
+x2000CC00);
 		gtable[gpio].init = 1;
+	}
 	val = 0x4 | action;
 	/* pull up/down */
-	vlv_gpio_nc_write(dev_priv, pad, val);
+	vlv_iosf_sb_write(dev_priv, IOSF_PORT_GPIO_NC, pad, val);
 	mutex_unlock(&dev_priv->sb_lock);
+out:
+	return data;
+}
 static const u8 *mipi_exec_i2c_skip(struct intel_dsi *intel_dsi, const u8 *data)
 out:
-	return data;
+	return data + *(data + 6) + 7;
-}
+}
-typedef const u8 * (*fn_mipi_elem_exec)(struct intel_dsi *intel_dsi,
-					const u8 *data);
+typedef const u8 * (*fn_mipi_elem_exec)(struct intel_dsi *intel_dsi,
-static const fn_mipi_elem_exec exec_elem[] = {
+					const u8 *data);
-	NULL, /* reserved */
+static const fn_mipi_elem_exec exec_elem[] = {
-	mipi_exec_send_packet,
+	[MIPI_SEQ_ELEM_SEND_PKT] = mipi_exec_send_packet,
-	mipi_exec_delay,
+	[MIPI_SEQ_ELEM_DELAY] = mipi_exec_delay,
-	mipi_exec_gpio,
+	[MIPI_SEQ_ELEM_GPIO] = mipi_exec_gpio,
-	NULL, /* status read; later */
+	[MIPI_SEQ_ELEM_I2C] = mipi_exec_i2c_skip,
 };
-/*
- * MIPI Sequence from VBT #53 parsing logic
+/*
- * We have already separated each seqence during bios parsing
+ * MIPI Sequence from VBT #53 parsing logic
- * Following is generic execution function for any sequence
+ * We have already separated each seqence during bios parsing
- */
+ * Following is generic execution function for any sequence
+ */
+static const char * const seq_name[] = {
+	[MIPI_SEQ_ASSERT_RESET] = "MIPI_SEQ_ASSERT_RESET",
+	[MIPI_SEQ_INIT_OTP] = "MIPI_SEQ_INIT_OTP",
+	[MIPI_SEQ_DISPLAY_ON] = "MIPI_SEQ_DISPLAY_ON",
+	[MIPI_SEQ_DISPLAY_OFF]  = "MIPI_SEQ_DISPLAY_OFF",
-static const char * const seq_name[] = {
+	[MIPI_SEQ_DEASSERT_RESET] = "MIPI_SEQ_DEASSERT_RESET",
+	[MIPI_SEQ_BACKLIGHT_ON] = "MIPI_SEQ_BACKLIGHT_ON",
+	[MIPI_SEQ_BACKLIGHT_OFF] = "MIPI_SEQ_BACKLIGHT_OFF",
+	[MIPI_SEQ_TEAR_ON] = "MIPI_SEQ_TEAR_ON",
+	[MIPI_SEQ_TEAR_OFF] = "MIPI_SEQ_TEAR_OFF",
+	[MIPI_SEQ_POWER_ON] = "MIPI_SEQ_POWER_ON",
+	[MIPI_SEQ_POWER_OFF] = "MIPI_SEQ_POWER_OFF",
+};
-	"UNDEFINED",
+static const char *sequence_name(enum mipi_seq seq_id)
 	"MIPI_SEQ_ASSERT_RESET",
+	if (seq_id < ARRAY_SIZE(seq_name) && seq_name[seq_id])
+		return seq_name[seq_id];
+	else
+		return "(unknown)";
 	"MIPI_SEQ_INIT_OTP",
-	"MIPI_SEQ_DISPLAY_ON",
-	"MIPI_SEQ_DISPLAY_OFF",
-	"MIPI_SEQ_DEASSERT_RESET"
+static void generic_exec_sequence(struct drm_panel *panel, enum mipi_seq seq_id)
-};
-static void generic_exec_sequence(struct intel_dsi *intel_dsi, const u8 *data)
+{
-{
+	struct vbt_panel *vbt_panel = to_vbt_panel(panel);
-	fn_mipi_elem_exec mipi_elem_exec;
-	int index;
+	struct intel_dsi *intel_dsi = vbt_panel->intel_dsi;
-	if (!data)
-		return;
+	struct drm_i915_private *dev_priv = to_i915(intel_dsi->base.base.dev);
-	DRM_DEBUG_DRIVER("Starting MIPI sequence - %s\n", seq_name[*data]);
 	const u8 *data;
-	/* go to the first element of the sequence */
+	fn_mipi_elem_exec mipi_elem_exec;
+	if (WARN_ON(seq_id >= ARRAY_SIZE(dev_priv->vbt.dsi.sequence)))
+		return;
+	data = dev_priv->vbt.dsi.sequence[seq_id];
-	data++;
+	if (!data) {
 		DRM_DEBUG_KMS("MIPI sequence %d - %s not available\n",
-	/* parse each byte till we reach end of sequence byte - 0x00 */
+			      seq_id, sequence_name(seq_id));
-	while (1) {
+		return;
+	}
-		index = *data;
-		mipi_elem_exec = exec_elem[index];
+	WARN_ON(*data != seq_id);
-		if (!mipi_elem_exec) {
-			DRM_ERROR("Unsupported MIPI element, skipping sequence execution\n");
-			return;
+	DRM_DEBUG_KMS("Starting MIPI sequence %d - %s\n",
-		}
+		      seq_id, sequence_name(seq_id));
+	/* Skip Sequence Byte. */
+	data++;
+	/* Skip Size of Sequence. */
+	if (dev_priv->vbt.dsi.seq_version >= 3)
+		data += 4;
+	while (1) {
+		u8 operation_byte = *data++;
+		u8 operation_size = 0;
+		if (operation_byte == MIPI_SEQ_ELEM_END)
+			break;
+		if (operation_byte < ARRAY_SIZE(exec_elem))
+			mipi_elem_exec = exec_elem[operation_byte];
+		else
+			mipi_elem_exec = NULL;
+		/* Size of Operation. */
+		if (dev_priv->vbt.dsi.seq_version >= 3)
+			operation_size = *data++;
-		/* goto element payload */
+		if (mipi_elem_exec) {
-		data++;
+			data = mipi_elem_exec(intel_dsi, data);
 		} else if (operation_size) {
-		/* execute the element specific rotines */
+			/* We have size, skip. */
-		data = mipi_elem_exec(intel_dsi, 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)
+			DRM_DEBUG_KMS("Unsupported MIPI operation byte %u\n",
-			break;
-	}
-}
+				      operation_byte);
 			data += operation_size;
-static int vbt_panel_prepare(struct drm_panel *panel)
+		} else {
 			/* No size, can't skip without parsing. */
-	struct vbt_panel *vbt_panel = to_vbt_panel(panel);
+			DRM_ERROR("Unsupported MIPI operation byte %u\n",
-	struct intel_dsi *intel_dsi = vbt_panel->intel_dsi;
-	struct drm_device *dev = intel_dsi->base.base.dev;
-	struct drm_i915_private *dev_priv = dev->dev_private;
-	const u8 *sequence;
-	sequence = dev_priv->vbt.dsi.sequence[MIPI_SEQ_ASSERT_RESET];
-	generic_exec_sequence(intel_dsi, sequence);
+				  operation_byte);
-	sequence = dev_priv->vbt.dsi.sequence[MIPI_SEQ_INIT_OTP];
+			return;
 	generic_exec_sequence(intel_dsi, sequence);
+	}
 	return 0;
-}
-static int vbt_panel_unprepare(struct drm_panel *panel)
-{
-	struct vbt_panel *vbt_panel = to_vbt_panel(panel);
-	struct intel_dsi *intel_dsi = vbt_panel->intel_dsi;
-	struct drm_device *dev = intel_dsi->base.base.dev;
-	struct drm_i915_private *dev_priv = dev->dev_private;
-	const u8 *sequence;
+static int vbt_panel_prepare(struct drm_panel *panel)
+{
-	sequence = dev_priv->vbt.dsi.sequence[MIPI_SEQ_DEASSERT_RESET];
+	generic_exec_sequence(panel, MIPI_SEQ_ASSERT_RESET);
-	generic_exec_sequence(intel_dsi, sequence);
+	generic_exec_sequence(panel, MIPI_SEQ_INIT_OTP);
-	return 0;
-}
-static int vbt_panel_enable(struct drm_panel *panel)
-{
-	struct vbt_panel *vbt_panel = to_vbt_panel(panel);
-	struct intel_dsi *intel_dsi = vbt_panel->intel_dsi;
-	struct drm_device *dev = intel_dsi->base.base.dev;
+	return 0;
 	struct drm_i915_private *dev_priv = dev->dev_private;
 	const u8 *sequence;
 	intel_dsi->lane_count = mipi_config->lane_cnt + 1;
 	intel_dsi->pixel_format = mipi_config->videomode_color_format << 7;
 	intel_dsi->dual_link = mipi_config->dual_link;
 	intel_dsi->pixel_overlap = mipi_config->pixel_overlap;
-	if (intel_dsi->pixel_format == VID_MODE_FORMAT_RGB666)
-		bits_per_pixel = 18;
-	else if (intel_dsi->pixel_format == VID_MODE_FORMAT_RGB565)
-		bits_per_pixel = 16;
+	bits_per_pixel = dsi_pixel_format_bpp(intel_dsi->pixel_format);
 	intel_dsi->operation_mode = mipi_config->is_cmd_mode;
 	intel_dsi->video_mode_format = mipi_config->video_transfer_mode;
 	intel_dsi->panel_off_delay = pps->panel_off_delay / 10;
 	intel_dsi->panel_pwr_cycle_delay = pps->panel_power_cycle_delay / 10;
 	/* This is cheating a bit with the cleanup. */
+    vbt_panel = kzalloc(sizeof(*vbt_panel), GFP_KERNEL);
+	if (!vbt_panel)
-    vbt_panel = kzalloc(sizeof(*vbt_panel), GFP_KERNEL);
+		return NULL;
 	vbt_panel->intel_dsi = intel_dsi;
 	drm_panel_init(&vbt_panel->panel);

Subversion Repositories Kolibri OS

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