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
  15static inline bool is_switching_user(void *old, void *new)
  16{
  17	if (!old || !new)
  18		return false;
  19
  20	return old != new;
  21}
  22
  23static struct komeda_pipeline_state *
  24komeda_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
  36struct komeda_pipeline_state *
  37komeda_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
  48static struct komeda_pipeline_state *
  49komeda_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 */
  61static struct komeda_pipeline_state *
  62komeda_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
  98static struct komeda_component_state *
  99komeda_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
 113static struct komeda_component_state *
 114komeda_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 */
 150static struct komeda_component_state *
 151komeda_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
 183static void
 184komeda_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
 206static int
 207komeda_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
 228static void
 229komeda_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
 237static int
 238komeda_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 */
 254static struct komeda_scaler *
 255komeda_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
 273static void
 274komeda_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
 282static int
 283komeda_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
 289	if (!komeda_fb_is_layer_supported(kfb, layer->layer_type, dflow->rot))
 290		return -EINVAL;
 291
 292	if (layer->base.id == KOMEDA_COMPONENT_WB_LAYER) {
 293		src_x = dflow->out_x;
 294		src_y = dflow->out_y;
 295		src_w = dflow->out_w;
 296		src_h = dflow->out_h;
 297	} else {
 298		src_x = dflow->in_x;
 299		src_y = dflow->in_y;
 300		src_w = dflow->in_w;
 301		src_h = dflow->in_h;
 302	}
 303
 304	if (komeda_fb_check_src_coords(kfb, src_x, src_y, src_w, src_h))
 305		return -EINVAL;
 306
 307	if (!in_range(&layer->hsize_in, src_w)) {
 308		DRM_DEBUG_ATOMIC("invalidate src_w %d.\n", src_w);
 309		return -EINVAL;
 310	}
 311
 312	if (!in_range(&layer->vsize_in, src_h)) {
 313		DRM_DEBUG_ATOMIC("invalidate src_h %d.\n", src_h);
 314		return -EINVAL;
 315	}
 316
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 317	return 0;
 318}
 319
 320static int
 321komeda_layer_validate(struct komeda_layer *layer,
 322		      struct komeda_plane_state *kplane_st,
 323		      struct komeda_data_flow_cfg *dflow)
 324{
 325	struct drm_plane_state *plane_st = &kplane_st->base;
 326	struct drm_framebuffer *fb = plane_st->fb;
 327	struct komeda_fb *kfb = to_kfb(fb);
 328	struct komeda_component_state *c_st;
 329	struct komeda_layer_state *st;
 330	int i, err;
 331
 332	err = komeda_layer_check_cfg(layer, kfb, dflow);
 333	if (err)
 334		return err;
 335
 336	c_st = komeda_component_get_state_and_set_user(&layer->base,
 337			plane_st->state, plane_st->plane, plane_st->crtc);
 338	if (IS_ERR(c_st))
 339		return PTR_ERR(c_st);
 340
 341	st = to_layer_st(c_st);
 342
 343	st->rot = dflow->rot;
 344
 345	if (fb->modifier) {
 346		st->hsize = kfb->aligned_w;
 347		st->vsize = kfb->aligned_h;
 348		st->afbc_crop_l = dflow->in_x;
 349		st->afbc_crop_r = kfb->aligned_w - dflow->in_x - dflow->in_w;
 350		st->afbc_crop_t = dflow->in_y;
 351		st->afbc_crop_b = kfb->aligned_h - dflow->in_y - dflow->in_h;
 352	} else {
 353		st->hsize = dflow->in_w;
 354		st->vsize = dflow->in_h;
 355		st->afbc_crop_l = 0;
 356		st->afbc_crop_r = 0;
 357		st->afbc_crop_t = 0;
 358		st->afbc_crop_b = 0;
 359	}
 360
 361	for (i = 0; i < fb->format->num_planes; i++)
 362		st->addr[i] = komeda_fb_get_pixel_addr(kfb, dflow->in_x,
 363						       dflow->in_y, i);
 364
 365	err = komeda_component_validate_private(&layer->base, c_st);
 366	if (err)
 367		return err;
 368
 369	/* update the data flow for the next stage */
 370	komeda_component_set_output(&dflow->input, &layer->base, 0);
 371
 372	/*
 373	 * The rotation has been handled by layer, so adjusted the data flow for
 374	 * the next stage.
 375	 */
 376	komeda_rotate_data_flow(dflow, st->rot);
 377
 378	return 0;
 379}
 380
 381static int
 382komeda_wb_layer_validate(struct komeda_layer *wb_layer,
 383			 struct drm_connector_state *conn_st,
 384			 struct komeda_data_flow_cfg *dflow)
 385{
 386	struct komeda_fb *kfb = to_kfb(conn_st->writeback_job->fb);
 387	struct komeda_component_state *c_st;
 388	struct komeda_layer_state *st;
 389	int i, err;
 390
 391	err = komeda_layer_check_cfg(wb_layer, kfb, dflow);
 392	if (err)
 393		return err;
 394
 395	c_st = komeda_component_get_state_and_set_user(&wb_layer->base,
 396			conn_st->state, conn_st->connector, conn_st->crtc);
 397	if (IS_ERR(c_st))
 398		return PTR_ERR(c_st);
 399
 400	st = to_layer_st(c_st);
 401
 402	st->hsize = dflow->out_w;
 403	st->vsize = dflow->out_h;
 404
 405	for (i = 0; i < kfb->base.format->num_planes; i++)
 406		st->addr[i] = komeda_fb_get_pixel_addr(kfb, dflow->out_x,
 407						       dflow->out_y, i);
 408
 409	komeda_component_add_input(&st->base, &dflow->input, 0);
 410	komeda_component_set_output(&dflow->input, &wb_layer->base, 0);
 411
 412	return 0;
 413}
 414
 415static bool scaling_ratio_valid(u32 size_in, u32 size_out,
 416				u32 max_upscaling, u32 max_downscaling)
 417{
 418	if (size_out > size_in * max_upscaling)
 419		return false;
 420	else if (size_in > size_out * max_downscaling)
 421		return false;
 422	return true;
 423}
 424
 425static int
 426komeda_scaler_check_cfg(struct komeda_scaler *scaler,
 427			struct komeda_crtc_state *kcrtc_st,
 428			struct komeda_data_flow_cfg *dflow)
 429{
 430	u32 hsize_in, vsize_in, hsize_out, vsize_out;
 431	u32 max_upscaling;
 432
 433	hsize_in = dflow->in_w;
 434	vsize_in = dflow->in_h;
 435	hsize_out = dflow->out_w;
 436	vsize_out = dflow->out_h;
 437
 438	if (!in_range(&scaler->hsize, hsize_in) ||
 439	    !in_range(&scaler->hsize, hsize_out)) {
 440		DRM_DEBUG_ATOMIC("Invalid horizontal sizes");
 441		return -EINVAL;
 442	}
 443
 444	if (!in_range(&scaler->vsize, vsize_in) ||
 445	    !in_range(&scaler->vsize, vsize_out)) {
 446		DRM_DEBUG_ATOMIC("Invalid vertical sizes");
 447		return -EINVAL;
 448	}
 449
 450	/* If input comes from compiz that means the scaling is for writeback
 451	 * and scaler can not do upscaling for writeback
 452	 */
 453	if (has_bit(dflow->input.component->id, KOMEDA_PIPELINE_COMPIZS))
 454		max_upscaling = 1;
 455	else
 456		max_upscaling = scaler->max_upscaling;
 457
 458	if (!scaling_ratio_valid(hsize_in, hsize_out, max_upscaling,
 459				 scaler->max_downscaling)) {
 460		DRM_DEBUG_ATOMIC("Invalid horizontal scaling ratio");
 461		return -EINVAL;
 462	}
 463
 464	if (!scaling_ratio_valid(vsize_in, vsize_out, max_upscaling,
 465				 scaler->max_downscaling)) {
 466		DRM_DEBUG_ATOMIC("Invalid vertical scaling ratio");
 467		return -EINVAL;
 468	}
 469
 470	if (hsize_in > hsize_out || vsize_in > vsize_out) {
 471		struct komeda_pipeline *pipe = scaler->base.pipeline;
 472		int err;
 473
 474		err = pipe->funcs->downscaling_clk_check(pipe,
 475					&kcrtc_st->base.adjusted_mode,
 476					komeda_crtc_get_aclk(kcrtc_st), dflow);
 477		if (err) {
 478			DRM_DEBUG_ATOMIC("aclk can't satisfy the clock requirement of the downscaling\n");
 479			return err;
 480		}
 481	}
 482
 483	return 0;
 484}
 485
 486static int
 487komeda_scaler_validate(void *user,
 488		       struct komeda_crtc_state *kcrtc_st,
 489		       struct komeda_data_flow_cfg *dflow)
 490{
 491	struct drm_atomic_state *drm_st = kcrtc_st->base.state;
 492	struct komeda_component_state *c_st;
 493	struct komeda_scaler_state *st;
 494	struct komeda_scaler *scaler;
 495	int err = 0;
 496
 497	if (!(dflow->en_scaling || dflow->en_img_enhancement))
 498		return 0;
 499
 500	scaler = komeda_component_get_avail_scaler(dflow->input.component,
 501						   drm_st);
 502	if (!scaler) {
 503		DRM_DEBUG_ATOMIC("No scaler available");
 504		return -EINVAL;
 505	}
 506
 507	err = komeda_scaler_check_cfg(scaler, kcrtc_st, dflow);
 508	if (err)
 509		return err;
 510
 511	c_st = komeda_component_get_state_and_set_user(&scaler->base,
 512			drm_st, user, kcrtc_st->base.crtc);
 513	if (IS_ERR(c_st))
 514		return PTR_ERR(c_st);
 515
 516	st = to_scaler_st(c_st);
 517
 518	st->hsize_in = dflow->in_w;
 519	st->vsize_in = dflow->in_h;
 520	st->hsize_out = dflow->out_w;
 521	st->vsize_out = dflow->out_h;
 522	st->right_crop = dflow->right_crop;
 523	st->left_crop = dflow->left_crop;
 524	st->total_vsize_in = dflow->total_in_h;
 525	st->total_hsize_in = dflow->total_in_w;
 526	st->total_hsize_out = dflow->total_out_w;
 527
 528	/* Enable alpha processing if the next stage needs the pixel alpha */
 529	st->en_alpha = dflow->pixel_blend_mode != DRM_MODE_BLEND_PIXEL_NONE;
 530	st->en_scaling = dflow->en_scaling;
 531	st->en_img_enhancement = dflow->en_img_enhancement;
 532	st->en_split = dflow->en_split;
 533	st->right_part = dflow->right_part;
 534
 535	komeda_component_add_input(&st->base, &dflow->input, 0);
 536	komeda_component_set_output(&dflow->input, &scaler->base, 0);
 537	return err;
 538}
 539
 540static void komeda_split_data_flow(struct komeda_scaler *scaler,
 541				   struct komeda_data_flow_cfg *dflow,
 542				   struct komeda_data_flow_cfg *l_dflow,
 543				   struct komeda_data_flow_cfg *r_dflow);
 544
 545static int
 546komeda_splitter_validate(struct komeda_splitter *splitter,
 547			 struct drm_connector_state *conn_st,
 548			 struct komeda_data_flow_cfg *dflow,
 549			 struct komeda_data_flow_cfg *l_output,
 550			 struct komeda_data_flow_cfg *r_output)
 551{
 552	struct komeda_component_state *c_st;
 553	struct komeda_splitter_state *st;
 554
 555	if (!splitter) {
 556		DRM_DEBUG_ATOMIC("Current HW doesn't support splitter.\n");
 557		return -EINVAL;
 558	}
 559
 560	if (!in_range(&splitter->hsize, dflow->in_w)) {
 561		DRM_DEBUG_ATOMIC("split in_w:%d is out of the acceptable range.\n",
 562				 dflow->in_w);
 563		return -EINVAL;
 564	}
 565
 566	if (!in_range(&splitter->vsize, dflow->in_h)) {
 567		DRM_DEBUG_ATOMIC("split in_h: %d exceeds the acceptable range.\n",
 568				 dflow->in_h);
 569		return -EINVAL;
 570	}
 571
 572	c_st = komeda_component_get_state_and_set_user(&splitter->base,
 573			conn_st->state, conn_st->connector, conn_st->crtc);
 574
 575	if (IS_ERR(c_st))
 576		return PTR_ERR(c_st);
 577
 578	komeda_split_data_flow(splitter->base.pipeline->scalers[0],
 579			       dflow, l_output, r_output);
 580
 581	st = to_splitter_st(c_st);
 582	st->hsize = dflow->in_w;
 583	st->vsize = dflow->in_h;
 584	st->overlap = dflow->overlap;
 585
 586	komeda_component_add_input(&st->base, &dflow->input, 0);
 587	komeda_component_set_output(&l_output->input, &splitter->base, 0);
 588	komeda_component_set_output(&r_output->input, &splitter->base, 1);
 589
 590	return 0;
 591}
 592
 593static int
 594komeda_merger_validate(struct komeda_merger *merger,
 595		       void *user,
 596		       struct komeda_crtc_state *kcrtc_st,
 597		       struct komeda_data_flow_cfg *left_input,
 598		       struct komeda_data_flow_cfg *right_input,
 599		       struct komeda_data_flow_cfg *output)
 600{
 601	struct komeda_component_state *c_st;
 602	struct komeda_merger_state *st;
 603	int err = 0;
 604
 605	if (!merger) {
 606		DRM_DEBUG_ATOMIC("No merger is available");
 607		return -EINVAL;
 608	}
 609
 610	if (!in_range(&merger->hsize_merged, output->out_w)) {
 611		DRM_DEBUG_ATOMIC("merged_w: %d is out of the accepted range.\n",
 612				 output->out_w);
 613		return -EINVAL;
 614	}
 615
 616	if (!in_range(&merger->vsize_merged, output->out_h)) {
 617		DRM_DEBUG_ATOMIC("merged_h: %d is out of the accepted range.\n",
 618				 output->out_h);
 619		return -EINVAL;
 620	}
 621
 622	c_st = komeda_component_get_state_and_set_user(&merger->base,
 623			kcrtc_st->base.state, kcrtc_st->base.crtc, kcrtc_st->base.crtc);
 624
 625	if (IS_ERR(c_st))
 626		return PTR_ERR(c_st);
 627
 628	st = to_merger_st(c_st);
 629	st->hsize_merged = output->out_w;
 630	st->vsize_merged = output->out_h;
 631
 632	komeda_component_add_input(c_st, &left_input->input, 0);
 633	komeda_component_add_input(c_st, &right_input->input, 1);
 634	komeda_component_set_output(&output->input, &merger->base, 0);
 635
 636	return err;
 637}
 638
 639void pipeline_composition_size(struct komeda_crtc_state *kcrtc_st,
 640			       u16 *hsize, u16 *vsize)
 641{
 642	struct drm_display_mode *m = &kcrtc_st->base.adjusted_mode;
 643
 644	if (hsize)
 645		*hsize = m->hdisplay;
 646	if (vsize)
 647		*vsize = m->vdisplay;
 648}
 649
 650static int
 651komeda_compiz_set_input(struct komeda_compiz *compiz,
 652			struct komeda_crtc_state *kcrtc_st,
 653			struct komeda_data_flow_cfg *dflow)
 654{
 655	struct drm_atomic_state *drm_st = kcrtc_st->base.state;
 656	struct komeda_component_state *c_st, *old_st;
 657	struct komeda_compiz_input_cfg *cin;
 658	u16 compiz_w, compiz_h;
 659	int idx = dflow->blending_zorder;
 660
 661	pipeline_composition_size(kcrtc_st, &compiz_w, &compiz_h);
 662	/* check display rect */
 663	if ((dflow->out_x + dflow->out_w > compiz_w) ||
 664	    (dflow->out_y + dflow->out_h > compiz_h) ||
 665	     dflow->out_w == 0 || dflow->out_h == 0) {
 666		DRM_DEBUG_ATOMIC("invalid disp rect [x=%d, y=%d, w=%d, h=%d]\n",
 667				 dflow->out_x, dflow->out_y,
 668				 dflow->out_w, dflow->out_h);
 669		return -EINVAL;
 670	}
 671
 672	c_st = komeda_component_get_state_and_set_user(&compiz->base, drm_st,
 673			kcrtc_st->base.crtc, kcrtc_st->base.crtc);
 674	if (IS_ERR(c_st))
 675		return PTR_ERR(c_st);
 676
 677	if (komeda_component_check_input(c_st, &dflow->input, idx))
 678		return -EINVAL;
 679
 680	cin = &(to_compiz_st(c_st)->cins[idx]);
 681
 682	cin->hsize   = dflow->out_w;
 683	cin->vsize   = dflow->out_h;
 684	cin->hoffset = dflow->out_x;
 685	cin->voffset = dflow->out_y;
 686	cin->pixel_blend_mode = dflow->pixel_blend_mode;
 687	cin->layer_alpha = dflow->layer_alpha;
 688
 689	old_st = komeda_component_get_old_state(&compiz->base, drm_st);
 690	WARN_ON(!old_st);
 691
 692	/* compare with old to check if this input has been changed */
 693	if (memcmp(&(to_compiz_st(old_st)->cins[idx]), cin, sizeof(*cin)))
 694		c_st->changed_active_inputs |= BIT(idx);
 695
 696	komeda_component_add_input(c_st, &dflow->input, idx);
 697	komeda_component_set_output(&dflow->input, &compiz->base, 0);
 698
 699	return 0;
 700}
 701
 702static int
 703komeda_compiz_validate(struct komeda_compiz *compiz,
 704		       struct komeda_crtc_state *state,
 705		       struct komeda_data_flow_cfg *dflow)
 706{
 707	struct komeda_component_state *c_st;
 708	struct komeda_compiz_state *st;
 709
 710	c_st = komeda_component_get_state_and_set_user(&compiz->base,
 711			state->base.state, state->base.crtc, state->base.crtc);
 712	if (IS_ERR(c_st))
 713		return PTR_ERR(c_st);
 714
 715	st = to_compiz_st(c_st);
 716
 717	pipeline_composition_size(state, &st->hsize, &st->vsize);
 718
 719	komeda_component_set_output(&dflow->input, &compiz->base, 0);
 720
 721	/* compiz output dflow will be fed to the next pipeline stage, prepare
 722	 * the data flow configuration for the next stage
 723	 */
 724	if (dflow) {
 725		dflow->in_w = st->hsize;
 726		dflow->in_h = st->vsize;
 727		dflow->out_w = dflow->in_w;
 728		dflow->out_h = dflow->in_h;
 729		/* the output data of compiz doesn't have alpha, it only can be
 730		 * used as bottom layer when blend it with master layers
 731		 */
 732		dflow->pixel_blend_mode = DRM_MODE_BLEND_PIXEL_NONE;
 733		dflow->layer_alpha = 0xFF;
 734		dflow->blending_zorder = 0;
 735	}
 736
 737	return 0;
 738}
 739
 740static int
 741komeda_improc_validate(struct komeda_improc *improc,
 742		       struct komeda_crtc_state *kcrtc_st,
 743		       struct komeda_data_flow_cfg *dflow)
 744{
 745	struct drm_crtc *crtc = kcrtc_st->base.crtc;
 
 746	struct komeda_component_state *c_st;
 747	struct komeda_improc_state *st;
 748
 749	c_st = komeda_component_get_state_and_set_user(&improc->base,
 750			kcrtc_st->base.state, crtc, crtc);
 751	if (IS_ERR(c_st))
 752		return PTR_ERR(c_st);
 753
 754	st = to_improc_st(c_st);
 755
 756	st->hsize = dflow->in_w;
 757	st->vsize = dflow->in_h;
 758
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 759	komeda_component_add_input(&st->base, &dflow->input, 0);
 760	komeda_component_set_output(&dflow->input, &improc->base, 0);
 761
 762	return 0;
 763}
 764
 765static int
 766komeda_timing_ctrlr_validate(struct komeda_timing_ctrlr *ctrlr,
 767			     struct komeda_crtc_state *kcrtc_st,
 768			     struct komeda_data_flow_cfg *dflow)
 769{
 770	struct drm_crtc *crtc = kcrtc_st->base.crtc;
 771	struct komeda_timing_ctrlr_state *st;
 772	struct komeda_component_state *c_st;
 773
 774	c_st = komeda_component_get_state_and_set_user(&ctrlr->base,
 775			kcrtc_st->base.state, crtc, crtc);
 776	if (IS_ERR(c_st))
 777		return PTR_ERR(c_st);
 778
 779	st = to_ctrlr_st(c_st);
 780
 781	komeda_component_add_input(&st->base, &dflow->input, 0);
 782	komeda_component_set_output(&dflow->input, &ctrlr->base, 0);
 783
 784	return 0;
 785}
 786
 787void komeda_complete_data_flow_cfg(struct komeda_layer *layer,
 788				   struct komeda_data_flow_cfg *dflow,
 789				   struct drm_framebuffer *fb)
 790{
 791	struct komeda_scaler *scaler = layer->base.pipeline->scalers[0];
 792	u32 w = dflow->in_w;
 793	u32 h = dflow->in_h;
 794
 795	dflow->total_in_w = dflow->in_w;
 796	dflow->total_in_h = dflow->in_h;
 797	dflow->total_out_w = dflow->out_w;
 798
 799	/* if format doesn't have alpha, fix blend mode to PIXEL_NONE */
 800	if (!fb->format->has_alpha)
 801		dflow->pixel_blend_mode = DRM_MODE_BLEND_PIXEL_NONE;
 802
 803	if (drm_rotation_90_or_270(dflow->rot))
 804		swap(w, h);
 805
 806	dflow->en_scaling = (w != dflow->out_w) || (h != dflow->out_h);
 807	dflow->is_yuv = fb->format->is_yuv;
 808
 809	/* try to enable image enhancer if data flow is a 2x+ upscaling */
 810	dflow->en_img_enhancement = dflow->out_w >= 2 * w ||
 811				    dflow->out_h >= 2 * h;
 812
 813	/* try to enable split if scaling exceed the scaler's acceptable
 814	 * input/output range.
 815	 */
 816	if (dflow->en_scaling && scaler)
 817		dflow->en_split = !in_range(&scaler->hsize, dflow->in_w) ||
 818				  !in_range(&scaler->hsize, dflow->out_w);
 819}
 820
 821static bool merger_is_available(struct komeda_pipeline *pipe,
 822				struct komeda_data_flow_cfg *dflow)
 823{
 824	u32 avail_inputs = pipe->merger ?
 825			   pipe->merger->base.supported_inputs : 0;
 826
 827	return has_bit(dflow->input.component->id, avail_inputs);
 828}
 829
 830int komeda_build_layer_data_flow(struct komeda_layer *layer,
 831				 struct komeda_plane_state *kplane_st,
 832				 struct komeda_crtc_state *kcrtc_st,
 833				 struct komeda_data_flow_cfg *dflow)
 834{
 835	struct drm_plane *plane = kplane_st->base.plane;
 836	struct komeda_pipeline *pipe = layer->base.pipeline;
 837	int err;
 838
 839	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]",
 840			 layer->base.name, plane->base.id, plane->name,
 841			 dflow->in_x, dflow->in_y, dflow->in_w, dflow->in_h,
 842			 dflow->out_x, dflow->out_y, dflow->out_w, dflow->out_h);
 843
 844	err = komeda_layer_validate(layer, kplane_st, dflow);
 845	if (err)
 846		return err;
 847
 848	err = komeda_scaler_validate(plane, kcrtc_st, dflow);
 849	if (err)
 850		return err;
 851
 852	/* if split, check if can put the data flow into merger */
 853	if (dflow->en_split && merger_is_available(pipe, dflow))
 854		return 0;
 855
 856	err = komeda_compiz_set_input(pipe->compiz, kcrtc_st, dflow);
 857
 858	return err;
 859}
 860
 861/*
 862 * Split is introduced for workaround scaler's input/output size limitation.
 863 * The idea is simple, if one scaler can not fit the requirement, use two.
 864 * So split splits the big source image to two half parts (left/right) and do
 865 * the scaling by two scaler separately and independently.
 866 * But split also imports an edge problem in the middle of the image when
 867 * scaling, to avoid it, split isn't a simple half-and-half, but add an extra
 868 * pixels (overlap) to both side, after split the left/right will be:
 869 * - left: [0, src_length/2 + overlap]
 870 * - right: [src_length/2 - overlap, src_length]
 871 * The extra overlap do eliminate the edge problem, but which may also generates
 872 * unnecessary pixels when scaling, we need to crop them before scaler output
 873 * the result to the next stage. and for the how to crop, it depends on the
 874 * unneeded pixels, another words the position where overlay has been added.
 875 * - left: crop the right
 876 * - right: crop the left
 877 *
 878 * The diagram for how to do the split
 879 *
 880 *  <---------------------left->out_w ---------------->
 881 * |--------------------------------|---right_crop-----| <- left after split
 882 *  \                                \                /
 883 *   \                                \<--overlap--->/
 884 *   |-----------------|-------------|(Middle)------|-----------------| <- src
 885 *                     /<---overlap--->\                               \
 886 *                    /                 \                               \
 887 * right after split->|-----left_crop---|--------------------------------|
 888 *                    ^<------------------- right->out_w --------------->^
 889 *
 890 * NOTE: To consistent with HW the output_w always contains the crop size.
 891 */
 892
 893static void komeda_split_data_flow(struct komeda_scaler *scaler,
 894				   struct komeda_data_flow_cfg *dflow,
 895				   struct komeda_data_flow_cfg *l_dflow,
 896				   struct komeda_data_flow_cfg *r_dflow)
 897{
 898	bool r90 = drm_rotation_90_or_270(dflow->rot);
 899	bool flip_h = has_flip_h(dflow->rot);
 900	u32 l_out, r_out, overlap;
 901
 902	memcpy(l_dflow, dflow, sizeof(*dflow));
 903	memcpy(r_dflow, dflow, sizeof(*dflow));
 904
 905	l_dflow->right_part = false;
 906	r_dflow->right_part = true;
 907	r_dflow->blending_zorder = dflow->blending_zorder + 1;
 908
 909	overlap = 0;
 910	if (dflow->en_scaling && scaler)
 911		overlap += scaler->scaling_split_overlap;
 912
 913	/* original dflow may fed into splitter, and which doesn't need
 914	 * enhancement overlap
 915	 */
 916	dflow->overlap = overlap;
 917
 918	if (dflow->en_img_enhancement && scaler)
 919		overlap += scaler->enh_split_overlap;
 920
 921	l_dflow->overlap = overlap;
 922	r_dflow->overlap = overlap;
 923
 924	/* split the origin content */
 925	/* left/right here always means the left/right part of display image,
 926	 * not the source Image
 927	 */
 928	/* DRM rotation is anti-clockwise */
 929	if (r90) {
 930		if (dflow->en_scaling) {
 931			l_dflow->in_h = ALIGN(dflow->in_h, 2) / 2 + l_dflow->overlap;
 932			r_dflow->in_h = l_dflow->in_h;
 933		} else if (dflow->en_img_enhancement) {
 934			/* enhancer only */
 935			l_dflow->in_h = ALIGN(dflow->in_h, 2) / 2 + l_dflow->overlap;
 936			r_dflow->in_h = dflow->in_h / 2 + r_dflow->overlap;
 937		} else {
 938			/* split without scaler, no overlap */
 939			l_dflow->in_h = ALIGN(((dflow->in_h + 1) >> 1), 2);
 940			r_dflow->in_h = dflow->in_h - l_dflow->in_h;
 941		}
 942
 943		/* Consider YUV format, after split, the split source w/h
 944		 * may not aligned to 2. we have two choices for such case.
 945		 * 1. scaler is enabled (overlap != 0), we can do a alignment
 946		 *    both left/right and crop the extra data by scaler.
 947		 * 2. scaler is not enabled, only align the split left
 948		 *    src/disp, and the rest part assign to right
 949		 */
 950		if ((overlap != 0) && dflow->is_yuv) {
 951			l_dflow->in_h = ALIGN(l_dflow->in_h, 2);
 952			r_dflow->in_h = ALIGN(r_dflow->in_h, 2);
 953		}
 954
 955		if (flip_h)
 956			l_dflow->in_y = dflow->in_y + dflow->in_h - l_dflow->in_h;
 957		else
 958			r_dflow->in_y = dflow->in_y + dflow->in_h - r_dflow->in_h;
 959	} else {
 960		if (dflow->en_scaling) {
 961			l_dflow->in_w = ALIGN(dflow->in_w, 2) / 2 + l_dflow->overlap;
 962			r_dflow->in_w = l_dflow->in_w;
 963		} else if (dflow->en_img_enhancement) {
 964			l_dflow->in_w = ALIGN(dflow->in_w, 2) / 2 + l_dflow->overlap;
 965			r_dflow->in_w = dflow->in_w / 2 + r_dflow->overlap;
 966		} else {
 967			l_dflow->in_w = ALIGN(((dflow->in_w + 1) >> 1), 2);
 968			r_dflow->in_w = dflow->in_w - l_dflow->in_w;
 969		}
 970
 971		/* do YUV alignment when scaler enabled */
 972		if ((overlap != 0) && dflow->is_yuv) {
 973			l_dflow->in_w = ALIGN(l_dflow->in_w, 2);
 974			r_dflow->in_w = ALIGN(r_dflow->in_w, 2);
 975		}
 976
 977		/* on flip_h, the left display content from the right-source */
 978		if (flip_h)
 979			l_dflow->in_x = dflow->in_w + dflow->in_x - l_dflow->in_w;
 980		else
 981			r_dflow->in_x = dflow->in_w + dflow->in_x - r_dflow->in_w;
 982	}
 983
 984	/* split the disp_rect */
 985	if (dflow->en_scaling || dflow->en_img_enhancement)
 986		l_dflow->out_w = ((dflow->out_w + 1) >> 1);
 987	else
 988		l_dflow->out_w = ALIGN(((dflow->out_w + 1) >> 1), 2);
 989
 990	r_dflow->out_w = dflow->out_w - l_dflow->out_w;
 991
 992	l_dflow->out_x = dflow->out_x;
 993	r_dflow->out_x = l_dflow->out_w + l_dflow->out_x;
 994
 995	/* calculate the scaling crop */
 996	/* left scaler output more data and do crop */
 997	if (r90) {
 998		l_out = (dflow->out_w * l_dflow->in_h) / dflow->in_h;
 999		r_out = (dflow->out_w * r_dflow->in_h) / dflow->in_h;
1000	} else {
1001		l_out = (dflow->out_w * l_dflow->in_w) / dflow->in_w;
1002		r_out = (dflow->out_w * r_dflow->in_w) / dflow->in_w;
1003	}
1004
1005	l_dflow->left_crop  = 0;
1006	l_dflow->right_crop = l_out - l_dflow->out_w;
1007	r_dflow->left_crop  = r_out - r_dflow->out_w;
1008	r_dflow->right_crop = 0;
1009
1010	/* out_w includes the crop length */
1011	l_dflow->out_w += l_dflow->right_crop + l_dflow->left_crop;
1012	r_dflow->out_w += r_dflow->right_crop + r_dflow->left_crop;
1013}
1014
1015/* For layer split, a plane state will be split to two data flows and handled
1016 * by two separated komeda layer input pipelines. komeda supports two types of
1017 * layer split:
1018 * - none-scaling split:
1019 *             / layer-left -> \
1020 * plane_state                  compiz-> ...
1021 *             \ layer-right-> /
1022 *
1023 * - scaling split:
1024 *             / layer-left -> scaler->\
1025 * plane_state                          merger -> compiz-> ...
1026 *             \ layer-right-> scaler->/
1027 *
1028 * Since merger only supports scaler as input, so for none-scaling split, two
1029 * layer data flows will be output to compiz directly. for scaling_split, two
1030 * data flow will be merged by merger firstly, then merger outputs one merged
1031 * data flow to compiz.
1032 */
1033int komeda_build_layer_split_data_flow(struct komeda_layer *left,
1034				       struct komeda_plane_state *kplane_st,
1035				       struct komeda_crtc_state *kcrtc_st,
1036				       struct komeda_data_flow_cfg *dflow)
1037{
1038	struct drm_plane *plane = kplane_st->base.plane;
1039	struct komeda_pipeline *pipe = left->base.pipeline;
1040	struct komeda_layer *right = left->right;
1041	struct komeda_data_flow_cfg l_dflow, r_dflow;
1042	int err;
1043
1044	komeda_split_data_flow(pipe->scalers[0], dflow, &l_dflow, &r_dflow);
1045
1046	DRM_DEBUG_ATOMIC("Assign %s + %s to [PLANE:%d:%s]: "
1047			 "src[x/y:%d/%d, w/h:%d/%d] disp[x/y:%d/%d, w/h:%d/%d]",
1048			 left->base.name, right->base.name,
1049			 plane->base.id, plane->name,
1050			 dflow->in_x, dflow->in_y, dflow->in_w, dflow->in_h,
1051			 dflow->out_x, dflow->out_y, dflow->out_w, dflow->out_h);
1052
1053	err = komeda_build_layer_data_flow(left, kplane_st, kcrtc_st, &l_dflow);
1054	if (err)
1055		return err;
1056
1057	err = komeda_build_layer_data_flow(right, kplane_st, kcrtc_st, &r_dflow);
1058	if (err)
1059		return err;
1060
1061	/* The rotation has been handled by layer, so adjusted the data flow */
1062	komeda_rotate_data_flow(dflow, dflow->rot);
1063
1064	/* left and right dflow has been merged to compiz already,
1065	 * no need merger to merge them anymore.
1066	 */
1067	if (r_dflow.input.component == l_dflow.input.component)
1068		return 0;
1069
1070	/* line merger path */
1071	err = komeda_merger_validate(pipe->merger, plane, kcrtc_st,
1072				     &l_dflow, &r_dflow, dflow);
1073	if (err)
1074		return err;
1075
1076	err = komeda_compiz_set_input(pipe->compiz, kcrtc_st, dflow);
1077
1078	return err;
1079}
1080
1081/* writeback data path: compiz -> scaler -> wb_layer -> memory */
1082int komeda_build_wb_data_flow(struct komeda_layer *wb_layer,
1083			      struct drm_connector_state *conn_st,
1084			      struct komeda_crtc_state *kcrtc_st,
1085			      struct komeda_data_flow_cfg *dflow)
1086{
1087	struct drm_connector *conn = conn_st->connector;
1088	int err;
1089
1090	err = komeda_scaler_validate(conn, kcrtc_st, dflow);
1091	if (err)
1092		return err;
1093
1094	return komeda_wb_layer_validate(wb_layer, conn_st, dflow);
1095}
1096
1097/* writeback scaling split data path:
1098 *                   /-> scaler ->\
1099 * compiz -> splitter              merger -> wb_layer -> memory
1100 *                   \-> scaler ->/
1101 */
1102int komeda_build_wb_split_data_flow(struct komeda_layer *wb_layer,
1103				    struct drm_connector_state *conn_st,
1104				    struct komeda_crtc_state *kcrtc_st,
1105				    struct komeda_data_flow_cfg *dflow)
1106{
1107	struct komeda_pipeline *pipe = wb_layer->base.pipeline;
1108	struct drm_connector *conn = conn_st->connector;
1109	struct komeda_data_flow_cfg l_dflow, r_dflow;
1110	int err;
1111
1112	err = komeda_splitter_validate(pipe->splitter, conn_st,
1113				       dflow, &l_dflow, &r_dflow);
1114	if (err)
1115		return err;
1116	err = komeda_scaler_validate(conn, kcrtc_st, &l_dflow);
1117	if (err)
1118		return err;
1119
1120	err = komeda_scaler_validate(conn, kcrtc_st, &r_dflow);
1121	if (err)
1122		return err;
1123
1124	err = komeda_merger_validate(pipe->merger, conn_st, kcrtc_st,
1125				     &l_dflow, &r_dflow, dflow);
1126	if (err)
1127		return err;
1128
1129	return komeda_wb_layer_validate(wb_layer, conn_st, dflow);
1130}
1131
1132/* build display output data flow, the data path is:
1133 * compiz -> improc -> timing_ctrlr
1134 */
1135int komeda_build_display_data_flow(struct komeda_crtc *kcrtc,
1136				   struct komeda_crtc_state *kcrtc_st)
1137{
1138	struct komeda_pipeline *master = kcrtc->master;
1139	struct komeda_pipeline *slave  = kcrtc->slave;
1140	struct komeda_data_flow_cfg m_dflow; /* master data flow */
1141	struct komeda_data_flow_cfg s_dflow; /* slave data flow */
1142	int err;
1143
1144	memset(&m_dflow, 0, sizeof(m_dflow));
1145	memset(&s_dflow, 0, sizeof(s_dflow));
1146
1147	if (slave && has_bit(slave->id, kcrtc_st->active_pipes)) {
1148		err = komeda_compiz_validate(slave->compiz, kcrtc_st, &s_dflow);
1149		if (err)
1150			return err;
1151
1152		/* merge the slave dflow into master pipeline */
1153		err = komeda_compiz_set_input(master->compiz, kcrtc_st,
1154					      &s_dflow);
1155		if (err)
1156			return err;
1157	}
1158
1159	err = komeda_compiz_validate(master->compiz, kcrtc_st, &m_dflow);
1160	if (err)
1161		return err;
1162
1163	err = komeda_improc_validate(master->improc, kcrtc_st, &m_dflow);
1164	if (err)
1165		return err;
1166
1167	err = komeda_timing_ctrlr_validate(master->ctrlr, kcrtc_st, &m_dflow);
1168	if (err)
1169		return err;
1170
1171	return 0;
1172}
1173
1174static void
1175komeda_pipeline_unbound_components(struct komeda_pipeline *pipe,
1176				   struct komeda_pipeline_state *new)
1177{
1178	struct drm_atomic_state *drm_st = new->obj.state;
1179	struct komeda_pipeline_state *old = priv_to_pipe_st(pipe->obj.state);
1180	struct komeda_component_state *c_st;
1181	struct komeda_component *c;
1182	u32 disabling_comps, id;
1183
1184	WARN_ON(!old);
1185
1186	disabling_comps = (~new->active_comps) & old->active_comps;
1187
1188	/* unbound all disabling component */
1189	dp_for_each_set_bit(id, disabling_comps) {
1190		c = komeda_pipeline_get_component(pipe, id);
1191		c_st = komeda_component_get_state_and_set_user(c,
1192				drm_st, NULL, new->crtc);
1193		WARN_ON(IS_ERR(c_st));
1194	}
1195}
1196
1197/* release unclaimed pipeline resource */
1198int komeda_release_unclaimed_resources(struct komeda_pipeline *pipe,
1199				       struct komeda_crtc_state *kcrtc_st)
1200{
1201	struct drm_atomic_state *drm_st = kcrtc_st->base.state;
1202	struct komeda_pipeline_state *st;
1203
1204	/* ignore the pipeline which is not affected */
1205	if (!pipe || !has_bit(pipe->id, kcrtc_st->affected_pipes))
1206		return 0;
1207
1208	if (has_bit(pipe->id, kcrtc_st->active_pipes))
1209		st = komeda_pipeline_get_new_state(pipe, drm_st);
1210	else
1211		st = komeda_pipeline_get_state_and_set_crtc(pipe, drm_st, NULL);
1212
1213	if (WARN_ON(IS_ERR_OR_NULL(st)))
1214		return -EINVAL;
1215
1216	komeda_pipeline_unbound_components(pipe, st);
1217
1218	return 0;
1219}
1220
1221void komeda_pipeline_disable(struct komeda_pipeline *pipe,
 
 
 
 
 
 
 
 
 
 
1222			     struct drm_atomic_state *old_state)
1223{
1224	struct komeda_pipeline_state *old;
1225	struct komeda_component *c;
1226	struct komeda_component_state *c_st;
1227	u32 id, disabling_comps = 0;
1228
1229	old = komeda_pipeline_get_old_state(pipe, old_state);
1230
1231	disabling_comps = old->active_comps;
1232	DRM_DEBUG_ATOMIC("PIPE%d: disabling_comps: 0x%x.\n",
1233			 pipe->id, disabling_comps);
 
 
 
 
 
1234
1235	dp_for_each_set_bit(id, disabling_comps) {
1236		c = komeda_pipeline_get_component(pipe, id);
1237		c_st = priv_to_comp_st(c->obj.state);
1238
1239		/*
1240		 * If we disabled a component then all active_inputs should be
1241		 * put in the list of changed_active_inputs, so they get
1242		 * re-enabled.
1243		 * This usually happens during a modeset when the pipeline is
1244		 * first disabled and then the actual state gets committed
1245		 * again.
1246		 */
1247		c_st->changed_active_inputs |= c_st->active_inputs;
1248
1249		c->funcs->disable(c);
1250	}
 
 
 
 
 
 
 
1251}
1252
1253void komeda_pipeline_update(struct komeda_pipeline *pipe,
1254			    struct drm_atomic_state *old_state)
1255{
1256	struct komeda_pipeline_state *new = priv_to_pipe_st(pipe->obj.state);
1257	struct komeda_pipeline_state *old;
1258	struct komeda_component *c;
1259	u32 id, changed_comps = 0;
1260
1261	old = komeda_pipeline_get_old_state(pipe, old_state);
1262
1263	changed_comps = new->active_comps | old->active_comps;
1264
1265	DRM_DEBUG_ATOMIC("PIPE%d: active_comps: 0x%x, changed: 0x%x.\n",
1266			 pipe->id, new->active_comps, changed_comps);
1267
1268	dp_for_each_set_bit(id, changed_comps) {
1269		c = komeda_pipeline_get_component(pipe, id);
1270
1271		if (new->active_comps & BIT(c->id))
1272			c->funcs->update(c, priv_to_comp_st(c->obj.state));
1273		else
1274			c->funcs->disable(c);
1275	}
1276}