komeda_pipeline.h 16.9 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92
/* SPDX-License-Identifier: GPL-2.0 */
/*
 * (C) COPYRIGHT 2018 ARM Limited. All rights reserved.
 * Author: James.Qian.Wang <james.qian.wang@arm.com>
 *
 */
#ifndef _KOMEDA_PIPELINE_H_
#define _KOMEDA_PIPELINE_H_

#include <linux/types.h>
#include <drm/drm_atomic.h>
#include <drm/drm_atomic_helper.h>
#include "malidp_utils.h"

#define KOMEDA_MAX_PIPELINES		2
#define KOMEDA_PIPELINE_MAX_LAYERS	4
#define KOMEDA_PIPELINE_MAX_SCALERS	2
#define KOMEDA_COMPONENT_N_INPUTS	5

/* pipeline component IDs */
enum {
	KOMEDA_COMPONENT_LAYER0		= 0,
	KOMEDA_COMPONENT_LAYER1		= 1,
	KOMEDA_COMPONENT_LAYER2		= 2,
	KOMEDA_COMPONENT_LAYER3		= 3,
	KOMEDA_COMPONENT_WB_LAYER	= 7, /* write back layer */
	KOMEDA_COMPONENT_SCALER0	= 8,
	KOMEDA_COMPONENT_SCALER1	= 9,
	KOMEDA_COMPONENT_SPLITTER	= 12,
	KOMEDA_COMPONENT_MERGER		= 14,
	KOMEDA_COMPONENT_COMPIZ0	= 16, /* compositor */
	KOMEDA_COMPONENT_COMPIZ1	= 17,
	KOMEDA_COMPONENT_IPS0		= 20, /* post image processor */
	KOMEDA_COMPONENT_IPS1		= 21,
	KOMEDA_COMPONENT_TIMING_CTRLR	= 22, /* timing controller */
};

#define KOMEDA_PIPELINE_LAYERS		(BIT(KOMEDA_COMPONENT_LAYER0) |\
					 BIT(KOMEDA_COMPONENT_LAYER1) |\
					 BIT(KOMEDA_COMPONENT_LAYER2) |\
					 BIT(KOMEDA_COMPONENT_LAYER3))

#define KOMEDA_PIPELINE_SCALERS		(BIT(KOMEDA_COMPONENT_SCALER0) |\
					 BIT(KOMEDA_COMPONENT_SCALER1))

#define KOMEDA_PIPELINE_COMPIZS		(BIT(KOMEDA_COMPONENT_COMPIZ0) |\
					 BIT(KOMEDA_COMPONENT_COMPIZ1))

#define KOMEDA_PIPELINE_IMPROCS		(BIT(KOMEDA_COMPONENT_IPS0) |\
					 BIT(KOMEDA_COMPONENT_IPS1))
struct komeda_component;
struct komeda_component_state;

/** komeda_component_funcs - component control functions */
struct komeda_component_funcs {
	/** @validate: optional,
	 * component may has special requirements or limitations, this function
	 * supply HW the ability to do the further HW specific check.
	 */
	int (*validate)(struct komeda_component *c,
			struct komeda_component_state *state);
	/** @update: update is a active update */
	void (*update)(struct komeda_component *c,
		       struct komeda_component_state *state);
	/** @disable: disable component */
	void (*disable)(struct komeda_component *c);
	/** @dump_register: Optional, dump registers to seq_file */
	void (*dump_register)(struct komeda_component *c, struct seq_file *seq);
};

/**
 * struct komeda_component
 *
 * struct komeda_component describe the data flow capabilities for how to link a
 * component into the display pipeline.
 * all specified components are subclass of this structure.
 */
struct komeda_component {
	/** @obj: treat component as private obj */
	struct drm_private_obj obj;
	/** @pipeline: the komeda pipeline this component belongs to */
	struct komeda_pipeline *pipeline;
	/** @name: component name */
	char name[32];
	/**
	 * @reg:
	 * component register base,
	 * which is initialized by chip and used by chip only
	 */
	u32 __iomem *reg;
	/** @id: component id */
	u32 id;
93 94 95
	/**
	 * @hw_id: component hw id,
	 * which is initialized by chip and used by chip only
96 97 98 99 100
	 */
	u32 hw_id;

