Support DSC (Display Stream Compression) panels (#25)

Co-authored-by: jenneron <[email protected]>
Co-authored-by: Caleb Connolly <[email protected]>

Author: 3 people

driver.py

@@ -7,7 +7,7 @@
 import simple
 import wrap
 from generator import Options, GpioFlag
-from panel import Panel, BacklightControl, CommandSequence
+from panel import Panel, BacklightControl, CommandSequence, CompressionMode
 
 
 def generate_includes(p: Panel, options: Options) -> str:
@@ -31,6 +31,9 @@ def generate_includes(p: Panel, options: Options) -> str:
 		includes['linux'].add('regulator/consumer.h')
 	if p.backlight == BacklightControl.DCS or options.backlight_fallback_dcs:
 		includes['linux'].add('backlight.h')
+	if p.compression_mode == CompressionMode.DSC:
+		includes['drm'].add('display/drm_dsc.h')
+		includes['drm'].add('display/drm_dsc_helper.h')
 
 	for cmd in p.cmds.values():
 		if 'MIPI_DCS_' in cmd.generated:
@@ -55,6 +58,9 @@ def generate_struct(p: Panel, options: Options) -> str:
 		'struct mipi_dsi_device *dsi',
 	]
 
+	if p.compression_mode == CompressionMode.DSC:
+		variables.append('struct drm_dsc_config dsc')
+
 	if options.regulator:
 		if len(options.regulator) > 1:
 			variables.append(f'struct regulator_bulk_data supplies[{len(options.regulator)}]')
@@ -164,6 +170,14 @@ def generate_prepare(p: Panel, options: Options) -> str:
 {{
 	struct {p.short_id} *ctx = to_{p.short_id}(panel);
 	struct device *dev = &ctx->dsi->dev;
+'''
+
+	if p.compression_mode == CompressionMode.DSC:
+		s += '''\
+	struct drm_dsc_picture_parameter_set pps;
+'''
+
+	s += f'''\
 	int ret;
 
 	if (ctx->prepared)
@@ -197,10 +211,31 @@ def generate_prepare(p: Panel, options: Options) -> str:
 		dev_err(dev, "Failed to initialize panel: %d\\n", ret);{generate_cleanup(p, options, 2)}
 		return ret;
 	}}
+'''
+
+	if p.compression_mode == CompressionMode.DSC:
+		s += '''
+	drm_dsc_pps_payload_pack(&pps, &ctx->dsc);
+
+	ret = mipi_dsi_picture_parameter_set(ctx->dsi, &pps);
+	if (ret < 0) {
+		dev_err(panel->dev, "failed to transmit PPS: %d\\n", ret);
+		return ret;
+	}
+
+	ret = mipi_dsi_compression_mode(ctx->dsi, true);
+	if (ret < 0) {
+		dev_err(dev, "failed to enable compression mode: %d\\n", ret);
+		return ret;
+	}
+
+	msleep(28); /* TODO: Is this panel-dependent? */
+'''
 
+	s += '''
 	ctx->prepared = true;
 	return 0;
-}}
+}
 '''
 	return s
 
@@ -325,6 +360,9 @@ def generate_probe(p: Panel, options: Options) -> str:
 {{
 	struct device *dev = &dsi->dev;
 	struct {p.short_id} *ctx;
+'''
+
+	s += f'''\
 	int ret;
 
 	ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
@@ -407,14 +445,40 @@ def generate_probe(p: Panel, options: Options) -> str:
 
 	s += '''
 	drm_panel_add(&ctx->panel);
+'''
+
+	if p.compression_mode == CompressionMode.DSC:
+		s += f'''
+	/* This panel only supports DSC; unconditionally enable it */
+	dsi->dsc = &ctx->dsc;
+
+	ctx->dsc.dsc_version_major = {(p.dsc_version >> 4) & 0xf};
+	ctx->dsc.dsc_version_minor = {p.dsc_version & 0xf};
+
+	/* TODO: Pass slice_per_pkt = {p.dsc_slice_per_pkt} */
+	ctx->dsc.slice_height = {p.dsc_slice_height};
+	ctx->dsc.slice_width = {p.dsc_slice_width};
+	/*
+	 * TODO: hdisplay should be read from the selected mode once
+	 * it is passed back to drm_panel (in prepare?)
+	 */
+	WARN_ON({p.h.px} % ctx->dsc.slice_width);
+	ctx->dsc.slice_count = {p.h.px} / ctx->dsc.slice_width;
+	ctx->dsc.bits_per_component = {p.dsc_bit_per_component};
+	ctx->dsc.bits_per_pixel = {p.dsc_bit_per_pixel} << 4; /* 4 fractional bits */
+	ctx->dsc.block_pred_enable = {"true" if p.dsc_block_prediction else "false"};
+'''
 
+	s += '''
 	ret = mipi_dsi_attach(dsi);
 	if (ret < 0) {
 		dev_err(dev, "Failed to attach to DSI host: %d\\n", ret);
 		drm_panel_remove(&ctx->panel);
 		return ret;
 	}
+'''
 
+	s += '''
 	return 0;
 }
 '''

panel.py

@@ -97,6 +97,11 @@ class BacklightControl(Enum):
 	SAMSUNG_PWM = 'bl_ctrl_ss_pwm'
 
 
+@unique
+class CompressionMode(Enum):
+	DSC = "dsc"
+
+
 class Dimension:
 	@unique
 	class Type(Enum):
@@ -308,6 +313,21 @@ def __init__(self, name: str, fdt: Fdt2, node: int) -> None:
 		self.lp11_init = fdt.getprop_or_none(node, 'qcom,mdss-dsi-lp11-init') is not None
 		self.init_delay = fdt.getprop_uint32(node, 'qcom,mdss-dsi-init-delay-us')
 
+		# Display Stream Compression
+		compression_mode = fdt.getprop_or_none(mode_node, 'qcom,compression-mode')
+		self.compression_mode = CompressionMode(compression_mode.as_str()) if compression_mode else None
+
+		if self.compression_mode == CompressionMode.DSC:
+			self.dsc_slice_height = fdt.getprop(mode_node, 'qcom,mdss-dsc-slice-height').as_uint32()
+			self.dsc_slice_width = fdt.getprop(mode_node, 'qcom,mdss-dsc-slice-width').as_uint32()
+			self.dsc_slice_per_pkt = fdt.getprop(mode_node, 'qcom,mdss-dsc-slice-per-pkt').as_uint32()
+			self.dsc_bit_per_component = fdt.getprop(mode_node, 'qcom,mdss-dsc-bit-per-component').as_uint32()
+			self.dsc_bit_per_pixel = fdt.getprop(mode_node, 'qcom,mdss-dsc-bit-per-pixel').as_uint32()
+			self.dsc_block_prediction = fdt.getprop_or_none(mode_node, 'qcom,mdss-dsc-block-prediction-enable') is not None
+
+			self.dsc_version = fdt.getprop_uint32(mode_node, 'qcom,mdss-dsc-version', default=0x11)
+			self.dsc_scr_version = fdt.getprop_uint32(mode_node, 'qcom,mdss-dsc-scr-version', default=0)
+
 	@staticmethod
 	def parse(fdt: Fdt2, node: int) -> Panel:
 		name = fdt.getprop_or_none(node, 'qcom,mdss-dsi-panel-name')