1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * (C) COPYRIGHT 2018 ARM Limited. All rights reserved.
4  * Author: James.Qian.Wang <james.qian.wang@arm.com>
5  *
6  */
7 
8 #include <drm/drm_print.h>
9 #include <linux/clk.h>
10 #include "komeda_dev.h"
11 #include "komeda_kms.h"
12 #include "komeda_pipeline.h"
13 #include "komeda_framebuffer.h"
14 
15 static inline bool is_switching_user(void *old, void *new)
16 {
17 	if (!old || !new)
18 		return false;
19 
20 	return old != new;
21 }
22 
23 static struct komeda_pipeline_state *
24 komeda_pipeline_get_state(struct komeda_pipeline *pipe,
25 			  struct drm_atomic_state *state)
26 {
27 	struct drm_private_state *priv_st;
28 
29 	priv_st = drm_atomic_get_private_obj_state(state, &pipe->obj);
30 	if (IS_ERR(priv_st))
31 		return ERR_CAST(priv_st);
32 
33 	return priv_to_pipe_st(priv_st);
34 }
35 
36 struct komeda_pipeline_state *
37 komeda_pipeline_get_old_state(struct komeda_pipeline *pipe,
38 			      struct drm_atomic_state *state)
39 {
40 	struct drm_private_state *priv_st;
41 
42 	priv_st = drm_atomic_get_old_private_obj_state(state, &pipe->obj);
43 	if (priv_st)
44 		return priv_to_pipe_st(priv_st);
45 	return NULL;
46 }
47 
48 static struct komeda_pipeline_state *
49 komeda_pipeline_get_new_state(struct komeda_pipeline *pipe,
50 			      struct drm_atomic_state *state)
51 {
52 	struct drm_private_state *priv_st;
53 
54 	priv_st = drm_atomic_get_new_private_obj_state(state, &pipe->obj);
55 	if (priv_st)
56 		return priv_to_pipe_st(priv_st);
57 	return NULL;
58 }
59 
60 /* Assign pipeline for crtc */
61 static struct komeda_pipeline_state *
62 komeda_pipeline_get_state_and_set_crtc(struct komeda_pipeline *pipe,
63 				       struct drm_atomic_state *state,
64 				       struct drm_crtc *crtc)
65 {
66 	struct komeda_pipeline_state *st;
67 
68 	st = komeda_pipeline_get_state(pipe, state);
69 	if (IS_ERR(st))
70 		return st;
71 
72 	if (is_switching_user(crtc, st->crtc)) {
73 		DRM_DEBUG_ATOMIC("CRTC%d required pipeline%d is busy.\n",
74 				 drm_crtc_index(crtc), pipe->id);
75 		return ERR_PTR(-EBUSY);
76 	}
77 
78 	/* pipeline only can be disabled when the it is free or unused */
79 	if (!crtc && st->active_comps) {
80 		DRM_DEBUG_ATOMIC("Disabling a busy pipeline:%d.\n", pipe->id);
81 		return ERR_PTR(-EBUSY);
82 	}
83 
84 	st->crtc = crtc;
85 
86 	if (crtc) {
87 		struct komeda_crtc_state *kcrtc_st;
88 
89 		kcrtc_st = to_kcrtc_st(drm_atomic_get_new_crtc_state(state,
90 								     crtc));
91 
92 		kcrtc_st->active_pipes |= BIT(pipe->id);
93 		kcrtc_st->affected_pipes |= BIT(pipe->id);
94 	}
95 	return st;
96 }
97 
98 static struct komeda_component_state *
99 komeda_component_get_state(struct komeda_component *c,
100 			   struct drm_atomic_state *state)
101 {
102 	struct drm_private_state *priv_st;
103 
104 	WARN_ON(!drm_modeset_is_locked(&c->pipeline->obj.lock));
105 
106 	priv_st = drm_atomic_get_private_obj_state(state, &c->obj);
107 	if (IS_ERR(priv_st))
108 		return ERR_CAST(priv_st);
109 
110 	return priv_to_comp_st(priv_st);
111 }
112 
113 static struct komeda_component_state *
114 komeda_component_get_old_state(struct komeda_component *c,
115 			       struct drm_atomic_state *state)
116 {
117 	struct drm_private_state *priv_st;
118 
119 	priv_st = drm_atomic_get_old_private_obj_state(state, &c->obj);
120 	if (priv_st)
121 		return priv_to_comp_st(priv_st);
122 	return NULL;
123 }
124 
125 /**
126  * komeda_component_get_state_and_set_user()
127  *
128  * @c: component to get state and set user
129  * @state: global atomic state
130  * @user: direct user, the binding user
131  * @crtc: the CRTC user, the big boss :)
132  *
133  * This function accepts two users:
134  * -   The direct user: can be plane/crtc/wb_connector depends on component
135  * -   The big boss (CRTC)
136  * CRTC is the big boss (the final user), because all component resources
137  * eventually will be assigned to CRTC, like the layer will be binding to
138  * kms_plane, but kms plane will be binding to a CRTC eventually.
139  *
140  * The big boss (CRTC) is for pipeline assignment, since &komeda_component isn't
141  * independent and can be assigned to CRTC freely, but belongs to a specific
142  * pipeline, only pipeline can be shared between crtc, and pipeline as a whole
143  * (include all the internal components) assigned to a specific CRTC.
144  *
145  * So when set a user to komeda_component, need first to check the status of
146  * component->pipeline to see if the pipeline is available on this specific
147  * CRTC. if the pipeline is busy (assigned to another CRTC), even the required
148  * component is free, the component still cannot be assigned to the direct user.
149  */
150 static struct komeda_component_state *
151 komeda_component_get_state_and_set_user(struct komeda_component *c,
152 					struct drm_atomic_state *state,
153 					void *user,
154 					struct drm_crtc *crtc)
155 {
156 	struct komeda_pipeline_state *pipe_st;
157 	struct komeda_component_state *st;
158 
159 	/* First check if the pipeline is available */
160 	pipe_st = komeda_pipeline_get_state_and_set_crtc(c->pipeline,
161 							 state, crtc);
162 	if (IS_ERR(pipe_st))
163 		return ERR_CAST(pipe_st);
164 
165 	st = komeda_component_get_state(c, state);
166 	if (IS_ERR(st))
167 		return st;
168 
169 	/* check if the component has been occupied */
170 	if (is_switching_user(user, st->binding_user)) {
171 		DRM_DEBUG_ATOMIC("required %s is busy.\n", c->name);
172 		return ERR_PTR(-EBUSY);
173 	}
174 
175 	st->binding_user = user;
176 	/* mark the component as active if user is valid */
177 	if (st->binding_user)
178 		pipe_st->active_comps |= BIT(c->id);
179 
180 	return st;
181 }
182 
183 static void
184 komeda_component_add_input(struct komeda_component_state *state,
185 			   struct komeda_component_output *input,
186 			   int idx)
187 {
188 	struct komeda_component *c = state->component;
189 
190 	WARN_ON((idx < 0 || idx >= c->max_active_inputs));
191 
192 	/* since the inputs[i] is only valid when it is active. So if a input[i]
193 	 * is a newly enabled input which switches from disable to enable, then
194 	 * the old inputs[i] is undefined (NOT zeroed), we can not rely on
195 	 * memcmp, but directly mark it changed
196 	 */
197 	if (!has_bit(idx, state->affected_inputs) ||
198 	    memcmp(&state->inputs[idx], input, sizeof(*input))) {
199 		memcpy(&state->inputs[idx], input, sizeof(*input));
200 		state->changed_active_inputs |= BIT(idx);
201 	}
202 	state->active_inputs |= BIT(idx);
203 	state->affected_inputs |= BIT(idx);
204 }
205 
206 static int
207 komeda_component_check_input(struct komeda_component_state *state,
208 			     struct komeda_component_output *input,
209 			     int idx)
210 {
211 	struct komeda_component *c = state->component;
212 
213 	if ((idx < 0) || (idx >= c->max_active_inputs)) {
214 		DRM_DEBUG_ATOMIC("%s required an invalid %s-input[%d].\n",
215 				 input->component->name, c->name, idx);
216 		return -EINVAL;
217 	}
218 
219 	if (has_bit(idx, state->active_inputs)) {
220 		DRM_DEBUG_ATOMIC("%s required %s-input[%d] has been occupied already.\n",
221 				 input->component->name, c->name, idx);
222 		return -EINVAL;
223 	}
224 
225 	return 0;
226 }
227 
228 static void
229 komeda_component_set_output(struct komeda_component_output *output,
230 			    struct komeda_component *comp,
231 			    u8 output_port)
232 {
233 	output->component = comp;
234 	output->output_port = output_port;
235 }
236 
237 static int
238 komeda_component_validate_private(struct komeda_component *c,
239 				  struct komeda_component_state *st)
240 {
241 	int err;
242 
243 	if (!c->funcs->validate)
244 		return 0;
245 
246 	err = c->funcs->validate(c, st);
247 	if (err)
248 		DRM_DEBUG_ATOMIC("%s validate private failed.\n", c->name);
249 
250 	return err;
251 }
252 
253 /* Get current available scaler from the component->supported_outputs */
254 static struct komeda_scaler *
255 komeda_component_get_avail_scaler(struct komeda_component *c,
256 				  struct drm_atomic_state *state)
257 {
258 	struct komeda_pipeline_state *pipe_st;
259 	u32 avail_scalers;
260 
261 	pipe_st = komeda_pipeline_get_state(c->pipeline, state);
262 	if (!pipe_st)
263 		return NULL;
264 
265 	avail_scalers = (pipe_st->active_comps & KOMEDA_PIPELINE_SCALERS) ^
266 			KOMEDA_PIPELINE_SCALERS;
267 
268 	c = komeda_component_pickup_output(c, avail_scalers);
269 
270 	return to_scaler(c);
271 }
272 
273 static void
274 komeda_rotate_data_flow(struct komeda_data_flow_cfg *dflow, u32 rot)
275 {
276 	if (drm_rotation_90_or_270(rot)) {
277 		swap(dflow->in_h, dflow->in_w);
278 		swap(dflow->total_in_h, dflow->total_in_w);
279 	}
280 }
281 
282 static int
283 komeda_layer_check_cfg(struct komeda_layer *layer,
284 		       struct komeda_fb *kfb,
285 		       struct komeda_data_flow_cfg *dflow)
286 {
287 	u32 src_x, src_y, src_w, src_h;
288 	u32 line_sz, max_line_sz;
289 
290 	if (!komeda_fb_is_layer_supported(kfb, layer->layer_type, dflow->rot))
291 		return -EINVAL;
292 
293 	if (layer->base.id == KOMEDA_COMPONENT_WB_LAYER) {
294 		src_x = dflow->out_x;
295 		src_y = dflow->out_y;
296 		src_w = dflow->out_w;
297 		src_h = dflow->out_h;
298 	} else {
299 		src_x = dflow->in_x;
300 		src_y = dflow->in_y;
301 		src_w = dflow->in_w;
302 		src_h = dflow->in_h;
303 	}
304 
305 	if (komeda_fb_check_src_coords(kfb, src_x, src_y, src_w, src_h))
306 		return -EINVAL;
307 
308 	if (!in_range(&layer->hsize_in, src_w)) {
309 		DRM_DEBUG_ATOMIC("invalidate src_w %d.\n", src_w);
310 		return -EINVAL;
311 	}
312 
313 	if (!in_range(&layer->vsize_in, src_h)) {
314 		DRM_DEBUG_ATOMIC("invalidate src_h %d.\n", src_h);
315 		return -EINVAL;
316 	}
317 
318 	if (drm_rotation_90_or_270(dflow->rot))
319 		line_sz = dflow->in_h;
320 	else
321 		line_sz = dflow->in_w;
322 
323 	if (kfb->base.format->hsub > 1)
324 		max_line_sz = layer->yuv_line_sz;
325 	else
326 		max_line_sz = layer->line_sz;
327 
328 	if (line_sz > max_line_sz) {
329 		DRM_DEBUG_ATOMIC("Required line_sz: %d exceeds the max size %d\n",
330 				 line_sz, max_line_sz);
331 		return -EINVAL;
332 	}
333 
334 	return 0;
335 }
336 
337 static int
338 komeda_layer_validate(struct komeda_layer *layer,
339 		      struct komeda_plane_state *kplane_st,
340 		      struct komeda_data_flow_cfg *dflow)
341 {
342 	struct drm_plane_state *plane_st = &kplane_st->base;
343 	struct drm_framebuffer *fb = plane_st->fb;
344 	struct komeda_fb *kfb = to_kfb(fb);
345 	struct komeda_component_state *c_st;
346 	struct komeda_layer_state *st;
347 	int i, err;
348 
349 	err = komeda_layer_check_cfg(layer, kfb, dflow);
350 	if (err)
351 		return err;
352 
353 	c_st = komeda_component_get_state_and_set_user(&layer->base,
354 			plane_st->state, plane_st->plane, plane_st->crtc);
355 	if (IS_ERR(c_st))
356 		return PTR_ERR(c_st);
357 
358 	st = to_layer_st(c_st);
359 
360 	st->rot = dflow->rot;
361 
362 	if (fb->modifier) {
363 		st->hsize = kfb->aligned_w;
364 		st->vsize = kfb->aligned_h;
365 		st->afbc_crop_l = dflow->in_x;
366 		st->afbc_crop_r = kfb->aligned_w - dflow->in_x - dflow->in_w;
367 		st->afbc_crop_t = dflow->in_y;
368 		st->afbc_crop_b = kfb->aligned_h - dflow->in_y - dflow->in_h;
369 	} else {
370 		st->hsize = dflow->in_w;
371 		st->vsize = dflow->in_h;
372 		st->afbc_crop_l = 0;
373 		st->afbc_crop_r = 0;
374 		st->afbc_crop_t = 0;
375 		st->afbc_crop_b = 0;
376 	}
377 
378 	for (i = 0; i < fb->format->num_planes; i++)
379 		st->addr[i] = komeda_fb_get_pixel_addr(kfb, dflow->in_x,
380 						       dflow->in_y, i);
381 
382 	err = komeda_component_validate_private(&layer->base, c_st);
383 	if (err)
384 		return err;
385 
386 	/* update the data flow for the next stage */
387 	komeda_component_set_output(&dflow->input, &layer->base, 0);
388 
389 	/*
390 	 * The rotation has been handled by layer, so adjusted the data flow for
391 	 * the next stage.
392 	 */
393 	komeda_rotate_data_flow(dflow, st->rot);
394 
395 	return 0;
396 }
397 
398 static int
399 komeda_wb_layer_validate(struct komeda_layer *wb_layer,
400 			 struct drm_connector_state *conn_st,
401 			 struct komeda_data_flow_cfg *dflow)
402 {
403 	struct komeda_fb *kfb = to_kfb(conn_st->writeback_job->fb);
404 	struct komeda_component_state *c_st;
405 	struct komeda_layer_state *st;
406 	int i, err;
407 
408 	err = komeda_layer_check_cfg(wb_layer, kfb, dflow);
409 	if (err)
410 		return err;
411 
412 	c_st = komeda_component_get_state_and_set_user(&wb_layer->base,
413 			conn_st->state, conn_st->connector, conn_st->crtc);
414 	if (IS_ERR(c_st))
415 		return PTR_ERR(c_st);
416 
417 	st = to_layer_st(c_st);
418 
419 	st->hsize = dflow->out_w;
420 	st->vsize = dflow->out_h;
421 
422 	for (i = 0; i < kfb->base.format->num_planes; i++)
423 		st->addr[i] = komeda_fb_get_pixel_addr(kfb, dflow->out_x,
424 						       dflow->out_y, i);
425 
426 	komeda_component_add_input(&st->base, &dflow->input, 0);
427 	komeda_component_set_output(&dflow->input, &wb_layer->base, 0);
428 
429 	return 0;
430 }
431 
432 static bool scaling_ratio_valid(u32 size_in, u32 size_out,
433 				u32 max_upscaling, u32 max_downscaling)
434 {
435 	if (size_out > size_in * max_upscaling)
436 		return false;
437 	else if (size_in > size_out * max_downscaling)
438 		return false;
439 	return true;
440 }
441 
442 static int
443 komeda_scaler_check_cfg(struct komeda_scaler *scaler,
444 			struct komeda_crtc_state *kcrtc_st,
445 			struct komeda_data_flow_cfg *dflow)
446 {
447 	u32 hsize_in, vsize_in, hsize_out, vsize_out;
448 	u32 max_upscaling;
449 
450 	hsize_in = dflow->in_w;
451 	vsize_in = dflow->in_h;
452 	hsize_out = dflow->out_w;
453 	vsize_out = dflow->out_h;
454 
455 	if (!in_range(&scaler->hsize, hsize_in) ||
456 	    !in_range(&scaler->hsize, hsize_out)) {
457 		DRM_DEBUG_ATOMIC("Invalid horizontal sizes");
458 		return -EINVAL;
459 	}
460 
461 	if (!in_range(&scaler->vsize, vsize_in) ||
462 	    !in_range(&scaler->vsize, vsize_out)) {
463 		DRM_DEBUG_ATOMIC("Invalid vertical sizes");
464 		return -EINVAL;
465 	}
466 
467 	/* If input comes from compiz that means the scaling is for writeback
468 	 * and scaler can not do upscaling for writeback
469 	 */
470 	if (has_bit(dflow->input.component->id, KOMEDA_PIPELINE_COMPIZS))
471 		max_upscaling = 1;
472 	else
473 		max_upscaling = scaler->max_upscaling;
474 
475 	if (!scaling_ratio_valid(hsize_in, hsize_out, max_upscaling,
476 				 scaler->max_downscaling)) {
477 		DRM_DEBUG_ATOMIC("Invalid horizontal scaling ratio");
478 		return -EINVAL;
479 	}
480 
481 	if (!scaling_ratio_valid(vsize_in, vsize_out, max_upscaling,
482 				 scaler->max_downscaling)) {
483 		DRM_DEBUG_ATOMIC("Invalid vertical scaling ratio");
484 		return -EINVAL;
485 	}
486 
487 	if (hsize_in > hsize_out || vsize_in > vsize_out) {
488 		struct komeda_pipeline *pipe = scaler->base.pipeline;
489 		int err;
490 
491 		err = pipe->funcs->downscaling_clk_check(pipe,
492 					&kcrtc_st->base.adjusted_mode,
493 					komeda_crtc_get_aclk(kcrtc_st), dflow);
494 		if (err) {
495 			DRM_DEBUG_ATOMIC("aclk can't satisfy the clock requirement of the downscaling\n");
496 			return err;
497 		}
498 	}
499 
500 	return 0;
501 }
502 
503 static int
504 komeda_scaler_validate(void *user,
505 		       struct komeda_crtc_state *kcrtc_st,
506 		       struct komeda_data_flow_cfg *dflow)
507 {
508 	struct drm_atomic_state *drm_st = kcrtc_st->base.state;
509 	struct komeda_component_state *c_st;
510 	struct komeda_scaler_state *st;
511 	struct komeda_scaler *scaler;
512 	int err = 0;
513 
514 	if (!(dflow->en_scaling || dflow->en_img_enhancement))
515 		return 0;
516 
517 	scaler = komeda_component_get_avail_scaler(dflow->input.component,
518 						   drm_st);
519 	if (!scaler) {
520 		DRM_DEBUG_ATOMIC("No scaler available");
521 		return -EINVAL;
522 	}
523 
524 	err = komeda_scaler_check_cfg(scaler, kcrtc_st, dflow);
525 	if (err)
526 		return err;
527 
528 	c_st = komeda_component_get_state_and_set_user(&scaler->base,
529 			drm_st, user, kcrtc_st->base.crtc);
530 	if (IS_ERR(c_st))
531 		return PTR_ERR(c_st);
532 
533 	st = to_scaler_st(c_st);
534 
535 	st->hsize_in = dflow->in_w;
536 	st->vsize_in = dflow->in_h;
537 	st->hsize_out = dflow->out_w;
538 	st->vsize_out = dflow->out_h;
539 	st->right_crop = dflow->right_crop;
540 	st->left_crop = dflow->left_crop;
541 	st->total_vsize_in = dflow->total_in_h;
542 	st->total_hsize_in = dflow->total_in_w;
543 	st->total_hsize_out = dflow->total_out_w;
544 
545 	/* Enable alpha processing if the next stage needs the pixel alpha */
546 	st->en_alpha = dflow->pixel_blend_mode != DRM_MODE_BLEND_PIXEL_NONE;
547 	st->en_scaling = dflow->en_scaling;
548 	st->en_img_enhancement = dflow->en_img_enhancement;
549 	st->en_split = dflow->en_split;
550 	st->right_part = dflow->right_part;
551 
552 	komeda_component_add_input(&st->base, &dflow->input, 0);
553 	komeda_component_set_output(&dflow->input, &scaler->base, 0);
554 	return err;
555 }
556 
557 static void komeda_split_data_flow(struct komeda_scaler *scaler,
558 				   struct komeda_data_flow_cfg *dflow,
559 				   struct komeda_data_flow_cfg *l_dflow,
560 				   struct komeda_data_flow_cfg *r_dflow);
561 
562 static int
563 komeda_splitter_validate(struct komeda_splitter *splitter,
564 			 struct drm_connector_state *conn_st,
565 			 struct komeda_data_flow_cfg *dflow,
566 			 struct komeda_data_flow_cfg *l_output,
567 			 struct komeda_data_flow_cfg *r_output)
568 {
569 	struct komeda_component_state *c_st;
570 	struct komeda_splitter_state *st;
571 
572 	if (!splitter) {
573 		DRM_DEBUG_ATOMIC("Current HW doesn't support splitter.\n");
574 		return -EINVAL;
575 	}
576 
577 	if (!in_range(&splitter->hsize, dflow->in_w)) {
578 		DRM_DEBUG_ATOMIC("split in_w:%d is out of the acceptable range.\n",
579 				 dflow->in_w);
580 		return -EINVAL;
581 	}
582 
583 	if (!in_range(&splitter->vsize, dflow->in_h)) {
584 		DRM_DEBUG_ATOMIC("split in_h: %d exceeds the acceptable range.\n",
585 				 dflow->in_h);
586 		return -EINVAL;
587 	}
588 
589 	c_st = komeda_component_get_state_and_set_user(&splitter->base,
590 			conn_st->state, conn_st->connector, conn_st->crtc);
591 
592 	if (IS_ERR(c_st))
593 		return PTR_ERR(c_st);
594 
595 	komeda_split_data_flow(splitter->base.pipeline->scalers[0],
596 			       dflow, l_output, r_output);
597 
598 	st = to_splitter_st(c_st);
599 	st->hsize = dflow->in_w;
600 	st->vsize = dflow->in_h;
601 	st->overlap = dflow->overlap;
602 
603 	komeda_component_add_input(&st->base, &dflow->input, 0);
604 	komeda_component_set_output(&l_output->input, &splitter->base, 0);
605 	komeda_component_set_output(&r_output->input, &splitter->base, 1);
606 
607 	return 0;
608 }
609 
610 static int
611 komeda_merger_validate(struct komeda_merger *merger,
612 		       void *user,
613 		       struct komeda_crtc_state *kcrtc_st,
614 		       struct komeda_data_flow_cfg *left_input,
615 		       struct komeda_data_flow_cfg *right_input,
616 		       struct komeda_data_flow_cfg *output)
617 {
618 	struct komeda_component_state *c_st;
619 	struct komeda_merger_state *st;
620 	int err = 0;
621 
622 	if (!merger) {
623 		DRM_DEBUG_ATOMIC("No merger is available");
624 		return -EINVAL;
625 	}
626 
627 	if (!in_range(&merger->hsize_merged, output->out_w)) {
628 		DRM_DEBUG_ATOMIC("merged_w: %d is out of the accepted range.\n",
629 				 output->out_w);
630 		return -EINVAL;
631 	}
632 
633 	if (!in_range(&merger->vsize_merged, output->out_h)) {
634 		DRM_DEBUG_ATOMIC("merged_h: %d is out of the accepted range.\n",
635 				 output->out_h);
636 		return -EINVAL;
637 	}
638 
639 	c_st = komeda_component_get_state_and_set_user(&merger->base,
640 			kcrtc_st->base.state, kcrtc_st->base.crtc, kcrtc_st->base.crtc);
641 
642 	if (IS_ERR(c_st))
643 		return PTR_ERR(c_st);
644 
645 	st = to_merger_st(c_st);
646 	st->hsize_merged = output->out_w;
647 	st->vsize_merged = output->out_h;
648 
649 	komeda_component_add_input(c_st, &left_input->input, 0);
650 	komeda_component_add_input(c_st, &right_input->input, 1);
651 	komeda_component_set_output(&output->input, &merger->base, 0);
652 
653 	return err;
654 }
655 
656 void pipeline_composition_size(struct komeda_crtc_state *kcrtc_st,
657 			       u16 *hsize, u16 *vsize)
658 {
659 	struct drm_display_mode *m = &kcrtc_st->base.adjusted_mode;
660 
661 	if (hsize)
662 		*hsize = m->hdisplay;
663 	if (vsize)
664 		*vsize = m->vdisplay;
665 }
666 
667 static int
668 komeda_compiz_set_input(struct komeda_compiz *compiz,
669 			struct komeda_crtc_state *kcrtc_st,
670 			struct komeda_data_flow_cfg *dflow)
671 {
672 	struct drm_atomic_state *drm_st = kcrtc_st->base.state;
673 	struct komeda_component_state *c_st, *old_st;
674 	struct komeda_compiz_input_cfg *cin;
675 	u16 compiz_w, compiz_h;
676 	int idx = dflow->blending_zorder;
677 
678 	pipeline_composition_size(kcrtc_st, &compiz_w, &compiz_h);
679 	/* check display rect */
680 	if ((dflow->out_x + dflow->out_w > compiz_w) ||
681 	    (dflow->out_y + dflow->out_h > compiz_h) ||
682 	     dflow->out_w == 0 || dflow->out_h == 0) {
683 		DRM_DEBUG_ATOMIC("invalid disp rect [x=%d, y=%d, w=%d, h=%d]\n",
684 				 dflow->out_x, dflow->out_y,
685 				 dflow->out_w, dflow->out_h);
686 		return -EINVAL;
687 	}
688 
689 	c_st = komeda_component_get_state_and_set_user(&compiz->base, drm_st,
690 			kcrtc_st->base.crtc, kcrtc_st->base.crtc);
691 	if (IS_ERR(c_st))
692 		return PTR_ERR(c_st);
693 
694 	if (komeda_component_check_input(c_st, &dflow->input, idx))
695 		return -EINVAL;
696 
697 	cin = &(to_compiz_st(c_st)->cins[idx]);
698 
699 	cin->hsize   = dflow->out_w;
700 	cin->vsize   = dflow->out_h;
701 	cin->hoffset = dflow->out_x;
702 	cin->voffset = dflow->out_y;
703 	cin->pixel_blend_mode = dflow->pixel_blend_mode;
704 	cin->layer_alpha = dflow->layer_alpha;
705 
706 	old_st = komeda_component_get_old_state(&compiz->base, drm_st);
707 
708 	/* compare with old to check if this input has been changed */
709 	if (WARN_ON(!old_st) ||
710 	    memcmp(&(to_compiz_st(old_st)->cins[idx]), cin, sizeof(*cin)))
711 		c_st->changed_active_inputs |= BIT(idx);
712 
713 	komeda_component_add_input(c_st, &dflow->input, idx);
714 	komeda_component_set_output(&dflow->input, &compiz->base, 0);
715 
716 	return 0;
717 }
718 
719 static int
720 komeda_compiz_validate(struct komeda_compiz *compiz,
721 		       struct komeda_crtc_state *state,
722 		       struct komeda_data_flow_cfg *dflow)
723 {
724 	struct komeda_component_state *c_st;
725 	struct komeda_compiz_state *st;
726 
727 	c_st = komeda_component_get_state_and_set_user(&compiz->base,
728 			state->base.state, state->base.crtc, state->base.crtc);
729 	if (IS_ERR(c_st))
730 		return PTR_ERR(c_st);
731 
732 	st = to_compiz_st(c_st);
733 
734 	pipeline_composition_size(state, &st->hsize, &st->vsize);
735 
736 	komeda_component_set_output(&dflow->input, &compiz->base, 0);
737 
738 	/* compiz output dflow will be fed to the next pipeline stage, prepare
739 	 * the data flow configuration for the next stage
740 	 */
741 	if (dflow) {
742 		dflow->in_w = st->hsize;
743 		dflow->in_h = st->vsize;
744 		dflow->out_w = dflow->in_w;
745 		dflow->out_h = dflow->in_h;
746 		/* the output data of compiz doesn't have alpha, it only can be
747 		 * used as bottom layer when blend it with master layers
748 		 */
749 		dflow->pixel_blend_mode = DRM_MODE_BLEND_PIXEL_NONE;
750 		dflow->layer_alpha = 0xFF;
751 		dflow->blending_zorder = 0;
752 	}
753 
754 	return 0;
755 }
756 
757 static int
758 komeda_improc_validate(struct komeda_improc *improc,
759 		       struct komeda_crtc_state *kcrtc_st,
760 		       struct komeda_data_flow_cfg *dflow)
761 {
762 	struct drm_crtc *crtc = kcrtc_st->base.crtc;
763 	struct drm_crtc_state *crtc_st = &kcrtc_st->base;
764 	struct komeda_component_state *c_st;
765 	struct komeda_improc_state *st;
766 
767 	c_st = komeda_component_get_state_and_set_user(&improc->base,
768 			kcrtc_st->base.state, crtc, crtc);
769 	if (IS_ERR(c_st))
770 		return PTR_ERR(c_st);
771 
772 	st = to_improc_st(c_st);
773 
774 	st->hsize = dflow->in_w;
775 	st->vsize = dflow->in_h;
776 
777 	if (drm_atomic_crtc_needs_modeset(crtc_st)) {
778 		u32 output_depths, output_formats;
779 		u32 avail_depths, avail_formats;
780 
781 		komeda_crtc_get_color_config(crtc_st, &output_depths,
782 					     &output_formats);
783 
784 		avail_depths = output_depths & improc->supported_color_depths;
785 		if (avail_depths == 0) {
786 			DRM_DEBUG_ATOMIC("No available color depths, conn depths: 0x%x & display: 0x%x\n",
787 					 output_depths,
788 					 improc->supported_color_depths);
789 			return -EINVAL;
790 		}
791 
792 		avail_formats = output_formats &
793 				improc->supported_color_formats;
794 		if (!avail_formats) {
795 			DRM_DEBUG_ATOMIC("No available color_formats, conn formats 0x%x & display: 0x%x\n",
796 					 output_formats,
797 					 improc->supported_color_formats);
798 			return -EINVAL;
799 		}
800 
801 		st->color_depth = __fls(avail_depths);
802 		st->color_format = BIT(__ffs(avail_formats));
803 	}
804 
805 	if (kcrtc_st->base.color_mgmt_changed) {
806 		drm_lut_to_fgamma_coeffs(kcrtc_st->base.gamma_lut,
807 					 st->fgamma_coeffs);
808 		drm_ctm_to_coeffs(kcrtc_st->base.ctm, st->ctm_coeffs);
809 	}
810 
811 	komeda_component_add_input(&st->base, &dflow->input, 0);
812 	komeda_component_set_output(&dflow->input, &improc->base, 0);
813 
814 	return 0;
815 }
816 
817 static int
818 komeda_timing_ctrlr_validate(struct komeda_timing_ctrlr *ctrlr,
819 			     struct komeda_crtc_state *kcrtc_st,
820 			     struct komeda_data_flow_cfg *dflow)
821 {
822 	struct drm_crtc *crtc = kcrtc_st->base.crtc;
823 	struct komeda_timing_ctrlr_state *st;
824 	struct komeda_component_state *c_st;
825 
826 	c_st = komeda_component_get_state_and_set_user(&ctrlr->base,
827 			kcrtc_st->base.state, crtc, crtc);
828 	if (IS_ERR(c_st))
829 		return PTR_ERR(c_st);
830 
831 	st = to_ctrlr_st(c_st);
832 
833 	komeda_component_add_input(&st->base, &dflow->input, 0);
834 	komeda_component_set_output(&dflow->input, &ctrlr->base, 0);
835 
836 	return 0;
837 }
838 
839 void komeda_complete_data_flow_cfg(struct komeda_layer *layer,
840 				   struct komeda_data_flow_cfg *dflow,
841 				   struct drm_framebuffer *fb)
842 {
843 	struct komeda_scaler *scaler = layer->base.pipeline->scalers[0];
844 	u32 w = dflow->in_w;
845 	u32 h = dflow->in_h;
846 
847 	dflow->total_in_w = dflow->in_w;
848 	dflow->total_in_h = dflow->in_h;
849 	dflow->total_out_w = dflow->out_w;
850 
851 	/* if format doesn't have alpha, fix blend mode to PIXEL_NONE */
852 	if (!fb->format->has_alpha)
853 		dflow->pixel_blend_mode = DRM_MODE_BLEND_PIXEL_NONE;
854 
855 	if (drm_rotation_90_or_270(dflow->rot))
856 		swap(w, h);
857 
858 	dflow->en_scaling = (w != dflow->out_w) || (h != dflow->out_h);
859 	dflow->is_yuv = fb->format->is_yuv;
860 
861 	/* try to enable image enhancer if data flow is a 2x+ upscaling */
862 	dflow->en_img_enhancement = dflow->out_w >= 2 * w ||
863 				    dflow->out_h >= 2 * h;
864 
865 	/* try to enable split if scaling exceed the scaler's acceptable
866 	 * input/output range.
867 	 */
868 	if (dflow->en_scaling && scaler)
869 		dflow->en_split = !in_range(&scaler->hsize, dflow->in_w) ||
870 				  !in_range(&scaler->hsize, dflow->out_w);
871 }
872 
873 static bool merger_is_available(struct komeda_pipeline *pipe,
874 				struct komeda_data_flow_cfg *dflow)
875 {
876 	u32 avail_inputs = pipe->merger ?
877 			   pipe->merger->base.supported_inputs : 0;
878 
879 	return has_bit(dflow->input.component->id, avail_inputs);
880 }
881 
882 int komeda_build_layer_data_flow(struct komeda_layer *layer,
883 				 struct komeda_plane_state *kplane_st,
884 				 struct komeda_crtc_state *kcrtc_st,
885 				 struct komeda_data_flow_cfg *dflow)
886 {
887 	struct drm_plane *plane = kplane_st->base.plane;
888 	struct komeda_pipeline *pipe = layer->base.pipeline;
889 	int err;
890 
891 	DRM_DEBUG_ATOMIC("%s handling [PLANE:%d:%s]: src[x/y:%d/%d, w/h:%d/%d] disp[x/y:%d/%d, w/h:%d/%d]",
892 			 layer->base.name, plane->base.id, plane->name,
893 			 dflow->in_x, dflow->in_y, dflow->in_w, dflow->in_h,
894 			 dflow->out_x, dflow->out_y, dflow->out_w, dflow->out_h);
895 
896 	err = komeda_layer_validate(layer, kplane_st, dflow);
897 	if (err)
898 		return err;
899 
900 	err = komeda_scaler_validate(plane, kcrtc_st, dflow);
901 	if (err)
902 		return err;
903 
904 	/* if split, check if can put the data flow into merger */
905 	if (dflow->en_split && merger_is_available(pipe, dflow))
906 		return 0;
907 
908 	err = komeda_compiz_set_input(pipe->compiz, kcrtc_st, dflow);
909 
910 	return err;
911 }
912 
913 /*
914  * Split is introduced for workaround scaler's input/output size limitation.
915  * The idea is simple, if one scaler can not fit the requirement, use two.
916  * So split splits the big source image to two half parts (left/right) and do
917  * the scaling by two scaler separately and independently.
918  * But split also imports an edge problem in the middle of the image when
919  * scaling, to avoid it, split isn't a simple half-and-half, but add an extra
920  * pixels (overlap) to both side, after split the left/right will be:
921  * - left: [0, src_length/2 + overlap]
922  * - right: [src_length/2 - overlap, src_length]
923  * The extra overlap do eliminate the edge problem, but which may also generates
924  * unnecessary pixels when scaling, we need to crop them before scaler output
925  * the result to the next stage. and for the how to crop, it depends on the
926  * unneeded pixels, another words the position where overlay has been added.
927  * - left: crop the right
928  * - right: crop the left
929  *
930  * The diagram for how to do the split
931  *
932  *  <---------------------left->out_w ---------------->
933  * |--------------------------------|---right_crop-----| <- left after split
934  *  \                                \                /
935  *   \                                \<--overlap--->/
936  *   |-----------------|-------------|(Middle)------|-----------------| <- src
937  *                     /<---overlap--->\                               \
938  *                    /                 \                               \
939  * right after split->|-----left_crop---|--------------------------------|
940  *                    ^<------------------- right->out_w --------------->^
941  *
942  * NOTE: To consistent with HW the output_w always contains the crop size.
943  */
944 
945 static void komeda_split_data_flow(struct komeda_scaler *scaler,
946 				   struct komeda_data_flow_cfg *dflow,
947 				   struct komeda_data_flow_cfg *l_dflow,
948 				   struct komeda_data_flow_cfg *r_dflow)
949 {
950 	bool r90 = drm_rotation_90_or_270(dflow->rot);
951 	bool flip_h = has_flip_h(dflow->rot);
952 	u32 l_out, r_out, overlap;
953 
954 	memcpy(l_dflow, dflow, sizeof(*dflow));
955 	memcpy(r_dflow, dflow, sizeof(*dflow));
956 
957 	l_dflow->right_part = false;
958 	r_dflow->right_part = true;
959 	r_dflow->blending_zorder = dflow->blending_zorder + 1;
960 
961 	overlap = 0;
962 	if (dflow->en_scaling && scaler)
963 		overlap += scaler->scaling_split_overlap;
964 
965 	/* original dflow may fed into splitter, and which doesn't need
966 	 * enhancement overlap
967 	 */
968 	dflow->overlap = overlap;
969 
970 	if (dflow->en_img_enhancement && scaler)
971 		overlap += scaler->enh_split_overlap;
972 
973 	l_dflow->overlap = overlap;
974 	r_dflow->overlap = overlap;
975 
976 	/* split the origin content */
977 	/* left/right here always means the left/right part of display image,
978 	 * not the source Image
979 	 */
980 	/* DRM rotation is anti-clockwise */
981 	if (r90) {
982 		if (dflow->en_scaling) {
983 			l_dflow->in_h = ALIGN(dflow->in_h, 2) / 2 + l_dflow->overlap;
984 			r_dflow->in_h = l_dflow->in_h;
985 		} else if (dflow->en_img_enhancement) {
986 			/* enhancer only */
987 			l_dflow->in_h = ALIGN(dflow->in_h, 2) / 2 + l_dflow->overlap;
988 			r_dflow->in_h = dflow->in_h / 2 + r_dflow->overlap;
989 		} else {
990 			/* split without scaler, no overlap */
991 			l_dflow->in_h = ALIGN(((dflow->in_h + 1) >> 1), 2);
992 			r_dflow->in_h = dflow->in_h - l_dflow->in_h;
993 		}
994 
995 		/* Consider YUV format, after split, the split source w/h
996 		 * may not aligned to 2. we have two choices for such case.
997 		 * 1. scaler is enabled (overlap != 0), we can do a alignment
998 		 *    both left/right and crop the extra data by scaler.
999 		 * 2. scaler is not enabled, only align the split left
1000 		 *    src/disp, and the rest part assign to right
1001 		 */
1002 		if ((overlap != 0) && dflow->is_yuv) {
1003 			l_dflow->in_h = ALIGN(l_dflow->in_h, 2);
1004 			r_dflow->in_h = ALIGN(r_dflow->in_h, 2);
1005 		}
1006 
1007 		if (flip_h)
1008 			l_dflow->in_y = dflow->in_y + dflow->in_h - l_dflow->in_h;
1009 		else
1010 			r_dflow->in_y = dflow->in_y + dflow->in_h - r_dflow->in_h;
1011 	} else {
1012 		if (dflow->en_scaling) {
1013 			l_dflow->in_w = ALIGN(dflow->in_w, 2) / 2 + l_dflow->overlap;
1014 			r_dflow->in_w = l_dflow->in_w;
1015 		} else if (dflow->en_img_enhancement) {
1016 			l_dflow->in_w = ALIGN(dflow->in_w, 2) / 2 + l_dflow->overlap;
1017 			r_dflow->in_w = dflow->in_w / 2 + r_dflow->overlap;
1018 		} else {
1019 			l_dflow->in_w = ALIGN(((dflow->in_w + 1) >> 1), 2);
1020 			r_dflow->in_w = dflow->in_w - l_dflow->in_w;
1021 		}
1022 
1023 		/* do YUV alignment when scaler enabled */
1024 		if ((overlap != 0) && dflow->is_yuv) {
1025 			l_dflow->in_w = ALIGN(l_dflow->in_w, 2);
1026 			r_dflow->in_w = ALIGN(r_dflow->in_w, 2);
1027 		}
1028 
1029 		/* on flip_h, the left display content from the right-source */
1030 		if (flip_h)
1031 			l_dflow->in_x = dflow->in_w + dflow->in_x - l_dflow->in_w;
1032 		else
1033 			r_dflow->in_x = dflow->in_w + dflow->in_x - r_dflow->in_w;
1034 	}
1035 
1036 	/* split the disp_rect */
1037 	if (dflow->en_scaling || dflow->en_img_enhancement)
1038 		l_dflow->out_w = ((dflow->out_w + 1) >> 1);
1039 	else
1040 		l_dflow->out_w = ALIGN(((dflow->out_w + 1) >> 1), 2);
1041 
1042 	r_dflow->out_w = dflow->out_w - l_dflow->out_w;
1043 
1044 	l_dflow->out_x = dflow->out_x;
1045 	r_dflow->out_x = l_dflow->out_w + l_dflow->out_x;
1046 
1047 	/* calculate the scaling crop */
1048 	/* left scaler output more data and do crop */
1049 	if (r90) {
1050 		l_out = (dflow->out_w * l_dflow->in_h) / dflow->in_h;
1051 		r_out = (dflow->out_w * r_dflow->in_h) / dflow->in_h;
1052 	} else {
1053 		l_out = (dflow->out_w * l_dflow->in_w) / dflow->in_w;
1054 		r_out = (dflow->out_w * r_dflow->in_w) / dflow->in_w;
1055 	}
1056 
1057 	l_dflow->left_crop  = 0;
1058 	l_dflow->right_crop = l_out - l_dflow->out_w;
1059 	r_dflow->left_crop  = r_out - r_dflow->out_w;
1060 	r_dflow->right_crop = 0;
1061 
1062 	/* out_w includes the crop length */
1063 	l_dflow->out_w += l_dflow->right_crop + l_dflow->left_crop;
1064 	r_dflow->out_w += r_dflow->right_crop + r_dflow->left_crop;
1065 }
1066 
1067 /* For layer split, a plane state will be split to two data flows and handled
1068  * by two separated komeda layer input pipelines. komeda supports two types of
1069  * layer split:
1070  * - none-scaling split:
1071  *             / layer-left -> \
1072  * plane_state                  compiz-> ...
1073  *             \ layer-right-> /
1074  *
1075  * - scaling split:
1076  *             / layer-left -> scaler->\
1077  * plane_state                          merger -> compiz-> ...
1078  *             \ layer-right-> scaler->/
1079  *
1080  * Since merger only supports scaler as input, so for none-scaling split, two
1081  * layer data flows will be output to compiz directly. for scaling_split, two
1082  * data flow will be merged by merger firstly, then merger outputs one merged
1083  * data flow to compiz.
1084  */
1085 int komeda_build_layer_split_data_flow(struct komeda_layer *left,
1086 				       struct komeda_plane_state *kplane_st,
1087 				       struct komeda_crtc_state *kcrtc_st,
1088 				       struct komeda_data_flow_cfg *dflow)
1089 {
1090 	struct drm_plane *plane = kplane_st->base.plane;
1091 	struct komeda_pipeline *pipe = left->base.pipeline;
1092 	struct komeda_layer *right = left->right;
1093 	struct komeda_data_flow_cfg l_dflow, r_dflow;
1094 	int err;
1095 
1096 	komeda_split_data_flow(pipe->scalers[0], dflow, &l_dflow, &r_dflow);
1097 
1098 	DRM_DEBUG_ATOMIC("Assign %s + %s to [PLANE:%d:%s]: "
1099 			 "src[x/y:%d/%d, w/h:%d/%d] disp[x/y:%d/%d, w/h:%d/%d]",
1100 			 left->base.name, right->base.name,
1101 			 plane->base.id, plane->name,
1102 			 dflow->in_x, dflow->in_y, dflow->in_w, dflow->in_h,
1103 			 dflow->out_x, dflow->out_y, dflow->out_w, dflow->out_h);
1104 
1105 	err = komeda_build_layer_data_flow(left, kplane_st, kcrtc_st, &l_dflow);
1106 	if (err)
1107 		return err;
1108 
1109 	err = komeda_build_layer_data_flow(right, kplane_st, kcrtc_st, &r_dflow);
1110 	if (err)
1111 		return err;
1112 
1113 	/* The rotation has been handled by layer, so adjusted the data flow */
1114 	komeda_rotate_data_flow(dflow, dflow->rot);
1115 
1116 	/* left and right dflow has been merged to compiz already,
1117 	 * no need merger to merge them anymore.
1118 	 */
1119 	if (r_dflow.input.component == l_dflow.input.component)
1120 		return 0;
1121 
1122 	/* line merger path */
1123 	err = komeda_merger_validate(pipe->merger, plane, kcrtc_st,
1124 				     &l_dflow, &r_dflow, dflow);
1125 	if (err)
1126 		return err;
1127 
1128 	err = komeda_compiz_set_input(pipe->compiz, kcrtc_st, dflow);
1129 
1130 	return err;
1131 }
1132 
1133 /* writeback data path: compiz -> scaler -> wb_layer -> memory */
1134 int komeda_build_wb_data_flow(struct komeda_layer *wb_layer,
1135 			      struct drm_connector_state *conn_st,
1136 			      struct komeda_crtc_state *kcrtc_st,
1137 			      struct komeda_data_flow_cfg *dflow)
1138 {
1139 	struct drm_connector *conn = conn_st->connector;
1140 	int err;
1141 
1142 	err = komeda_scaler_validate(conn, kcrtc_st, dflow);
1143 	if (err)
1144 		return err;
1145 
1146 	return komeda_wb_layer_validate(wb_layer, conn_st, dflow);
1147 }
1148 
1149 /* writeback scaling split data path:
1150  *                   /-> scaler ->\
1151  * compiz -> splitter              merger -> wb_layer -> memory
1152  *                   \-> scaler ->/
1153  */
1154 int komeda_build_wb_split_data_flow(struct komeda_layer *wb_layer,
1155 				    struct drm_connector_state *conn_st,
1156 				    struct komeda_crtc_state *kcrtc_st,
1157 				    struct komeda_data_flow_cfg *dflow)
1158 {
1159 	struct komeda_pipeline *pipe = wb_layer->base.pipeline;
1160 	struct drm_connector *conn = conn_st->connector;
1161 	struct komeda_data_flow_cfg l_dflow, r_dflow;
1162 	int err;
1163 
1164 	err = komeda_splitter_validate(pipe->splitter, conn_st,
1165 				       dflow, &l_dflow, &r_dflow);
1166 	if (err)
1167 		return err;
1168 	err = komeda_scaler_validate(conn, kcrtc_st, &l_dflow);
1169 	if (err)
1170 		return err;
1171 
1172 	err = komeda_scaler_validate(conn, kcrtc_st, &r_dflow);
1173 	if (err)
1174 		return err;
1175 
1176 	err = komeda_merger_validate(pipe->merger, conn_st, kcrtc_st,
1177 				     &l_dflow, &r_dflow, dflow);
1178 	if (err)
1179 		return err;
1180 
1181 	return komeda_wb_layer_validate(wb_layer, conn_st, dflow);
1182 }
1183 
1184 /* build display output data flow, the data path is:
1185  * compiz -> improc -> timing_ctrlr
1186  */
1187 int komeda_build_display_data_flow(struct komeda_crtc *kcrtc,
1188 				   struct komeda_crtc_state *kcrtc_st)
1189 {
1190 	struct komeda_pipeline *master = kcrtc->master;
1191 	struct komeda_pipeline *slave  = kcrtc->slave;
1192 	struct komeda_data_flow_cfg m_dflow; /* master data flow */
1193 	struct komeda_data_flow_cfg s_dflow; /* slave data flow */
1194 	int err;
1195 
1196 	memset(&m_dflow, 0, sizeof(m_dflow));
1197 	memset(&s_dflow, 0, sizeof(s_dflow));
1198 
1199 	if (slave && has_bit(slave->id, kcrtc_st->active_pipes)) {
1200 		err = komeda_compiz_validate(slave->compiz, kcrtc_st, &s_dflow);
1201 		if (err)
1202 			return err;
1203 
1204 		/* merge the slave dflow into master pipeline */
1205 		err = komeda_compiz_set_input(master->compiz, kcrtc_st,
1206 					      &s_dflow);
1207 		if (err)
1208 			return err;
1209 	}
1210 
1211 	err = komeda_compiz_validate(master->compiz, kcrtc_st, &m_dflow);
1212 	if (err)
1213 		return err;
1214 
1215 	err = komeda_improc_validate(master->improc, kcrtc_st, &m_dflow);
1216 	if (err)
1217 		return err;
1218 
1219 	err = komeda_timing_ctrlr_validate(master->ctrlr, kcrtc_st, &m_dflow);
1220 	if (err)
1221 		return err;
1222 
1223 	return 0;
1224 }
1225 
1226 static void
1227 komeda_pipeline_unbound_components(struct komeda_pipeline *pipe,
1228 				   struct komeda_pipeline_state *new)
1229 {
1230 	struct drm_atomic_state *drm_st = new->obj.state;
1231 	struct komeda_pipeline_state *old = priv_to_pipe_st(pipe->obj.state);
1232 	struct komeda_component_state *c_st;
1233 	struct komeda_component *c;
1234 	u32 disabling_comps, id;
1235 
1236 	WARN_ON(!old);
1237 
1238 	disabling_comps = (~new->active_comps) & old->active_comps;
1239 
1240 	/* unbound all disabling component */
1241 	dp_for_each_set_bit(id, disabling_comps) {
1242 		c = komeda_pipeline_get_component(pipe, id);
1243 		c_st = komeda_component_get_state_and_set_user(c,
1244 				drm_st, NULL, new->crtc);
1245 		WARN_ON(IS_ERR(c_st));
1246 	}
1247 }
1248 
1249 /* release unclaimed pipeline resource */
1250 int komeda_release_unclaimed_resources(struct komeda_pipeline *pipe,
1251 				       struct komeda_crtc_state *kcrtc_st)
1252 {
1253 	struct drm_atomic_state *drm_st = kcrtc_st->base.state;
1254 	struct komeda_pipeline_state *st;
1255 
1256 	/* ignore the pipeline which is not affected */
1257 	if (!pipe || !has_bit(pipe->id, kcrtc_st->affected_pipes))
1258 		return 0;
1259 
1260 	if (has_bit(pipe->id, kcrtc_st->active_pipes))
1261 		st = komeda_pipeline_get_new_state(pipe, drm_st);
1262 	else
1263 		st = komeda_pipeline_get_state_and_set_crtc(pipe, drm_st, NULL);
1264 
1265 	if (WARN_ON(IS_ERR_OR_NULL(st)))
1266 		return -EINVAL;
1267 
1268 	komeda_pipeline_unbound_components(pipe, st);
1269 
1270 	return 0;
1271 }
1272 
1273 /* Since standalong disabled components must be disabled separately and in the
1274  * last, So a complete disable operation may needs to call pipeline_disable
1275  * twice (two phase disabling).
1276  * Phase 1: disable the common components, flush it.
1277  * Phase 2: disable the standalone disabled components, flush it.
1278  *
1279  * RETURNS:
1280  * true: disable is not complete, needs a phase 2 disable.
1281  * false: disable is complete.
1282  */
1283 bool komeda_pipeline_disable(struct komeda_pipeline *pipe,
1284 			     struct drm_atomic_state *old_state)
1285 {
1286 	struct komeda_pipeline_state *old;
1287 	struct komeda_component *c;
1288 	struct komeda_component_state *c_st;
1289 	u32 id, disabling_comps = 0;
1290 
1291 	old = komeda_pipeline_get_old_state(pipe, old_state);
1292 
1293 	disabling_comps = old->active_comps &
1294 			  (~pipe->standalone_disabled_comps);
1295 	if (!disabling_comps)
1296 		disabling_comps = old->active_comps &
1297 				  pipe->standalone_disabled_comps;
1298 
1299 	DRM_DEBUG_ATOMIC("PIPE%d: active_comps: 0x%x, disabling_comps: 0x%x.\n",
1300 			 pipe->id, old->active_comps, disabling_comps);
1301 
1302 	dp_for_each_set_bit(id, disabling_comps) {
1303 		c = komeda_pipeline_get_component(pipe, id);
1304 		c_st = priv_to_comp_st(c->obj.state);
1305 
1306 		/*
1307 		 * If we disabled a component then all active_inputs should be
1308 		 * put in the list of changed_active_inputs, so they get
1309 		 * re-enabled.
1310 		 * This usually happens during a modeset when the pipeline is
1311 		 * first disabled and then the actual state gets committed
1312 		 * again.
1313 		 */
1314 		c_st->changed_active_inputs |= c_st->active_inputs;
1315 
1316 		c->funcs->disable(c);
1317 	}
1318 
1319 	/* Update the pipeline state, if there are components that are still
1320 	 * active, return true for calling the phase 2 disable.
1321 	 */
1322 	old->active_comps &= ~disabling_comps;
1323 
1324 	return old->active_comps ? true : false;
1325 }
1326 
1327 void komeda_pipeline_update(struct komeda_pipeline *pipe,
1328 			    struct drm_atomic_state *old_state)
1329 {
1330 	struct komeda_pipeline_state *new = priv_to_pipe_st(pipe->obj.state);
1331 	struct komeda_pipeline_state *old;
1332 	struct komeda_component *c;
1333 	u32 id, changed_comps = 0;
1334 
1335 	old = komeda_pipeline_get_old_state(pipe, old_state);
1336 
1337 	changed_comps = new->active_comps | old->active_comps;
1338 
1339 	DRM_DEBUG_ATOMIC("PIPE%d: active_comps: 0x%x, changed: 0x%x.\n",
1340 			 pipe->id, new->active_comps, changed_comps);
1341 
1342 	dp_for_each_set_bit(id, changed_comps) {
1343 		c = komeda_pipeline_get_component(pipe, id);
1344 
1345 		if (new->active_comps & BIT(c->id))
1346 			c->funcs->update(c, priv_to_comp_st(c->obj.state));
1347 		else
1348 			c->funcs->disable(c);
1349 	}
1350 }
1351