	/**
	 * @max_active_inputs:
101
	 * @max_active_outputs:
102
	 *
103
	 * maximum number of inputs/outputs that can be active at the same time
104 105 106 107 108 109
	 * Note:
	 * the number isn't the bit number of @supported_inputs or
	 * @supported_outputs, but may be less than it, since component may not
	 * support enabling all @supported_inputs/outputs at the same time.
	 */
	u8 max_active_inputs;
110
	/** @max_active_outputs: maximum number of outputs */
111 112 113 114 115
	u8 max_active_outputs;
	/**
	 * @supported_inputs:
	 * @supported_outputs:
	 *
116
	 * bitmask of BIT(component->id) for the supported inputs/outputs,
117 118 119 120
	 * describes the possibilities of how a component is linked into a
	 * pipeline.
	 */
	u32 supported_inputs;
121
	/** @supported_outputs: bitmask of supported output componenet ids */
122 123 124 125 126
	u32 supported_outputs;

	/**
	 * @funcs: chip functions to access HW
	 */
127
	const struct komeda_component_funcs *funcs;
128 129 130 131 132 133 134 135 136 137 138 139
};

/**
 * struct komeda_component_output
 *
 * a component has multiple outputs, if want to know where the data
 * comes from, only know the component is not enough, we still need to know
 * its output port
 */
struct komeda_component_output {
	/** @component: indicate which component the data comes from */
	struct komeda_component *component;
140 141
	/**
	 * @output_port:
142 143 144 145 146 147 148 149 150 151 152 153 154 155 156
	 * the output port of the &komeda_component_output.component
	 */
	u8 output_port;
};

/**
 * struct komeda_component_state
 *
 * component_state is the data flow configuration of the component, and it's
 * the superclass of all specific component_state like @komeda_layer_state,
 * @komeda_scaler_state
 */
struct komeda_component_state {
	/** @obj: tracking component_state by drm_atomic_state */
	struct drm_private_state obj;
157
	/** @component: backpointer to the component */
158 159 160
	struct komeda_component *component;
	/**
	 * @binding_user:
161 162
	 * currently bound user, the user can be @crtc, @plane or @wb_conn,
	 * which is valid decided by @component and @inputs
163 164 165 166 167 168 169
	 *
	 * -  Layer: its user always is plane.
	 * -  compiz/improc/timing_ctrlr: the user is crtc.
	 * -  wb_layer: wb_conn;
	 * -  scaler: plane when input is layer, wb_conn if input is compiz.
	 */
	union {
170
		/** @crtc: backpointer for user crtc */
171
		struct drm_crtc *crtc;
172
		/** @plane: backpointer for user plane */
173
		struct drm_plane *plane;
174
		/** @wb_conn: backpointer for user wb_connector  */
175 176 177
		struct drm_connector *wb_conn;
		void *binding_user;
	};
178

179 180 181 182 183
	/**
	 * @active_inputs:
	 *
	 * active_inputs is bitmask of @inputs index
	 *
184 185
	 * -  active_inputs = changed_active_inputs | unchanged_active_inputs
	 * -  affected_inputs = old->active_inputs | new->active_inputs;
186
	 * -  disabling_inputs = affected_inputs ^ active_inputs;
187
	 * -  changed_inputs = disabling_inputs | changed_active_inputs;
188 189 190 191 192 193 194
	 *
	 * NOTE:
	 * changed_inputs doesn't include all active_input but only
	 * @changed_active_inputs, and this bitmask can be used in chip
	 * level for dirty update.
	 */
	u16 active_inputs;
195
	/** @changed_active_inputs: bitmask of the changed @active_inputs */
196
	u16 changed_active_inputs;
197
	/** @affected_inputs: bitmask for affected @inputs */
198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
	u16 affected_inputs;
	/**
	 * @inputs:
	 *
	 * the specific inputs[i] only valid on BIT(i) has been set in
	 * @active_inputs, if not the inputs[i] is undefined.
	 */
	struct komeda_component_output inputs[KOMEDA_COMPONENT_N_INPUTS];
};

static inline u16 component_disabling_inputs(struct komeda_component_state *st)
{
	return st->affected_inputs ^ st->active_inputs;
}

static inline u16 component_changed_inputs(struct komeda_component_state *st)
{
	return component_disabling_inputs(st) | st->changed_active_inputs;
}

218 219 220 221
#define for_each_changed_input(st, i)	\
	for ((i) = 0; (i) < (st)->component->max_active_inputs; (i)++)	\
		if (has_bit((i), component_changed_inputs(st)))

222 223 224 225 226
#define to_comp(__c)	(((__c) == NULL) ? NULL : &((__c)->base))
#define to_cpos(__c)	((struct komeda_component **)&(__c))

struct komeda_layer {
	struct komeda_component base;
227 228 229 230
	/* accepted h/v input range before rotation */
	struct malidp_range hsize_in, vsize_in;
	u32 layer_type; /* RICH, SIMPLE or WB */
	u32 supported_rots;
231 232 233 234 235 236
	/* komeda supports layer split which splits a whole image to two parts
	 * left and right and handle them by two individual layer processors
	 * Note: left/right are always according to the final display rect,
	 * not the source buffer.
	 */
	struct komeda_layer *right;
237 238 239 240 241
};

struct komeda_layer_state {
	struct komeda_component_state base;
	/* layer specific configuration state */
242 243
	u16 hsize, vsize;
	u32 rot;
244 245 246 247
	u16 afbc_crop_l;
	u16 afbc_crop_r;
	u16 afbc_crop_t;
	u16 afbc_crop_b;
248
	dma_addr_t addr[3];
249 250
};

251
struct komeda_scaler {
252
	struct komeda_component base;
253 254 255
	struct malidp_range hsize, vsize;
	u32 max_upscaling;
	u32 max_downscaling;
256 257
	u8 scaling_split_overlap; /* split overlap for scaling */
	u8 enh_split_overlap; /* split overlap for image enhancement */
258 259
};

260
struct komeda_scaler_state {
261
	struct komeda_component_state base;
262 263
	u16 hsize_in, vsize_in;
	u16 hsize_out, vsize_out;
264 265 266
	u16 total_hsize_in, total_vsize_in;
	u16 total_hsize_out; /* total_xxxx are size before split */
	u16 left_crop, right_crop;
267
	u8 en_scaling : 1,
268
	   en_alpha : 1, /* enable alpha processing */
269 270 271
	   en_img_enhancement : 1,
	   en_split : 1,
	   right_part : 1; /* right part of split image */
272 273
};

274
struct komeda_compiz {
275
	struct komeda_component base;
276
	struct malidp_range hsize, vsize;
277 278
};

279 280 281 282 283 284 285
struct komeda_compiz_input_cfg {
	u16 hsize, vsize;
	u16 hoffset, voffset;
	u8 pixel_blend_mode, layer_alpha;
};

struct komeda_compiz_state {
286
	struct komeda_component_state base;
287 288 289
	/* composition size */
	u16 hsize, vsize;
	struct komeda_compiz_input_cfg cins[KOMEDA_COMPONENT_N_INPUTS];
290 291
};

292 293 294 295 296 297 298 299 300 301 302 303
struct komeda_merger {
	struct komeda_component base;
	struct malidp_range hsize_merged;
	struct malidp_range vsize_merged;
};

struct komeda_merger_state {
	struct komeda_component_state base;
	u16 hsize_merged;
	u16 vsize_merged;
};

304 305 306 307 308 309 310 311 312 313 314
struct komeda_splitter {
	struct komeda_component base;
	struct malidp_range hsize, vsize;
};

struct komeda_splitter_state {
	struct komeda_component_state base;
	u16 hsize, vsize;
	u16 overlap;
};

315 316
struct komeda_improc {
	struct komeda_component base;
317 318 319 320 321
	u32 supported_color_formats;  /* DRM_RGB/YUV444/YUV420*/
	u32 supported_color_depths; /* BIT(8) | BIT(10)*/
	u8 supports_degamma : 1;
	u8 supports_csc : 1;
	u8 supports_gamma : 1;
322 323 324 325
};

struct komeda_improc_state {
	struct komeda_component_state base;
326
	u16 hsize, vsize;
327 328 329 330 331
};

/* display timing controller */
struct komeda_timing_ctrlr {
	struct komeda_component base;
332
	u8 supports_dual_link : 1;
333 334 335 336 337 338
};

struct komeda_timing_ctrlr_state {
	struct komeda_component_state base;
};

339 340 341 342 343 344 345 346 347 348 349
/* Why define A separated structure but not use plane_state directly ?
 * 1. Komeda supports layer_split which means a plane_state can be split and
 *    handled by two layers, one layer only handle half of plane image.
 * 2. Fix up the user properties according to HW's capabilities, like user
 *    set rotation to R180, but HW only supports REFLECT_X+Y. the rot here is
 *    after drm_rotation_simplify()
 */
struct komeda_data_flow_cfg {
	struct komeda_component_output input;
	u16 in_x, in_y, in_w, in_h;
	u32 out_x, out_y, out_w, out_h;
350 351 352
	u16 total_in_h, total_in_w;
	u16 total_out_w;
	u16 left_crop, right_crop, overlap;
353 354 355
	u32 rot;
	int blending_zorder;
	u8 pixel_blend_mode, layer_alpha;
356
	u8 en_scaling : 1,
357 358
	   en_img_enhancement : 1,
	   en_split : 1,
359
	   is_yuv : 1,
360
	   right_part : 1; /* right part of display image if split enabled */
361 362
};

363
struct komeda_pipeline_funcs {
364
	/* check if the aclk (main engine clock) can satisfy the clock
365 366 367 368
	 * requirements of the downscaling that specified by dflow
	 */
	int (*downscaling_clk_check)(struct komeda_pipeline *pipe,
				     struct drm_display_mode *mode,
369
				     unsigned long aclk_rate,
370
				     struct komeda_data_flow_cfg *dflow);
371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391
	/* dump_register: Optional, dump registers to seq_file */
	void (*dump_register)(struct komeda_pipeline *pipe,
			      struct seq_file *sf);
};

/**
 * struct komeda_pipeline
 *
 * Represent a complete display pipeline and hold all functional components.
 */
struct komeda_pipeline {
	/** @obj: link pipeline as private obj of drm_atomic_state */
	struct drm_private_obj obj;
	/** @mdev: the parent komeda_dev */
	struct komeda_dev *mdev;
	/** @pxlclk: pixel clock */
	struct clk *pxlclk;
	/** @id: pipeline id */
	int id;
	/** @avail_comps: available components mask of pipeline */
	u32 avail_comps;
392
	/** @n_layers: the number of layer on @layers */
393
	int n_layers;
394
	/** @layers: the pipeline layers */
395
	struct komeda_layer *layers[KOMEDA_PIPELINE_MAX_LAYERS];
396
	/** @n_scalers: the number of scaler on @scalers */
397
	int n_scalers;
398
	/** @scalers: the pipeline scalers */
399
	struct komeda_scaler *scalers[KOMEDA_PIPELINE_MAX_SCALERS];
400
	/** @compiz: compositor */
401
	struct komeda_compiz *compiz;
402 403
	/** @splitter: for split the compiz output to two half data flows */
	struct komeda_splitter *splitter;
404 405
	/** @merger: merger */
	struct komeda_merger *merger;
406
	/** @wb_layer: writeback layer */
407
	struct komeda_layer  *wb_layer;
408
	/** @improc: post image processor */
409
	struct komeda_improc *improc;
410
	/** @ctrlr: timing controller */
411
	struct komeda_timing_ctrlr *ctrlr;
412 413
	/** @funcs: chip private pipeline functions */
	const struct komeda_pipeline_funcs *funcs;
414 415 416 417 418 419 420

	/** @of_node: pipeline dt node */
	struct device_node *of_node;
	/** @of_output_port: pipeline output port */
	struct device_node *of_output_port;
	/** @of_output_dev: output connector device node */
	struct device_node *of_output_dev;
421 422 423 424 425 426 427 428 429 430 431 432
};

/**
 * struct komeda_pipeline_state
 *
 * NOTE:
 * Unlike the pipeline, pipeline_state doesn’t gather any component_state
 * into it. It because all component will be managed by drm_atomic_state.
 */
struct komeda_pipeline_state {
	/** @obj: tracking pipeline_state by drm_atomic_state */
	struct drm_private_state obj;
433
	/** @pipe: backpointer to the pipeline */
434 435 436 437 438 439 440 441 442 443 444 445 446 447
	struct komeda_pipeline *pipe;
	/** @crtc: currently bound crtc */
	struct drm_crtc *crtc;
	/**
	 * @active_comps:
	 *
	 * bitmask - BIT(component->id) of active components
	 */
	u32 active_comps;
};

#define to_layer(c)	container_of(c, struct komeda_layer, base)
#define to_compiz(c)	container_of(c, struct komeda_compiz, base)
#define to_scaler(c)	container_of(c, struct komeda_scaler, base)
448
#define to_splitter(c)	container_of(c, struct komeda_splitter, base)
449
#define to_merger(c)	container_of(c, struct komeda_merger, base)
450 451 452 453 454
#define to_improc(c)	container_of(c, struct komeda_improc, base)
#define to_ctrlr(c)	container_of(c, struct komeda_timing_ctrlr, base)

#define to_layer_st(c)	container_of(c, struct komeda_layer_state, base)
#define to_compiz_st(c)	container_of(c, struct komeda_compiz_state, base)
455 456 457
#define to_scaler_st(c)	container_of(c, struct komeda_scaler_state, base)
#define to_splitter_st(c) container_of(c, struct komeda_splitter_state, base)
#define to_merger_st(c)	container_of(c, struct komeda_merger_state, base)
458 459 460
#define to_improc_st(c)	container_of(c, struct komeda_improc_state, base)
#define to_ctrlr_st(c)	container_of(c, struct komeda_timing_ctrlr_state, base)

461
#define priv_to_comp_st(o) container_of(o, struct komeda_component_state, obj)
462
#define priv_to_pipe_st(o) container_of(o, struct komeda_pipeline_state, obj)
463

464 465 466
/* pipeline APIs */
struct komeda_pipeline *
komeda_pipeline_add(struct komeda_dev *mdev, size_t size,
467
		    const struct komeda_pipeline_funcs *funcs);
468 469
void komeda_pipeline_destroy(struct komeda_dev *mdev,
			     struct komeda_pipeline *pipe);
470 471
struct komeda_pipeline *
komeda_pipeline_get_slave(struct komeda_pipeline *master);
472
int komeda_assemble_pipelines(struct komeda_dev *mdev);
473 474
struct komeda_component *
komeda_pipeline_get_component(struct komeda_pipeline *pipe, int id);
475 476 477
struct komeda_component *
komeda_pipeline_get_first_component(struct komeda_pipeline *pipe,
				    u32 comp_mask);
478

479 480 481
void komeda_pipeline_dump_register(struct komeda_pipeline *pipe,
				   struct seq_file *sf);

482
/* component APIs */
483
extern __printf(10, 11)
484 485 486
struct komeda_component *
komeda_component_add(struct komeda_pipeline *pipe,
		     size_t comp_sz, u32 id, u32 hw_id,
487
		     const struct komeda_component_funcs *funcs,
488 489 490 491 492 493 494
		     u8 max_active_inputs, u32 supported_inputs,
		     u8 max_active_outputs, u32 __iomem *reg,
		     const char *name_fmt, ...);

void komeda_component_destroy(struct komeda_dev *mdev,
			      struct komeda_component *c);

495 496 497 498 499 500 501 502
static inline struct komeda_component *
komeda_component_pickup_output(struct komeda_component *c, u32 avail_comps)
{
	u32 avail_inputs = c->supported_outputs & (avail_comps);

	return komeda_pipeline_get_first_component(c->pipeline, avail_inputs);
}

503 504
struct komeda_plane_state;
struct komeda_crtc_state;
505
struct komeda_crtc;
506

507 508 509
void pipeline_composition_size(struct komeda_crtc_state *kcrtc_st,
			       u16 *hsize, u16 *vsize);

510 511 512 513
int komeda_build_layer_data_flow(struct komeda_layer *layer,
				 struct komeda_plane_state *kplane_st,
				 struct komeda_crtc_state *kcrtc_st,
				 struct komeda_data_flow_cfg *dflow);
514 515 516 517
int komeda_build_wb_data_flow(struct komeda_layer *wb_layer,
			      struct drm_connector_state *conn_st,
			      struct komeda_crtc_state *kcrtc_st,
			      struct komeda_data_flow_cfg *dflow);
518 519
int komeda_build_display_data_flow(struct komeda_crtc *kcrtc,
				   struct komeda_crtc_state *kcrtc_st);
520

521 522 523 524
int komeda_build_layer_split_data_flow(struct komeda_layer *left,
				       struct komeda_plane_state *kplane_st,
				       struct komeda_crtc_state *kcrtc_st,
				       struct komeda_data_flow_cfg *dflow);
525 526 527 528
int komeda_build_wb_split_data_flow(struct komeda_layer *wb_layer,
				    struct drm_connector_state *conn_st,
				    struct komeda_crtc_state *kcrtc_st,
				    struct komeda_data_flow_cfg *dflow);
529

530 531 532
int komeda_release_unclaimed_resources(struct komeda_pipeline *pipe,
				       struct komeda_crtc_state *kcrtc_st);

533 534 535
struct komeda_pipeline_state *
komeda_pipeline_get_old_state(struct komeda_pipeline *pipe,
			      struct drm_atomic_state *state);
536 537 538 539 540
void komeda_pipeline_disable(struct komeda_pipeline *pipe,
			     struct drm_atomic_state *old_state);
void komeda_pipeline_update(struct komeda_pipeline *pipe,
			    struct drm_atomic_state *old_state);

541 542
void komeda_complete_data_flow_cfg(struct komeda_layer *layer,
				   struct komeda_data_flow_cfg *dflow,
543
				   struct drm_framebuffer *fb);
544

545
#endif /* _KOMEDA_PIPELINE_H_*/